@@ -5,7 +5,7 @@ Learning on Simple Hypergraph
 
 Definition
 -----------------
-`Simple hypergraph <https://en.wikipedia.org/wiki/Hypergraph>`_ (also called undirected hypergraph) can be indicated with :math:`\mathcal{G} = \{\mathcal{V}, \mathcal{E}\}`.
+A `simple hypergraph <https://en.wikipedia.org/wiki/Hypergraph>`_ (also called undirected hypergraph) can be indicated with :math:`\mathcal{G} = \{\mathcal{V}, \mathcal{E}\}`.
 
 - :math:`\mathcal{V}`, is a set of **vertices** (also called **nodes** or **points**);
 - :math:`\mathcal{E} \subseteq \{ \mathcal{P}(\mathcal{V}) \}`, a set of **hyperedges** (also called **edges**), where :math:`\mathcal{P}(\mathcal{V})` is the `power set <https://en.wikipedia.org/wiki/Power_set>`_ of :math:`\mathcal{V}`.
@@ -22,7 +22,7 @@ An undirected hypergraph is also called a set system or a family of sets drawn f
 
 Construction
 ---------------------
-The simple hypergraph structure can be constructed by the following methods. More details can refer to aaaaaaaaaaaaa.
+The simple hypergraph structure can be constructed by the following methods. More details can refer to :ref:`here <build_hypergraph>`.
 
 - Hyperedge list (**default**) :py:class:`dhg.Hypergraph`
 - Features with k-Nearest Neighbors :py:meth:`dhg.Hypergraph.from_feature_kNN`
 
@@ -22,7 +22,7 @@ different scenarios like: movie/news/goods/hotels/products/services recommender.
 
 Construction
 -------------------------
-The bipartite graph structure can be constructed by the following methods. More details can refer to aaaaaaaaaaaaa.
+The bipartite graph structure can be constructed by the following methods. More details can refer to :ref:`here <build_bipartite_graph>`.
 
 - Edge list (**default**) :py:class:`dhg.BiGraph`
 - Adjacency list :py:meth:`dhg.BiGraph.from_adj_list`
 
@@ -21,7 +21,7 @@ A vertex may exist in a directed graph and not belong to an edge. The edge :math
 Construction
 -------------------------
 
-The directed graph structure can be constructed by the following methods. More details can refer to aaaaaaaaaaaaa.
+The directed graph structure can be constructed by the following methods. More details can refer to :ref:`here <build_directed_graph>`.
 
 - Edge list (**default**) :py:class:`dhg.DiGraph`
 - Adjacency list :py:meth:`dhg.DiGraph.from_adj_list`
 
@@ -16,7 +16,7 @@ A vertex may exist in a simple graph and not belong to an edge.
 
 Construction
 -------------------------
-The simple graph structure can be constructed by the following methods. More details can refer to aaaaaaaaaaaaa.
+The simple graph structure can be constructed by the following methods. More details can refer to :ref:`here <build_graph>`.
 
 - Edge list (**default**) :py:class:`dhg.Graph`
 - Adjacency list :py:meth:`dhg.Graph.from_adj_list`
 
@@ -32,12 +32,12 @@ Applications
     :header: Structure, "Applications", "Example Code"
     :widths: 2, 6, 3
 
-    "Simple Graph", "Paper Classification of Citation Networks, *etc.*", "aaaaaaaaaa"
-    "Directed Graph", "Point Clouds Classification, *etc.*", "aaaaaaaaa"
+    "Simple Graph", "Paper Classification of Citation Networks, *etc.*", ":doc:`example </examples/vertex_cls/graph>`"
+    "Directed Graph", "Point Clouds Classification, *etc.*", "\-"
     "Bipartite Graph", "| Item Recommender of User-Item Graph,
-    | Correlation Prediction of Potein-Drug Graph, *etc.*", "aaaaaaaaaaa"
+    | Correlation Prediction of Potein-Drug Graph, *etc.*", ":doc:`example </examples/recommender>`"
     "Simple Hypergraph", "| Vertex Classification of Social Networks, 
-    | Visual Object Classification on Multi-Modal Visual Object Graph, *etc.*", "aaaaaaaaaa"
+    | Visual Object Classification on Multi-Modal Visual Object Graph, *etc.*", ":doc:`example </examples/vertex_cls/hypergraph>`"
     
 
 Two Core Operations
@@ -309,8 +309,8 @@ Add Early Self-loop and Late Self-Loop
 
 Self-loop is a important structure for feature learning especially for the simple graph structure. 
 In the following examples, we introduce how to add early self-loop and late self-loop for spatial-based learning on the simple graph structure.
+We use :math:`\mathbf{A} \in \mathbb{R}^{N \times N}` to indicate the adjacency matrix of a given simple graph and :math:`\mathbf{X} \in \mathbb{R}^{N \times C}` to indicate the features of vertices in the given simple graph.
 
-Add mathematical definition aaaaaaaaaaaaaaaaaaaaaaaaa
 
     .. code:: python
 
@@ -336,6 +336,16 @@ Add mathematical definition aaaaaaaaaaaaaaaaaaaaaaaaa
 Message Passing with Early Self-Loop 
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+    .. math::
+
+        \left\{  
+        \begin{align}
+        \mathbf{X}^\prime &= \hat{\mathbf{A}} \mathbf{X}\\
+        \hat{\mathbf{A}} &= \mathbf{A} + \mathbf{I}   
+        \end{align}
+        \right.  
+
+
     .. code:: python
         
         >>> # Print edges in the graph
@@ -364,6 +374,11 @@ Message Passing with Early Self-Loop
 Message Passing with Late Self-Loop
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+    .. math::
+
+        \mathbf{X}^\prime = \mathbf{A} \mathbf{X} + \mathbf{X}
+
+
     .. code:: python
         
         >>> # Print edges in the graph
 
@@ -1,12 +1,19 @@
 Build Structure
 ===================================
 Correlation structures are the core of **DHG**. In this section, we introduce the basic construction methods of different structures 
-and some structure transformation functions of them like: *reducing the high-order structrue to the low-order structure* 
-and *promoting the low-order structure to the high-order structure.*
+and some structure transformation functions of them like: 
+
+- Reducing the high-order structrue to the low-order structure 
+- Promoting the low-order structure to the high-order structure
 
 Low-Order Structures
 -----------------------
 
+Currently, DHG's low-order structures include simple graph, directed graph, and bipartite graph. 
+In the future, we will add more low-order structures.
+
+.. _build_graph:
+
 Build Simple Graph
 +++++++++++++++++++++++
 
@@ -232,6 +239,7 @@ a method to reduce the hyperedges in the hypergraph to the edges in the simple g
             [0.3333, 0.3333, 0.3333, 0.0000, 0.3333],
             [0.0000, 0.0000, 0.0000, 0.3333, 0.0000]])
 
+.. _build_directed_graph:
 
 Build Directed Graph
 +++++++++++++++++++++++
@@ -316,6 +324,7 @@ Reduced from High-Order Structures
 
 Welcome to contribute!
 
+.. _build_bipartite_graph:
 
 Build Bipartite Graph
 +++++++++++++++++++++++
@@ -433,17 +442,122 @@ We first define a simple hypergraph as:
             [0., 1., 1., 0., 0.],
             [1., 0., 0., 1., 1.]])
 
+
 High-Order Structures
 -----------------------
-Comming soon
+
+Currently, DHG's high-order structures include simple hypergraph. 
+In the future, we will add more high-order structures like directed hypergraph.
+
+.. _build_hypergraph:
 
 Build Simple Hypergraph
 ++++++++++++++++++++++++++
-Comming soon
+A `simple hypergraph <https://en.wikipedia.org/wiki/Hypergraph>`_ is a hypergraph with no direction information in each hyperedge. 
+Each hyperedge in a hypergraph can connect more than two vertices, which can be indicated with a sub-set of total vertices.
+Simple hypergraph can be constructed by the following methods:
+
+- Hyperedge list (**default**) :py:class:`dhg.Hypergraph`
+- Features with k-Nearest Neighbors :py:meth:`dhg.Hypergraph.from_feature_kNN`
+- Promoted from the low-order structures
+
+  - Simple Graph :py:meth:`dhg.Hypergraph.from_graph`
+  - k-Hop Neighbors of vertices in a simple graph :py:meth:`dhg.Hypergraph.from_graph_kHop`
+  - Bipartite Graph :py:meth:`dhg.Hypergraph.from_bigraph`
+
 
 Common Methods
 ^^^^^^^^^^^^^^^^^^^
-Comming soon
+
+**Construct a simple hypergraph from edge list with** :py:class:`dhg.Hypergraph`
+
+.. code-block:: python
+
+    >>> hg = dhg.Hypergraph(5, [(0, 1, 2), (2, 3), (0, 4)])
+    >>> hg
+    Simple Hypergraph(num_v=5, num_e=3)
+    >>> hg.e
+    ([(0, 1, 2), (2, 3), (0, 4)], [1.0, 1.0, 1.0])
+    >>> # print the incidence matrix of the simple hypergraph
+    >>> hg.H.to_dense()
+    tensor([[1., 0., 1.],
+            [1., 0., 0.],
+            [1., 1., 0.],
+            [0., 1., 0.],
+            [0., 0., 1.]])
+
+.. important:: 
+
+    Each hyperedge in the hypergraph is an unordered set of vertices, which means that ``(0, 1, 2)``, ``(0, 2, 1)``, and ``(2, 1, 0)`` are all the same hyperedge.
+
+.. code-block:: python
+
+    >>> hg = dhg.Hypergraph(5, [(0, 2, 1), (2, 3), (0, 4)])
+    >>> hg.e
+    ([(0, 1, 2), (2, 3), (0, 4)], [1.0, 1.0, 1.0])
+    >>> hg.H.to_dense()
+    tensor([[1., 0., 1.],
+            [1., 0., 0.],
+            [1., 1., 0.],
+            [0., 1., 0.],
+            [0., 0., 1.]])
+    >>> hg = dhg.Hypergraph(5, [(1, 0, 2), (2, 3), (0, 4)])
+    >>> hg.e
+    ([(0, 1, 2), (2, 3), (0, 4)], [1.0, 1.0, 1.0])
+    >>> hg.H.to_dense()
+    tensor([[1., 0., 1.],
+            [1., 0., 0.],
+            [1., 1., 0.],
+            [0., 1., 0.],
+            [0., 0., 1.]])
+
+.. note:: 
+
+    If the added hyperedges have duplicate hyperedges, those duplicate hyperedges will be automatically merged with specified ``merge_op``.
+
+.. code-block:: python
+
+    >>> hg = dhg.Hypergraph(5, [(0, 1, 2), (2, 3), (2, 3), (0, 4)], merge_op="mean")
+    >>> hg.e
+    ([(0, 1, 2), (2, 3), (0, 4)], [1.0, 1.0, 1.0])
+    >>> hg = dhg.Hypergraph(5, [(0, 1, 2), (2, 3), (2, 3), (0, 4)], merge_op="sum")
+    >>> hg.e
+    ([(0, 1, 2), (2, 3), (0, 4)], [1.0, 2.0, 1.0])
+    >>> hg.add_hyperedges([(0, 2, 1), (0, 4)], merge_op="mean")
+    >>> hg.e
+    ([(0, 1, 2), (2, 3), (0, 4)], [1.0, 2.0, 1.0])
+    >>> hg.add_hyperedges([(0, 2, 1), (0, 4)], merge_op="sum")
+    >>> hg.e
+    ([(0, 1, 2), (2, 3), (0, 4)], [2.0, 2.0, 2.0])
+
+You can find the weight of the last hyperedge is ``1.0`` and ``2.0``, if you set the ``merge_op`` to ``mean`` and ``sum``, respectively.
+
+
+**Construct a simple hypergraph from feature k-Nearest Neighbors with** :py:meth:`dhg.Hypergraph.from_feature_kNN`
+
+.. code-block:: python
+
+    >>> X = torch.tensor(([[0.6460, 0.0247],
+                           [0.9853, 0.2172],
+                           [0.7791, 0.4780],
+                           [0.0092, 0.4685],
+                           [0.9049, 0.6371]]))
+    >>> hg = dhg.Hypergraph.from_feature_kNN(X, k=2)
+    >>> hg
+    Simple Hypergraph(num_v=5, num_e=3)
+    >>> hg.e
+    ([(0, 1, 2), (1, 2, 4), (0, 2, 3)], [1.0, 1.0, 1.0])
+    >>> hg.H.to_dense()
+    tensor([[1., 0., 1.],
+            [1., 1., 0.],
+            [1., 1., 1.],
+            [0., 0., 1.],
+            [0., 1., 0.]])
+
+.. note:: 
+
+    Those duplicated hyperedges are merged with ``mean`` operation.
+
 
 Prometed from Low-Order Structures
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -1,6 +1,6 @@
 .. _zh_start_learning_on_simple_hypergraph:
 
-基于简单超图的学习
+简单超图上的表示学习
 =================================
 
 定义
 
@@ -1,4 +1,4 @@
-根据高阶关联结构学习
+高阶关联结构上的表示学习
 =====================================
 
 
 
@@ -1,7 +1,7 @@
 
 .. _zh_start_learning_on_bipartite_graph:
 
-基于二分图的学习
+二分图上的表示学习
 ==============================
 
 定义
 
@@ -1,5 +1,5 @@
 
-基于有向图的学习
+有向图上的表示学习
 =============================
 
 定义
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-根据高阶关联结构学习`
	`1`	`+高阶关联结构上的表示学习`
`2`	`2`	`=====================================`
`3`	`3`
`4`	`4`