# Exploring Cohesive Subgraphs in Hypergraphs: The $(k,g)$-core Approach

Dahee Kim<EMAIL_ADDRESS>Junghoon Kim<EMAIL_ADDRESS>Sungsu Lim
<EMAIL_ADDRESS>Hyun Ji Jeong<EMAIL_ADDRESS>Ulsan National Institute
of Science & Technology, 44191, South Korea  Chungnam National University,
34134, South Korea  Kongju National University, 31080, South Korea

###### Abstract

Identifying cohesive subgraphs in hypergraphs is a fundamental problem that
has received recent attention in data mining and engineering fields. Existing
approaches mainly focus on a strongly induced subhypergraph or edge
cardinality, overlooking the importance of the frequency of co-occurrence. In
this paper, we propose a new cohesive subgraph named $(k,g)$-core, which
considers both neighbour and co-occurrence simultaneously. The $(k,g)$-core
has various applications including recommendation system, network analysis,
and fraud detection. To the best of our knowledge, this is the first work to
combine these factors. We extend an existing efficient algorithm to find
solutions for $(k,g)$-core. Finally, we conduct extensive experimental studies
that demonstrate the efficiency and effectiveness of our proposed algorithm.

###### keywords:

Hypergraph Mining, Cohesive subgraph discovery

##  1 Introduction

Complex systems such as social networks, biological networks, and market
transaction systems are becoming increasingly intricate. The ability to
accurately model and analyse these systems is important for understanding
their behaviour and predicting their evolution. Traditional graph theory [1],
which has been widely used to represent relationships between entities in a
system, often falls short in capturing the high-order relationships in complex
systems [2]. Hypergraphs [3], which generalise traditional graph theory, offer
a more flexible framework by allowing edges to connect any number of nodes,
unlike traditional graphs where edges connect only two nodes. This
characteristic makes hypergraphs particularly suitable for capturing
multifaceted relationships and interactions in real-world networks, ranging
from social networks to biological systems and beyond.

Real-world networks exhibit complex interactions that go beyond pairwise
connections. For example, co-authorship networks [4], co-purchase networks
[5], and location-tagged social networks [6] have complex relationships that
cannot be adequately represented by traditional graphs. Hypergraphs provide
more expressive representations for such networks, enabling a deeper
understanding of underlying structures and interactions [2].

Despite the increasing popularity and wide-ranging applications of mining
hypergraphs [7], understanding their structural properties remains a
challenging task. One of the key aspects of this challenge is to find cohesive
subgraphs within a hypergraph, which are more densely connected internally
than with the rest of the graph. In general, identifying the cohesive
structure is important for understanding the overall structure and function of
the graph, as they often represent key communities or roles [8]. In addition,
it provides insights into the robustness of networks [9], aiding in network
analysis [10] and identifying influential nodes [11], and revealing query-
centric communities [12].

Table 1: Model comparison | nbr-$k$-core |  $(k,d)$-core |  $(k,q)$-core | Clique-core | $(k,g)$-core |  $(\alpha,\beta)$-core
---|---|---|---|---|---|---
objective | maximize subgraph size
1st param | strongly induced. subgraph | deg. const. | neighbour size const. | deg. const.
2nd param | - | deg. const. | cardinality const. | - | co-occur. const. | cardinality const.

Recently, several cohesive models have been proposed for hypergraphs. The
first approach involves converting the hypergraph into a clique-like graph,
then applying $k$-core algorithm [13, 14]. $k$-core is a maximal set of nodes
of which every node has at least $k$ neighbour nodes in the $k$-core. We refer
to this approach as the clique-core. Lee et al. [15] introduced the
$(k,q)$-core, a maximal subgraph in which each node has at least $k$ degree,
and each hyperedge contains at least $q$ nodes. With the similar period, the
nbr-$k$-core was proposed by Arafat et al. [13]. The nbr-$k$-core is the
maximal strongly induced connected subhypergraph [16, 17] $H$ such that every
node has at least $k$ neighbours in $H$. Note that the strongly induced
subhypergraph indicates that every node in the hyperedge belongs to the
subhypergraph if and only if all nodes of the hyperedge exist. Arafat et al.
[13] also formulated the $(k,d)$-core, a maximal strongly induced connected
subhypergraph in which every node has at least $k$ neighbours and degree
(number of hyperedges incident on a node) is greater than or equal to $d$ in
strongly induced subhypergraph.

While these proposed models have proven useful, they may not capture all
aspects of cohesion in hypergraphs. Especially, hyperedges in hypergraphs have
some distinct characteristics: (1) hyperedge nesting: Hyperedges often nest,
with one’s vertex set being a subset of another’s, representing hierarchical
or containment relationships. For instance, in biological networks, smaller
modules may nest within larger ones, and in transaction networks, certain
products may repeatedly co-occur in transactions; (2) nodes belong to multiple
hyperedges: Nodes can engage in multiple relationships, each depicted by a
hyperedge. In social networks, an individual may be associated with different
communities or groups through distinct hyperedges.

However, existing models do not mainly consider these characteristics when
designing cohesive subgraph models. To effectively address the above issues,
we incorporate the frequency of co-occurrence of nodes within hyperedges,
which can be a crucial aspect of cohesion in many systems. Taking into account
the frequency with which entities co-occur has proven to be effective in
domains [18] such as recommendation systems. This is particularly effective in
the context of user-based collaborative filtering [19, 20]. In user-based
collaborative filtering, it is important to find users who have similar
preferences or tastes to a given user. This is because fundamental principle
of user-based collaborative filtering is to recommend items based on the
choices of similar users. Cohesive subgraphs of hypergraphs based on the
frequency of co-occurrence among users help to define target similar users for
capturing collaborative signals.

Therefore, we propose a new concept $(k,g)$-core by extending traditional
$k$-core [14] by incorporating the occurrence of the cohesive subgraphs. The
$(k,g)$-core is a maximal subgraph in which each node has at least $k$
neighbours which appear in at least $g$ hyperedges together in the
$(k,g)$-core. Note that $(k,g)$-core can be solved by converting a clique-
based graph. However, it is not desired since this step inflates the size of
the problem [21]. In the following, we point out the motivating applications
of the $(k,g)$-core.

Applications. (1) Fraudster Detection: Within a social commerce service, user
purchasing data can be organised into a hypergraph, where edges represent
groups of items bought by users. Fraudsters often exhibit similar behaviours
and have connections through shared product purchases [22]. For example, a
seller may recruit individuals to inflate review ratings for their mobile
devices, resulting in fraudulent activity. By identifying shared
characteristics among users, it becomes possible to cluster these fraudsters
within the hypergraph network; (2) Biomedical Systems: The $(k,g)$-core model
finds extensive application in modeling biological systems, such as protein-
protein interaction networks and gene regulatory networks [23]. Leveraging
this model helps to identify highly interconnected substructures within these
networks, revealing crucial protein complexes or functional modules that play
key roles in biological processes; and (3) Recommendation Systems: The
$(k,g)$-core model offers valuable insights in recommendation systems by
finding user clusters with similar preferences. By detecting $(k,g)$-core
subgraphs in the hypergraph representing user-item interactions, personalised
recommendations can be generated, capitalising on the co-occurrence patterns
of items within these subgraphs.

##  2 RELATED WORK

The study of hypergraphs has seen a surge of interest in recent years, with
numerous methods proposed based on different criteria [24, 25]. In this
section, we review the most relevant previous study.

$(k,q)$-core [15]. One of the models for finding cohesive subgraphs by
considering hyperedges and nodes together in hypergraphs is the $(k,q)$-core,
proposed by Lee et al. This model defines a $(k,q)$-core as the largest
subgraph in which each node has at least $k$ degree, and each hyperedge
contains at least $q$ nodes. Even if this model has various applications,
providing valuable insights into the structure of hypergraphs, it does not
consider the frequency of co-occurrence of nodes within hyperedges, which can
be a crucial aspect of cohesion in many systems.

nbr-$k$-core [13]. nbr-$k$-core is proposed by Arafat et al. It is the maximal
strongly induced subhypergraph [16, 17] such that every node has at least $k$
neighbours. The concept strongly induced subhypergraph implies that for each
node within a hyperedge, it must be included in the subhypergraph if and only
if all other nodes within the same hyperedge are also present. Note that
utilising a strongly induced subhypergraph may have some issues. A hyperedge
can be present in its entirety or not at all in a subhypergraph due to its
definition. When a node is included in a large hyperedge, a size of the
strongly induced subhypergraph can be very large, leading to difficulties in
analysing an extracting meaningful information.

$(k,d)$-core [13]. Arafat et al. [13] observed the problem that the
nbr-$k$-core usually return a very large cohesive subgraph as a result if it
is included in a large-sized hyperedge. To address this issue, they proposed a
more comprehensive cohesive subgraph model, $(k,d)$-core, by considering
neighbourhood and degree constraints simultaneously. The $(k,d)$-core is
defined the maximal subhypergraph in which every node has at least $k$
neighbours and degree of every node is at least $d$ in strongly induced
subhypergraph. However, this approach could not capture the strength of the
neighbours due to the lack of consideration for co-occurrence.

Clique-core [26]. The Clique-core is the same with traditional $k$-core by
converting a hypergraph as clique-structured graph. After preprocessing, it
aims to find a maximal set of nodes of which every node has at least $k$
neighbour nodes in the clique graph. This clique-based approach is known as
inflating the problem-size [21].

$(\alpha,\beta)$-core [27]. The $(\alpha,\beta)$-core is another model widely
used in the study of bipartite networks. It aims to find a set of nodes in the
bipartite graph where each side has at least $\alpha$ and $\beta$ bipartite
edges, respectively. A hypergraph can be converted to a bipartite graph that
consists of nodes as the first set of nodes, and the hyperedge as other node
set and creates an edge between two node sets if the hyperedge in the second
set involves a node in the first set. While this model has proven useful in
bipartite networks, it cannot be directly utilised to find cohesive subgraphs
in hypergraphs due to the lack of neighbour structure information. In
addition, constructing a bipartite graph may suffer from size inflating
problem [21].

##  3 PROBLEM STATEMENT

A hypergraph network can be modelled as a graph $G=(V,E)$ with nodes $V$ and
edges $E$. Following previous studies [13, 15], we consider that $G$ is
undirected and unweighted. In hypergraph notation, we use the term degree to
represent the count of hyperedges incident to a particular node. Moreover, we
employ the term neighbour to refer to any two nodes that appear together in a
hyperedge.

######  Definition 1.

($(k,g)$-core). Given a hypergraph $G$, $k\geq 1$ and $g\geq 1$, $(k,g)$-core
is the maximal set of nodes in which each node has at least $k$ neighbours
which appear in at least $g$ hyperedges together in an induced subhypergraph
by the $(k,g)$-core.

We next discuss two essential properties of $(k,g)$-core: uniqueness and
containment. These properties are fundamental for understanding the behaviour
and structure of the $(k,g)$-core.

Figure 1: Motivating example

######  Property 1.

Uniqueness: $(k,g)$-core is unique.

###### Proof.

$(k,g)$-core is unique due to the maximality constraint, as it represents the
maximal set of nodes in which all nodes have at least $k$ neighbours which
appear in at least $g$ hyperedges, achieved by iteratively removing nodes
until satisfying the constraints. ∎

######  Property 2.

Containment: $(k,g)$-core has hierarchical structure, i.e., $(k+1,g)$-core
$\subseteq$ $(k,g)$-core and $(k,g+1)$-core $\subseteq$ $(k,g)$-core.

###### Proof.

The hierarchy structure of the $(k,g)$-core is a result of a gradual node
removal process, ensuring that if a node belongs to the $(k,g)$-core, it also
belongs to all higher-order cores due to the cumulative neighbour and co-
occurrence constraints. satisfied by the remaining nodes. ∎

######  Example 1.

Let us consider an example using a simple hypergraph with $9$ nodes and $7$
hyperedges, as illustrated in Figure 1. This example demonstrates the distinct
results and characteristics of different cohesive subgraph models.

  * •

The $(k,q)$-core yields $\\{u_{1},u_{2},u_{3},u_{4},u_{7},u_{8}\\}$ with $k=2$
and $q=2$. This is because the nodes $u_{5}$, $u_{6}$, and $u_{9}$ are
iteratively removed due to the degree constraint. The remaining graph then
satisfies the $(k,q)$-core constraint.

  * •

The nbr-$k$-core returns the entire graph when $k$=2, and $\\{u_{2},u_{3},$
$u_{5},u_{6}\\}$ when $k$=3 since there are hyperedges involving only
$u_{2}$,$u_{3}$,$u_{5}$ and $u_{6}$, every node has 3 neighbours.

  * •

The $(k,d)$-core returns the entire graph for $k=2$ and $d=1$,
$\\{u_{2},u_{3},u_{5},u_{6}\\}$ for $k=3$ and $d=1$. When $k=2$ and $d=2$, it
returns an empty set. We can observe that $u_{1},u_{2},u_{3},u_{4},u_{7},$ and
$u_{8}$ have two or more neighbours and belong to at least two hyperedges.
Note that the $(k,d)$-core is a strongly induced subhypergraph. Thus,
hyperedges such as $\\{u_{1},u_{3},u_{9}\\}$ and
$\\{u_{2},u_{3},u_{5},u_{6}\\}$ are not considered. Therefore, the node
$u_{3}$ must be removed. This removal process is repeated iteratively until no
nodes remain in the resulting graph.

  * •

Clique-core returns the entire graph for $k=2$, and returns
$\\{u_{2},u_{3},u_{5}$ $,u_{6}\\}$ for $k=3$ due to the neighbour constraint.

  * •

The $(\alpha,\beta)$-core returns $\\{u_{1},u_{2},u_{3},u_{4},u_{7},u_{8}\\}$
for $\alpha=2$ and $\beta=2$. Since every node is included in at least $2$
hyperedge, and a hyperedge has at least two nodes, $u_{5}$, $u_{6}$ and
$u_{9}$ cannot be included because they belong to only a single hyperedge.

  * •

Lastly, the $(k,g)$-core gives $\\{u_{1},u_{2},u_{3}\\}$ for $k=2$ and $g=2$.
In this case, each node has at least $k$ neighbours and each node pair appears
in at least $g$ edges together, signifying a cohesive structure within the
hypergraph.

Input: Hypergraph $G=(V,E)$, parameters $k$ and $g$

Output: The $(k,g)$-core of $G$

$H\leftarrow V$ ;

// Initialise $H$ as the set of all nodes

1 Initialise neighbour occur. map $NOM$;

2 foreach  _$v\in H$_ do

3 foreach  _hyperedge $e$ that contains $v$_ do

4 foreach  _$u\in e$_ do

5 if  _$u\neq v$_ then

6 Increment the occur. count of $u$ in $NOM[v]$;

7Keep neighbours in $NOM[v]$ for each $v\in V$ where the occur. count is $\geq
g$;

8 $changed\leftarrow\text{True}$;

9 while  _$changed$_ do

10 $changed\leftarrow\text{False}$;

11 for  _$w\in H$_ do

12 if  _$|NOM[w]| <k$_ then

13 $H\leftarrow H\setminus\\{w\\}$;

14 Update the occur. map;

15 $changed\leftarrow\text{True}$;

16

return _$H$_

Algorithm 1 Peeling Algorithm for $(k,g)$-core

##  4 PEELING ALGORITHM

In this section, we present the peeling algorithm to find $(k,g)$-core. We
extend the existing peeling algorithm for the $k$-core computation [28].
Basically, it iteratively removes a set of nodes until satisfying the
cohesiveness constraint. For each iteration, it finds nodes which do not
satisfy the $(k,g)$-core criteria, and removes them from the hypergraph. The
algorithm continues until no more nodes can be removed. Finally, the remaining
subgraph can be the $(k,g)$-core.

The pseudo description of the algorithm can be checked in Algorithm 1. It
starts by initialising $H$ as the set of all nodes in the hypergraph. It then
initialises the neighbour occurrence map, $NOM$, for each node in $V$ with an
empty dictionary data structure. The algorithm iterates over each node in $H$
and counts the occurrences of its neighbours on the hyperedges. After that, it
keeps only the neighbours in $NOM[v]$ for each node $v$ where the occurrence
count is $\geq g$. The algorithm proceeds in a loop that continues until no
more changes are made. Within the loop, it iterates over each node $w$ in $H$.
If $NOM[w]$ does not contain at least $k$ nodes, indicating that node $w$ does
not satisfy the $(k,g)$-core criteria, it is removed from $H$, and the
occurrence map is updated accordingly. This process continues until no more
nodes can be removed. Finally, it returns the nodes $H$ as a result.

This peeling method is efficient to find the $(k,g)$-core in a hypergraph. The
time complexity of the peeling algorithm is $O(|V|^{2}|E|)$. In the worst-
case, the algorithm iterates over each node and its corresponding hyperedges
to construct the occurrence map. As each hyperedge can contain up to $|V|$
nodes, constructing the occurrence map for each node takes $O(|V||E|)$ time,
resulting in a time complexity of $O(|V|^{2}|E|)$ for this step. During the
iterative removal procedure, the algorithm performs a maximum of $|V|$
iterations, and each removal operation has a time complexity of $O(|V|)$. As a
result, the overall time complexity is $O(|V|^{2}|E|)$. However, it’s
important to note that the algorithm may terminate earlier as nodes can be
removed together.

##  5 EXPERIMENTS

To validate effectiveness of the proposed $(k,g)$-core and efficiency of the
peeling algorithm, we conducted extensive experiments on real-world
hypergraphs.

Experimental setup. We implemented the $(k,g)$-core model in Python using the
NetworkX library [29]. The experiments were run on a Linux machine with Intel
Xeon 6248R and 256GB of RAM.

Table 2: Real-world dataset Dataset | $|V|$ | $|E|$ | Avg. nbr size | Avg. edge card.
---|---|---|---|---
Contact | 242 | 12,704 | 68.74 | 2.42
Congress | 1,718 | 83,105 | 494.68 | 8.81
Enron | 4,423 | 5,734 | 25.35 | 5.25
Meetup | 24,115 | 11,027 | 65.27 | 10.3
DBLP | 1,836,596 | 2,170,260 | 9.05 | 3.43
Aminer | 27,850,748 | 17,120,546 | 8.39 | 3.77

Dataset. Table 2 provides the essential statistics of six real-world datasets.
These datasets are publicly available and can be accessed from the sources
mentioned in the references [13, 30]. In the table, the term ‘nbr’ denotes a
neighbour, and ‘card’ indicates cardinality.

Evaluation measure. We evaluated the performance of the $(k,g)$-core model by
checking the number of nodes and the running time.

(a) Fixing $k=3$

(b) Fixing $g=3$

Figure 2: Comparison of number of nodes

Performance of $(k,g)$-core. We varied the user parameters to analyse the
behaviour of the $(k,g)$-core. In Figure 2(a), we fix the value $k$ as $3$ and
vary $g$ as $3$, $5$, $7$, and $9$. The experimental results report the number
of nodes in the $(k,g)$-core for each $g$ value. The results show that an
increase in the value of $g$ also leads to a decrease in the number of nodes
within the $(k,g)$-core. Similarly, in Figure 2(b), the value of $g$ is fixed
as $3$, while $k$ is varied as $3$, $5$, $7$, and $9$. It is observed that
when $k$ increases, the number of nodes in the $(k,g)$-core decreases. Both
results indicate that a higher value of $k$ and $g$ results in more densely
connected.

(a) Fixing $k=3$

(b) Fixing $g=3$

Figure 3: Comparison of running time

Next, we focus on analysing the running time of the algorithm while keeping
the parameters fixed. Figure 3 presents the results obtained by varying the
values of $k$ and $g$. The experimental results indicate that increasing $k$
and $g$ does not have a significant impact on the running time. This implies
that the running time of the $(k,g)$-core is not primarily determined by the
user-defined parameters $k$ and $g$. Instead, the majority of the
computational complexity arises from calculating the occurrence of the
neighbours as we have discussed in Section 4.

Figure 4: Scalability test

Scalability test. To evaluate scalability of the algorithm, we conducted a
scalability test using $k$-uniform hypergraph generation models [31]. With a
fixed value of $k$ ($100$) and a set number of nodes ($10,000$), we varied the
number of hyperedges from 4,000 to $20,000$ to observe the impact on running
time. By converting the hypergraph into a bipartite network, we obtained a
bipartite graph with $30,000$ nodes and $2$ million bipartite edges when the
number of hyperedges was $20,000$. Figure 4 shows the experimental result. It
reveals a linear increase in running time when the number of hyperedges
increases, indicating that the algorithm scales efficiently with larger
hypergraphs. This scalability test demonstrates the algorithm’s capability to
handle large-sized hypergraphs.

##  6 CONCLUSION

In this paper, we introduce the $(k,g)$-core model for cohesive subgraph
discovery in hypergraphs, an extension of the existing $k$-core model that
takes into account node co-occurrence within hyperedges. We also propose a
peeling algorithm that effectively identifies the $(k,g)$-core by iteratively
removing nodes that do not satisfy the specified criteria. Experimental
evaluations on six real-world networks demonstrate the characteristics of
proposed $(k,g)$-core. In future work, we plan to recommend appropriate values
for $k$ and $g$ to identify meaningful cohesive subgraphs, thereby eliminating
the need for user-specified parameters.

## References

  * [1] D. B. West, et al., Introduction to graph theory, Vol. 2, Prentice hall Upper Saddle River, 2001.
  * [2] C. Berge, Hypergraphs: combinatorics of finite sets, Vol. 45, Elsevier, 1984.
  * [3] A. Bretto, Hypergraph theory, An introduction. Mathematical Engineering. Cham: Springer (2013).
  * [4] R. I. Lung, N. Gaskó, M. A. Suciu, A hypergraph model for representing scientific output, Scientometrics 117 (2018) 1361–1379.
  * [5] X. Xia, H. Yin, J. Yu, Q. Wang, L. Cui, X. Zhang, Self-supervised hypergraph convolutional networks for session-based recommendation, in: Proceedings of the AAAI conference on artificial intelligence, Vol. 35, 2021, pp. 4503–4511.
  * [6] T. Kumar, K. Darwin, S. Parthasarathy, B. Ravindran, Hpra: Hyperedge prediction using resource allocation, in: 12th ACM conference on web science, 2020, pp. 135–143.
  * [7] G. Lee, J. Yoo, K. Shin, Mining of real-world hypergraphs: Patterns, tools, and generators, in: Proceedings of the 31st ACM International Conference on Information & Knowledge Management, 2022, pp. 5144–5147.
  * [8] F. D. Malliaros, C. Giatsidis, A. N. Papadopoulos, M. Vazirgiannis, The core decomposition of networks: Theory, algorithms and applications, The VLDB Journal 29 (2020) 61–92.
  * [9] C. Giatsidis, D. M. Thilikos, M. Vazirgiannis, Evaluating cooperation in communities with the k-core structure, in: 2011 International conference on advances in social networks analysis and mining, IEEE, 2011, pp. 87–93.
  * [10] A. Adiga, A. K. S. Vullikanti, How robust is the core of a network?, in: Machine Learning and Knowledge Discovery in Databases: European Conference, ECML PKDD 2013, Prague, Czech Republic, September 23-27, 2013, Proceedings, Part I 13, Springer, 2013, pp. 541–556.
  * [11] M. Kitsak, L. K. Gallos, S. Havlin, F. Liljeros, L. Muchnik, H. E. Stanley, H. A. Makse, Identification of influential spreaders in complex networks, Nature physics 6 (11) (2010) 888–893.
  * [12] Y. Fang, X. Huang, L. Qin, Y. Zhang, W. Zhang, R. Cheng, X. Lin, A survey of community search over big graphs, The VLDB Journal 29 (2020) 353–392.
  * [13] N. A. Arafat, A. Khan, A. K. Rai, B. Ghosh, Neighborhood-based hypergraph core decomposition, Proceedings of the VLDB Endowment 16 (9) (2023) 2061–2074.
  * [14] S. B. Seidman, Network structure and minimum degree, Social networks 5 (3) (1983) 269–287.
  * [15] J. Lee, K.-I. Goh, D.-S. Lee, B. Kahng, (k,q)-core decomposition of hypergraphs, Chaos, Solitons & Fractals 173 (2023) 113645.
  * [16] M. A. Bahmanian, M. Sajna, Connection and separation in hypergraphs, Theory and Applications of Graphs 2 (2) (2015) 5.
  * [17] R. Graham, M. Grötschel, L. Lovász, Handbook of combinatorics (vol. 2) (1996).
  * [18] J. Kim, S. Lim, J. Kim, Ocsm: Finding overlapping cohesive subgraphs with minimum degree, Information Sciences 607 (2022) 585–602.
  * [19] J. S. Breese, D. Heckerman, C. Kadie, Empirical analysis of predictive algorithms for collaborative filtering, arXiv preprint arXiv:1301.7363 (2013).
  * [20] J. Yu, H. Yin, J. Li, Q. Wang, N. Q. V. Hung, X. Zhang, Self-supervised multi-channel hypergraph convolutional network for social recommendation, in: Proceedings of the Web Conference 2021, WWW ’21, Association for Computing Machinery, New York, NY, USA, 2021, p. 413–424.  doi:10.1145/3442381.3449844.
URL https://doi.org/10.1145/3442381.3449844

  * [21] J. Huang, R. Zhang, J. X. Yu, Scalable hypergraph learning and processing, in: 2015 IEEE International Conference on Data Mining, IEEE, 2015, pp. 775–780.
  * [22] J. Kim, K. Feng, G. Cong, D. Zhu, W. Yu, C. Miao, Abc: attributed bipartite co-clustering, Proceedings of the VLDB Endowment 15 (10) (2022) 2134–2147.
  * [23] S. Feng, E. Heath, B. Jefferson, C. Joslyn, H. Kvinge, H. D. Mitchell, B. Praggastis, A. J. Eisfeld, A. C. Sims, L. B. Thackray, et al., Hypergraph models of biological networks to identify genes critical to pathogenic viral response, BMC bioinformatics 22 (1) (2021) 1–21.
  * [24] Q. Luo, D. Yu, Z. Cai, X. Lin, X. Cheng, Hypercore maintenance in dynamic hypergraphs, in: 2021 IEEE 37th International Conference on Data Engineering (ICDE), IEEE, 2021, pp. 2051–2056.
  * [25] X. Wang, Y. Chen, Z. Zhang, P. Qiao, G. Wang, Efficient truss computation for large hypergraphs, in: Web Information Systems Engineering–WISE 2022: 23rd International Conference, Biarritz, France, November 1–3, 2022, Proceedings, Springer, 2022, pp. 290–305.
  * [26] V. Batagelj, M. Zaveršnik, Fast algorithms for determining (generalized) core groups in social networks, Advances in Data Analysis and Classification 5 (2) (2011) 129–145.
  * [27] D. Ding, H. Li, Z. Huang, N. Mamoulis, Efficient fault-tolerant group recommendation using alpha-beta-core, in: Proceedings of the 2017 ACM on Conference on Information and Knowledge Management, 2017, pp. 2047–2050.
  * [28] V. Batagelj, M. Zaversnik, An o (m) algorithm for cores decomposition of networks, arXiv preprint cs/0310049 (2003).
  * [29] A. Hagberg, P. Swart, D. S Chult, Exploring network structure, dynamics, and function using networkx, Tech. rep., Los Alamos National Lab.(LANL), Los Alamos, NM (United States) (2008).
  * [30] A. R. Benson, R. Abebe, M. T. Schaub, A. Jadbabaie, J. Kleinberg, Simplicial closure and higher-order link prediction, Proceedings of the National Academy of Sciences 115 (48) (2018) E11221–E11230.
  * [31] Y. Feng, H. You, Z. Zhang, R. Ji, Y. Gao, Hypergraph neural networks, in: Proceedings of the AAAI conference on artificial intelligence, Vol. 33, 2019, pp. 3558–3565.