Fundamental Computational Problems and Algorithms for SuperHyperGraphs

Fundamental Computational Problems and Algorithms for SuperHyperGraphs, pp.
240-272, in Takaaki Fujita, Florentin Smarandache:

Advancing Uncertain Combinatorics through Graphization, Hyperization, and Uncertainization: Fuzzy, Neutrosophic, Soft, Rough, and Beyond.
Second volume. Gallup, NM, United States of America – Guayaquil (Ecuador): NSIA Publishing House, 2024, 518 p.
Fundamental Computational Problems and Algorithms for

SuperHyperGraphs
Takaaki Fujita 1 ∗, Florentin Smarandache2
1 Independent Researcher, Shinjuku, Shinjuku-ku, Tokyo, Japan.
2 University of New Mexico, Gallup Campus, NM 87301, USA.
Corresponding Emails: t171d603@gunma-u.ac.jp
Abstract
Hypergraphs extend traditional graphs by allowing edges (known as hyperedges) to connect more than
two vertices, rather than just pairs. This paper explores fundamental problems and algorithms in the
context of SuperHypergraphs, an advanced extension of hypergraphs enabling modeling of hierarchical
and complex relationships. Topics covered include constructing SuperHyperGraphs, recognizing
SuperHyperTrees, and computing SuperHyperTree-width. We address a range of optimization problems,
such as the SuperHy-pergraph Partition Problem, Reachability, Minimum Spanning SuperHypertree, and
Single-Source Shortest Path. Furthermore, adaptations of classical problems like the Traveling Salesman
Problem, Chinese Postman Problem, and Longest Simple Path Problem are presented in the SuperHypergraph
framework.
Keywords: Superhypergraph, Hypergraph, Tree-width, Algorithm
MSC 2010 classifications: 05C65 - Hypergraphs, 68R10 - Graph theory in computer science
1 Introduction
1.1 Graphs and Hypergraphs
Graph theory serves as a foundational framework for analyzing networks, consisting of nodes (vertices) and
their connections (edges). It provides valuable insights into the structure, connectivity, and properties of diverse
networks [28].
Hypergraphs extend traditional graphs by allowing edges (known as hyperedges) to connect more than
two vertices, rather than just pairs. These generalized structures have gained significant attention due to their
broad applications in graph theory, computer science, and related fields [6, 21, 32, 49, 58, 116]. Further
extending hypergraphs, SuperHypergraphs introduce even greater flexibility and are a topic of emerging
interest in recent studies [105,106]. A SuperHypergraph generalizes hypergraphs, allowing vertices and
hyperedges to represent sets or subsets, enabling modeling of hierarchical and complex relationships.
In the context of graphs, hypergraphs, and superhypergraphs, tree structures have been extensively studied.
For instance, Hypertrees have been explored in hypergraphs [54], while SuperHypertrees have been
investigated in superhypergraphs [51]. The concept of tree structures is widely adopted due to their
simplicity and efficiency in applications. Beyond graph-related concepts, tree structures have been applied
in various fields, including Tree Automata [17,23], TreeSoft sets [9,41,109], and Decision Trees [19,20],
contributing to ongoing research and advancements in these areas.
1.2 Graph Width Parameters
Graph characteristics are often analyzed using various parameters, with significant research devoted to un-
derstanding these measures. Among these, graph width parameters such as tree-width [14–16, 90, 91, 96] are
particularly prominent. These parameters evaluate how closely a graph approximates a tree structure, which is
essential for many practical applications.
For hypergraphs, analogous parameters like Hypertree-width [3,53,55,75,121] and Hyperpath-width [2,78,83]
have been developed. These metrics measure the resemblance of a hypergraph to a tree or a path, addressing
the need to extend tree-based analyses to more complex structures.
240
1.3 Computational Complexity
An algorithm is a finite sequence of well-defined instructions intended to solve a specific problem or perform a
computation [31]. The time and space complexities of the algorithm are often subjects of analysis. Computa-
tional complexity evaluates the resources, such as time and space, required by an algorithm to solve a problem
as a function of input size, offering theoretical efficiency bounds [1, 10, 61, 85].
Algorithms in graph theory are referred to as graph algorithms [31]. For graphs and hypergraphs, numerous
problems and algorithms have been studied, with research also exploring real-world applications (e.g. [46, 64,
82]).
1.4 Contributions of This Paper
Research on problems and algorithms related to SuperHypergraphs remains limited. Therefore, this paper
investigates various fundamental problems in SuperHypergraphs and proposes algorithms to address them.
• Exact Construction of SuperHyperGraph: Develops an algorithm to construct a SuperHyperGraph from

a given vertex and edge set.
• Recognizing a SuperHyperTree: Provides an algorithm to determine if a given structure is a valid
SuperHyperTree.
• Computation of SuperHyperTree-width:
– Exact Algorithm: Defines an exact algorithm to compute the SuperHyperTree-width of a superhy-
pergraph.
– Approximation Algorithm: Proposes an approximation algorithm for computationally efficient
SuperHyperTree-width calculation.
• Superhypergraph Partition Problem: Studies methods to partition a SuperHyperGraph into disjoint
subsets while minimizing inter-partition connections.
• Reachability Problem in SuperHypergraphs: Explores algorithms to verify if a path exists between two
vertices in a SuperHyperGraph.
• Minimum Spanning SuperHypertree Problem: Presents a method to compute a SuperHypertree with the
minimum total edge weight.
• Single-Source Shortest Path Problem in a SuperHypergraph: Develops an algorithm to find shortest
paths from a single source vertex in a SuperHyperGraph.
• Traveling Salesman Problem in a SuperHypergraph: Examines the adaptation of TSP to SuperHyper-
Graphs, finding the minimum tour covering all vertices.
• Chinese Postman Problem (CPP) in SuperHypergraphs: Analyzes how to find an Eulerian circuit in
SuperHyperGraphs under given conditions.
• Longest Simple Path Problem in SuperHypergraphs: Studies methods to identify the longest acyclic path
in a SuperHyperGraph.
• Maximum Spanning Tree Problem in SuperHypergraphs: Proposes algorithms to compute a SuperHy-

pertree with the maximum total edge weight.
• Horn Satisfiability Problem in a SuperHypergraph: Extends the Horn Satisfiability Problem to Super-
HyperGraphs with adapted algorithms and proofs.
1.5 The Structure of the Paper
The structure of this paper is as follows.
241
1 Introduction 1
1.1 Graphs and Hypergraphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Graph Width Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Computational Complexity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Contributions of This Paper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.5 The Structure of the Paper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 Preliminaries and Definitions 3
2.1 Graphs and Hypergraphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Tree-width and Hypertree-width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 SuperHyperGraph and Superhypertree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 SuperHyperTree-width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5 Basic Definition of Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3 Results in this Paper 10
3.1 Exact Construct SuperHyperGraph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.2 Algorithm: Recognizing a SuperHyperTree . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.3 Computation of SuperHyperTree-width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3.1 Exact Algorithm for Computation of SuperHyperTree-width . . . . . . . . . . . . . . 13
3.3.2 Approximation Algorithm for SuperHyperTree-width . . . . . . . . . . . . . . . . . . 14
3.4 Superhypergraph Partition Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.5 Reachability Problem in Superhypergraph . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.6 Minimum Spanning SuperHypertree Problem . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.7 Single-Source Shortest Path Problem in a SuperHypergraph . . . . . . . . . . . . . . . . . . . 21
3.8 Traveling Salesman Problem in a SuperHypergraph . . . . . . . . . . . . . . . . . . . . . . . 22
3.9 Chinese Postman Problem (CPP) in superhypergraph . . . . . . . . . . . . . . . . . . . . . . 23
3.10 Longest Simple Path Problem in SuperHypergraphs . . . . . . . . . . . . . . . . . . . . . . . 24
3.11 Maximum Spanning Tree Problem in SuperHypergraphs . . . . . . . . . . . . . . . . . . . . 25
3.12 Horn satisfiability problem in a Superhypergraph . . . . . . . . . . . . . . . . . . . . . . . . 26
4 Future Tasks of This Research 27
2 Preliminaries and Definitions
In this section, we provide the preliminaries and definitions. Readers seeking foundational concepts and
notations in graph theory are encouraged to consult standard texts, surveys, or lecture notes, such as [26–28,119].
This work also utilizes basic principles from set theory, for which references like [35, 62, 66, 67, 72] are
recommended. For detailed discussions on specific operations and related topics addressed in this paper,
readers may refer to the respective references for additional insights.
2.1 Graphs and Hypergraphs
Graph theory provides a fundamental framework for analyzing networks, which are composed of nodes
(vertices) and their connections (edges). A hypergraph extends the traditional graph concept by allowing
hyperedges, which can connect multiple vertices rather than just pairs, enabling the representation of more
complex relationships between elements [11–13, 54–56]. The basic definitions of graphs and hypergraphs are
presented below.
Definition 2.1 (Graph). [28] A graph 𝐺 is a mathematical structure consisting of a set of vertices 𝑉 (𝐺) and
a set of edges 𝐸 (𝐺) that connect pairs of vertices, representing relationships or connections between them.
Formally, a graph is defined as 𝐺 = (𝑉, 𝐸), where 𝑉 is the vertex set and 𝐸 is the edge set.
Definition 2.2 (Subgraph). [28] Let 𝐺 = (𝑉, 𝐸) be a graph. A subgraph 𝐻 = (𝑉𝐻 , 𝐸 𝐻 ) of 𝐺 is a graph such
that:
• 𝑉𝐻 ⊆ 𝑉, i.e., the vertex set of 𝐻 is a subset of the vertex set of 𝐺.
• 𝐸 𝐻 ⊆ 𝐸, i.e., the edge set of 𝐻 is a subset of the edge set of 𝐺.

• Each edge in 𝐸 𝐻 connects vertices in 𝑉𝐻 .
242
Definition 2.3 (Tree in a Graph). Let 𝐺 = (𝑉, 𝐸) be an undirected graph, where 𝑉 is the set of vertices and 𝐸
is the set of edges. A subgraph 𝑇 = (𝑉𝑇 , 𝐸𝑇 ) of 𝐺 is called a tree if it satisfies the following conditions:
1. Acyclicity: 𝑇 does not contain any cycles. Formally, for any subset of edges 𝐸 ′ ⊆ 𝐸𝑇 , the graph (𝑉𝑇 , 𝐸 ′ )
does not contain a closed path.
2. Connectivity: For every pair of vertices 𝑢, 𝑣 ∈ 𝑉𝑇 , there exists a unique path in 𝑇 connecting 𝑢 and 𝑣.
3. Minimality: 𝑇 contains exactly |𝑉𝑇 | − 1 edges, where |𝑉𝑇 | is the number of vertices in 𝑇.
Definition 2.4 (Path in a Graph). Let 𝐺 = (𝑉, 𝐸) be an undirected graph, where 𝑉 is the set of vertices and 𝐸
is the set of edges. A path in 𝐺 is a sequence of vertices 𝑃 = (𝑣 1 , 𝑣 2 , . . . , 𝑣 𝑘 ) such that:
1. For every 𝑖 = 1, 2, . . . , 𝑘 − 1, (𝑣 𝑖 , 𝑣 𝑖+1 ) ∈ 𝐸, i.e., there is an edge connecting consecutive vertices in the
sequence.
2. All vertices 𝑣 1 , 𝑣 2 , . . . , 𝑣 𝑘 are distinct, ensuring that the path does not revisit any vertex (a simple path).
The length of the path is the number of edges in the sequence, which is 𝑘 − 1.
Definition 2.5 (Eulerian circuit). An Eulerian circuit is a closed path in a graph that traverses every edge
exactly once, starting and ending at the same vertex.
Definition 2.6 (Hypergraph). [13] A hypergraph 𝐻 = (𝑉, 𝐸) is a generalization of a graph, consisting of:
• A set 𝑉, called the vertex set, where each element 𝑣 ∈ 𝑉 represents a vertex.
• A set 𝐸, called the hyperedge set, where each element 𝑒 ∈ 𝐸 is a subset of 𝑉, representing a hyperedge.
Thus, 𝑒 ⊆ 𝑉.
Key properties of a hypergraph:
• The hyperedge set 𝐸 is a subset of the power set of 𝑉, i.e., 𝐸 ⊆ P (𝑉), where P (𝑉) denotes the collection
of all subsets of 𝑉.
• Unlike standard graphs where edges connect exactly two vertices, in a hypergraph, a hyperedge can
connect any number of vertices, including just one vertex or the entire vertex set.
Example 2.7. For example, given a vertex set 𝑉 = {𝑣 1 , 𝑣 2 , 𝑣 3 , 𝑣 4 }, a hypergraph can have hyperedges such as:
𝐸 = {{𝑣 1 , 𝑣 2 }, {𝑣 3 }, {𝑣 1 , 𝑣 3 , 𝑣 4 }}.
Here, the hyperedge {𝑣 1 , 𝑣 3 , 𝑣 4 } connects three vertices simultaneously, illustrating the generality of hyperedges.
Definition 2.8 (Hypertree). [55] A hypertree is a hypergraph 𝐻 = (𝑉, 𝐸) with the following properties:
1. Tree-like Structure: There exists a tree 𝑇 = (𝑉𝑇 , 𝐸𝑇 ), called the host tree, such that:
• Each vertex 𝑡 ∈ 𝑉𝑇 is associated with a bag 𝐵𝑡 ⊆ 𝑉, where 𝐵𝑡 is a subset of the vertices of 𝐻.
• Each hyperedge 𝑒 ∈ 𝐸 of the hypergraph is a subset of at least one bag 𝐵𝑡 , i.e., ∃𝑡 ∈ 𝑉𝑇 such that
𝑒 ⊆ 𝐵𝑡 .
2. Connectivity Condition: For any vertex 𝑣 ∈ 𝑉, the set of nodes 𝑡 ∈ 𝑉𝑇 where 𝑣 ∈ 𝐵𝑡 forms a connected
subtree of 𝑇. This ensures that each vertex in 𝐻 is consistently represented across the tree structure.
3. Acyclicity Condition: The host tree 𝑇 must be acyclic, maintaining the tree-like structure of the decom-
position.
243
Definition 2.9 (Hyperpath in a Hypergraph). ( [22, 70, 74]) Let 𝐻 = (𝑉, 𝐸) be a hypergraph, where 𝑉 is the
set of vertices and 𝐸 ⊆ P (𝑉) is the set of hyperedges. A hyperpath 𝑃 in 𝐻 connecting two vertices 𝑢, 𝑣 ∈ 𝑉 is
a sequence of hyperedges:
𝑃 = (𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ) with 𝑒 𝑖 ∈ 𝐸 for 𝑖 = 1, . . . , 𝑘,
satisfying the following conditions:
• Adjacency Condition: For all 1 ≤ 𝑖 ≤ 𝑘 − 1, 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅, i.e., consecutive hyperedges share at least
one common vertex.
• Endpoint Condition: 𝑢 ∈ 𝑒 1 and 𝑣 ∈ 𝑒 𝑘 .

• Acyclic Condition:
Ð𝑘 The sequence does not form a cycle, meaning the set of vertices visited by 𝑃, denoted
as 𝑉 (𝑃) = 𝑖=1 𝑒 𝑖 , does not contain repeated visits to the same hyperedge.
The length of the hyperpath is the number of hyperedges in 𝑃, denoted |𝑃| = 𝑘.
2.2 Tree-width and Hypertree-width
Tree-width quantifies how closely a graph resembles a tree by representing it using a tree-like structure with
minimal width [92–96]. Hypertree-width generalizes this concept to hypergraphs, measuring how effectively
a hypergraph can be decomposed into a tree-like structure [2, 3, 52–55, 75, 121]. The formal definitions of
Tree-width and Hypertree-width are presented below.
Definition 2.10. [96] A tree-decomposition of an undirected graph 𝐺 is a pair (𝑇, 𝑊), where 𝑇 is a tree, and
𝑊 = (𝑊𝑡 | 𝑡 ∈ 𝑉 (𝑇)) is a family of subsets that associates with every node 𝑡 of 𝑇 a subset 𝑊𝑡 of vertices of 𝐺
such that:
Ð
(T1) 𝑡 ∈𝑉 (𝑇 ) 𝑊𝑡 = 𝑉 (𝐺),
(T2) For each edge (𝑢, 𝑣) ∈ 𝐸 (𝐺), there exists some node 𝑡 of 𝑇 such that {𝑢, 𝑣} ⊆ 𝑊𝑡 , and
(T3) For all nodes 𝑟, 𝑠, 𝑡 in 𝑇, if 𝑠 is on the unique path from 𝑟 to 𝑡 then 𝑊𝑟 ∩ 𝑊𝑡 ⊆ 𝑊𝑠 .
The width of a tree-decomposition (𝑇, 𝑊) is the maximum of |𝑊𝑡 | − 1 over all nodes 𝑡 of 𝑇. The tree-width of
𝐺 is the minimum width over all tree-decompositions of 𝐺.
Definition 2.11. [3] A generalized hypertree decomposition of a hypergraph 𝐻 = (𝑉 (𝐻), 𝐸 (𝐻)) is a triple
(𝑇, 𝐵, 𝐶), where:
• (𝑇, 𝐵) is a tree decomposition of 𝐻, where:

– 𝑇 is a tree with vertex set 𝑉 (𝑇),
– 𝐵 = {𝐵𝑡 | 𝑡 ∈ 𝑉 (𝑇)} is a family of subsets of 𝑉 (𝐻), called bags, satisfying the tree decomposition
properties.
• 𝐶 = {𝐶𝑡 | 𝑡 ∈ 𝑉 (𝑇)} is a family of subsets of 𝐸 (𝐻) (hyperedges of 𝐻), called guards.
The decomposition must satisfy the following conditions for each 𝑡 ∈ 𝑉 (𝑇):
Ð Ð
1. 𝐵𝑡 ⊆ 𝐶𝑡 , where 𝐶𝑡 is defined as:
Ø
𝐶𝑡 = {𝑣 ∈ 𝑉 (𝐻) | ∃𝑒 ∈ 𝐶𝑡 : 𝑣 ∈ 𝑒}.
In other words, every vertex in 𝐵𝑡 must belong to at least one hyperedge in 𝐶𝑡 .
244
The width of the generalized hypertree decomposition (𝑇, 𝐵, 𝐶) is defined as:
width(𝑇, 𝐵, 𝐶) = max{|𝐶𝑡 | | 𝑡 ∈ 𝑉 (𝑇)},
where |𝐶𝑡 | denotes the number of hyperedges in 𝐶𝑡 .
The generalized hypertree width of 𝐻, denoted ghw(𝐻), is the minimum width among all possible generalized
hypertree decompositions of 𝐻.
A hypertree decomposition of 𝐻 is a special case of a generalized hypertree decomposition (𝑇, 𝐵, 𝐶) that

satisfies the following additional condition for all 𝑡 ∈ 𝑉 (𝑇):
Ø Ø
( 𝐶𝑡 ) ∩ 𝐵𝑢 ⊆ 𝐵𝑡 ,
𝑢∈𝑉 (𝑇𝑡 )
Ð
where 𝑇𝑡 is the subtree of 𝑇 rooted at 𝑡, and 𝑢∈𝑉 (𝑇𝑡 ) 𝐵𝑢 denotes the union of the bags associated with all
nodes in 𝑇𝑡 .
The width of a hypertree decomposition is defined in the same way as for a generalized hypertree decomposition.
The hypertree width of 𝐻, denoted hw(𝐻), is the minimum width among all possible hypertree decompositions
of 𝐻.
2.3 SuperHyperGraph and Superhypertree
A Superhypertree is a tree in a Superhypergraph [39, 51]. A Superhypergraph is known as a generalization

of concepts such as graphs and hypergraphs (cf. [39, 42, 59, 60, 89, 105–108, 110, 110, 111]). The definitions,
including related concepts, are provided below.
Definition 2.12 (SuperHyperGraph). [105, 106] Let 𝑉 be a finite set of vertices. A superhypergraph is an
ordered pair 𝐻 = (𝑉, 𝐸), where:
• 𝑉 ⊆ 𝑃(𝑉) (the power set of 𝑉), meaning that each element of 𝑉 can be either a single vertex or a subset
of vertices (called a supervertex).
• 𝐸 ⊆ 𝑃(𝑉) represents the set of edges, called superedges, where each 𝑒 ∈ 𝐸 can connect multiple
supervertices.
In this framework, a superhypergraph can accommodate complex relationships among groups of vertices,
including single edges, hyperedges, superedges, and multi-edges. Superhypergraphs provide a flexible structure
to represent high-order and hierarchical relationships.
Proposition 2.13. [42] Every superhypergraph can be transformed into a hypergraph.
Proof. Refer to [42] for details. □

Definition 2.14 (SuperHyperTree). [39, 51] A SuperHyperTree (SHT) is a SuperHyperGraph SHT = (𝑉, 𝐸)
that satisfies the following conditions:
1. Host Tree Condition: There exists a tree 𝑇 = (𝑉𝑇 , 𝐸𝑇 ), called the host tree, such that:
• The vertex set of 𝑇 is 𝑉𝑇 = 𝑉.
• Each superedge 𝑒 ∈ 𝐸 corresponds to a connected subtree of 𝑇.
2. Acyclicity Condition: The host tree 𝑇 must be acyclic, ensuring that SHT inherits this property.
3. Connectedness Condition: For any 𝑣, 𝑤 ∈ 𝑉, there exists a sequence of superedges 𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ∈ 𝐸

such that 𝑣 ∈ 𝑒 1 , 𝑤 ∈ 𝑒 𝑘 , and 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅ for 1 ≤ 𝑖 < 𝑘.
245
Definition 2.15 (SuperHyperpath in a SuperHypergraph). Let SHG = (𝑉, 𝐸) be a superhypergraph, where
𝑉 ⊆ P (𝑉0 ) is a set of supervertices (each being a subset of some base set 𝑉0 ) and 𝐸 ⊆ P (𝑉) is a set
of superhyperedges. A superhyperpath 𝑃 in SHG connecting two supervertices 𝑢, 𝑣 ∈ 𝑉 is a sequence of
superhyperedges:
𝑃 = (𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ) with 𝑒 𝑖 ∈ 𝐸 for 𝑖 = 1, . . . , 𝑘,
satisfying the following conditions:
• Adjacency Condition: For all 1 ≤ 𝑖 ≤ 𝑘 − 1, 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅, i.e., the union of vertices in consecutive
Ð Ð
superhyperedges share at least one vertex in the base set 𝑉0 .
• Endpoint Condition: 𝑢 ∈ 𝑒 1 and 𝑣 ∈ 𝑒 𝑘 .
• Acyclic Condition: Ð
The sequence does not form a cycle, meaning the set of supervertices visited by 𝑃,
𝑘
denoted as 𝑉 (𝑃) = 𝑖=1 𝑒 𝑖 , does not revisit the same supervertex in the same sequence.
The length of the superhyperpath is the number of superhyperedges in 𝑃, denoted |𝑃| = 𝑘.

Proposition 2.16. A SuperHyperpath 𝑃 in a superhypergraph SHG = (𝑉, 𝐸) is a SuperHyperTree (SHT)
if and only if 𝑃 satisfies the Host Tree Condition, Acyclicity Condition, and Connectedness Condition of a
SuperHyperTree.
Proof. We will prove the proposition in two parts:
• (1) If 𝑃 is a SuperHyperpath, then 𝑃 satisfies the conditions of a SuperHyperTree.

• (2) If 𝑃 satisfies the conditions of a SuperHyperTree, then 𝑃 is a SuperHyperpath.
(1) 𝑃 as a SuperHyperpath implies 𝑃 is a SuperHyperTree Let 𝑃 = (𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ) be a SuperHyperpath.
1. Host Tree Condition:Ð SinceÐ𝑃 is a SuperHyperpath, its superedges 𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 are connected se-
quentially such that 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅ for 1 ≤ 𝑖 ≤ 𝑘 − 1. We can construct a tree 𝑇 = (𝑉𝑇 , 𝐸𝑇 ),
where: Ø Ø
𝑉𝑇 = {𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 }, 𝐸𝑇 = {(𝑒 𝑖 , 𝑒 𝑖+1 ) | 𝑒𝑖 ∩ 𝑒 𝑖+1 ≠ ∅}.
Thus, 𝑃 satisfies the Host Tree Condition.
2. Acyclicity Condition: By definition, 𝑃 is a path and does not revisit any supervertex in the sequence of
superedges. Therefore, the constructed tree 𝑇 is acyclic.
Ð𝑘
3. Connectedness Condition: In 𝑃, every pair of supervertices 𝑢, 𝑣 ∈ 𝑉 in 𝑉 (𝑃) = 𝑖=1 𝑒 𝑖 is connected
through a sequence of superedges 𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 . Hence, 𝑃 satisfies the Connectedness Condition.
Since all three conditions of a SuperHyperTree are satisfied, 𝑃 is a SuperHyperTree.
(2) 𝑃 satisfies SuperHyperTree conditions implies 𝑃 is a SuperHyperpath Let 𝑃 satisfy the Host Tree
Condition, Acyclicity Condition, and Connectedness Condition of a SuperHyperTree.
1. By the Host Tree Condition, there exists a tree 𝑇 = (𝑉𝑇 , 𝐸𝑇 ), where each superedge 𝑒 ∈ 𝐸 corresponds
to a subtree of 𝑇. In particular, the tree structure ensures that consecutive superedges 𝑒 𝑖 and 𝑒 𝑖+1 share
at least one vertex in the base set 𝑉0 . Thus, 𝑃 satisfies the Adjacency Condition of a SuperHyperpath.
2. By the Acyclicity Condition, 𝑃 forms a simple path with no repeated supervertices in the sequence of
superedges. Therefore, 𝑃 satisfies the Acyclic Condition of a SuperHyperpath.
246
3. By the Connectedness Condition, 𝑃 ensures that for any pair of vertices 𝑢, 𝑣 ∈ 𝑉 (𝑃), there exists a
sequence of superedges 𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 connecting 𝑢 and 𝑣. Hence, 𝑃 satisfies the Endpoint Condition of
a SuperHyperpath.
Since 𝑃 satisfies all the conditions of a SuperHyperpath, 𝑃 is a SuperHyperpath.
From parts (1) and (2), we conclude that a SuperHyperpath is a SuperHyperTree if and only if it satisfies the
conditions of a SuperHyperTree. □
Proposition 2.17. A SuperHyperTree generalizes a Hypertree.
Proof. Let 𝐻 = (𝑉, 𝐸) be a hypergraph that satisfies the conditions of a Hypertree:
• There exists a host tree 𝑇 = (𝑉𝑇 , 𝐸𝑇 ), where each vertex 𝑡 ∈ 𝑉𝑇 is associated with a bag 𝐵𝑡 ⊆ 𝑉, and
each hyperedge 𝑒 ∈ 𝐸 is contained within at least one bag 𝐵𝑡 , i.e., 𝑒 ⊆ 𝐵𝑡 for some 𝑡 ∈ 𝑉𝑇 .
• The connectivity condition ensures that for any 𝑣 ∈ 𝑉, the set of tree nodes 𝑡 ∈ 𝑉𝑇 where 𝑣 ∈ 𝐵𝑡 forms a
connected subtree of 𝑇.
• The host tree 𝑇 is acyclic.
Consider a SuperHyperTree SHT = (𝑉SHT , 𝐸 SHT ), where 𝑉SHT ⊆ P (𝑉) (the power set of the vertices of 𝐻),
and 𝐸 SHT ⊆ P (𝑉SHT ). By definition, a SuperHyperTree satisfies:
• There exists a host tree 𝑇SHT such that each superedge 𝑒 ∈ 𝐸 SHT corresponds to a connected subtree of
𝑇SHT .
• The host tree 𝑇SHT is acyclic.
• The connectivity condition ensures that any two vertices 𝑣, 𝑤 ∈ 𝑉SHT can be connected through a
sequence of superedges.
To show that a Hypertree 𝐻 is a special case of a SuperHyperTree SHT:
1. Let each vertex 𝑣 ∈ 𝑉 of the Hypertree 𝐻 correspond to a singleton set {𝑣} ∈ 𝑉SHT , making 𝑉SHT =
{{𝑣} | 𝑣 ∈ 𝑉 }.
2. Let each hyperedge 𝑒 ∈ 𝐸 of 𝐻 correspond to a superedge 𝑒 SHT ∈ 𝐸 SHT , where 𝑒 SHT = {{𝑣} | 𝑣 ∈ 𝑒}.
With this mapping:
• Each hyperedge 𝑒 ∈ 𝐸 is contained within a bag 𝐵𝑡 of the Hypertree 𝐻, and thus the corresponding
superedge 𝑒 SHT forms a subtree in 𝑇SHT .
• The connectivity condition and acyclicity of the Hypertree 𝐻 directly translate to the SuperHyperTree
SHT.
Therefore, a Hypertree 𝐻 is a specific case of a SuperHyperTree SHT, where the supervertices of SHT are
restricted to singleton sets. □
Proposition 2.18. A SuperHyperPath generalizes a HyperPath.
Proof. Let 𝐻 = (𝑉, 𝐸) be a hypergraph and 𝑃 = (𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ) be a hyperpath in 𝐻, satisfying:
247
• For all 1 ≤ 𝑖 ≤ 𝑘 − 1, 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅, ensuring that consecutive hyperedges share at least one vertex.
• 𝑢 ∈ 𝑒 1 and 𝑣 ∈ 𝑒 𝑘 , ensuring that 𝑃 connects 𝑢 to 𝑣.
• 𝑃 does not form a cycle, ensuring acyclicity.
Consider a SuperHyperPath 𝑃SHT in a SuperHyperGraph SHG = (𝑉SHT , 𝐸 SHT ), where:
• 𝑉SHT ⊆ P (𝑉), and 𝐸 SHT ⊆ P (𝑉SHT ).

• 𝑃SHT = (𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ) satisfies:
Ð Ð
– 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅, ensuring that consecutive superedges share at least one vertex.
– 𝑢 ∈ 𝑒 1 and 𝑣 ∈ 𝑒 𝑘 , where 𝑢, 𝑣 ∈ 𝑉SHT , ensuring that 𝑃SHT connects 𝑢 to 𝑣.
– 𝑃SHT does not form a cycle.
To show that a HyperPath 𝑃 is a special case of a SuperHyperPath 𝑃SHT :
1. Let each vertex 𝑣 ∈ 𝑉 correspond to a singleton set {𝑣} ∈ 𝑉SHT .

2. Let each hyperedge 𝑒 𝑖 ∈ 𝑃 correspond to a superedge 𝑒 SHT
𝑖 ∈ 𝐸 SHT , where 𝑒 SHT
𝑖 = {{𝑣} | 𝑣 ∈ 𝑒 𝑖 }.
This mapping preserves:
• The adjacency condition, as 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅ in 𝑃 implies 𝑒 SHT 𝑒 SHT

Ð Ð
𝑖 ∩ 𝑖+1 ≠ ∅ in 𝑃SHT .
• The endpoint condition, as 𝑢 ∈ 𝑒 1 and 𝑣 ∈ 𝑒 𝑘 in 𝑃 correspond to 𝑢 ∈ 𝑒 SHT

1 and 𝑣 ∈ 𝑒 SHT
𝑘 in 𝑃SHT .
• The acyclicity condition.
Thus, a HyperPath 𝑃 is a specific case of a SuperHyperPath 𝑃SHT , where the supervertices are singleton
sets. □
2.4 SuperHyperTree-width
SuperHyperTree-width is an abstraction of Hypertree-width, extending the concept of Tree-width. The defini-

tion is presented as follows [39].
Definition 2.19 (SuperHyperTree Decomposition and SuperHyperTree-width). [39] Let SHT = (𝑉, 𝐸) be a
SuperHyperGraph. A SuperHyperTree decomposition of SHT is a tuple (𝑇, B, C), where:
• 𝑇 = (𝑉𝑇 , 𝐸𝑇 ) is a tree.
• B = {𝐵𝑡 | 𝑡 ∈ 𝑉𝑇 }, a collection of subsets of 𝑉 (called bags), satisfying:
1. For every superedge 𝑒 ∈ 𝐸, there exists a node 𝑡 ∈ 𝑉𝑇 such that 𝑒 ⊆ 𝐵𝑡 .
2. For every vertex 𝑣 ∈ 𝑉, the set {𝑡 ∈ 𝑉𝑇 | 𝑣 ∈ 𝐵𝑡 } induces a connected subtree of 𝑇.
• C = {𝐶𝑡 | 𝑡 ∈ 𝑉𝑇 }, a collection of subsets of 𝐸 (called guards), such that:
Ð Ð
1. For every node 𝑡 ∈ 𝑉𝑇 , 𝐵𝑡 ⊆ 𝐶𝑡 , where 𝐶𝑡 = {𝑣 ∈ 𝑉 | ∃𝑒 ∈ 𝐶𝑡 such that 𝑣 ∈ 𝑒}.
Ð Ð
2. For every node 𝑡 ∈ 𝑉𝑇 , ( 𝐶𝑡 ) ∩ 𝑢∈𝑇𝑡 𝐵𝑢 ⊆ 𝐵𝑡 , where 𝑇𝑡 is the subtree of 𝑇 rooted at 𝑡.
The width of a SuperHyperTree decomposition (𝑇, B, C) is defined as:

width(𝑇, B, C) = max |𝐶𝑡 |.
𝑡 ∈𝑉𝑇
The SuperHyperTree-width of SHT, denoted SHT-width(SHT), is the minimum width over all possible Super-
HyperTree decompositions:
SHT-width(SHT) = min width(𝑇, B, C).
(𝑇 , B, C)
248
2.5 Basic Definition of Algorithm
The basic definitions related to the algorithms described in the Results section are provided here. Readers may
refer to the Lecture Notes or the Introduction for additional details as needed [24, 31, 99].
Definition 2.20. (cf. [85, 99]) The Total Time Complexity of an algorithm is defined as the sum of the time
required to execute each step of the algorithm, expressed as a function of the input size. If an algorithm involves
multiple steps or operations, the total time complexity is determined by the maximum time required for the
most time-consuming operation.
Formally, let 𝑇 (𝑛, 𝑚) be the time complexity as a function of input sizes 𝑛 and 𝑚. The total time complexity is:
𝑇 (𝑛, 𝑚) = max(𝑇operation1 (𝑛, 𝑚), 𝑇operation2 (𝑛, 𝑚), . . . , 𝑇operationk (𝑛, 𝑚)),
where 𝑛 is the size of the set of propositions and 𝑚 is the size or complexity of the context.
Definition 2.21. (cf. [85, 99]) The Space Complexity of an algorithm is the total amount of memory required
to execute the algorithm, expressed as a function of the input size. This includes:
• The input space, which depends on the size of the input 𝑛, 𝑚,
• The auxiliary space, which includes temporary variables, data structures, or storage used during com-
putation.
Formally, let 𝑆(𝑛, 𝑚) be the space complexity as a function of input sizes 𝑛 and 𝑚. The total space complexity
is:
𝑆(𝑛, 𝑚) = 𝑆input (𝑛, 𝑚) + 𝑆auxiliary (𝑛, 𝑚).
Definition 2.22. (cf. [85, 99]) Big-O notation is a mathematical concept used to describe the upper bound of
the time or space complexity of an algorithm. Let 𝑓 (𝑛) and 𝑔(𝑛) be functions that map non-negative integers
to non-negative real numbers. We say:
𝑓 (𝑛) ∈ 𝑂 (𝑔(𝑛))
if there exist constants 𝑐 > 0 and 𝑛0 ≥ 0 such that:
𝑓 (𝑛) ≤ 𝑐 · 𝑔(𝑛) for all 𝑛 ≥ 𝑛0 .
Definition 2.23 (NP-hard). (cf. [63, 120]) A decision problem is classified as NP-hard if every problem in
the class NP can be reduced to it in polynomial time. Formally, a problem 𝑃 is NP-hard if there exists a
polynomial-time reduction from any problem 𝑄 ∈ NP to 𝑃, such that solving 𝑃 allows the solution of 𝑄.
Importantly, NP-hard problems may not necessarily belong to the class NP, as they are not required to have a
solution verifiable in polynomial time.
3 Results in this Paper
The results of this paper are presented below.
3.1 Exact Construct SuperHyperGraph
We consider about the algorithm of Constructing SuperHyperGraph. The problem considered in this subsection
is described below.
Problem 3.1. Given a finite set of vertices 𝑉 and a collection of subsets of 𝑉, construct a valid SuperHyperGraph
𝐻 = (𝑉, 𝐸) where 𝐸 is the set of superedges.
249
The algorithm and related theorems for the above problem are presented below.
Algorithm 1: Construct SuperHyperGraph

Input: A set 𝑉 = {𝑣 1 , 𝑣 2 , . . . , 𝑣 𝑛 } and a collection C ⊆ P (𝑉).
Output: A SuperHyperGraph 𝐻 = (𝑉, 𝐸).
1 Initialize 𝐸 ← ∅;
2 foreach subset 𝑆 ∈ C do
3 if 𝑆 ≠ ∅ then
4 Add 𝑆 to 𝐸;
5 return 𝐻 = (𝑉, 𝐸);
Theorem 3.2. The algorithm constructs a valid SuperHyperGraph 𝐻 = (𝑉, 𝐸) such that 𝑉 and 𝐸 satisfy the
definition of a SuperHyperGraph.
Proof. The algorithm iterates over the input collection C and includes each non-empty subset 𝑆 ∈ C into the
set of superedges 𝐸. By definition:
• 𝑉 remains unchanged and consists of the original set of vertices.

• 𝐸 ⊆ P (𝑉) \ {∅}, as only non-empty subsets are added.
Thus, the output 𝐻 = (𝑉, 𝐸) satisfies the definition of a SuperHyperGraph. □

Theorem 3.3. The time complexity of the algorithm is 𝑂 (|C|), where |C| is the size of the input collection of
subsets.
Proof. The algorithm processes each subset 𝑆 ∈ C exactly once. For each subset, the inclusion check and
addition to 𝐸 take constant time. Therefore, the overall time complexity is 𝑂 (|C|). □
Theorem 3.4. The space complexity of the algorithm is 𝑂 (|C| + |𝑉 |).
Proof. The algorithm requires space to store:
• The vertex set 𝑉, requiring 𝑂 (|𝑉 |) space.

• The collection of superedges 𝐸, which is derived from C and requires 𝑂 (|C|) space.
Thus, the total space complexity is 𝑂 (|C| + |𝑉 |). □
3.2 Algorithm: Recognizing a SuperHyperTree
In this subsection, we examine the algorithm for recognizing a SuperHyperTree. For example, in the context of
hypergraphs, recognizing algorithms for Hypertrees have been developed [114]. Here, we extend this concept
to the SuperHyperTree framework. The problem considered in this subsection is described below.
Problem 3.5. Given a SuperHyperGraph 𝐻 = (𝑉, 𝐸), determine whether 𝐻 is a SuperHyperTree.
250
Algorithm 2: Recognize SuperHyperTree

Input: A SuperHyperGraph 𝐻 = (𝑉, 𝐸).
Output: True if 𝐻 is a SuperHyperTree; False otherwise.
1 Construct a graph 𝑇 = (𝑉, 𝐸𝑇 ), where 𝐸𝑇 consists of edges connecting all vertices in each 𝑒 ∈ 𝐸;
2 Check if 𝑇 is acyclic;
3 if 𝑇 is not acyclic then
4 return False;
5 foreach 𝑒 ∈ 𝐸 do
6 Verify that 𝑒 forms a connected subtree of 𝑇;
7 if 𝑒 does not form a connected subtree then
8 return False;
9 Check that 𝐻 satisfies the connectedness condition;
10 if 𝐻 does not satisfy the connectedness condition then
11 return False;
12 return True;
Theorem 3.6. The algorithm correctly determines whether 𝐻 is a SuperHyperTree.
Proof. The algorithm verifies:
• The acyclicity of the host tree 𝑇.

• That each superedge 𝑒 ∈ 𝐸 forms a connected subtree of 𝑇.
• That 𝐻 satisfies the connectedness condition.
Since these are the defining properties of a SuperHyperTree, the algorithm is correct. □
Theorem 3.7. The time complexity of the algorithm is 𝑂 (|𝑉 | + |𝐸 | · |𝑉 |).
Proof. Constructing the graph 𝑇 requires 𝑂 (|𝑉 | + |𝐸 | · |𝑉 |) time, as each superedge may connect multiple
vertices. Checking acyclicity and verifying subtree conditions also require 𝑂 (|𝑉 | + |𝐸 | · |𝑉 |) time. Thus, the
overall time complexity is 𝑂 (|𝑉 | + |𝐸 | · |𝑉 |). □
Theorem 3.8. The space complexity of the algorithm is 𝑂 (|𝑉 | + |𝐸 |).
Proof. The algorithm requires space to store the graph 𝑇 and the original SuperHyperGraph 𝐻. Thus, the
space complexity is 𝑂 (|𝑉 | + |𝐸 |). □
3.3 Computation of SuperHyperTree-width
This subsection examines the Algorithm for the Computation of SuperHyperTree-width. The problem consid-
ered in this subsection is described below.
Problem 3.9. The problem is to compute the exact SuperHyperTree-width of a given SuperHyperGraph
𝐻 = (𝑉, 𝐸). This involves finding a SuperHyperTree decomposition (T , X) such that the width of the
decomposition is minimized. The objective is to determine the smallest possible width, denoted as 𝑤 min ,
satisfying the host tree, acyclicity, and connectedness conditions for all superhyperedges 𝑒 ∈ 𝐸 within 𝐻.
251
3.3.1 Exact Algorithm for Computation of SuperHyperTree-width
The Exact Algorithm for the Computation of SuperHyperTree-width is introduced as follows.
Algorithm 3: Computation of SuperHyperTree-width

Input: SuperHyperGraph SHT = (𝑉, 𝐸)
Output: SuperHyperTree-width 𝑤 min and the corresponding decomposition (T , X)
1 Initialize a tree decomposition algorithm for SHT;
2 Set an initial upper bound for the tree-width: 𝑤 min ← ∞;
3 foreach possible tree decomposition (T , X) of SHT do
4 Compute the width of the decomposition;
5 if width of decomposition < 𝑤 min then
6 Update 𝑤 min ;
7 Store the corresponding decomposition (T , X);
8 return 𝑤 min , (T , X);
Theorem 3.10. The above algorithm correctly computes the SuperHyperTree-width of the given SuperHyper-
Graph SHT.
Proof. Completeness: The algorithm considers all possible tree decompositions over the vertex set 𝑉 and
evaluates each decomposition to ensure that it satisfies the necessary conditions for a valid SuperHyperTree-
decomposition. The algorithm guarantees that it explores every possible decomposition that could potentially
minimize the SuperHyperTree-width.
Soundness: By systematically testing all feasible decompositions and comparing their widths, the algorithm
ensures that the computed SuperHyperTree-width is indeed the smallest possible value, thus providing an
accurate result. □
Theorem 3.11 (Time Complexity). The time complexity of the approximation algorithm for computing the
2
SuperHyperTree-width is 𝑂 (2 |𝑉 | ), where |𝑉 | is the number of vertices in the SuperHyperGraph.
Proof. Let 𝐻 = (𝑉, 𝐸) be the given SuperHyperGraph with vertex set 𝑉 and edge set 𝐸. The core of the
algorithm involves enumerating and processing various tree decompositions of the graph, which correspond to
subsets of 𝑉.
The total number of possible tree decompositions over 𝑉 is exponential in the number of vertices. Specifically,
2
we need to consider all possible ways to partition 𝑉 into subsets, which is of the order of 𝑂 (2 |𝑉 | ). This arises
from the fact that each pair of vertices can either be in the same subset or in different subsets, leading to an
exponential number of possible combinations.
Since each decomposition requires checking the structural constraints of the SuperHyperGraph (i.e., the
superedges), the time complexity for evaluating each decomposition is polynomial in |𝑉 |. However, the
2
dominant factor is the number of decompositions, which grows exponentially as 2 |𝑉 | .
2
Thus, the overall time complexity of the algorithm is 𝑂 (2 |𝑉 | ). □
Theorem 3.12 (Space Complexity). The space complexity of the approximation algorithm for computing the
2
SuperHyperTree-width is 𝑂 (2 |𝑉 | ), where |𝑉 | is the number of vertices in the SuperHyperGraph.
Proof. The space complexity of the algorithm is determined by the storage requirements for enumerating and
processing the possible tree decompositions of the graph.
Each tree decomposition is represented as a set of subsets of the vertex set 𝑉. The number of subsets of 𝑉 is
𝑂 (2 |𝑉 | ), and each subset requires storing a list of vertices. Thus, the space required for each decomposition is
proportional to 𝑂 (2 |𝑉 | ).
252
2
Moreover, the algorithm needs to store all possible decompositions, which can be of the order 𝑂 (2 |𝑉 | ), as
explained in the time complexity analysis. Therefore, the total space required is dominated by the number of
2
decompositions, leading to a space complexity of 𝑂 (2 |𝑉 | ).
2
Thus, the overall space complexity is 𝑂 (2 |𝑉 | ). □
3.3.2 Approximation Algorithm for SuperHyperTree-width
An approximation algorithm provides near-optimal solutions to computationally hard problems within a prov-
able error bound, ensuring efficiency and feasibility. Given a SuperHyperGraph 𝐻 = (𝑉, 𝐸), we present
an approximation algorithm for computing its SuperHyperTree-width. The algorithm is designed to run in
polynomial time and approximates the SuperHyperTree-width within a factor of 𝑂 (log |𝑉 |).
Algorithm 4: Approximation Algorithm for SuperHyperTree-width

Input: SuperHyperGraph 𝐻 = (𝑉, 𝐸)
Output: Approximation of the SuperHyperTree-width
1 Initialize an empty tree decomposition 𝑇;
2 Construct an initial decomposition using a greedy approach:;
3 foreach superedge 𝑒 𝑖 ∈ 𝐸 do
4 Select the smallest superedge 𝑒 𝑖 based on the number of vertices connected;
5 Add 𝑒 𝑖 to the decomposition 𝑇;
6 Perform a greedy refinement:;
7 foreach superedge 𝑒 𝑖 in 𝑇 do
8 Try to connect 𝑒 𝑖 to existing parts of the decomposition with minimal additional width;
9 if improvement is found then
10 Adjust the decomposition;
11 Terminate the algorithm when no further improvements are possible;
12 return the SuperHyperTree-width of the final decomposition;
Theorem 3.13 (Correctness of the Approximation Algorithm). The algorithm correctly computes an approxi-
mation of the SuperHyperTree-width of the SuperHyperGraph 𝐻.
Proof. The correctness of the algorithm follows from the fact that:
1. The greedy tree decomposition approach used in the algorithm always provides a decomposition whose
treewidth is within a constant factor of the optimal treewidth.
2. The hypertree-width of a SuperHyperGraph is bounded above by the treewidth of any valid tree decompo-
sition, and the algorithm uses such a decomposition to compute an approximation.
3. Therefore, the approximation computed by the algorithm will always be a valid approximation to the true
SuperHyperTree-width. □
Theorem 3.14 (Time Complexity). Let 𝑛 = |𝑉 | be the number of vertices and 𝑚 = |𝐸 | be the number of
hyperedges in the SuperHyperGraph. The time complexity of the approximation algorithm is 𝑂 (𝑛2 ).
Proof. The time complexity is dominated by the steps where we construct the tree decomposition and compute
the hypertree-width approximation.
1. Constructing a tree decomposition with treewidth approximation 𝜏 can be done in 𝑂 (𝑛2 ) time using greedy
algorithms or dynamic programming techniques for tree decomposition.
2. Computing the hypertree-width from the tree decomposition requires linear time in terms of the size of the
decomposition, which is at most 𝑂 (𝑛2 ).
Therefore, the overall time complexity is 𝑂 (𝑛2 ). □
253
Theorem 3.15 (Space Complexity). Let 𝑛 = |𝑉 | be the number of vertices and 𝑚 = |𝐸 | be the number of
hyperedges in the SuperHyperGraph. The space complexity of the approximation algorithm is 𝑂 (𝑛2 ).
Proof. The space required to store the SuperHyperGraph 𝐻 = (𝑉, 𝐸) is 𝑂 (𝑚), where 𝑚 is the number of
hyperedges. Additionally, the space required to store the tree decomposition and related data structures is
𝑂 (𝑛2 ), since the decomposition involves a set of nodes and edges that depend on the number of vertices and
hyperedges in the graph. Thus, the overall space complexity is 𝑂 (𝑛2 ). □
Theorem 3.16 (Approximation Bound). Let SuperHyperTree-width(𝐻) denote the true SuperHyperTree-width
of 𝐻, and 𝜏 the approximation computed by the algorithm. Then, the algorithm computes an approximation
such that:
SuperHyperTree-width(𝐻) ≤ 𝜏 ≤ 𝛽 · SuperHyperTree-width(𝐻),
where 𝛽 is a constant factor depending on the quality of the greedy heuristic used in the tree decomposition
algorithm (e.g., 𝛽 = 2 for simple greedy heuristics).
Proof. The approximation bound follows from the properties of the greedy tree decomposition algorithm. In
particular, if the tree decomposition has treewidth 𝜏, the hypertree-width of the SuperHyperGraph is at most 𝜏.
Since the greedy heuristic for tree decomposition guarantees that the treewidth is within a constant factor 𝛽 of
the optimal treewidth, the approximation 𝜏 computed by the algorithm will be within a factor of 𝛽 of the true
SuperHyperTree-width. □
3.4 Superhypergraph Partition Problem
We consider the well-known Graph Partition Problem. The Graph Partition Problem aims to divide the vertices
of a graph into disjoint subsets while minimizing edge cuts or maximizing intra-group connectivity [33,71,100].
The Hypergraph Partition Problem generalizes this by partitioning the vertices of a hypergraph into subsets
while minimizing hyperedge cuts, where hyperedges connect multiple vertices [34,69,98,113]. These problems
are further extended in this study to the context of superhypergraphs. The problem considered in this subsection
is described below.
Problem 3.17 (Superhypergraph Partition Problem). Given a superhypergraph 𝐻 = (𝑉, 𝐸) and an integer
𝑘 ≥ 2, partition 𝑉 into 𝑘 disjoint subsets 𝑉1 , 𝑉2 , . . . , 𝑉𝑘 such that:
l m
|𝑉 |
• Balance Constraint: For each 𝑖, |𝑉𝑖 | ≤ (1 + 𝜖) 𝑘 for some small 𝜖 > 0.
• Cut Minimization: The number of hyperedges that are cut is minimized. A hyperedge is said to be cut
if it contains vertices from more than one partition.
The algorithm for solving this problem is presented below.

Remark 3.18. The algorithm consists of the following steps:
1. Coarsening Phase: Reduce the size of the superhypergraph by collapsing vertices and hyperedges to
create a hierarchy of smaller superhypergraphs.
• Matching: Pair vertices based on some similarity metric (e.g., the number of shared hyperedges).
• Aggregation: Merge matched vertices to form supervertices.
• Hyperedge Reduction: Adjust hyperedges to reflect the new supervertices.
2. Initial Partitioning: Use a simple partitioning algorithm (e.g., greedy assignment) on the coarsest
superhypergraph 𝐻𝑙 .
254
3. Uncoarsening Phase: Project the partition back onto the original superhypergraph, refining the partition
at each level to improve the cut size and balance. In the algorithm, At each level 𝑖, project the partition
𝑃𝑖+1 onto 𝐻𝑖 and refine it using a local optimization method (e.g., Kernighan–Lin algorithm adapted for
superhypergraphs).
Algorithm 5: Superhypergraph Partitioning Algorithm

Input: Superhypergraph 𝐻 = (𝑉, 𝐸), number of partitions 𝑘 ≥ 2
Output: Partition 𝑉1 , 𝑉2 , . . . , 𝑉𝑘 of 𝑉
1 𝐻0 ← 𝐻;
2 𝑙 ← 0;
3 while Size of 𝐻𝑙 is greater than threshold do
4 𝐻𝑙+1 ← Coarsen(𝐻𝑙 );
5 𝑙 ← 𝑙 + 1;
6 𝑃𝑙 ← InitialPartition(𝐻𝑙 , 𝑘);
7 for 𝑖 ← 𝑙 − 1 down to 0 do
8 𝑃𝑖 ← Refine(𝐻𝑖 , 𝑃𝑖+1 );
9 return 𝑃0 ;
Theorem 3.19. The algorithm produces a valid partition of the vertex set 𝑉 into 𝑘 disjoint subsets 𝑉1 , 𝑉2 , . . . , 𝑉𝑘
that satisfy the balance constraint.
Proof. The algorithm maintains the balance constraint at each level:
• During initial partitioning, the algorithm assigns vertices to partitions such that the balance constraint is
satisfied.
• During uncoarsening and refinement, vertices are moved between partitions only if the balance constraint
is not violated.
Since the coarsening and uncoarsening processes are designed to preserve the structure of the original super-
hypergraph, the final partition 𝑃0 is valid and satisfies the balance constraint. □
Theorem 3.20. The time complexity of the algorithm is 𝑂 (|𝐸 | log |𝑉 |).
Proof. The algorithm consists of multiple phases:
• Coarsening Phase:
– Each level reduces the number of vertices by a constant factor.
– The number of levels is 𝑂 (log |𝑉 |).
– At each level, matching and aggregation can be done in 𝑂 (|𝐸 |) time.
• Initial Partitioning:
– The coarsest superhypergraph has significantly fewer vertices.
– Partitioning can be done in 𝑂 (1) time relative to the original graph size.
• Uncoarsening and Refinement:
– At each level, refinement operations (e.g., swapping vertices between partitions) can be performed
in 𝑂 (|𝐸 |) time.
– There are 𝑂 (log |𝑉 |) levels.
Therefore, the total time complexity is 𝑂 (|𝐸 | log |𝑉 |). □
255
Proof. At each level, the algorithm stores:
• The superhypergraph 𝐻𝑖 , which has at most |𝑉 | vertices and |𝐸 | hyperedges.
• The partition 𝑃𝑖 , which is a mapping from vertices to partition indices.
Since the size of 𝐻𝑖 decreases with each level, the total space required is dominated by the original superhy-
pergraph 𝐻, requiring 𝑂 (|𝑉 | + |𝐸 |) space. □
Theorem 3.22. The SuperHypergraph Partition Problem is NP-hard.
Proof. We reduce the Graph Partition Problem (GPP), which is known to be NP-hard, to the SuperHypergraph
Partition Problem (SHGP). Let 𝐺 = (𝑉𝐺 , 𝐸 𝐺 ) be an instance of GPP. Construct a superhypergraph SHG =
(𝑉, 𝐸) as follows:
• For each vertex 𝑣 ∈ 𝑉𝐺 , create a supervertex {𝑣} ∈ 𝑉.

• For each edge (𝑢, 𝑣) ∈ 𝐸 𝐺 , create a superhyperedge {{𝑢}, {𝑣}} ∈ 𝐸.
Any solution to SHGP corresponds to a partition of 𝑉𝐺 that minimizes edge cuts in 𝐺. Thus, SHGP is at least
as hard as GPP, proving its NP-hardness. □
3.5 Reachability Problem in Superhypergraph
The Reachability Problem determines whether there exists a path between two vertices in a graph or hypergraph
using its edges [7, 8]. The problem considered in this subsection is described below.
Definition 3.23. Given a Superhypergraph 𝐻 = (𝑉, 𝐸), where 𝑉 is a finite set of vertices and 𝐸 is a set of
hyperedges, the Reachability Problem asks whether there exists a path from a vertex 𝑣 1 ∈ 𝑉 to a vertex 𝑣 2 ∈ 𝑉
using hyperedges in 𝐸.
The algorithm for solving the Reachability problem follows a depth-first search (DFS) [115] strategy adapted
for hypergraphs. In a traditional DFS, we explore vertices by following edges. For a Superhypergraph, a
hyperedge can connect any number of vertices, and we need to modify the DFS to consider all vertices that a
hyperedge connects.
Algorithm 6: Reachability in Superhypergraph

Input: Superhypergraph 𝐻 = (𝑉, 𝐸), vertices 𝑣 1 , 𝑣 2 ∈ 𝑉
Output: True if there is a path from 𝑣 1 to 𝑣 2 , False otherwise
1 Initialize a set visited ← ∅;
2 Call DFS(𝑣 1 , 𝑣 2 , 𝐻, visited);
3 if DFS returns True then
4 return True;
5 else
6 return False;
Theorem 3.24. The algorithm explores all reachable vertices from 𝑣 1 by traversing through all hyperedges in
𝐻. Since each hyperedge connects a set of vertices, DFS ensures that if there is a path from 𝑣 1 to 𝑣 2 , it will be
discovered.
256
Proof. If there is a path from 𝑣 1 to 𝑣 2 , DFS will eventually visit 𝑣 2 by following the hyperedges. If 𝑣 2 is
not reachable, the algorithm will not visit 𝑣 2 , and the function will return False. Thus, the algorithm is
correct. □
Theorem 3.25. The time complexity is 𝑂 (|𝑉 | + |𝐸 |) .
Proof. In the worst case, the algorithm needs to explore all vertices and all hyperedges in the graph. Since
there are |𝑉 | vertices and |𝐸 | hyperedges, the time complexity is 𝑂 (|𝑉 | + |𝐸 |). □
Theorem 3.26. The Space Complexity is 𝑂 (|𝑉 | + |𝐸 |) .
Proof. The space complexity is dominated by the storage of the visited set and the recursion stack in the DFS.
Therefore, the space complexity is 𝑂 (|𝑉 |). □
3.6 Minimum Spanning SuperHypertree Problem
The Minimum Spanning Tree Problem identifies a tree connecting all graph vertices with the minimum total
edge weight [4, 57, 124]. The Minimum Spanning Hypertree Problem extends this concept to hypergraphs,
seeking a tree-like structure minimizing hyperedge weights [118]. In this subsection, we examine the Minimum
Spanning SuperHypertree Problem. The problem considered is described below.
Definition 3.27 (Weighted SuperHyperGraph). Let 𝑉 be a finite set of vertices. A weighted superhypergraph
is an ordered pair 𝐻 = (𝑉, 𝐸), where:
• 𝑉 ⊆ P (𝑉), the power set of 𝑉, meaning that each element of 𝑉 can be either a single vertex or a subset
of vertices (called a supervertex).
• 𝐸 is a set of superhyperedges, where each 𝑒 ∈ 𝐸 is a non-empty subset of 𝑉 (i.e., 𝑒 ⊆ 𝑉 and 𝑒 ≠ ∅).
• Each superhyperedge 𝑒 ∈ 𝐸 has an associated positive weight 𝑤(𝑒) ∈ R+ .
Definition 3.28 (Minimum Spanning SuperHypertree Problem). Given a weighted superhypergraph 𝐻 =
(𝑉, 𝐸), the Minimum Spanning SuperHypertree (MSST) is a subgraph 𝑇 = (𝑉, 𝐸𝑇 ) satisfying:
1. 𝐸𝑇 ⊆ 𝐸.
2. 𝑇 is a superhypertree, meaning it satisfies the conditions of a SuperHyperTree as defined below.
Í
3. The total weight 𝑤(𝑇) = 𝑒∈𝐸𝑇 𝑤(𝑒) is minimized among all possible superhypertrees of 𝐻.
We propose an algorithm inspired by Kruskal’s algorithm [18] for finding a Minimum Spanning Tree (MST)
in graphs. The algorithm operates as follows:
Algorithm 7: Minimum Spanning SuperHypertree Algorithm

Input: A weighted superhypergraph 𝐻 = (𝑉, 𝐸)
Output: A Minimum Spanning SuperHypertree 𝑇 = (𝑉, 𝐸𝑇 )
1 Initialize the edge set of the superhypertree: 𝐸𝑇 ← ∅;
2 Sort the superhyperedges 𝐸 in non-decreasing order of weight;
3 Initialize a disjoint-set data structure D for the vertices in 𝑉;
4 foreach superhyperedge 𝑒 ∈ 𝐸 (in sorted order) do
5 Compute Ð the union of sets containing vertices in 𝑒:
6 C𝑒 ← 𝑣 ∈𝑒 Find(𝑣);
7 if |C𝑒 | > 1 then
8 Add 𝑒 to 𝐸𝑇 ;
9 Update the disjoint-set structure by performing:
10 Union(Find(𝑣)) for all 𝑣 ∈ 𝑒;
11 Construct the Minimum Spanning SuperHypertree: 𝑇 ← (𝑉, 𝐸𝑇 );
12 return 𝑇;
257
Theorem 3.29. The algorithm correctly finds a Minimum Spanning SuperHypertree of the weighted superhy-
pergraph 𝐻.
Proof. We need to show that:
1. The algorithm produces a superhypertree.

2. The superhypertree is spanning and minimal in total weight.
1. Produces a SuperHypertree:
Acyclicity: The algorithm only adds superhyperedges that connect disjoint components, ensuring no cycles are
formed.
Connectivity: By uniting components whenever a superhyperedge is added, eventually all vertices become
connected.
2. Minimal Total Weight:
The algorithm always chooses the smallest available superhyperedge that does not create a cycle, similar to
Kruskal’s algorithm.
Suppose there exists another superhypertree 𝑇 ′ with a smaller total weight. Then, there must be at least one
superhyperedge 𝑒 in 𝑇 ′ not in 𝑇 with weight less than or equal to the heaviest superhyperedge in 𝑇.
Replacing superhyperedges in 𝑇 with those in 𝑇 ′ cannot lead to a total weight less than 𝑇 without violating
acyclicity or connectivity.Therefore, 𝑇 is minimal. □
Theorem 3.30. The time complexity of the algorithm is 𝑂 (|𝐸 | log |𝐸 | + |𝐸 | · 𝛼(|𝑉 |)), where 𝛼 is the inverse
Ackermann function.
Proof. The algorithm can be divided into the following steps:
• Sorting the Superhyperedges:

– Sorting |𝐸 | superhyperedges by weight takes 𝑂 (|𝐸 | log |𝐸 |) time.
• Processing Each Superhyperedge:
– For each superhyperedge 𝑒, the following operations are performed:
∗ Find Operations: For each Í vertex 𝑣 ∈ 𝑒, a Find(𝑣) operation is performed. The total number
of find operations is 𝑂 ( 𝑒∈𝐸 |𝑒|), which is proportional to the size of all superhyperedges
combined.
∗ Union Operation: If 𝑒 is added to the spanning superhypertree, a union operation is performed.
The number of union operations is at most |𝐸𝑇 | ≤ |𝑉 | − 1, where |𝐸𝑇 | is the number of edges
in the final superhypertree.
– Each Union-Find operation (find or union) takes 𝑂 (𝛼(|𝑉 |)) time.
Í
Assuming the total size of all superhyperedges is 𝑒∈𝐸 |𝑒| = 𝑂 (|𝐸 | · 𝑚), where 𝑚 is the maximum size of a
superhyperedge:
• The time complexity for Union-Find operations becomes 𝑂 (|𝐸 | · 𝑚 · 𝛼(|𝑉 |)).
However, in practical cases:
258
• The Union-Find operations are dominated by 𝑂 (|𝐸 | · 𝛼(|𝑉 |)), as 𝛼(|𝑉 |) grows extremely slowly, and 𝑚
(the size of superhyperedges) is typically much smaller than |𝑉 |.
Thus, the overall time complexity of the algorithm is:
𝑂 (|𝐸 | log |𝐸 | + |𝐸 | · 𝛼(|𝑉 |)).
□
Proof. The space requirements for the algorithm are as follows:
• Storage for Vertices 𝑉: 𝑂 (|𝑉 |) space is required to store the vertex set.
• Storage for Superhyperedges 𝐸: 𝑂 (|𝐸 |) space is required to store the list of superhyperedges.
• Union-Find Data Structure: 𝑂 (|𝑉 |) space is required to store parent and rank arrays for the Union-Find
operations.
• Edge List of the Spanning SuperHypertree 𝐸𝑇 : 𝑂 (|𝐸 |) space is required in the worst case, where all
superhyperedges are included.
Combining these, the total space complexity is:
𝑂 (|𝑉 | + |𝐸 |).
□
Example 3.32. To illustrate the algorithm, consider the following weighted superhypergraph 𝐻 = (𝑉, 𝐸):
• 𝑉 = {𝑣 1 , 𝑣 2 , 𝑣 3 , 𝑣 4 }.
• 𝐸 = {𝑒 1 , 𝑒 2 , 𝑒 3 }, with:
– 𝑒 1 = {𝑣 1 , 𝑣 2 }, 𝑤(𝑒 1 ) = 1.
– 𝑒 2 = {𝑣 2 , 𝑣 3 , 𝑣 4 }, 𝑤(𝑒 2 ) = 2.
– 𝑒 3 = {𝑣 1 , 𝑣 4 }, 𝑤(𝑒 3 ) = 3.
Step-by-Step Execution of the Algorithm:
1. Sort 𝐸:
• Sort the superhyperedges by weight: 𝑒 1 , 𝑒 2 , 𝑒 3 .
2. Initialize Union-Find Data Structure:
• Each vertex 𝑣 ∈ 𝑉 is its own set.
3. Process 𝑒 1 = {𝑣 1 , 𝑣 2 }:
• Find(𝑣 1 ) ≠ Find(𝑣 2 ).
• Add 𝑒 1 to 𝐸𝑇 .
• Union 𝑣 1 and 𝑣 2 .
4. Process 𝑒 2 = {𝑣 2 , 𝑣 3 , 𝑣 4 }:
• Find(𝑣 2 ) ≠ Find(𝑣 3 ) and Find(𝑣 2 ) ≠ Find(𝑣 4 ).
259
• Add 𝑒 2 to 𝐸𝑇 .
• Union 𝑣 2 , 𝑣 3 , and 𝑣 4 .
5. Process 𝑒 3 = {𝑣 1 , 𝑣 4 }:
• All vertices are now in the same connected component.
• Adding 𝑒 3 would create a cycle, so 𝑒 3 is skipped.
The resulting Minimum Spanning SuperHypertree is:
𝑇 = (𝑉, {𝑒 1 , 𝑒 2 }),
with a total weight:

𝑤(𝑇) = 1 + 2 = 3.
This example demonstrates the step-by-step execution of the algorithm for finding the Minimum Spanning
SuperHypertree in a weighted superhypergraph. The analysis confirms the correctness and efficiency of the
algorithm, with a time complexity of 𝑂 (|𝐸 | log |𝐸 | + |𝐸 | · 𝛼(|𝑉 |)) and a space complexity of 𝑂 (|𝑉 | + |𝐸 |).
3.7 Single-Source Shortest Path Problem in a SuperHypergraph
The Single-Source Shortest Path Problem [77, 84, 88] in a SuperHypergraph involves finding the shortest paths
from a source vertex to all other vertices, minimizing the total weight of traversed superhyperedges. The
problem considered is described below.
Problem 3.33. Given a weighted superhypergraph SHG = (𝑉, 𝐸) and a source supervertex 𝑠 ∈ 𝑉, the Single-
Source Shortest Path Problem seeks to find the shortest superhyperpaths from 𝑠 to all other supervertices 𝑣 ∈ 𝑉,
minimizing the total weight.
Algorithm 8: Single-Source Shortest Path in SuperHypergraph

Input: A weighted superhypergraph SHG = (𝑉, 𝐸), source supervertex 𝑠 ∈ 𝑉
Output: Shortest path distances 𝑑 (𝑣) from 𝑠 to each 𝑣 ∈ 𝑉
1 Initialize 𝑑 (𝑣) ← ∞ for all 𝑣 ∈ 𝑉; set 𝑑 (𝑠) ← 0
2 Initialize priority queue 𝑄 ← {(𝑠, 𝑑 (𝑠))}
3 while 𝑄 is not empty do
4 Extract supervertex 𝑢 with minimal 𝑑 (𝑢) from 𝑄
5 foreach superhyperedge 𝑒 ∈ 𝐸 such that 𝑢 ∈ 𝑒 do
6 foreach supervertex 𝑣 ∈ 𝑒 do
7 if 𝑑 (𝑣) > 𝑑 (𝑢) + 𝑤(𝑒) then
8 𝑑 (𝑣) ← 𝑑 (𝑢) + 𝑤(𝑒)
9 Insert or update 𝑣 in 𝑄 with priority 𝑑 (𝑣)
10 return 𝑑 (𝑣) for all 𝑣 ∈ 𝑉
Theorem 3.34. Algorithm 8 correctly computes the shortest path distances from the source supervertex 𝑠 to
every other supervertex 𝑣 ∈ 𝑉 in SHG.
Proof. We prove the correctness of the algorithm by induction on the number of supervertices whose shortest
path distances from 𝑠 have been finalized.
Base Case: Initially, only 𝑠 has a finalized distance 𝑑 (𝑠) = 0, which is correct.
Inductive Step: Assume that the distances 𝑑 (𝑢) are correct for all supervertices whose shortest paths have been
found. When we extract the supervertex 𝑢 with the minimal tentative distance 𝑑 (𝑢) from the priority queue,
260
we know that 𝑑 (𝑢) is the shortest possible distance from 𝑠 to 𝑢. This is because all weights 𝑤(𝑒) are positive,
and any alternative path to 𝑢 via other supervertices would have a total weight at least 𝑑 (𝑢) or greater.
For each superhyperedge 𝑒 containing 𝑢, we consider all supervertices 𝑣 ∈ 𝑒. If the path from 𝑠 to 𝑣 via
𝑒 and 𝑢 offers a shorter distance than the current 𝑑 (𝑣), we update 𝑑 (𝑣) accordingly. Since we consider all
such superhyperedges and supervertices, we ensure that the shortest distances are propagated throughout the
superhypergraph.
By continuously selecting the supervertex with the minimal tentative distance and updating distances of adjacent
supervertices, we guarantee that once a supervertex 𝑢 is extracted from 𝑄, 𝑑 (𝑢) is indeed the shortest distance
from 𝑠 to 𝑢.
Therefore, by induction, the algorithm correctly computes the shortest path distances from 𝑠 to all supervertices
in 𝑉. □
Theorem 3.35. The time complexity of the algorithm is 𝑂 (|𝐸 | · 𝑚 · log |𝑉 |), where 𝑚 is the maximum number
of supervertices in a superhyperedge.
Proof. The algorithm processes each superhyperedge 𝑒 ∈ 𝐸 for each supervertex 𝑢 extracted from the priority
queue 𝑄. For each superhyperedge 𝑒 containing 𝑢, we examine all supervertices 𝑣 ∈ 𝑒, resulting in up to 𝑚
operations per superhyperedge.
The number of times we extract a supervertex from 𝑄 is 𝑂 (|𝑉 |). For each extraction, we may perform
𝑂 (𝑚 · deg(𝑢)) operations, where deg(𝑢) is the number of superhyperedges containing 𝑢.
Assuming deg(𝑢) ≤ |𝐸 |, the total number of operations is 𝑂 (|𝑉 | · |𝐸 | · 𝑚). Each priority queue operation
(insert or extract) takes 𝑂 (log |𝑉 |) time.
Therefore, the overall time complexity is 𝑂 (|𝑉 | · |𝐸 | · 𝑚 · log |𝑉 |). However, since |𝑉 | ≤ |𝐸 | · 𝑚, we can simplify
the time complexity to 𝑂 (|𝐸 | · 𝑚 · log |𝑉 |). □
Theorem 3.36. The space complexity of the algorithm is 𝑂 (|𝑉 | + |𝐸 | · 𝑚).
Proof. The space requirements are as follows:
• Distance array 𝑑 (𝑣) for each 𝑣 ∈ 𝑉: 𝑂 (|𝑉 |).

• Priority queue 𝑄: at most 𝑂 (|𝑉 |) elements.
• Storage of the superhypergraph structure: 𝑂 (|𝐸 | · 𝑚), since each superhyperedge can contain up to 𝑚
supervertices.
Thus, the total space complexity is 𝑂 (|𝑉 | + |𝐸 | · 𝑚). □
3.8 Traveling Salesman Problem in a SuperHypergraph
The Traveling Salesman Problem [29, 73, 87] in a SuperHypergraph seeks a minimum-weight tour visiting all
supervertices exactly once, considering superhyperedges’ weights, and returning to the starting supervertex
while ensuring connectivity constraints. The problem considered is described below.
Problem 3.37. Given a weighted superhypergraph SHG = (𝑉, 𝐸), the Traveling Salesman Problem (TSP)
seeks a minimal-weight closed superhyperpath that visits each supervertex 𝑣 ∈ 𝑉 at least once.
Theorem 3.38. The Traveling Salesman Problem in a superhypergraph is NP-hard.
Proof. We prove this by reduction from the classical TSP in graphs, which is known to be NP-hard. Given an
instance of the TSP in a graph 𝐺 = (𝑉𝐺 , 𝐸 𝐺 ), we construct a corresponding superhypergraph SHG = (𝑉, 𝐸)
as follows:
261
• For each vertex 𝑣 ∈ 𝑉𝐺 , create a supervertex 𝑣 ∈ 𝑉 in the superhypergraph.
• For each edge (𝑢, 𝑣) ∈ 𝐸 𝐺 , create a superhyperedge 𝑒 = {𝑢, 𝑣} ∈ 𝐸 with the same weight as the edge in
𝐺.
In this construction, the superhypergraph essentially mirrors the original graph. Therefore, any solution to the
TSP in SHG corresponds to a solution in 𝐺, and vice versa.
Since the TSP in graphs is NP-hard, and we can polynomially reduce any instance of the TSP in graphs to an
instance in superhypergraphs, it follows that the TSP in superhypergraphs is also NP-hard. □
3.9 Chinese Postman Problem (CPP) in superhypergraph
The Chinese Postman Problem (CPP) [30, 79, 117] in a superhypergraph seeks a minimum-weight closed
walk traversing all superhyperedges at least once, ensuring efficiency in traversal. The problem considered is
described below.
Problem 3.39. Given a weighted superhypergraph SHG = (𝑉, 𝐸), the Chinese Postman Problem (CPP) seeks
a minimal-weight closed superhyperpath that traverses every superhyperedge at least once.
Algorithm 9: Chinese Postman Problem in SuperHypergraph

Input: A weighted superhypergraph SHG = (𝑉, 𝐸)
Output: A minimal-weight closed superhyperpath traversing every superhyperedge at least once
1 Initialization:
2 Construct an incidence multigraph 𝐺 = (𝑉 ′ , 𝐸 ′ ), where:
• 𝑉 ′ = 𝑉, the vertices of SHG,
• 𝐸 ′ is formed by replacing each superhyperedge 𝑒 ∈ 𝐸 with all edges between pairs of supervertices in 𝑒.
3 Degree Calculation:
4 Compute the degree deg(𝑣) of each vertex 𝑣 ∈ 𝑉 ′ in 𝐺.
5 Identify the set 𝑂 ⊆ 𝑉 ′ of vertices with odd degree in 𝐺.
6 Shortest Path Computation:
7 Compute the shortest paths between all pairs of vertices in 𝑂 using the Floyd-Warshall algorithm.
8 Perfect Matching:
9 Find a minimum-weight perfect matching 𝑀 on 𝑂 based on the shortest path distances.
10 Graph Augmentation:
11 Augment 𝐺 by adding the edges from the matching 𝑀.
12 Eulerian Circuit and Transformation:
13 Find an Eulerian circuit 𝐶 in the augmented graph 𝐺.
14 Transform the Eulerian circuit 𝐶 back into a superhyperpath in SHG.
15 return The minimal-weight closed superhyperpath corresponding to the Eulerian circuit 𝐶.
Theorem 3.40. Algorithm 9 finds a minimal-weight closed superhyperpath that traverses every superhyperedge
at least once in SHG.
Proof. The correctness of the algorithm relies on the properties of Eulerian circuits and the transformation
between the superhypergraph and the incidence multigraph.
Construction of 𝐺: By replacing each superhyperedge 𝑒 with edges between every pair of supervertices in 𝑒,
we create a multigraph 𝐺 that captures the connectivity of SHG.
262
Eulerian Circuit Existence: In 𝐺, we compute the degrees of all vertices. By adding edges (paths) between
pairs of vertices with odd degrees to make all degrees even (through the minimum weight perfect matching
𝑀), we ensure that the augmented graph 𝐺 is Eulerian.
Minimum Weight Matching: The matching 𝑀 is chosen to minimize the additional weight added to 𝐺, which
corresponds to minimizing the total traversal cost in SHG.
Eulerian Circuit and Superhyperpath Correspondence: An Eulerian circuit in 𝐺 traverses every edge at least
once. Since edges in 𝐺 correspond to superhyperedges or shortest paths between supervertices in SHG, the
circuit can be mapped back to a closed superhyperpath in SHG that traverses every superhyperedge at least
once.
Optimality: The algorithm constructs a circuit with minimal total weight because it only adds the minimum
necessary edges (with minimal total weight) to make the graph Eulerian. Therefore, the resulting superhyperpath
is of minimal weight. □
Theorem 3.41. The algorithm runs in polynomial time, specifically 𝑂 (|𝑉 | 3 ).
Proof. The time complexity of each step is as follows:
• Constructing 𝐺: Replacing each superhyperedge 𝑒 with edges between every pair of supervertices in 𝑒
can be done in 𝑂 (|𝐸 | · 𝑚 2 ), where 𝑚 is the maximum size of a superhyperedge. Since 𝑚 ≤ |𝑉 |, this step
is 𝑂 (|𝐸 | · |𝑉 | 2 ).
• Computing Degrees: Calculated in 𝑂 (|𝑉 |).
• Identifying Odd-Degree Vertices 𝑂: 𝑂 (|𝑉 |).
• Computing Shortest Paths: Using the Floyd-Warshall algorithm(cf. [5, 65]), this takes 𝑂 (|𝑉 | 3 ).
• Minimum Weight Perfect Matching(cf. [25]): Can be found in 𝑂 (|𝑉 | 3 ) using algorithms such as the
Hungarian method.
• Finding Eulerian Circuit: Linear in the number of edges, 𝑂 (|𝐸 ′ |).
• Transforming Circuit Back to SHG: 𝑂 (|𝐸 ′ |).
The dominant terms are the shortest path computation and the matching, both 𝑂 (|𝑉 | 3 ). Therefore, the overall
time complexity is 𝑂 (|𝑉 | 3 ). □
3.10 Longest Simple Path Problem in SuperHypergraphs
The Longest Simple Path Problem in SuperHypergraphs involves finding a maximum-length path that visits
each supervertex at most once, satisfying adjacency constraints defined by the superhyperedges [86]. The
problem considered in this subsection is described below.
Problem 3.42. Given a superhypergraph SHG = (𝑉, 𝐸) and two supervertices 𝑢, 𝑣 ∈ 𝑉, the Longest Simple
Path Problem seeks the longest superhyperpath connecting 𝑢 and 𝑣, where the path is defined in terms of the
number of superhyperedges.
Theorem 3.43. The Longest Simple Path Problem in SuperHypergraphs is NP-hard.
Proof. We reduce the classical Longest Path Problem (LPP) in graphs, known to be NP-hard, to the Longest
Simple Path Problem in superhypergraphs. Let 𝐺 = (𝑉𝐺 , 𝐸 𝐺 ) be an instance of LPP. Construct a superhyper-
graph SHG = (𝑉, 𝐸) as follows:
• For each vertex 𝑣 ∈ 𝑉𝐺 , create a supervertex {𝑣} ∈ 𝑉.

• For each edge (𝑢, 𝑣) ∈ 𝐸 𝐺 , create a superhyperedge {{𝑢}, {𝑣}} ∈ 𝐸.
A simple path in 𝐺 corresponds to a superhyperpath in SHG. Therefore, solving the Longest Simple Path
Problem in SHG provides a solution to LPP in 𝐺. Since LPP is NP-hard, the Longest Simple Path Problem in
superhypergraphs is also NP-hard. □
263
3.11 Maximum Spanning Tree Problem in SuperHypergraphs
The Maximum Spanning Tree Problem (cf. [47, 76, 81]) in SuperHypergraphs seeks a superhypertree that
connects all supervertices while maximizing the total weight of selected superhyperedges, maintaining tree-
like structural constraints. The problem considered in this subsection is described below.
Problem 3.44. Given a weighted superhypergraph SHG = (𝑉, 𝐸), the Maximum Spanning Tree Problem seeks
a superhypertree 𝑇 = (𝑉, 𝐸𝑇 ) such that:
1. 𝑇 satisfies the conditions of a superhypertree.

Í
2. The total weight of 𝑇, defined as 𝑤(𝑇) = 𝑒∈𝐸𝑇 𝑤(𝑒), is maximized.
Algorithm 10: Maximum Spanning SuperHypertree Algorithm

Input: A weighted superhypergraph SHG = (𝑉, 𝐸)
Output: A Maximum Spanning SuperHypertree 𝑇 = (𝑉, 𝐸𝑇 )
1 Initialize 𝐸𝑇 ← ∅;
2 Sort the superhyperedges 𝐸 in non-increasing order of weight;
3 Initialize a disjoint-set data structure for vertices in 𝑉;
4 foreach superhyperedge 𝑒 ∈ 𝐸 (in sorted order) do
5 Compute the union of sets containing vertices in 𝑒;
6 if adding 𝑒 does not create a cycle then
7 Add 𝑒 to 𝐸𝑇 ;
8 Update the disjoint-set structure for all vertices in 𝑒;
9 return 𝑇 = (𝑉, 𝐸𝑇 );
Theorem 3.45. The above algorithm correctly computes the Maximum Spanning SuperHypertree for a weighted
superhypergraph SHG.
Proof. The algorithm iteratively adds the heaviest superhyperedge 𝑒 to 𝐸𝑇 while maintaining the superhypertree
properties:
• Acyclicity: The disjoint-set structure ensures that no cycles are formed.

• Connectedness: By construction, the algorithm only terminates when 𝐸𝑇 connects all supervertices in
𝑉.
• Optimality: At each step, the algorithm selects the heaviest available superhyperedge that maintains the
superhypertree properties, ensuring the total weight 𝑤(𝑇) is maximized.
Thus, the algorithm is correct. □

Theorem 3.46. The time complexity of the algorithm is 𝑂 (|𝐸 |·log |𝐸 |+|𝐸 |·𝑚·𝛼(|𝑉 |)), where 𝑚 is the maximum
size of a superhyperedge and 𝛼 is the inverse Ackermann function. The space complexity is 𝑂 (|𝑉 | + |𝐸 |).
Proof. Time Complexity:
• Sorting the superhyperedges takes 𝑂 (|𝐸 | · log |𝐸 |).

• Processing each superhyperedge involves:
– 𝑚 Find operations, each taking 𝑂 (𝛼(|𝑉 |)).
– At most one Union operation, taking 𝑂 (𝛼(|𝑉 |)).
264
• Thus, processing all superhyperedges takes 𝑂 (|𝐸 | · 𝑚 · 𝛼(|𝑉 |)).
The total time complexity is 𝑂 (|𝐸 | · log |𝐸 | + |𝐸 | · 𝑚 · 𝛼(|𝑉 |)).
Space Complexity:
• Storing the disjoint-set structure requires 𝑂 (|𝑉 |).

• Storing the superhyperedges requires 𝑂 (|𝐸 |).
Thus, the space complexity is 𝑂 (|𝑉 | + |𝐸 |). □
3.12 Horn satisfiability problem in a Superhypergraph
The Horn Satisfiability Problem determines whether a Boolean formula in conjunctive normal form, with at
most one positive literal per clause, is satisfiable(cf. [48]). In this subsection, we explore the Horn Satisfiability
Problem in a SuperHyperGraph. The related definitions and an overview of the problem are provided below.
Definition 3.47 (Boolean Variable). (cf. [68]) A Boolean variable is a variable that can take one of two possible
values: True (1) or False (0). Formally, a Boolean variable 𝑥 is defined as:
𝑥 ∈ {0, 1},
where 1 represents True and 0 represents False.
Definition 3.48 (Satisfiable). A Boolean formula is said to be satisfiable if there exists an assignment of
True (1) or False (0) to its Boolean variables such that the entire formula evaluates to True. Formally,
for a formula 𝐹 (𝑥 1 , 𝑥2 , . . . , 𝑥 𝑛 ) composed of Boolean variables 𝑥 1 , 𝑥2 , . . . , 𝑥 𝑛 , 𝐹 is satisfiable if there exists an
assignment 𝐴 : {𝑥 1 , 𝑥2 , . . . , 𝑥 𝑛 } → {0, 1} such that:
𝐹 ( 𝐴(𝑥1 ), 𝐴(𝑥2 ), . . . , 𝐴(𝑥 𝑛 )) = 1.
Definition 3.49 (Horn Clause). (cf. [48]) A Horn clause is a disjunction of literals with at most one positive
literal. Formally, a Horn clause 𝐶 is of the form:
¬𝑥1 ∨ ¬𝑥 2 ∨ · · · ∨ ¬𝑥 𝑘 ∨ 𝑥 𝑘+1 ,
where 𝑥 1 , 𝑥2 , . . . , 𝑥 𝑘 , 𝑥 𝑘+1 are Boolean variables. The clause is satisfied if at least one literal evaluates to True.
Problem 3.50 (Horn Satisfiability Problem in a Superhypergraph). (cf. [48, 80]) Let 𝐻 = (𝑉, 𝐸) be a super-
hypergraph, where 𝑉 is a set of supervertices and 𝐸 is a set of superhyperedges. Each superhyperedge 𝑒 ∈ 𝐸
represents a Horn clause. The Horn Satisfiability Problem in a Superhypergraph is to determine whether there
exists a satisfying assignment 𝑓 : 𝑉 → {True, False} such that every clause (superhyperedge) is satisfied.
We adapt the Unit Propagation algorithm, which is commonly used for Horn formulas, to solve the satisfiability
problem in Superhypergraphs.
Algorithm 11: Horn Satisfiability in a Superhypergraph

Input: A superhypergraph 𝐻 = (𝑉, 𝐸), where each 𝑒 ∈ 𝐸 represents a Horn clause.
Output: True if the Horn clauses are satisfiable, False otherwise.
1 Initialize all vertices 𝑣 ∈ 𝑉 as Unknown;
2 repeat
3 foreach hyperedge 𝑒 ∈ 𝐸 do
4 if all but one literal in 𝑒 are assigned a value and the remaining literal is unassigned then
5 Assign the remaining literal to satisfy the clause;
6 until no changes occur;

7 if all clauses are satisfied then
8 return True;
9 else
10 return False;
265
Theorem 3.51. The algorithm correctly determines whether the given Horn clauses represented by the super-
hypergraph are satisfiable.
Proof. The algorithm performs unit propagation, which ensures that:
1. If a Horn clause has all literals but one assigned and the remaining literal is unassigned, the remaining
literal is assigned a value to satisfy the clause.
2. This process repeats until no further assignments can be made.
If all clauses are satisfied after this process, the formula is satisfiable, and the algorithm returns True. If a
state is reached where no assignment can satisfy a clause, the formula is unsatisfiable, and the algorithm returns
False. □
Theorem 3.52 (Time Complexity). The worst-case time complexity of the algorithm is 𝑂 (|𝐸 |).
Proof. In each iteration, the algorithm processes all hyperedges 𝑒 ∈ 𝐸. Since each hyperedge is processed
once, the overall complexity is 𝑂 (|𝐸 |). □
Theorem 3.53 (Space Complexity). The space complexity of the algorithm is 𝑂 (|𝑉 |).
Proof. The algorithm requires space to store the assignment of truth values for all vertices 𝑣 ∈ 𝑉. Therefore,
the space complexity is 𝑂 (|𝑉 |). □
4 Future Tasks of This Research
This section outlines the future tasks related to this research.
Beyond the problems discussed in this paper, numerous classic problems in graph theory and computer science
are well-known for standard graphs [50]. Expanding these problems to the framework of superhypergraphs
presents an exciting avenue for future exploration.
Additionally, we hope that further investigations will focus on extending superhypergraph problems and
algorithms to fuzzy environments [97, 122, 123], neutrosophic environments [37, 101, 102, 112], hypersoft
environments [36, 43, 103], and plithogenic environments [38, 40, 44, 45, 104]. These extensions could provide
deeper insights and broader applications of superhypergraph theory.
Funding
This research received no external funding.
Acknowledgments
We humbly extend our heartfelt gratitude to everyone who has provided invaluable support, enabling the
successful completion of this paper. We also express our sincere appreciation to all readers who have taken the
time to engage with this work. Furthermore, we extend our deepest respect and gratitude to the authors of the
references cited in this paper. Thank you for your significant contributions.
Data Availability
This paper does not involve any data analysis.
266
Ethical Approval
This article does not involve any research with human participants or animals.
Conflicts of Interest
The authors declare that there are no conflicts of interest regarding the publication of this paper.
Disclaimer
This study primarily focuses on theoretical aspects, and its application to practical scenarios has not yet
been validated. Future research may involve empirical testing and refinement of the proposed methods. The
authors have made every effort to ensure that all references cited in this paper are accurate and appropriately
attributed. However, unintentional errors or omissions may occur. The authors bear no legal responsibility for
inaccuracies in external sources, and readers are encouraged to verify the information provided in the references
independently. Furthermore, the interpretations and opinions expressed in this paper are solely those of the
authors and do not necessarily reflect the views of any affiliated institutions.
References
[1] Scott Aaronson and Alex Arkhipov. The computational complexity of linear optics. In Proceedings of
the forty-third annual ACM symposium on Theory of computing, pages 333–342, 2011.
[2] Isolde Adler, Tomáš Gavenčiak, and Tereza Klimošová. Hypertree-depth and minors in hypergraphs.
Theoretical Computer Science, 463:84–95, 2012.
[3] Isolde Adler, Georg Gottlob, and Martin Grohe. Hypertree width and related hypergraph invariants.
European Journal of Combinatorics, 28(8):2167–2181, 2007.
[4] Hamed Ahmadi and José Ramon Martı́. Minimum-loss network reconfiguration: A minimum spanning
tree problem. Sustainable Energy, Grids and Networks, 1:1–9, 2015.
[5] Asghar Aini and Amir Salehipour. Speeding up the floyd-warshall algorithm for the cycled shortest path
problem. Appl. Math. Lett., 25:1–5, 2012.
[6] Md. Tanvir Alam, Chowdhury Farhan Ahmed, Md. Samiullah, and Carson Kai-Sang Leung. Mining
frequent patterns from hypergraph databases. In Pacific-Asia Conference on Knowledge Discovery and
Data Mining, 2021.
[7] Eric Allender. Reachability problems: An update. In Computation and Logic in the Real World: Third
Conference on Computability in Europe, CiE 2007, Siena, Italy, June 18-23, 2007. Proceedings 3, pages
25–27. Springer, 2007.
[8] Eric Allender, Samir Datta, and Sambuddha Roy. The directed planar reachability problem. In FSTTCS
2005: Foundations of Software Technology and Theoretical Computer Science: 25th International
Conference, Hyderabad, India, December 15-18, 2005. Proceedings 25, pages 238–249. Springer,
2005.
[9] Ali Alqazzaz and Karam M Sallam. Evaluation of sustainable waste valorization using treesoft set with
neutrosophic sets. Neutrosophic Sets and Systems, 65(1):9, 2024.
[10] Sanjeev Arora and Boaz Barak. Computational complexity: a modern approach. Cambridge University
Press, 2009.
[11] M Amin Bahmanian and Mateja Šajna. Hypergraphs: connection and separation. arXiv preprint
arXiv:1504.04274, 2015.
[12] Mohammad A Bahmanian and Mateja Sajna. Connection and separation in hypergraphs. Theory and
Applications of Graphs, 2(2):5, 2015.
[13] Claude Berge. Hypergraphs: combinatorics of finite sets, volume 45. Elsevier, 1984.
267
[14] Hans L Bodlaender. A tourist guide through treewidth. Acta cybernetica, 11(1-2):1–21, 1993.
[15] Hans L Bodlaender, Michael R Fellows, and Michael T Hallett. Beyond np-completeness for problems
of bounded width (extended abstract) hardness for the w hierarchy. In Proceedings of the twenty-sixth
annual ACM symposium on Theory of computing, pages 449–458, 1994.
[16] Hans L Bodlaender and Arie MCA Koster. Treewidth computations i. upper bounds. Information and
Computation, 208(3):259–275, 2010.
[17] Walter S Brainerd. The minimalization of tree automata. Information and Control, 13(5):484–491,
1968.
[18] Nicolas Broutin, Luc Devroye, and Erin McLeish. Note on the structure of kruskal’s algorithm. Algo-
rithmica, 56:141–159, 2010.
[19] Robin L. P. Chang and Theodosios Pavlidis. Fuzzy decision tree algorithms. IEEE Transactions on
Systems, Man, and Cybernetics, 7:28–35, 1977.
[20] Yi-lai Chen, Tao Wang, Ben-sheng Wang, and Zhou-jun Li. A survey of fuzzy decision tree classifier.
Fuzzy Information and Engineering, 1:149–159, 2009.
[21] Eli Chien, Chao Pan, Jianhao Peng, and Olgica Milenkovic. You are allset: A multiset function
framework for hypergraph neural networks. ArXiv, abs/2106.13264, 2021.
[22] Yusuf Civan and Demet Taylan. Coloring hypercomplete and hyperpath graphs. Turkish Journal of
Mathematics, 38(1):1–15, 2014.
[23] Hubert Comon, Max Dauchet, Rémi Gilleron, Florent Jacquemard, Denis Lugiez, Christof Löding,
Sophie Tison, and Marc Tommasi. Tree automata techniques and applications, 2008.
[24] Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms.
MIT press, 2022.
[25] Ulrich Derigs. A generalized hungarian method for solving minimum weight perfect matching problems
with algebraic objective. Discret. Appl. Math., 1:167–180, 1979.
[26] Reinhard Diestel. Graduate texts in mathematics: Graph theory.
[27] Reinhard Diestel. Graph theory 3rd ed. Graduate texts in mathematics, 173(33):12, 2005.
[28] Reinhard Diestel. Graph theory. Springer (print edition); Reinhard Diestel (eBooks), 2024.
[29] Marco Dorigo and Luca Maria Gambardella. Ant colony system: a cooperative learning approach to
the traveling salesman problem. IEEE Trans. Evol. Comput., 1:53–66, 1997.
[30] Horst A. Eiselt, Michel Gendreau, and Gilbert Laporte. Arc routing problems, part i: The chinese
postman problem. Oper. Res., 43:231–242, 1995.
[31] Shimon Even. Graph algorithms. Cambridge University Press, 2011.
[32] Yifan Feng, Haoxuan You, Zizhao Zhang, R. Ji, and Yue Gao. Hypergraph neural networks. In AAAI
Conference on Artificial Intelligence, 2018.
[33] Carlos Eduardo Ferreira, Alexander Martin, Cid C. de Souza, Robert Weismantel, and Laurence A.
Wolsey. The node capacitated graph partitioning problem: A computational study. Mathematical
Programming, 81:229–256, 1998.
[34] Eldar Fischer, Arie Matsliah, and Asaf Shapira. Approximate hypergraph partitioning and applications.
SIAM Journal on Computing, 39(7):3155–3185, 2010.
[35] Ronald C. Freiwald. An introduction to set theory and topology. 2014.
[36] Takaaki Fujita. Note for hypersoft filter and fuzzy hypersoft filter. Multicriteria Algorithms With
Applications, 5:32–51, 2024.
[37] Takaaki Fujita. Note for neutrosophic incidence and threshold graph. SciNexuses, 1:97–125, 2024.
268
[38] Takaaki Fujita. A review of the hierarchy of plithogenic, neutrosophic, and fuzzy graphs: Survey and
applications. ResearchGate(Preprint), 2024.
[39] Takaaki Fujita. Short note of supertree-width and n-superhypertree-width. Neutrosophic Sets and
Systems, 77:54–78, 2024.
[40] Takaaki Fujita. Advancing Uncertain Combinatorics through Graphization, Hyperization, and Uncer-
tainization: Fuzzy, Neutrosophic, Soft, Rough, and Beyond. Biblio Publishing, 2025.
[41] Takaaki Fujita. A comprehensive discussion on fuzzy hypersoft expert, superhypersoft, and indetermsoft
graphs. Neutrosophic Sets and Systems, 77:241–263, 2025.
[42] Takaaki Fujita and Florentin Smarandache. A concise study of some superhypergraph classes. Neutro-
sophic Sets and Systems, 77:548–593, 2024.
[43] Takaaki Fujita and Florentin Smarandache. A short note for hypersoft rough graphs. HyperSoft Set
Methods in Engineering, 3:1–25, 2024.
[44] Takaaki Fujita and Florentin Smarandache. Study for general plithogenic soft expert graphs. Plithogenic
Logic and Computation, 2:107–121, 2024.
[45] Takaaki Fujita and Florentin Smarandache. Uncertain automata and uncertain graph grammar. Neutro-
sophic Sets and Systems, 74:128–191, 2024.
[46] Harold N Gabow, Zvi Galil, Thomas Spencer, and Robert E Tarjan. Efficient algorithms for finding
minimum spanning trees in undirected and directed graphs. Combinatorica, 6(2):109–122, 1986.
[47] Giulia Galbiati, Angelo Morzenti, and Francesco Maffioli. On the approximability of some maximum
spanning tree problems. Theoretical Computer Science, 181(1):107–118, 1997.
[48] Giorgio Gallo, Claudio Gentile, Daniele Pretolani, and Gabriella Rago. Max horn sat and the minimum
cut problem in directed hypergraphs. Mathematical Programming, 80:213–237, 1998.
[49] Yue Gao, Yifan Feng, Shuyi Ji, and Rongrong Ji. Hgnn+: General hypergraph neural networks. IEEE
Transactions on Pattern Analysis and Machine Intelligence, 45:3181–3199, 2022.
[50] Michael R Garey and David S Johnson. Computers and intractability, volume 174. freeman San
Francisco, 1979.
[51] Masoud Ghods, Zahra Rostami, and Florentin Smarandache. Introduction to neutrosophic restricted su-
perhypergraphs and neutrosophic restricted superhypertrees and several of their properties. Neutrosophic
Sets and Systems, 50:480–487, 2022.
[52] Georg Gottlob, Gianluigi Greco, Nicola Leone, and Francesco Scarcello. Hypertree decompositions:
Questions and answers. In Proceedings of the 35th ACM SIGMOD-SIGACT-SIGAI Symposium on
Principles of Database Systems, pages 57–74, 2016.
[53] Georg Gottlob, Gianluigi Greco, Francesco Scarcello, et al. Treewidth and hypertree width. Tractability:
Practical Approaches to Hard Problems, 1:20, 2014.
[54] Georg Gottlob, Nicola Leone, and Francesco Scarcello. Hypertree decompositions and tractable queries.
In Proceedings of the eighteenth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database
systems, pages 21–32, 1999.
[55] Georg Gottlob, Nicola Leone, and Francesco Scarcello. Hypertree decompositions: A survey. In
Mathematical Foundations of Computer Science 2001: 26th International Symposium, MFCS 2001
Mariánské Lázne, Czech Republic, August 27–31, 2001 Proceedings 26, pages 37–57. Springer, 2001.
[56] Georg Gottlob and Reinhard Pichler. Hypergraphs in model checking: Acyclicity and hypertree-width
versus clique-width. SIAM Journal on Computing, 33(2):351–378, 2004.
[57] Ronald L. Graham and Pavol Hell. On the history of the minimum spanning tree problem. Annals of the
History of Computing, 7:43–57, 1985.
[58] Dae Geun Ha, Tae Wook Ha, Junghyuk Seo, and Myoung-Ho Kim. Index-based searching for isomorphic
subgraphs in hypergraph databases. Journal of KIISE, 2019.
269
[59] Mohammad Hamidi, Florentin Smarandache, and Elham Davneshvar. Spectrum of superhypergraphs
via flows. Journal of Mathematics, 2022(1):9158912, 2022.
[60] Mohammad Hamidi and Mohadeseh Taghinezhad. Application of Superhypergraphs-Based Domination
Number in Real World. Infinite Study, 2023.
[61] Juris Hartmanis and Richard E Stearns. On the computational complexity of algorithms. Transactions
of the American Mathematical Society, 117:285–306, 1965.
[62] Felix Hausdorff. Set theory, volume 119. American Mathematical Soc., 2021.
[63] Dorit S Hochba. Approximation algorithms for np-hard problems. ACM Sigact News, 28(2):40–52,
1997.
[64] Seok-Hee Hong. Algorithms for 1-planar graphs. In Beyond Planar Graphs: Communications of NII
Shonan Meetings, pages 69–87. Springer, 2020.
[65] Stefan Hougardy. The floyd-warshall algorithm on graphs with negative cycles. Inf. Process. Lett.,
110:279–281, 2010.
[66] Karel Hrbacek and Thomas Jech. Introduction to set theory, revised and expanded. 2017.
[67] Thomas Jech. Set theory: The third millennium edition, revised and expanded. Springer, 2003.
[68] Jeff Kahn, Gil Kalai, and Nathan Linial. The influence of variables on Boolean functions. Institute for
Mathematical Studies in the Social Sciences, 1989.
[69] George Karypis. Multilevel hypergraph partitioning. In Multilevel Optimization in VLSICAD, pages
125–154. Springer, 2003.
[70] Spencer Krieger and John Kececioglu. Shortest hyperpaths in directed hypergraphs for reaction pathway
inference. Journal of Computational Biology, 30(11):1198–1225, 2023.
[71] G. Laszewski. Intelligent structural operators for the k-way graph partitioning problem. In International
Conference on Genetic Algorithms, 1991.
[72] Azriel Levy. Basic set theory. Courier Corporation, 2012.
[73] Shen Lin and Brian W. Kernighan. An effective heuristic algorithm for the traveling-salesman problem.
Oper. Res., 21:498–516, 1973.
[74] David López and Angélica Lozano. Shortest hyperpaths in a multimodal hypergraph with real-time
information on some transit lines. Transportation Research Part A: Policy and Practice, 137:541–559,
2020.
[75] Dániel Marx. Approximating fractional hypertree width. ACM Transactions on Algorithms (TALG),
6(2):1–17, 2010.
[76] Sugama Maskar. Maximum spanning tree graph model: National examination data analysis of junior
high school in lampung province. In Proceeding International Conference on Science and Engineering,
volume 3, pages 375–378, 2020.
[77] Ulrich Meyer and Peter Sanders. Delta-stepping: A parallel single source shortest path algorithm. In
Embedded Systems and Applications, 1998.
[78] Zoltán Miklós. Understanding Tractable Decompositions for Constraint Satisfaction. PhD thesis,
University of Oxford, 2008.
[79] Edward Minieka. The chinese postman problem for mixed networks. Management Science, 25:643–648,
1979.
[80] Michel Minoux. The unique horn-satisfiability problem and quadratic boolean equations. Annals of
Mathematics and Artificial Intelligence, 6:253–266, 1992.
[81] Clyde Monma, Mike Paterson, Subhash Suri, and Frances Yao. Computing euclidean maximum spanning
trees. In Proceedings of the fourth annual symposium on Computational geometry, pages 241–251, 1988.
270
[82] Takao Nishizeki and Norishige Chiba. Planar graphs: Theory and algorithms. Elsevier, 1988.
[83] Dan Olteanu and Jakub Závodnỳ. Factorised representations of query results: size bounds and readability.
In Proceedings of the 15th International Conference on Database Theory, pages 285–298, 2012.
[84] James B. Orlin, Kamesh Madduri, K. Subramani, and Matthew D. Williamson. A faster algorithm
for the single source shortest path problem with few distinct positive lengths. J. Discrete Algorithms,
8:189–198, 2010.
[85] Christos H Papadimitriou. Computational complexity. In Encyclopedia of computer science, pages
260–265. 2003.
[86] Quang Dung Pham and Yves Deville. Solving the longest simple path problem with constraint-based
techniques. In Integration of AI and OR Techniques in Contraint Programming for Combinatorial
Optimzation Problems: 9th International Conference, CPAIOR 2012, Nantes, France, May 28–June1,
2012. Proceedings 9, pages 292–306. Springer, 2012.
[87] Petrica C. Pop, Ovidiu Cosma, Cosmin Sabo, and Corina Pop Sitar. A comprehensive survey on the
generalized traveling salesman problem. Eur. J. Oper. Res., 314:819–835, 2023.
[88] Gomathi Ramalingam and T. Reps. An incremental algorithm for a generalization of the shortest-path
problem. J. Algorithms, 21:267–305, 1996.
[89] Lisbeth J Reales-Chacón, Marı́a E Lucena de Ustáriz, Francisco J Ustáriz-Fajardo, Andrea C Peñafiel
Luna, Gabriela J Bonilla-Ayala, Pablo Djabayan-Djibeyan, José L Erazo-Parra, and Mónica A
Valdiviezo-Maygua. Study of the efficacy of neural mobilizations to improve sensory and functional
responses of lower extremities in older adults with diabetic peripheral neuropathy using plithogenic
n-superhypergraphs. Neutrosophic Sets and Systems, 74:1–12, 2024.
[90] Neil Robertson and Paul D. Seymour. Graph minors. i. excluding a forest. Journal of Combinatorial
Theory, Series B, 35(1):39–61, 1983.
[91] Neil Robertson and Paul D. Seymour. Graph minors. iii. planar tree-width. Journal of Combinatorial
Theory, Series B, 36(1):49–64, 1984.
[92] Neil Robertson and Paul D. Seymour. Graph minors. ii. algorithmic aspects of tree-width. Journal of
algorithms, 7(3):309–322, 1986.
[93] Neil Robertson and Paul D Seymour. Graph minors. v. excluding a planar graph. Journal of Combinatorial
Theory, Series B, 41(1):92–114, 1986.
[94] Neil Robertson and Paul D Seymour. Graph minors. iv. tree-width and well-quasi-ordering. Journal of
Combinatorial Theory, Series B, 48(2):227–254, 1990.
[95] Neil Robertson and Paul D Seymour. Graph minors. viii. a kuratowski theorem for general surfaces.
Journal of Combinatorial Theory, Series B, 48(2):255–288, 1990.
[96] Neil Robertson and Paul D. Seymour. Graph minors. x. obstructions to tree-decomposition. Journal of
Combinatorial Theory, Series B, 52(2):153–190, 1991.
[97] Azriel Rosenfeld. Fuzzy graphs. In Fuzzy sets and their applications to cognitive and decision processes,
pages 77–95. Elsevier, 1975.
[98] Sebastian Schlag, Tobias Heuer, Lars Gottesbüren, Yaroslav Akhremtsev, Christian Schulz, and Peter
Sanders. High-quality hypergraph partitioning. ACM Journal of Experimental Algorithmics, 27:1–39,
2023.
[99] Robert Sedgewick and Kevin Wayne. Algorithms. Addison-wesley professional, 2011.
[100] Arunabha Sen, Haiyong Deng, and Sumanta Guha. On a graph partition problem with application to
vlsi layout. Inf. Process. Lett., 43:87–94, 1992.
[101] Florentin Smarandache. A unifying field in logics: Neutrosophic logic. In Philosophy, pages 1–141.
American Research Press, 1999.
271
[102] Florentin Smarandache. Neutrosophic set-a generalization of the intuitionistic fuzzy set. International
journal of pure and applied mathematics, 24(3):287, 2005.
[103] Florentin Smarandache. Extension of soft set to hypersoft set, and then to plithogenic hypersoft set.
Neutrosophic sets and systems, 22(1):168–170, 2018.
[104] Florentin Smarandache. Plithogenic set, an extension of crisp, fuzzy, intuitionistic fuzzy, and neutrosophic
sets-revisited. Infinite study, 2018.
[105] Florentin Smarandache. n-superhypergraph and plithogenic n-superhypergraph. Nidus Idearum, 7:107–
113, 2019.
[106] Florentin Smarandache. Extension of HyperGraph to n-SuperHyperGraph and to Plithogenic n-

SuperHyperGraph, and Extension of HyperAlgebra to n-ary (Classical-/Neutro-/Anti-) HyperAlgebra.
Infinite Study, 2020.
[107] Florentin Smarandache. Introduction to the n-SuperHyperGraph-the most general form of graph today.
Infinite Study, 2022.
[108] Florentin Smarandache. Decision making based on valued fuzzy superhypergraphs. 2023.
[109] Florentin Smarandache. New types of soft sets “hypersoft set, indetermsoft set, indetermhypersoft set,
and treesoft set”: an improved version. Infinite Study, 2023.
[110] Florentin Smarandache. SuperHyperFunction, SuperHyperStructure, Neutrosophic SuperHyperFunc-
tion and Neutrosophic SuperHyperStructure: Current understanding and future directions. Infinite
Study, 2023.
[111] Florentin Smarandache. Foundation of superhyperstructure & neutrosophic superhyperstructure. Neu-
trosophic Sets and Systems, 63(1):21, 2024.
[112] Florentin Smarandache. Short introduction to standard and nonstandard neutrosophic set and logic.
Neutrosophic Sets and Systems, 77:395–404, 2025.
[113] Justin Sybrandt, Ruslan Shaydulin, and Ilya Safro. Hypergraph partitioning with embeddings. IEEE
Transactions on Knowledge and Data Engineering, 34(6):2771–2782, 2020.
[114] Robert E Tarjan and Mihalis Yannakakis. Simple linear-time algorithms to test chordality of graphs,
test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs. SIAM Journal on computing,
13(3):566–579, 1984.
[115] Robert Endre Tarjan. Depth-first search and linear graph algorithms. SIAM J. Comput., 1:146–160,
1972.
[116] Lev Telyatnikov, Maria Sofia Bucarelli, Guillermo Bernardez, Olga Zaghen, Simone Scardapane, and
Pietro Lió. Hypergraph neural networks through the lens of message passing: A common perspective
to homophily and architecture design. ArXiv, abs/2310.07684, 2023.
[117] Harold W. Thimbleby. The directed chinese postman problem. Software: Practice and Experience, 33,
2003.
[118] Ioan Tomescu and Marius Zimand. Minimum spanning hypertrees. Discret. Appl. Math., 54:67–76,
1994.
[119] Douglas Brent West et al. Introduction to graph theory, volume 2. Prentice hall Upper Saddle River,
2001.
[120] Gerhard J Woeginger. Exact algorithms for np-hard problems: A survey. In Combinatorial Optimization-
Eureka, You Shrink! Papers Dedicated to Jack Edmonds 5th International Workshop Aussois, France,
March 5–9, 2001 Revised Papers, pages 185–207. Springer, 2003.
[121] Nikola Yolov. Minor-matching hypertree width. In Proceedings of the Twenty-Ninth Annual ACM-SIAM
Symposium on Discrete Algorithms, pages 219–233. SIAM, 2018.
[122] Lotfi A Zadeh. Fuzzy sets. Information and control, 8(3):338–353, 1965.
272

Fundamental Computational Problems and Algorithms for SuperHyperGraphs

Uploaded by

Fundamental Computational Problems and Algorithms for SuperHyperGraphs

Uploaded by

Fundamental Computational Problems and Algorithms for SuperHyperGraphs, pp.

240-272, in Takaaki Fujita, Florentin Smarandache:

Fundamental Computational Problems and Algorithms for

Keywords: Superhypergraph, Hypergraph, Tree-width, Algorithm

1.1 Graphs and Hypergraphs

1.2 Graph Width Parameters

1.4 Contributions of This Paper

• Exact Construction of SuperHyperGraph: Develops an algorithm to construct a SuperHyperGraph from

• Maximum Spanning Tree Problem in SuperHypergraphs: Proposes algorithms to compute a SuperHy-

1.5 The Structure of the Paper

The structure of this paper is as follows.

2 Preliminaries and Definitions

2.1 Graphs and Hypergraphs

• 𝑉𝐻 ⊆ 𝑉, i.e., the vertex set of 𝐻 is a subset of the vertex set of 𝐺.

• 𝐸 𝐻 ⊆ 𝐸, i.e., the edge set of 𝐻 is a subset of the edge set of 𝐺.

Key properties of a hypergraph:

satisfying the following conditions:

• Endpoint Condition: 𝑢 ∈ 𝑒 1 and 𝑣 ∈ 𝑒 𝑘 .

The length of the hyperpath is the number of hyperedges in 𝑃, denoted |𝑃| = 𝑘.

2.2 Tree-width and Hypertree-width

• (𝑇, 𝐵) is a tree decomposition of 𝐻, where:

In other words, every vertex in 𝐵𝑡 must belong to at least one hyperedge in 𝐶𝑡 .

width(𝑇, 𝐵, 𝐶) = max{|𝐶𝑡 | | 𝑡 ∈ 𝑉 (𝑇)},

where |𝐶𝑡 | denotes the number of hyperedges in 𝐶𝑡 .

A hypertree decomposition of 𝐻 is a special case of a generalized hypertree decomposition (𝑇, 𝐵, 𝐶) that

2.3 SuperHyperGraph and Superhypertree

A Superhypertree is a tree in a Superhypergraph [39, 51]. A Superhypergraph is known as a generalization

Proof. Refer to [42] for details. □

3. Connectedness Condition: For any 𝑣, 𝑤 ∈ 𝑉, there exists a sequence of superedges 𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ∈ 𝐸

The length of the superhyperpath is the number of superhyperedges in 𝑃, denoted |𝑃| = 𝑘.

Proof. We will prove the proposition in two parts:

• (1) If 𝑃 is a SuperHyperpath, then 𝑃 satisfies the conditions of a SuperHyperTree.

(1) 𝑃 as a SuperHyperpath implies 𝑃 is a SuperHyperTree Let 𝑃 = (𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ) be a SuperHyperpath.

Since all three conditions of a SuperHyperTree are satisfied, 𝑃 is a SuperHyperTree.

Since 𝑃 satisfies all the conditions of a SuperHyperpath, 𝑃 is a SuperHyperpath.

Proof. Let 𝐻 = (𝑉, 𝐸) be a hypergraph that satisfies the conditions of a Hypertree:

• The host tree 𝑇 is acyclic.

To show that a Hypertree 𝐻 is a special case of a SuperHyperTree SHT:

With this mapping:

Proof. Let 𝐻 = (𝑉, 𝐸) be a hypergraph and 𝑃 = (𝑒 1 , 𝑒 2 , . . . , 𝑒 𝑘 ) be a hyperpath in 𝐻, satisfying:

Consider a SuperHyperPath 𝑃SHT in a SuperHyperGraph SHG = (𝑉SHT , 𝐸 SHT ), where:

• 𝑉SHT ⊆ P (𝑉), and 𝐸 SHT ⊆ P (𝑉SHT ).

To show that a HyperPath 𝑃 is a special case of a SuperHyperPath 𝑃SHT :

1. Let each vertex 𝑣 ∈ 𝑉 correspond to a singleton set {𝑣} ∈ 𝑉SHT .

This mapping preserves:

• The adjacency condition, as 𝑒 𝑖 ∩ 𝑒 𝑖+1 ≠ ∅ in 𝑃 implies 𝑒 SHT 𝑒 SHT

• The endpoint condition, as 𝑢 ∈ 𝑒 1 and 𝑣 ∈ 𝑒 𝑘 in 𝑃 correspond to 𝑢 ∈ 𝑒 SHT

SuperHyperTree-width is an abstraction of Hypertree-width, extending the concept of Tree-width. The defini-

The width of a SuperHyperTree decomposition (𝑇, B, C) is defined as:

• The input space, which depends on the size of the input 𝑛, 𝑚,

𝑓 (𝑛) ≤ 𝑐 · 𝑔(𝑛) for all 𝑛 ≥ 𝑛0 .

3 Results in this Paper

The results of this paper are presented below.

3.1 Exact Construct SuperHyperGraph

Algorithm 1: Construct SuperHyperGraph

• 𝑉 remains unchanged and consists of the original set of vertices.

Thus, the output 𝐻 = (𝑉, 𝐸) satisfies the definition of a SuperHyperGraph. □

Proof. The algorithm requires space to store:

• The vertex set 𝑉, requiring 𝑂 (|𝑉 |) space.

Thus, the total space complexity is 𝑂 (|C| + |𝑉 |). □

3.2 Algorithm: Recognizing a SuperHyperTree

Problem 3.5. Given a SuperHyperGraph 𝐻 = (𝑉, 𝐸), determine whether 𝐻 is a SuperHyperTree.

Algorithm 2: Recognize SuperHyperTree

Theorem 3.6. The algorithm correctly determines whether 𝐻 is a SuperHyperTree.

Proof. The algorithm verifies:

• The acyclicity of the host tree 𝑇.

3.3 Computation of SuperHyperTree-width

The Exact Algorithm for the Computation of SuperHyperTree-width is introduced as follows.

Algorithm 3: Computation of SuperHyperTree-width

3.3.2 Approximation Algorithm for SuperHyperTree-width

Algorithm 4: Approximation Algorithm for SuperHyperTree-width

Therefore, the overall time complexity is 𝑂 (𝑛2 ). □

3.4 Superhypergraph Partition Problem

The algorithm for solving this problem is presented below.

Algorithm 5: Superhypergraph Partitioning Algorithm

Proof. The algorithm maintains the balance constraint at each level: