Introduction for SuperHyperFunction and SuperHyperGraph with Some Algo-

1. Introduction

This section fixes the terminology and notation used throughout the paper. Unless stated otherwise, every graph considered here is finite.

2. Reviews: h, k-ary m, n-SuperHyperGraph

A m, n-SuperHyperGraph is a mathematical structure in which each vertex corresponds to an m, n-superhyperfunction defined on a base set, while the hyperedges group such functions together to represent higher-order relationships and contextual connections. An h, k-ary m, n-SuperHyperGraph further generalizes this idea by taking vertices as h, k-ary m, n-superhyperfunctions [22].

Notation 2.1. For a nonempty base set S define P0S := S, Pm1S := P PmS m ∈ N0, so P1S = PS, P2S = PPS, etc. We also use the Cartesian power X := X × · · · × X for h ∈ N.

| {z }

h copies

Definition 2.2 (m, n-superhyperfunction). [23, 24] Let m, n ∈ N and S ≠ . An m, n-superhyperfunction on S is a map f : PmS −→ PnS.

Equivalently, f ∈ Hom PmS, PnS as functions of sets.

Example 2.3 (Home cooking assistant: pantry ⇒ feasible recipes m, n = 1, 2). Let the base set of ingredients be S = {egg, milk, flour, tomato, cheese}.

Consider a fixed family of recipes (each recipe is a subset of S) R = {R1 = {egg, milk}, R2 = {flour, egg}, R3 = {tomato, cheese}} ⊆ P1S.

Define f : P1S −→ P2S, f A := { R ∈ R | R ⊆ A }.

Typing check. For any A ⊆ S, the set f A is a set of recipes, hence f A ⊆ P1S, i.e. f A ∈ PP1S = P2S.

Concrete evaluation. With pantry A = {egg, milk, flour}, f A = {R1, R2} = {{egg, milk}, {flour, egg}} ∈ P2S.

Property. If A ⊆ B then f A ⊆ f B (monotone w.r.t. ⊆).

Example 2.4 (Playlist curator: set of playlists ⇒ common tracks m, n = 2, 1). Let the base set of songs be S = {s1, s2, s3}. Three user playlists (each a subset of songs) are P1 = {s1, s2}, P2 = {s2, s3}, P3 = {s1, s2, s3} ∈ P1S.

Define f : P2S → P1S by intersection of all playlists in the input family:

U, U ≠ , fU := U∈U , U = .

Typing check. If U ∈ P2S, then U ⊆ P1S and U∈U U ⊆ S, so fU ∈ P1S.

Concrete evaluation. For U = {P1, P2} ∈ P2S, f{P1, P2} = P1 ∩ P2 = {s2} ∈ P1S.

Property. f is antitone: if U ⊆ V then fV ⊆ fU.

Definition 2.5 (m, n-SuperHyperGraph). [22] Fix m, n ∈ N and a nonempty base set S. Let m,nS := { f : PmS → PnS }.

An m, n-SuperHyperGraph is a pair SHG := V, E, where V ⊆ m,nS is a nonempty set of vertices (each vertex is a concrete m, n-superhyperfunction) and ≠ E ⊆ PV \ {} is a nonempty family of nonempty hyperedges. Each hyperedge E ∈ E groups a finite, nonempty set of superhyperfunctions to encode higher-order relations/constraints among them.

Example 2.6 (Urban mobility planners: m, n = 1, 2). Let the atomic services be S = {Bus_A, Subway_C, BikeDock_D, Taxi_E}.

Fix a catalogue of candidate itineraries (each a subset of S):

R = {R1 = {Bus_A, Subway_C}, R2 = {Subway_C, BikeDock_D}, R3 = {Taxi_E}} ⊆ P1S.

Define three 1, 2-superhyperfunctions fticket, fgreen, ffast : P1S → P2S by fticketA := { R ∈ R | Subway_C ∈ R and R ⊆ A }, fgreenA := { R ∈ R | BikeDock_D ∈ R and R ⊆ A }, ffastA := { R ∈ R | R ⊆ A and Taxi_E ∈ R or |R| = 1 }.

Then V = {fticket, fgreen, ffast} ⊆ 1,2S and we set E = { {fticket, fgreen}, {fticket, ffast} }.

Hence SHG = V, E is a valid m, n-SuperHyperGraph.

Concrete evaluation for A = {Bus_A, Subway_C, BikeDock_D}:

fticketA = {R1, R2}, fgreenA = {R2}, ffastA = {R1, R2}.

Each image is a subset of P1S, hence lies in P2S.

Example 2.7 (Hospital pathways: m, n = 1, 2). Let the atomic clinical events be S = {Triage, CTScan, Antibiotics, Admission, Discharge}.

Fix a small library of pathways Pth ⊆ P1S:

P1 = {Triage, CTScan, Admission}, P2 = {Triage, Antibiotics, Admission}, P3 = {Triage, CTScan, Discharge}.

Define 1, 2-superhyperfunctions fdiag, fabx, fadmit : P1S → P2S by fdiagA := { P ∈ Pth | CTScan ∈ P and P ⊆ A }, fabxA := { P ∈ Pth | Antibiotics ∈ P and P ⊆ A }, fadmitA := { P ∈ Pth | Admission ∈ P and P ⊆ A }.

Let V = {fdiag, fabx, fadmit} and E = { {fdiag, fabx}, {fdiag, fadmit}, {fabx, fadmit} }.

Then SHG = V, E is an m, n-SuperHyperGraph.

Concrete evaluation for A = {Triage, CTScan, Antibiotics, Admission}:

fdiagA = {P1}, fabxA = {P2}, fadmitA = {P1, P2}.

Each output is a subset of P1S, thus in P2S.

Example 2.8 (Retail aggregation and cross-sell: m, n = 2, 1). Let the atomic items be S = {Phone, Case, Charger}. Vertices are 2, 1-superhyperfunctions f : P2S → P1S:

U, U ≠ , f U := U∈U , U = , f∪U := U,

{Case}, ∃ U ∈ U with Phone ∈ U, fxsellU := , otherwise.

Set V = {f∩, f∪, fxsell} ⊆ 2,1S and E = { {f∩, f∪}, {f∪, fxsell} }.

Thus SHG = V, E is an m, n-SuperHyperGraph.

Concrete evaluation for U = {{Phone, Case}, {Phone, Charger}} ∈ P2S

f∩U = {Phone}, f∪U = {Phone, Case, Charger}, fxsellU = {Case}.

All outputs lie in P1S as required.

Definition 2.9 (h, k-ary m, n-superhyperfunction). Let h, k ∈ N and m, n ∈ N. An h, k-ary m, n-superhyperfunction on S is a map F : PmS −→ PnS .

Writing F A1, . . . , Ah = B1, . . . , Bk, each component Bj ∈ PnS is an n–level object determined by h many m–level inputs.

Example 2.10 (h, k = 2, 2, m, n = 1, 2: Two-input / two-output lift). Let the base set be S = {egg, milk, flour}. Define F : P1S −→ P2S , F A, B := B1A, B, B2A, B , with components B1A, B := { A, A ∪ B }, B2A, B := { A ∩ B, B }.

Typing check. Since A, B ∈ P1S, we have A ∪ B ∈ P1S and A ∩ B ∈ P1S. Thus B1A, B, B2A, B ⊆ P1S, i.e. B1A, B, B2A, B ∈ P2S, so F is well-typed: P1S → P2S .

Concrete evaluation. For A = {egg} and B = {milk, flour}, F A, B = {{egg}, {egg, milk, flour}}, { , {milk, flour} } ∈ P2S .

Example 2.11 (h, k = 3, 1, m, n = 2, 1: Three families to one set). Let S = {x, y, z} and consider three 2-level inputs U, V, W ∈ P2S (each is a set of subsets of S). Define G : P2S −→ P1S, GU, V, W := X ∩ Y ∪ Z ,

X∈U Y ∈V Z∈W

with the conventions := S and := .

Typing check. Each union/intersection of members of P1S is again a subset of S; hence GU, V, W ∈ P1S, so G : P2S → P1S is well-typed.

Concrete evaluation. Let U = {{x, y}, {y}}, V = {{y, z}, {y}}, W = {{z}}.

Then U = {x, y}, V = {y}, and W = {z}, so GU, V, W = {x, y} ∩ {y} ∪ {z} = {y, z} ∈ P1S.

The definition of an h, k-ary m, n-SuperHyperGraph is provided below.

Definition 2.12 (h, k-ary m, n-SuperHyperGraph). Fix m, n, h, k ∈ N and S ≠ . Let

h,k h k

m,nS := { F : PmS → PnS }.

An h, k-ary m, n-SuperHyperGraph is a pair

h,k h,k

SHGm,n := V, E , ≠ V ⊆ m,nS, ≠ E ⊆ PV \ {}.

Example 2.13 (Multimodal travel planning as an h, k-ary m, n-SuperHyperGraph: m, n = 1, 2, h = 2, k = 2). Let the atomic transport services be S = {Bus_A, Subway_C, BikeDock_D, Taxi_E}.

Fix a route catalogue (each route is a subset of S) R = {R1 = {Bus_A, Subway_C}, R2 = {Subway_C, BikeDock_D}, R3 = {Taxi_E}} ⊆ P1S.

Inputs are two m=1 level sets: morning availability Aam ∈ P1S and evening availability Apm ∈ P1S. Vertices are h, k-ary m, n-superhyperfunctions F : P1S → P2S :

FfeasAam, Apm := {R ∈ R | R ⊆ Aam ∪ Apm}, {R ∈ R | R ⊆ Aam ∪ Apm ∧ BikeDock_D ∈ R} , FsubwayAam, Apm := {R ∈ R | Subway_C ∈ R ⊆ Aam ∪ Apm}, {R ∈ R | Taxi_E ∉ R ⊆ Aam ∪ Apm} , Ftwo-hopAam, Apm := {R ∈ R | |R| = 2 ∧ R ⊆ Aam ∪ Apm}, {R ∈ R | |R| = 1 ∧ R ⊆ Aam ∪ Apm} . Set the vertex set and hyperedges by V = {Ffeas, Fsubway, Ftwo-hop}, E = { {Ffeas, Fsubway}, {Ffeas, Ftwo-hop} }.

Concrete evaluation with Aam = {Bus_A, Subway_C} and Apm = {BikeDock_D}:

FfeasAam, Apm = {R1, R2}, {R2} , FsubwayAam, Apm = {R1, R2}, {R1, R2} , Ftwo-hopAam, Apm = {R1, R2}, , each component lying in P2S.

Example 2.14 (Clinical triage aggregator as an h, k-ary m, n-SuperHyperGraph: m, n = 1, 2, h = 3, k = 2). Let the atomic clinical actions be S = {Triage, CT, Labs, Antibiotics, Admission, Isolation}.

Pathway library Pth ⊆ P1S:

P1 = {Triage, CT, Admission}, P2 = {Triage, Labs, Antibiotics}, P3 = {Triage, Isolation, Admission}. Inputs are observed actions A ∈ P1S, available resources B ∈ P1S, and risk flags C ∈ P1S. Define vertices F : P1S → P2S :

FcandA, B, C := { P ∈ Pth | P ⊆ A ∪ B ∪ C ∧ Isolation ∈ P ⇒ Isolation ∈ C }, { {x} | x ∈ {Triage, Isolation} ∩ A ∪ B ∪ C } .

FsplitA, B, C := { P ∈ Pth | CT ∈ P ⊆ A ∪ B }, { P ∈ Pth | Antibiotics ∈ P ⊆ A ∪ B } .

FriskA, B, C := { P ∈ Pth | Isolation ∈ P ⊆ A ∪ B ∪ C }, { P ∈ Pth | Admission ∉ P ∧ P ⊆ A ∪ B } .

Set V = {Fcand, Fsplit, Frisk} and E = { {Fcand, Frisk}, {Fsplit, Frisk} }.

Concrete evaluation with A = {Triage, Labs}, B = {CT, Admission}, C = {Isolation}:

FcandA, B, C = {P1, P3}, {{Triage}, {Isolation}} , FsplitA, B, C = {P1}, , FriskA, B, C = {P3}, , all components in P2S.

Example 2.15 (Document workflow compliance as an h, k-ary m, n-SuperHyperGraph: m, n = 1, 1, h = 2, k = 3). Let the atomic steps be S = {Draft, Review, Approve, Publish, Archive}.

Inputs are policy-required steps A ∈ P1S and system-capable steps B ∈ P1S. Vertices are F : P1S → P1S returning (Allowed, Required, Forbidden):

FbaseA, B := B, A, S \ B .

FstrictA, B := B, A ∪ {Archive}, S \ B ∪ {Publish} if Approve ∉ B .

FfastA, B := B \ {Review} ∪ {Publish} if Approve ∈ B , A \ {Review}, S \ B \ {Review} ∪ {Publish} if Approve ∈ B .

Take V = {Fbase, Fstrict, Ffast} and E = { {Fbase, Fstrict}, {Fstrict, Ffast} }.

Concrete evaluation with A = {Draft, Review, Approve} and B = {Draft, Review, Approve, Publish}:

FbaseA, B = {Draft, Review, Approve, Publish}, {Draft, Review, Approve}, {Archive} , FstrictA, B = {Draft, Review, Approve, Publish}, {Draft, Review, Approve, Archive}, {Archive} , FfastA, B = {Draft, Approve, Publish}, {Draft, Approve}, {Review, Archive} , each component lying in P1S.

Theorem 2.16 (Product–Hom decompositions). For any sets X, Y and h, k ∈ N there are natural bijections

h k h k h−1 k

Hom X , Y HomX , Y Hom X, HomX , Y .

Specializing to X = PmS and Y = PnS, every h, k-ary m, n-superhyperfunction F : X → Y can be viewed (i) as a k–tuple of h–ary m, n-superhyperfunctions, and (ii) in fully curried form.

Proof: The first bijection sends F to its component tuple π1◦ F, . . . , πk ◦ F and is inverted by stacking components. The second is the standard currying bijection. Naturality is routine. □

Definition 2.17 (Componentwise order and monotonicity). Equip PmS with ⊆, and PnS with the product order:

′ ′ ′

B1, . . . , Bk ⪯ B1, . . . , Bk ⇐⇒ ∀j Bj ⊆ Bj.

An h, k-ary m, n-superhyperfunction F is monotone if

′ ′ ′ ′

A1, . . . , Ah ⪯ A1, . . . , Ah =⇒ F A1, . . . , Ah ⪯ F A1, . . . , Ah.

Example 2.18 (Componentwise order and monotonicity). Let S = {a, b, c}, take m = n = 1, h = 2, k = 2, and consider F : P1S −→ P1S , F A, B := A ∩ B, A ∪ B .

′ ′ ′ ′

If A, B ⪯ A , B (i.e. A ⊆ A and B ⊆ B ), then

′ ′ ′ ′

A ∩ B ⊆ A ∩ B and A ∪ B ⊆ A ∪ B , hence F A, B ⪯ F A , B in the product order. Therefore F is monotone.

With A = {a}, B = {a, b}, A = {a, b}, B = {a, b, c}:

′ ′ ′ ′

A, B ⪯ A , B , F A, B = {a}, {a, b} ⪯ {a, b}, {a, b, c} = F A , B .

Theorem 2.19 (Closure under typed composition). Let

h k k ℓ

F : PmS −→ PnS , G : PnS −→ PrS .

Then the composite G ◦ F : PmS −→ PrS is an h, ℓ-ary m, r-superhyperfunction. If F and G are monotone (Definition 2.17), then G ◦ F is monotone.

Proof: Typing follows from function composition. Monotonicity is preserved by composition in product posets. □

3. Result: Algorithm of Recognizing h, k-ary m, n-SuperHyperGraph

In this section, we present the Algorithm of Recognizing an h, k-ary m, n-SuperHyperGraph, together with its subroutine algorithms. We then provide a detailed evaluation of their validity and analyze the computational complexity in order to establish both soundness and efficiency of the overall recognition procedure.

Notation 3.1. Fix a finite nonempty base set S and integers m, n, h, k ∈ N. Let V be a finite set of candidate vertices (each intended to be a total function F : PmS → PnS ), and let E be a finite family of candidate hyperedges (intended to be nonempty subsets of V ). Write P0S = S and Pt1S = PPtS.

IsInIterPowerset decides membership in the t-th iterated powerset recursively. If t = 0, it checks whether X ∈ S. Otherwise, it requires X to be finite and ensures that every element Y ∈ X recursively satisfies IsInIterPowersetY, t−1, S. The outline of the algorithms and the corresponding theorems are presented below.

Algorithm 1: IsInIterPowersetX, t, S Input: Finite S; integer t ≥ 0; object X.

Output: true iff X ∈ PtS.

1 if t = 0 then return X ∈ S 2 else 3 if X is not a finite set then return false 4 foreach Y ∈ X do 5 if IsInIterPowersetY, t − 1, S = false then return false

7 return true

Example 3.2 (Real-world use of IsInIterPowerset: validating a folder collection). Let S = {Readme, Report, Data} denote atomic files. Then P1S are folders (sets of files) and P2S are collections of folders. Define A = {Readme, Report}, B = {Data}, X = {A, B}.

Running IsInIterPowersetX, 2, S returns true: X is finite and each Y ∈ X satisfies IsInIterPowersetY, 1, S, since every y ∈ Y passes IsInIterPowersety, 0, S with y ∈ S. Thus X ∈ P2S, i.e., the folder collection is well-typed. Theorem 3.3 (Correctness of IsInIterPowerset). For any finite S, integer t ≥ 0, and object X, Algorithm 1 returns true if and only if X ∈ PtS.

Proof: By induction on t. Base t = 0: the algorithm returns true exactly when X ∈ S = P0S. Inductive step: for t ≥ 1, PtS consists of finite sets all of whose elements lie in Pt−1S. The algorithm enforces finiteness and recursively verifies each member with parameter t − 1. Hence it accepts precisely the members of PtS. □

Theorem 3.4 (Time and space of IsInIterPowerset). On input X, t, S with X ∈ PtS, Algorithm 1 runs in time Θ sizetX and uses Ot stack space. In particular, in the worst case (taking X = Pt−1S) the time is Ut := 1 Nt−1 Ut−1 U0 = 1 ⇒ Ut = 1 Nt−1 Nt−1Nt−2 · · · Ni, which is dominated by the product term and thus grows tower-exponentially with t.

Proof: Each node of the membership tree (the set itself plus all nested members down to depth t) is visited once with O1 local work, yielding the ΘsizetX bound. Recursion depth is exactly t, hence Ot stack space. For the worst case, set X = Pt−1S so |X| = Nt−1 and each recursive child can be chosen worst-case. This gives Ut = 1 Nt−1Ut−1 with U0 = 1, solving to the stated series. □

CheckVertexType iterates over all possible input tuples, verifies function F is defined everywhere, ensures outputs are valid k-tuples, and confirms each component belongs to the n-th iterated powerset. The outline of the algorithms and the corresponding theorems are presented below.

Algorithm 2: CheckVertexTypeF, m, n, h, k, S Input: Finite S; integers m, n, h, k; function F.

Output: true iff F : PmS → PnS is total and well-typed.

1 Generate an iterator over all h-tuples A1, . . . , Ah with Ai ∈ PmS.

2 foreach A1, . . . , Ah ∈ do 3 if F is undefined on A1, . . . , Ah then return false 4 Set Y := F A1, . . . , Ah.

5 if Y is not a k-tuple then return false 6 for j ← 1 to k do 7 if IsInIterPowersetYj, n, S = false then return false

10 return true

Example 3.5 (Real-world use of CheckVertexType: validating a notification policy). Let S = {Email, SMS, Push} and take m = n = 1, h = 1, k = 2. Define a policy F : P1S −→ P1S , F A := A \ {SMS}, S \ A , interpreted as (Allowed, Forbidden) channels.

Why CheckVertexType returns true. For every A ⊆ S, F is defined, F A is a 2-tuple, and each component is a subset of S, hence belongs to P1S. Therefore the loop in CheckVertexType never triggers a failure, and the algorithm returns true. Concrete check. For A = {Email, SMS}, Y = F A = {Email}, {Push} , which is a 2-tuple with both entries in P1S, so all tests pass.

Theorem 3.6 (Correctness of CheckVertexType). Let m, n, h, k ∈ N and finite S. The Algorithm returns true if and

h k h

only if F : PmS → PnS is total on PmS and every output component lies in PnS.

Proof: (If) If the algorithm returns true, it has iterated over every domain element A1, . . . , Ah ∈ PmS , found F defined there, confirmed the result is a k-tuple, and verified each component via Algorithm 1 that it belongs to PnS. Hence F is total and well-typed. (Only if) Conversely, if F is total and well-typed, each loop iteration succeeds and Algorithm 1 returns true for every component; thus the algorithm returns true. □

Nt h h

Theorem 3.7 (Time of CheckVertexType). Let N0 = |S| and Nt1 = 2 , so |PtS| = Nt. Set D = Nm = |PmS |. If one evaluation of F costs Teval, then T CheckVertexType = Θ D · Teval TnYj ,

where TnYj = Θ sizenYj by Theorem 3.4. In the worst case, TnYj ≤ Un, giving the crude bound T CheckVertexType = O D · Teval k Un , with recursion depth at most n per component check.

Proof: The algorithm performs a constant amount of overhead per domain element, one evaluation of F, and k calls to Algorithm 1. Summing over the D inputs yields the stated expression. By Theorem 3.4, each component check costs Θsizen·, and the worst-case over PnS is Un. □

Recognize_HK_MN_SuperHyperGraph verifies nonempty vertices and edges, type-checks every vertex, rejects edges containing non-vertices or empties, and accepts exactly when all structural conditions are satisfied. The outline of the algorithms and the corresponding theorems are presented below.

Algorithm 3: Recognize_HK_MN_SuperHyperGraphS, m, n, h, k, V, E Input: Finite S; integers m, n, h, k; finite vertex set V ; finite family E.

Output: Accept iff V, E is an h, k-ary m, n-SuperHyperGraph; otherwise Reject with a certificate.

1 if V = then 2 return Reject (empty vertex set).

4 foreach F ∈ V do 5 if CheckVertexTypeF, m, n, h, k, S = false then return Reject (ill-typed vertex F).

7 if E = then 8 return Reject (no hyperedges).

10 foreach E ∈ E do 11 if E = then return Reject (empty hyperedge).

12 foreach F ∈ E do 13 if F ∉ V then return Reject (hyperedge contains non-vertex).

16 return Accept

Example 3.8 (Real-world use of Recognize_HK_MN_SuperHyperGraph: validating policy graphs). Let S = {Email, SMS, Push} and take m = n = h = k = 1. Define two total, well-typed policies FidA = A and FnoSMSA = A \ {SMS}, so Fid, FnoSMS : P1S → P1S. Set V = {Fid, FnoSMS}, E = { {Fid}, {Fid, FnoSMS} }.

Recognition. The algorithm finds V ≠ ; both vertices pass CheckVertexType; E ≠ and every E ∈ E is nonempty with members in V . Hence it returns Accept, confirming an 1, 1–1, 1 SuperHyperGraph.

Theorem 3.9 (Correctness (Soundness and Completeness)). Let S be finite and m, n, h, k ∈ N. On input S, m, n, h, k, V, E, the algorithm Recognize_HK_MN_SuperHyperGraph returns Accept if and only if V, E is an h, k-ary m, n-SuperHyperGraph on S.

Proof: (Soundness) If the algorithm accepts, then: (i) V ≠ by the first check. (ii) For every F ∈ V , CheckVertexType

h h k

verified that F is total on PmS and that each image is a k-tuple with components in PnS. Hence F : PmS → PnS , so V ⊆ m,nS. (iii) E ≠ , and each E ∈ E is nonempty with all elements in V , hence E ⊆ PV \ {}. Therefore, by definition, V, E is an h, k-ary m, n-SuperHyperGraph.

(Completeness) Conversely, suppose V, E is an h, k-ary m, n-SuperHyperGraph. Then V ≠ and V ⊆ m,nS; thus every F ∈ V is a total, well-typed map from PmS to PnS , so CheckVertexType returns true. Moreover, E ≠ and each E ∈ E is a nonempty subset of V , so the edge checks pass. Hence the algorithm accepts. □

Nt h

Theorem 3.10 (Time Complexity). Let N0 = |S| and Nt1 = 2 for t ≥ 0; then |PtS| = Nt. Let D := Nm be the size of the domain PmS . Assume a single evaluation of a vertex F costs Teval time. Then the worst-case running time of Recognize_HK_MN_SuperHyperGraph is

O |V | · D · Teval k · Tn |E| |E| ,

where Tn is the cost of IsInIterPowerset on level n, which satisfies Tn = ONn. In particular, the recognition problem is (nonuniformly) tower-exponential in m and n via Nm and Nn.

Proof: The vertex-type phase processes each F ∈ V and all D = Nm inputs. For each input, it performs one evaluation (Teval) and k membership checks in PnS. By induction on n, IsInIterPowerset examines each element one level down and recurses, yielding Tn = ONn in the worst case (since a maximal element of PnS can contain Nn−1 elements, each with a worst-case membership cost ONn−1, etc., unfolding to ONn). Thus the vertex phase costs O |V | · D · Teval kTn . The edge phase checks emptiness and membership of each element of each hyperedge in V , costing O |E| E |E| . Summing both parts gives the stated bound. The dependence on m and n is through Nm and Nn, which are exponential towers by definition, so the overall worst-case complexity is tower-exponential. □

4. Result: Algorithm of Constructing h, k-ary m, n-SuperHyperGraph

The algorithm of constructing an h, k-ary m, n-SuperHyperGraph systematically verifies candidate functions, selects valid vertices, and organizes property-based hyperedges to build a consistent higher-order graph structure. The following section defines the algorithms, including the necessary subroutines, and evaluates their correctness to ensure that they faithfully implement the intended construction process.

Notation 4.1. Fix a finite, nonempty base set S and integers m, n, h, k ∈ N. We are given a finite library of candidate mappings F : PmS → PnS (templates or concrete functions), and a finite family of vertex predicates = {Φ1, . . . , Φp}, where each Φi is a (decidable) property on such F (e.g., monotonicity, diagonal idempotence, symmetry). We construct a vertex set V ⊆ m,nS by type-checking and a hyperedge family E by grouping vertices that satisfy the same property.

Nt h h

Notation 4.2. Let N0 = |S| and Nt1 = 2 so |PtS| = Nt. The domain size is D := | PmS | = Nm. Write Un for a worst-case membership-check cost on PnS (e.g., as in a structural check via IsInIterPowerset).

EvaluatePredicates iterates through the predicate family, tests each predicate on F, collects indices of those evaluating true into set I, and returns resulting index set. The outline of the algorithms and the corresponding theorems are presented below. Algorithm 4: EvaluatePredicatesF, Input: Function F : PmS → PnS ; predicate family = {Φ1, . . . , Φp}.

Output: Index set IF = { i ∈ {1, . . . , p} | ΦiF = true }.

1 I ← 2 for i ← 1 to p do 3 if ΦiF = true then 4 I ← I ∪ {i}

7 return I

Example 4.3 (Real-world use of EvaluatePredicates: notification policy). Let S = {Email, SMS, Push} and take m = n = h = k = 1. Define the policy (function) F : P1S → P1S by

F A := A \ {SMS} “never send SMS”.

Consider the predicate family = {Φ1, Φ2, Φ3, Φ4}:

Φ1 : ∀A ⊆ S F A ⊆ A (opt-out safety), Φ2 : ∀A ⊆ S SMS ∉ F A (no-SMS policy), Φ3 : ∀A ⊆ S F F A = F A (idempotent), Φ4 : ∀A ⊆ B ⊆ S F A ⊆ F B (monotone).

Each predicate holds for this F (e.g., F removes a fixed element, preserving inclusion and idempotence). Hence

EvaluatePredicatesF, = {1, 2, 3, 4}.

Concrete check: with A = {Email, SMS}, F A = {Email} and F F A = {Email} = F A; if A ⊆ B, then removing SMS from both preserves inclusion, so Φ4 holds.

Theorem 4.4 (Correctness of EvaluatePredicates). For any F : PmS → PnS and predicate family = {Φ1, . . . , Φp}, Algorithm 4 returns IF = { i ∈ {1, . . . , p} | ΦiF = true }.

Proof: Initialize I ← . The loop inspects each i = 1, . . . , p once and adds i to I iff the condition ΦiF = true holds. Thus, upon termination, I contains exactly those indices whose predicates are true. □

Theorem 4.5 (Time and Space of EvaluatePredicates). The running time is

p max

T EvaluatePredicatesF, = CΦ F ≤ p CΦ ,

and the extra space is O|IF| to store the output set (plus O1 overhead).

Proof: Each predicate is evaluated exactly once; summing their costs yields the stated time. Only the index set IF is stored, whose size is at most p; other storage is constant. □

ConstructVertices scans the library, uses CheckVertexType to verify each function’s total, well-typed mapping, accumulates valid ones into vertex set V, and returns the set. The outline of the algorithms and the corresponding theorems are presented below.

Algorithm 5: ConstructVerticesS, m, n, h, k, Input: Finite S; integers m, n, h, k; library of candidate functions.

Output: Vertex set V ⊆ m,nS.

1 V ← 2 foreach F ∈ do 3 if CheckVertexTypeF, m, n, h, k, S then 4 V ← V ∪ {F}

7 return V

Example 4.6 (Real-world use of ConstructVertices: selecting valid notification policies). Let S = {Email, SMS, Push} and take m = n = h = k = 1. Consider a library = {F1, F2, F3, F4} of candidate policies F : P1S → P1S:

F1A := A \ {SMS} (never send SMS), {SMS}, Email ∈ A, F2A := undefined, otherwise, F3A := A ∪ {Fax} Fax ∉ S, F4A := (mute all).

Running ConstructVertices keeps exactly those F that are total and well-typed.

Checks. F1 is total and F1A ⊆ S, so it is accepted. F2 is undefined at A = , hence rejected. F3 = {Fax} ⊈ S, hence rejected as ill-typed. F4 is total with image ∈ P1S, so it is accepted.

Therefore the algorithm returns V = {F1, F4} ⊆ 1,1 S.

Theorem 4.7 (Correctness of ConstructVertices). Algorithm 5 returns V = { F ∈ | CheckVertexTypeF, m, n, h, k, S = true }.

h,k h k

Consequently, V ⊆ m,nS and every F ∈ V is a total, well-typed map PmS → PnS .

Proof: The algorithm scans all F ∈ and inserts F into V iff CheckVertexType returns true. By the specification of CheckVertexType, this holds precisely for total, well-typed functions PmS → PnS . Hence the characterization and inclusion. □

Theorem 4.8 (Time and Space of ConstructVertices). Let TtypeF denote the running time of CheckVertexType on F,

max

and set Ttype := maxF ∈ TtypeF. Then

max

T ConstructVertices = TtypeF ≤ M Ttype , Space = O|V | for storing accepted vertices.

Proof: Each candidate is tested once by CheckVertexType; summing gives the time bound and the maximal bound follows immediately. Apart from V , the routine uses only constant extra space. □

BuildPropertyEdges initializes edge buckets, evaluates each vertex against all predicates, inserts vertices into satisfied buckets, removes empty ones, and returns resulting family of property-induced hyperedges. The outline of the algorithms and the corresponding theorems are presented below.

Algorithm 6: BuildPropertyEdgesV, Input: Vertex set V ; predicate family = {Φ1, . . . , Φp}.

Output: Hyperedge family E.

1 for i ← 1 to p do 2 Ei ←

4 foreach F ∈ V do 5 IF ←EvaluatePredicatesF, 6 foreach i ∈ IF do 7 Ei ← Ei ∪ {F}

10 E ← 11 for i ← 1 to p do 12 if Ei ≠ then 13 E ← E ∪ {Ei}

16 return E

Example 4.9 (Real-world use of BuildPropertyEdges: grouping notification policies). Let S = {Email, SMS, Push} with m = n = h = k = 1. Consider vertices V = {F1, F2, F3} where {Push}, Push ∈ A, F1A = A \ {SMS}, F2A = , F3A = , otherwise.

Predicates = {Φ1, Φ2, Φ3, Φ4}:

Φ1 : ∀A SMS ∉ F A (no-SMS), Φ2 : ∃A Push ∈ F A (push-enabled), Φ3 : ∀A F F A = F A (idempotent), Φ4 : ∀A F A = (mute-all).

Evaluations yield Φ1 Φ2 Φ3 Φ4 F1 ✓ ✓ ✓ × F2 ✓ × ✓ ✓ F3 ✓ ✓ ✓ × Hence BuildPropertyEdges returns the nonempty hyperedges E1 = {F1, F2, F3}, E2 = {F1, F3}, E3 = {F1, F2, F3}, E4 = {F2}.

These edges group policies by shared properties (no-SMS, push-enabled, idempotent, mute-all).

Theorem 4.10 (Correctness of BuildPropertyEdges). Let V be any vertex set and = {Φ1, . . . , Φp}. Algorithm 6 returns a family E such that for each i, Ei = { F ∈ V | ΦiF = true }, and E consists exactly of the nonempty Ei’s. Hence E ⊆ PV \ {}.

Proof: For each F ∈ V , the call IF ← EvaluatePredicatesF, (Thm. 4.4) returns the exact set of indices of true predicates. The algorithm inserts F into Ei for every i ∈ IF, so when all vertices are processed, each Ei is precisely {F ∈ V | ΦiF = true}. Empty Ei’s are discarded; the remaining edges are nonempty subsets of V . □

Theorem 4.11 (Time and Space of BuildPropertyEdges). Let TevalF := T EvaluatePredicatesF, . Then T BuildPropertyEdges = O p TevalF |Ei| , Space = O p |Ei| .

F ∈V i=1 i=1 max max

If CΦ is a uniform predicate bound, then T BuildPropertyEdges = O p |V | · p · CΦ i |Ei| .

Proof: Initialization and final filtering cost Op. For each F ∈ V , EvaluatePredicates costs TevalF (Theorem 4.5), and inserting F into Ei for each i ∈ IF yields a total of i |Ei| insertions across all vertices. Space is dominated by storing the

max max

p edge-containers and their members. With a uniform bound CΦ , TevalF ≤ p CΦ . □

UniformizeEdges traverses each hyperedge, orders its vertices, partitions them into consecutive blocks of size r, optionally emits a remainder block, and returns the r-uniform family. The outline of the algorithms and the corresponding theorems are presented below.

Algorithm 7: UniformizeEdgesE, r Input: Hyperedge family E; integer r ≥ 1.

Output: r-uniform hyperedge family E .

1 E ← 2 foreach E ∈ E do 3 Let F1, . . . , Fq be an arbitrary ordering of E.

4 for j ← 1 to ⌊qr⌋ do 5 E ← E ∪ {{Fj−1r1, . . . , Fjr}}

7 if q mod r ≠ 0 then 8 Create a final edge with the remaining elements (optional, if nonempty).

11 return E

Example 4.12 (Real-world use of UniformizeEdges: forming breakout rooms). Let the vertices be participants V = {A, B, C, D, E, F, G, H, I}. Two interest clusters (hyperedges) are EData = {A, B, C, D, E, F, G, H}, EUI = {C, D, E, F, I}.

With room size r = 3, UniformizeEdges partitions each hyperedge into consecutive blocks of three (and a possible remainder):

EData = {{A, B, C}, {D, E, F}, {G, H}} last is a remainder of size 2, EUI = {{C, D, E}, {F, I}} remainder of size 2.

If remainders are omitted, the family is strictly 3-uniform; if included, at most one smaller block per original edge appears.

Theorem 4.13 (Validity of UniformizeEdges). Fix r ≥ 1. For each input hyperedge E ∈ E with |E| = q, Algorithm 7 partitions E into ⌊qr⌋ disjoint blocks of size exactly r (and optionally one remainder block of size q mod r). Hence the output family E is r-uniform if the remainder is omitted; if the remainder is included, then E is r-uniform except for at most one smaller block per input edge.

Proof: The procedure orders the elements of E and groups them consecutively into ⌊qr⌋ sets of r elements; these are pairwise disjoint and their union covers the first r⌊qr⌋ elements. The leftover q mod r elements, if any, are either ignored (strict r-uniformity) or placed in a final block (single non-r remainder). Applying this independently to each E ∈ E produces the stated structure. □

Theorem 4.14 (Time and Space of UniformizeEdges). Let Q := E∈E |E| be the total size of all input hyperedges. Then Algorithm 7 runs in OQ time and uses OQ space to store the output (plus Or transient workspace per processed edge).

Proof: Each element of each E is visited once to form blocks, so the total time is linear in Q. The output stores every element at most once in some block, hence OQ space. At any moment we buffer at most one partial block of size r and loop-local variables, giving Or extra transient space per edge. □ Construct_HK_MN_SuperHyperGraph builds vertices via ConstructVertices, forms property-induced edges with BuildPropertyEdges, optionally uniformizes edges to size r, and returns a valid h, k–m, n SuperHyperGraph or fails. The outline of the algorithms and the corresponding theorems are presented below.

Algorithm 8: Construct_HK_MN_SuperHyperGraphS, m, n, h, k, , , r Input: Finite S; m, n, h, k ∈ N; library ; predicates ; optional r ∈ N.

Output: An h, k-ary m, n-SuperHyperGraph V, E .

1 V ←ConstructVerticesS, m, n, h, k, 2 if V = then 3 return Fail (no well-typed vertices)

5 E ←BuildPropertyEdgesV, 6 if E = then 7 return V, { {F} | F ∈ V } // Fallback: singleton edges

9 if r is provided then 10 E ←UniformizeEdgesE, r 11 if E = then 12 return V, E

14 return V, E

16 else 17 return V, E

Example 4.15 (Real-world use of Construct_HK_MN_SuperHyperGraph: smart-home policies). Let S = {Light, HVAC, DoorLock, Camera} and take m = n = h = k = 1. Candidate policies = {Fauto, Fsecure, Fcomfort} with FautoA = A, FsecureA = A ∪ {DoorLock} \ {Light}, FcomfortA = A ∪ {HVAC}.

All are total maps P1S → P1S, so ConstructVertices returns V = . Predicates = {Φ1, Φ2, Φ3}:

Φ1 : ∃A DoorLock ∈ F A, Φ2 : ∃A HVAC ∈ F A, Φ3 : ∀A F F A = F A.

Evaluations yield E1 = {Fsecure}, E2 = {Fcomfort}, E3 = {Fauto, Fsecure, Fcomfort}.

Thus BuildPropertyEdgesV, returns E = {E1, E2, E3}. With r = 2, UniformizeEdgesE, 2 gives E3 = {{Fauto, Fsecure}} remainder {Fcomfort} optional, and the algorithm returns the 1, 1–1, 1 SuperHyperGraph V, E ready for A/B testing of policy pairs.

Theorem 4.16 (Validity). Let S be finite and nonempty, and m, n, h, k ∈ N. If Algorithm 8 returns V, E , then V ≠ and V, E is an h, k-ary m, n-SuperHyperGraph on S. Moreover, if r is provided and E = UniformizeEdgesE, r is returned, then V, E is r-uniform.

Proof: By Algorithm 5, every F ∈ V satisfies CheckVertexType, hence F : PmS → PnS is total and well-typed. Therefore V ⊆ m,nS and V ≠ by the explicit check. Algorithm 6 forms each hyperedge Ei as a set of vertices that satisfy Φi; by construction Ei ⊆ V , and empty sets are discarded, so E ⊆ PV \ {}. If r is not provided, V, E is an h, k-ary m, n-SuperHyperGraph by definition. If r is provided, Algorithm 7 partitions each E ∈ E into blocks of size r (except possibly the final remainder, which is either included or dropped by the stated option), hence every hyperedge in E has size r (or the remainder policy yields nonempty edges by construction). Thus V, E is r-uniform and still a family of nonempty subsets of V . □ Theorem 4.17 (Time Complexity). Let M := || and p := | |. Write Teval for the time to evaluate F once, and let CΦ be a uniform upper bound on the time to decide ΦiF for any i and F. Then the running time of Algorithm 8 satisfies T = O M · D · Teval k Un O M · p · CΦ O |Ei| O |E| |V | O |E| .

| {z } | {z } i=1 | {z } E∈E | {z } | {z }

vertex typing predicate evaluation bookkeeping edge assembly uniformization (if used)

In particular, the dependence on m and n is carried by D = Nm and Un, which grow tower-exponentially with m and n.

Proof: Vertex typing. For each F ∈ , the Algorithm iterates over all D inputs, performs one F-evaluation (Teval), and checks k components for membership in PnS, each costing at most Un in the worst case; hence O D · Teval k Un per F, and M such F’s.

Predicate evaluation. For each F ∈ V ⊆ , each of the p predicates is tested once, costing at most CΦ each; hence OM pCΦ. Edge assembly. Each F contributes to Ei precisely when ΦiF holds; in total, writing Ei for the constructed property edges, the insertion work is Oi |Ei|, plus linear bookkeeping for collecting nonempty edges.

Uniformization. Algorithm 7 scans each E once and produces ⌊|E|r⌋ r-sized blocks (and optionally one remainder), hence O|E| per E, summing to OE∈E |E|. □

Theorem 4.18 (Space Complexity). The space usage of Algorithm 8 is O |V | |Ei| D , dominated by storage for vertices, property–induced edges, and the working memory needed to enumerate and type–check domain tuples. If uniformization is requested, an additional O E∈E |E| space is needed transiently.

Proof: We decompose peak memory by phases of Algorithm 8.

(1) Persistent structures. (i) The algorithm stores the accepted vertices V explicitly, contributing O|V | words (we count handles/pointers to functions). (ii) In BuildPropertyEdges, it constructs one container Ei ⊆ V for each predicate Φi and discards empty ones at the end. Hence the total edge storage is |Ei|, i.e., O i |Ei| .

(2) Working memory for type checking. In ConstructVertices every candidate F is tested by CheckVertexType, which

h h Nt

enumerates the domain PmS of size D = Nm with Nt1 = 2 and N0 = |S|. A streaming (lexicographic or mixed–radix) iterator needs:

(a) one current input tuple A = A1, . . . , Ah, (b) a constant number of loop counters/indices.

Each Ai ∈ PmS is itself a subset of Pm−1S, so storing A uses at most h Nm−1 atomic references in the worst case. The check of the output Y = FA = Y1, . . . , Yk can be performed componentwise and on the fly: for each j, we test Yj ∈ PnS using a structural membership routine that streams through Yj and then discards it; therefore no accumulation over different inputs occurs. The peak extra buffer while inspecting a single component is ONn−1, but since we process at most one component at a time and immediately release it, the global peak is bounded by the iterator’s working set plus the current tuple buffer.

Combining these, the transient workspace during type checking is O h Nm−1 (for A) plus O1 (counters).

h Nm−1 Nm−1 x

Because D = 2 (since Nm = 2 ), the inequality 2 ≥ x for x ≥ 1 yields D ≥ h Nm−1 whenever h Nm−1 ≥ 1. Thus the iterator/buffer footprint is upper–bounded by OD, which we use as a coarse but valid bound that subsumes the working set.

(3) Optional uniformization. If UniformizeEdges is invoked, it scans each E ∈ E once and emits r–blocks. At any moment it retains only a partial block (size ≤ r) and loop variables; the output family E itself is not counted as transient. Hence the additional transient space is O E∈E |E| across the pass (the output storage is charged to the final edge family).

(4) Peak aggregation. Summing persistent and transient contributions, the peak space is O |V | |Ei| D , i=1 |{z}

iterator / buffers plus the optional O E∈E |E| during uniformization. This proves the claim.

Sharper (optional) bound. If one prefers to avoid the coarse OD term, the working memory in (2) can be bounded more tightly by O h Nm−1 Nn−1 (current tuple plus one streamed output component), so the peak becomes O |V |i |Ei|h Nm−1 Nn−1 ,

h Nm−1

which is asymptotically ⊆ O |V | i |Ei| D because D = 2 ≥ h Nm−1 and, in typical regimes, Nn−1 ≤ D. We keep the theorem’s statement for simplicity. □

5. Conclusion

In this paper, we introduced the concept of an h, k-ary m, n-SuperHyperGraph, which extends the already well-studied SuperHyperGraph by employing the framework of h, k-ary m, n-SuperHyperFunctions. In future work, we aim to explore further extensions of the h, k-ary m, n-SuperHyperGraph using different paradigms such as Fuzzy Graphs[25, 26, 27], Intuitionistic Fuzzy Graphs[28, 29], Picture Fuzzy Graphs[30, 31], Linear Diophantine Fuzzy Graphs [32, 33], Hesitant Fuzzy Graphs[34, 35], Neutrosophic Graphs[36, 37, 38, 39, 40, 41, 42], and Plithogenic Graphs[43, 44].

Acknowledgments

We extend our sincere gratitude to everyone who provided insights, inspiration, and assistance throughout this research. We particularly thank our readers for their interest and acknowledge the authors of the cited works for laying the foundation that made our study possible. We also appreciate the support from individuals and institutions that provided the resources and infrastructure needed to produce and share this paper. Finally, we are grateful to all those who supported us in various ways during this project.

Consent to Publish declaration

The author approved to Publish declarations.

Ethics Approval and Consent to Participate

As this research is entirely theoretical in nature and does not involve human participants or animal subjects, no ethical approval is required.

Funding

This study did not receive any financial or external support from organizations or individuals.

Data Availability

This research is purely theoretical, involving no data collection or analysis. We encourage future researchers to pursue empirical investigations to further develop and validate the concepts introduced here.

Research Integrity

The authors hereby confirm that, to the best of their knowledge, this manuscript is their original work, has not been published in any other journal, and is not currently under consideration for publication elsewhere at this stage.

Disclaimer (Note on Computational Tools)

No computer-assisted proof, symbolic computation, or automated theorem proving tools (e.g., Mathematica, SageMath, Coq, etc.) were used in the development or verification of the results presented in this paper. All proofs and derivations were carried out manually and analytically by the authors.

Disclaimer (Limitations and Claims)

The theoretical concepts presented in this paper have not yet been subject to practical implementation or empirical validation. Future researchers are invited to explore these ideas in applied or experimental settings. Although every effort has been made to ensure the accuracy of the content and the proper citation of sources, unintentional errors or omissions may persist. Readers should independently verify any referenced materials.

To the best of the authors’ knowledge, all mathematical statements and proofs contained herein are correct and have been thoroughly vetted. Should you identify any potential errors or ambiguities, please feel free to contact the authors for clarification.

The results presented are valid only under the specific assumptions and conditions detailed in the manuscript. Extending these findings to broader mathematical structures may require additional research. The opinions and conclusions expressed in this work are those of the authors alone and do not necessarily reflect the official positions of their affiliated institutions.

Competing interests

Author has declared that no competing interests exist.

53. Fu ita and Mehmood | Uncert. Disc. Appl. 3(1) (2026) 33-53 j

[19]Khali, H. E., Güngör, G. D., & Zaina, M. A. N. (2022). Neutrosophic superhyper bi-topological spaces: Original notions and new insights. Neutrosophic sets and systems, 51(1), 3. https://fs.unm.edu/NSS/SuperHyperStructure.pdf [20]Smarandache, F. (2020). Extension of hypergraph to n-superhypergraph and to plithogenic n-superhypergraph, and extension of hyperalgebra to n-ary (classical-/neutro-/anti-) hyperalgebra. Infinite study.

https://www.researchgate.net/publication/343862930 [21]Smarandache, F. (2022). Introduction to the n-superhypergraph-the most general form of graph today. Infinite study.

https://doi.org/10.5281/zenodo.3783103 [22]Fujita, T. (2024). Hypergraph-and superhypergraph-based models for patient care, disease transmission, and healthcare collaboration networks (with an exploration of ( , )-superhypergraphs).

[23]Jdid, M., Smarandache, F., & Fujita, T. (2025). A linear mathematical model of the vocational training problem in a company using neutrosophic logic, hyperfunctions, and superhyperfunction. Neutrosophic sets and systems, 87(1), 1.

https://www.researchgate.net/profile/T-Fujita-2/publication/392238093 [24]Smarandache, F. S. (2023). Neutrosophic superhyperstructure: Current understanding and future directions. Infinite study.

[25]Rosenfeld, A. (1975). Fuzzy graphs. In fuzzy sets and their applications to cognitive and decision processes (pp. 77-95).

Academic press. https://doi.org/10.1016/B978-0-12-775260-0.50008-6 [26]Mordeson, J. N., & Nair, P. S. (2012). Fuzzy graphs and fuzzy hypergraphs (Vol. 46). Physica. https://www.amazon.nl/- /en/John-N-Mordeson/dp/3790812862 [27]Al-Hawary, T. (2011). Complete fuzzy graphs. International journal of mathematical combinatorics, 4, 26.

https://fs.unm.edu/IJMC/CompleteFuzzyGraphs.pdf [28]Kishore Kumar, P. K., Lavanya, S., Rashmanlou, H., & Jouybari, M. N. (2017). Magic labeling on interval-valued intuitionistic fuzzy graphs. Journal of intelligent & fuzzy systems, 33(6), 3999-4006. https://doi.org/10.3233/JIFS-17847 [29]Akram, M., Davvaz, B., & Feng, F. (2013). Intuitionistic fuzzy soft k-algebras. Mathematics in computer science, 7(3), 353- 365. https://doi.org/10.1007/s11786-013-0158-5 [30]Shoaib, M., Mahmood, W., Al-Kenani, A. N., & Islam, S. (2022). Notes on upper and lower truncation of picture fuzzy graphs. Discrete dynamics in nature and society, 2022(1), 7646828. https://doi.org/10.1155/2022/7646828 [31]Rosyida, I., & Indrati, C. R. (2023). An algorithm for coloring of picture fuzzy graphs based on strong and weak adjacencies, and its application. Algorithms, 16(12), 551. https://doi.org/10.3390/a16120551 [32]Hanif, M. Z., Yaqoob, N., Riaz, M., & Aslam, M. (2022). Linear Diophantine fuzzy graphs with new decision-making approach. AIMS Mathematics, 7(8), 14532–14556. https://doi.org/10.3934/math.2022798 [33]Parimala, M., & Jafari, S. (2024). Spherical linear Diophantine fuzzy graphs: Unleashing the power of fuzzy logic for uncertainty modeling and real-world applications. Axioms, 13(3), 153. https://doi.org/10.3390/axioms13030153 [34]Alkouri, A., AbuHijleh, E. A., Alafifi, G., Almuhur, E., & Al-Zubi, F. M. A. (2023). More on complex hesitant fuzzy graphs. AIMS Mathematics, 8(11), 27653–27674. https://doi.org/10.3934/math.20231408 [35]Gong, Z., & Wang, J. (2021). Hesitant fuzzy graphs, hesitant fuzzy hypergraphs and fuzzy graph decisions. Journal of Intelligent & Fuzzy Systems, 40(1), 865–875. https://doi.org/10.3233/JIFS-189203 [36]Broumi, S., Talea, M., Bakali, A., & Smarandache, F. (2016). Single valued neutrosophic graphs. Journal of New Theory, 10, 86–101. https://dergipark.org.tr/en/pub/jnt/issue/24472/259409 [37]Broumi, S., Talea, M., Bakali, A., Smarandache, F., & Kumar, P. K. (2017). Shortest path problem on single valued neutrosophic graphs. In 2017 International Symposium on Networks, Computers and Communications (ISNCC) (pp. 1–6). IEEE. https://doi.org/10.1109/ISNCC.2017.8072015 [38]Broumi, S., Bakali, A., & Bahnasse, A. (2018). Neutrosophic sets: An overview. Infinite Study.

https://fs.unm.edu/NeutrosophicSetsAnOverview.pdf [39]Shi, X., Kosari, S., Rashmanlou, H., Broumi, S., & Hussain, S. S. (2023). Properties of interval-valued quadripartitioned neutrosophic graphs with real-life application. Journal of Intelligent & Fuzzy Systems, 44(5), 7683–7697.

https://doi.org/10.3233/JIFS-223455 [40]Quek, S. G., Selvachandran, G., Ajay, D., Chellamani, P., Taniar, D., Fujita, H., Duong, P., Son, L. H., & Giang, N. L.

(2022). New concepts of pentapartitioned neutrosophic graphs and applications for determining safest paths and towns in response to COVID-19. Computational and Applied Mathematics, 41(4), 151. https://doi.org/10.1007/s40314-022-01835-4 [41]Broumi, S., Bakali, A., Talea, M., Smarandache, F., & Singh, P. K. (2019). Properties of interval-valued neutrosophic graphs. In Fuzzy Multi-criteria Decision-Making Using Neutrosophic Sets (pp. 173–202). Springer.

https://doi.org/10.1007/978-3-030-11471-8_8 [42]Broumi, S., Bakali, A., Talea, M., & Smarandache, F. (2018). An isolated bipolar single-valued neutrosophic graphs. In Information Systems Design and Intelligent Applications (pp. 816–822). Springer. https://doi.org/10.1007/978-981-10-4748-8_78 [43]Sultana, F., Gulistan, M., Ali, M., Yaqoob, N., Khan, M., Rashid, T., & Ahmed, T. (2023). A study of plithogenic graphs: Applications in spreading coronavirus disease (COVID-19) globally. Journal of Ambient Intelligence and Humanized Computing, 14(10), 13139–13159. https://doi.org/10.1007/s12652-021-03384-7 [44]Kandasamy, W. B. V., Ilanthenral, K., & Smarandache, F. (2020). Plithogenic graphs. Infinite Study.

https://fs.unm.edu/PlithogenicGraphs.pdf