From 67a688767243ef225225a128a6510f3ceb82f1ae Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 10 Feb 2025 10:41:48 +0100 Subject: [PATCH 1/9] feat: added two iterative generators --- xgi/generators/iterative.py | 151 ++++++++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 xgi/generators/iterative.py diff --git a/xgi/generators/iterative.py b/xgi/generators/iterative.py new file mode 100644 index 000000000..ea6eea27e --- /dev/null +++ b/xgi/generators/iterative.py @@ -0,0 +1,151 @@ +"""Generate iterative hypergraphs.""" + +import itertools +import operator +import random +import warnings +from functools import reduce + +import numpy as np +from scipy.special import comb + +from ..exception import XGIError +from ..utils import geometric +from .classic import complete_hypergraph, empty_hypergraph + +__all__ = [ + "pseudofractal_simplicial_complex", + "apollonian_complex", + +] + + +def pseudofractal_simplicial_complex(order, n_iter): + """ + Generate the pseudofractal simplicial complex of order `order`. + + Starting with a single d-simplex, at each iteration, the function adds new (d+1)-simplices + by attaching a new vertex to all existing (d-1)-simplices (as well as all their subfaces). + This process is deterministic. + + Parameters + ---------- + order : int + The ordder of the simplices to add (e.g., 2 for triangles, 3 for tetrahedra, etc.). + n_iter : int + The number of iterations to generate simplices. + + Returns + ------- + S : xgi.SimplicialComplex + Generated simplicial complex + + See also + -------- + apollonian_complex + + + References + ---------- + Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). + "Higher-order Laplacian Renormalization." + arXiv preprint arXiv:2401.11298. + https://arxiv.org/abs/2401.11298 + """ + + S = xgi.SimplicialComplex() + + # initialize the first d-simplex + first_simplex = tuple(range(order + 1)) + S.add_simplex(first_simplex) + + # generate simplices iteratively + for it in range(1, n_iter + 1): + # Find all (order - 1)-simplices present in the complex + nodes = S.nodes + subfaces = S.edges.filterby("order", order - 1).members() + max_index = max(nodes) + new_simplices = [] + + for subface in subfaces: + # create a new simplex by adding the new vertex to the existing d-simplex + max_index += 1 # new vertex index + + new_simplex = (*subface, max_index) + new_simplices.append(new_simplex) + + S.add_simplices_from(new_simplices) + + return S + + +def apollonian_complex(order, n_iter): + """ + Generate the apollonian complex of order `order`. + + Starting with a single d-simplex, at each iteration, the function adds new (d+1)-simplices + by attaching a new vertex to (d-1)-simplices that contain at least one newly added node. + This process is deterministic and generates a simplicial complex. + + + Parameters + ---------- + order : int + The ordder of the simplices to add (e.g., 2 for triangles, 3 for tetrahedra, etc.). + n_iter : int + The maximum iteration to generate simplices. + + Returns + ------- + S : xgi.SimplicialComplex + Generated simplicial complex + + See also + -------- + pseudofractal_simplicial_complex + + References + ---------- + Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). + "Higher-order Laplacian Renormalization." + arXiv preprint arXiv:2401.11298. + https://arxiv.org/abs/2401.11298 + """ + + S = xgi.SimplicialComplex() + + # initialize the first d-simplex + first_simplex = tuple(range(order + 1)) + S.add_simplex(first_simplex) + + new_simplices = [first_simplex] + new_indices = list(first_simplex) + + # generate simplices iteratively + for it in range(1, n_iter + 1): + # find all (order - 1)-simplices present in the complex + nodes = S.nodes + subfaces_previous_iter = S.edges.filterby("order", order - 1).members() + + # keep only those attached to new nodes + subfaces_previous_iter = [ + subface + for subface in subfaces_previous_iter + if any(new_index in subface for new_index in new_indices) + ] + + max_index = max(nodes) + new_simplices = [] + new_indices = [] + + for subface in subfaces_previous_iter: + # create a new simplex by adding the new vertex to the existing d-simplex + max_index += 1 # New vertex index + + new_simplex = (*subface, max_index) + new_simplices.append(new_simplex) + new_indices.append(max_index) + + S.add_simplices_from(new_simplices) + + return S From fa85fe19e68a015f0e2cfa73b97b23237c3d7e4d Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 10 Feb 2025 10:53:10 +0100 Subject: [PATCH 2/9] docs: added new generators to online docs --- docs/source/api/generators.rst | 1 + .../api/generators/xgi.generators.iterative.rst | 11 +++++++++++ 2 files changed, 12 insertions(+) create mode 100644 docs/source/api/generators/xgi.generators.iterative.rst diff --git a/docs/source/api/generators.rst b/docs/source/api/generators.rst index 46533d8cb..5da7e88ac 100644 --- a/docs/source/api/generators.rst +++ b/docs/source/api/generators.rst @@ -14,4 +14,5 @@ generators package ~xgi.generators.uniform ~xgi.generators.simplicial_complexes ~xgi.generators.randomizing + ~xgi.generators.iterative \ No newline at end of file diff --git a/docs/source/api/generators/xgi.generators.iterative.rst b/docs/source/api/generators/xgi.generators.iterative.rst new file mode 100644 index 000000000..2b8cd1238 --- /dev/null +++ b/docs/source/api/generators/xgi.generators.iterative.rst @@ -0,0 +1,11 @@ +xgi.generators.iterative +======================== + +.. currentmodule:: xgi.generators.iterative + +.. automodule:: xgi.generators.iterative + + .. rubric:: Functions + + .. autofunction:: apollonian_complex + .. autofunction:: pseudofractal_simplicial_complex From 61bbc110a22119232cc9612df52342507283b09f Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 10 Feb 2025 12:35:54 +0100 Subject: [PATCH 3/9] fix: typos --- xgi/generators/iterative.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/xgi/generators/iterative.py b/xgi/generators/iterative.py index ea6eea27e..f760d6048 100644 --- a/xgi/generators/iterative.py +++ b/xgi/generators/iterative.py @@ -16,7 +16,6 @@ __all__ = [ "pseudofractal_simplicial_complex", "apollonian_complex", - ] @@ -31,7 +30,7 @@ def pseudofractal_simplicial_complex(order, n_iter): Parameters ---------- order : int - The ordder of the simplices to add (e.g., 2 for triangles, 3 for tetrahedra, etc.). + The order of the simplices to add (e.g., 2 for triangles, 3 for tetrahedra, etc.). n_iter : int The number of iterations to generate simplices. @@ -47,10 +46,10 @@ def pseudofractal_simplicial_complex(order, n_iter): References ---------- - Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). - "Higher-order Laplacian Renormalization." - arXiv preprint arXiv:2401.11298. - https://arxiv.org/abs/2401.11298 + Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). + "Higher-order Laplacian Renormalization." + arXiv preprint arXiv:2401.11298. + https://arxiv.org/abs/2401.11298 """ S = xgi.SimplicialComplex() @@ -91,7 +90,7 @@ def apollonian_complex(order, n_iter): Parameters ---------- order : int - The ordder of the simplices to add (e.g., 2 for triangles, 3 for tetrahedra, etc.). + The order of the simplices to add (e.g., 2 for triangles, 3 for tetrahedra, etc.). n_iter : int The maximum iteration to generate simplices. @@ -106,9 +105,9 @@ def apollonian_complex(order, n_iter): References ---------- - Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). - "Higher-order Laplacian Renormalization." - arXiv preprint arXiv:2401.11298. + Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). + "Higher-order Laplacian Renormalization." + arXiv preprint arXiv:2401.11298. https://arxiv.org/abs/2401.11298 """ From 09b933f54e01210d8452db12ed677577b75abba2 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 10 Feb 2025 12:55:16 +0100 Subject: [PATCH 4/9] test: initial for pseudofractal --- tests/generators/test_iterative.py | 61 ++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 tests/generators/test_iterative.py diff --git a/tests/generators/test_iterative.py b/tests/generators/test_iterative.py new file mode 100644 index 000000000..87d597399 --- /dev/null +++ b/tests/generators/test_iterative.py @@ -0,0 +1,61 @@ +import pytest + +import xgi +from xgi.exception import XGIError + + +def test_pseudofractal(): + + # initial + S0 = xgi.pseudofractal_simplicial_complex(order=2, n_iter=0) + triangles = set(S0.edges.filterby("order", 2).members()) + + assert isinstance(S, xgi.SimplicialComplex) + assert S0.num_nodes == 3 + assert S0.num_edges == 4 + assert triangles == {frozenset({0, 1, 2})} + + # first iteration + S1 = xgi.pseudofractal_simplicial_complex(order=2, n_iter=1) + triangles = set(S1.edges.filterby("order", 2).members()) + + assert isinstance(S1, xgi.SimplicialComplex) + assert S1.num_nodes == 6 + assert xgi.num_edges_order(S1, d=2) == 4 + assert triangles == {frozenset({1, 2, 5}), + frozenset({0, 2, 4}), + frozenset({0, 1, 3}), + frozenset({0, 1, 2})} + + # second iteration + S2 = xgi.pseudofractal_simplicial_complex(order=2, n_iter=2) + triangles = set(S2.edges.filterby("order", 2).members()) + + assert isinstance(S2, xgi.SimplicialComplex) + assert S2.num_nodes == 15 + assert xgi.num_edges_order(S2, d=2) == 13 + assert triangles == {frozenset({0, 4, 10}), + frozenset({0, 2, 7}), + frozenset({0, 1, 2}), + frozenset({1, 5, 11}), + frozenset({1, 2, 5}), + frozenset({0, 2, 4}), + frozenset({0, 3, 12}), + frozenset({1, 3, 14}), + frozenset({2, 4, 9}), + frozenset({1, 2, 8}), + frozenset({0, 1, 6}), + frozenset({2, 5, 13}), + frozenset({0, 1, 3})} + +def test_apollonian(): + w + + H = xgi.sunflower(4, 3, 6) + for i in range(3): + H.nodes.memberships(i) == {0, 1, 2, 3} + + assert H.num_nodes == 15 + + for i in range(3, 15): + assert len(H.nodes.memberships(i)) == 1 From 691440560545811329422370840416e1df27c225 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 10 Feb 2025 12:59:38 +0100 Subject: [PATCH 5/9] style: black isort ruff --- tests/generators/test_iterative.py | 43 +++++++++++++++++------------- xgi/generators/iterative.py | 43 +++++++++++------------------- 2 files changed, 40 insertions(+), 46 deletions(-) diff --git a/tests/generators/test_iterative.py b/tests/generators/test_iterative.py index 87d597399..4231981cf 100644 --- a/tests/generators/test_iterative.py +++ b/tests/generators/test_iterative.py @@ -5,12 +5,12 @@ def test_pseudofractal(): - + # initial S0 = xgi.pseudofractal_simplicial_complex(order=2, n_iter=0) triangles = set(S0.edges.filterby("order", 2).members()) - assert isinstance(S, xgi.SimplicialComplex) + assert isinstance(S0, xgi.SimplicialComplex) assert S0.num_nodes == 3 assert S0.num_edges == 4 assert triangles == {frozenset({0, 1, 2})} @@ -22,10 +22,12 @@ def test_pseudofractal(): assert isinstance(S1, xgi.SimplicialComplex) assert S1.num_nodes == 6 assert xgi.num_edges_order(S1, d=2) == 4 - assert triangles == {frozenset({1, 2, 5}), - frozenset({0, 2, 4}), - frozenset({0, 1, 3}), - frozenset({0, 1, 2})} + assert triangles == { + frozenset({1, 2, 5}), + frozenset({0, 2, 4}), + frozenset({0, 1, 3}), + frozenset({0, 1, 2}), + } # second iteration S2 = xgi.pseudofractal_simplicial_complex(order=2, n_iter=2) @@ -34,19 +36,22 @@ def test_pseudofractal(): assert isinstance(S2, xgi.SimplicialComplex) assert S2.num_nodes == 15 assert xgi.num_edges_order(S2, d=2) == 13 - assert triangles == {frozenset({0, 4, 10}), - frozenset({0, 2, 7}), - frozenset({0, 1, 2}), - frozenset({1, 5, 11}), - frozenset({1, 2, 5}), - frozenset({0, 2, 4}), - frozenset({0, 3, 12}), - frozenset({1, 3, 14}), - frozenset({2, 4, 9}), - frozenset({1, 2, 8}), - frozenset({0, 1, 6}), - frozenset({2, 5, 13}), - frozenset({0, 1, 3})} + assert triangles == { + frozenset({0, 4, 10}), + frozenset({0, 2, 7}), + frozenset({0, 1, 2}), + frozenset({1, 5, 11}), + frozenset({1, 2, 5}), + frozenset({0, 2, 4}), + frozenset({0, 3, 12}), + frozenset({1, 3, 14}), + frozenset({2, 4, 9}), + frozenset({1, 2, 8}), + frozenset({0, 1, 6}), + frozenset({2, 5, 13}), + frozenset({0, 1, 3}), + } + def test_apollonian(): w diff --git a/xgi/generators/iterative.py b/xgi/generators/iterative.py index f760d6048..4a14bd262 100644 --- a/xgi/generators/iterative.py +++ b/xgi/generators/iterative.py @@ -1,17 +1,6 @@ """Generate iterative hypergraphs.""" -import itertools -import operator -import random -import warnings -from functools import reduce - -import numpy as np -from scipy.special import comb - -from ..exception import XGIError -from ..utils import geometric -from .classic import complete_hypergraph, empty_hypergraph +from ..core import SimplicialComplex __all__ = [ "pseudofractal_simplicial_complex", @@ -23,8 +12,8 @@ def pseudofractal_simplicial_complex(order, n_iter): """ Generate the pseudofractal simplicial complex of order `order`. - Starting with a single d-simplex, at each iteration, the function adds new (d+1)-simplices - by attaching a new vertex to all existing (d-1)-simplices (as well as all their subfaces). + Starting with a single d-simplex, at each iteration, the function adds new (d+1)-simplices + by attaching a new vertex to all existing (d-1)-simplices (as well as all their subfaces). This process is deterministic. Parameters @@ -46,13 +35,13 @@ def pseudofractal_simplicial_complex(order, n_iter): References ---------- - Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). - "Higher-order Laplacian Renormalization." - arXiv preprint arXiv:2401.11298. - https://arxiv.org/abs/2401.11298 + Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). + "Higher-order Laplacian Renormalization." + arXiv preprint arXiv:2401.11298. + https://arxiv.org/abs/2401.11298 """ - S = xgi.SimplicialComplex() + S = SimplicialComplex() # initialize the first d-simplex first_simplex = tuple(range(order + 1)) @@ -82,9 +71,9 @@ def apollonian_complex(order, n_iter): """ Generate the apollonian complex of order `order`. - Starting with a single d-simplex, at each iteration, the function adds new (d+1)-simplices - by attaching a new vertex to (d-1)-simplices that contain at least one newly added node. - This process is deterministic and generates a simplicial complex. + Starting with a single d-simplex, at each iteration, the function adds new (d+1)-simplices + by attaching a new vertex to (d-1)-simplices that contain at least one newly added node. + This process is deterministic and generates a simplicial complex. Parameters @@ -105,13 +94,13 @@ def apollonian_complex(order, n_iter): References ---------- - Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). - "Higher-order Laplacian Renormalization." - arXiv preprint arXiv:2401.11298. + Nurisso, M., Morandini, M., Lucas, M., Vaccarino, F., Gili, T., & Petri, G. (2024). + "Higher-order Laplacian Renormalization." + arXiv preprint arXiv:2401.11298. https://arxiv.org/abs/2401.11298 """ - - S = xgi.SimplicialComplex() + + S = SimplicialComplex() # initialize the first d-simplex first_simplex = tuple(range(order + 1)) From f208cea5572acceae105c9af577334b8ead56a90 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 10 Feb 2025 13:01:50 +0100 Subject: [PATCH 6/9] fix: test apollonian --- tests/generators/test_iterative.py | 47 +++++++++++++++++++++++++----- 1 file changed, 40 insertions(+), 7 deletions(-) diff --git a/tests/generators/test_iterative.py b/tests/generators/test_iterative.py index 4231981cf..b6564b03c 100644 --- a/tests/generators/test_iterative.py +++ b/tests/generators/test_iterative.py @@ -54,13 +54,46 @@ def test_pseudofractal(): def test_apollonian(): - w - H = xgi.sunflower(4, 3, 6) - for i in range(3): - H.nodes.memberships(i) == {0, 1, 2, 3} + # initial + S0 = xgi.apollonian_complex(order=2, n_iter=0) + triangles = set(S0.edges.filterby("order", 2).members()) - assert H.num_nodes == 15 + assert isinstance(S0, xgi.SimplicialComplex) + assert S0.num_nodes == 3 + assert S0.num_edges == 4 + assert triangles == {frozenset({0, 1, 2})} - for i in range(3, 15): - assert len(H.nodes.memberships(i)) == 1 + # first iteration + S1 = xgi.apollonian_complex(order=2, n_iter=1) + triangles = set(S1.edges.filterby("order", 2).members()) + + assert isinstance(S1, xgi.SimplicialComplex) + assert S1.num_nodes == 6 + assert xgi.num_edges_order(S1, d=2) == 4 + assert triangles == { + frozenset({1, 2, 5}), + frozenset({0, 2, 4}), + frozenset({0, 1, 3}), + frozenset({0, 1, 2}), + } + + # second iteration + S2 = xgi.apollonian_complex(order=2, n_iter=2) + triangles = set(S2.edges.filterby("order", 2).members()) + + assert isinstance(S2, xgi.SimplicialComplex) + assert S2.num_nodes == 12 + assert xgi.num_edges_order(S2, d=2) == 10 + assert triangles == { + frozenset({2, 4, 6}), + frozenset({1, 5, 8}), + frozenset({0, 3, 9}), + frozenset({0, 1, 2}), + frozenset({1, 2, 5}), + frozenset({0, 2, 4}), + frozenset({2, 5, 10}), + frozenset({1, 3, 11}), + frozenset({0, 1, 3}), + frozenset({0, 4, 7}), + } From 62ad845d1806bac62d33bf5667c158bae95699dc Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 10 Feb 2025 13:04:10 +0100 Subject: [PATCH 7/9] fix: __init__ --- xgi/generators/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/xgi/generators/__init__.py b/xgi/generators/__init__.py index 127a8da93..68d4429cf 100644 --- a/xgi/generators/__init__.py +++ b/xgi/generators/__init__.py @@ -1,5 +1,6 @@ from . import ( classic, + iterative, lattice, random, randomizing, @@ -8,6 +9,7 @@ uniform, ) from .classic import * +from .iterative import * from .lattice import * from .random import * from .randomizing import * From cde2bc12b13bdf7c7dd469fd885c13d1266e0f5a Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Tue, 11 Feb 2025 11:22:37 +0100 Subject: [PATCH 8/9] feat: added NGF generator --- xgi/generators/iterative.py | 117 +++++++++++++++++++++++++++++++++++- 1 file changed, 116 insertions(+), 1 deletion(-) diff --git a/xgi/generators/iterative.py b/xgi/generators/iterative.py index 4a14bd262..a451734dd 100644 --- a/xgi/generators/iterative.py +++ b/xgi/generators/iterative.py @@ -5,6 +5,7 @@ __all__ = [ "pseudofractal_simplicial_complex", "apollonian_complex", + "network_geometry_flavor", ] @@ -31,7 +32,7 @@ def pseudofractal_simplicial_complex(order, n_iter): See also -------- apollonian_complex - + network_geometry_flavor References ---------- @@ -91,6 +92,7 @@ def apollonian_complex(order, n_iter): See also -------- pseudofractal_simplicial_complex + network_geometry_flavor References ---------- @@ -137,3 +139,116 @@ def apollonian_complex(order, n_iter): S.add_simplices_from(new_simplices) return S + + +def network_geometry_flavor( + order, s, beta, n_iter, energy_distribution=None, seed=None +): + """ + Generate a Network Geometry with Flavor (NGF) simplicial complex. + + The model grows a d-dimensional simplicial complex (where d is `order`) by iteratively attaching + d-simplices to existing (d-1)-simplices, with attachment probabilities controlled + by the flavor parameter `s` and an energy-based selection process. + + Parameters + ---------- + order : int + The order of the simplices to add. + s : int + The flavor parameter (-1, 0, or 1). + beta : float + The inverse temperature parameter controlling randomness. + n_iter : int + The total number of d-simplices to generate. + energy_dist : callable, optional + A function to sample vertex energies (default: uniform [0,10)). + seed : int, optional + Random seed for reproducibility. + + Returns + ------- + S : xgi.SimplicialComplex + The generated NGF simplicial complex. + + See also + -------- + apollonian_complex + pseudofractal_simplicial_complex + + References + ---------- + Bianconi, G., & Rahmede, C. (2016). + "Network geometry with flavor: from complexity to quantum geometry." + Physical Review E, 93(3), 032315. + https://arxiv.org/abs/1511.04539 + """ + if seed is not None: + np.random.seed(seed) + + # initialize the hypergraph + S = xgi.SimplicialComplex() + + # assign energies to vertices + if energy_distribution is None: + energy_distribution = lambda: np.random.uniform(0, 9) + + energy_nodes = {} + + # create initial d-simplex + initial_simplex = list(range(order + 1)) + for node in initial_simplex: + energy_nodes[node] = energy_distribution() + S.add_simplex(initial_simplex) + + # track (d-1)-simplices and their counts + face_counts = {} + + def count_face(face): + """Adds or updates a (d-1)-simplex count.""" + face = tuple(sorted(face)) + if face in face_counts: + face_counts[face] += 1 + else: + face_counts[face] = 1 + + # initialize (d-1)-simplices from the first simplex + for face in xgi.subfaces([initial_simplex], order=order - 1): + count_face(face) + + # iterative growth + for it in range(order + 2, order + 2 + n_iter): + # compute attachment probabilities + Z = 0 + probs = {} + + for face, count in face_counts.items(): + energy = sum(energy_nodes[node] for node in face) + weight = np.exp(-beta * energy) * (1 + s * (count - 1)) + if s == -1 and count >= 2: + weight = 0 # Prevent further attachment to these faces + probs[face] = weight + Z += weight + + # normalize probabilities + if Z == 0: + break # no valid attachment sites left + + for face in probs: + probs[face] /= Z + + # choose a (d-1)-simplex to attach the new simplex + chosen_idx = np.random.choice(len(probs), p=list(probs.values())) + chosen_face = list(probs.keys())[chosen_idx] + + # add new node and new simplex + new_node = it + energy_nodes[new_node] = energy_distribution() + new_simplex = list(chosen_face) + [new_node] + S.add_simplex(new_simplex) + + # update face counts + for face in xgi.subfaces([new_simplex], order=order - 1): + count_face(face) + + return S From e372067a2e7c7b58bf0e79002d5a03ca79ffda0e Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Tue, 11 Feb 2025 11:26:31 +0100 Subject: [PATCH 9/9] fix: added function to online docs --- docs/source/api/generators/xgi.generators.iterative.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/source/api/generators/xgi.generators.iterative.rst b/docs/source/api/generators/xgi.generators.iterative.rst index 2b8cd1238..a8fb20ee9 100644 --- a/docs/source/api/generators/xgi.generators.iterative.rst +++ b/docs/source/api/generators/xgi.generators.iterative.rst @@ -8,4 +8,5 @@ xgi.generators.iterative .. rubric:: Functions .. autofunction:: apollonian_complex - .. autofunction:: pseudofractal_simplicial_complex + .. autofunction:: network_geometry_flavor + .. autofunction:: pseudofractal_simplicial_complex \ No newline at end of file