hons 0.1.0__py3-none-any.whl

hons-0.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: hons
+Version: 0.1.0
+Summary: Select network thresholds using persistent homology.
+Author-email: "Russell J. Funk" <rfunk@umn.edu>
+License-Expression: MIT
+Project-URL: Source, https://github.com/rfunklab/hons
+Project-URL: Issues, https://github.com/rfunklab/hons/issues
+Keywords: persistent homology,network thresholding,topological data analysis
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3,>=1.26.4
+Requires-Dist: pandas<4,>=2.1.4
+Requires-Dist: gudhi<3.12,>=3.10.1
+Requires-Dist: networkx<4,>=3.2
+Provides-Extra: plot
+Requires-Dist: matplotlib<4,>=3.8; extra == "plot"
+Dynamic: license-file
+
+# Higher-order network selection
+
+<img src="https://raw.githubusercontent.com/rfunklab/hons/a763c0b43e692ad65491f555a7ab080b6846567b/docs/hons_logo.png" alt="HONS logo" width="300">
+
+Network thresholding helps researchers extract interpretable structure from dense relational data by removing nodes or edges according to their properties. Choosing the cutoffs is harder: a ground-truth network is rarely available, thresholds are often selected by trial and error, and small changes can produce substantially different networks. Criteria based on individual nodes or edges can also overlook connections that contribute to higher-order structure.
+
+**HONS selects thresholds for numerical node attributes or edge weights using the network's cycles and cavities.** These features depend on how groups of connections fit together, beyond counts of nodes, edges or triangles. HONS uses persistent homology to measure those features across a grid of candidate thresholds and selects the network whose topological representation changes least under nearby threshold changes. Minimum feature-count constraints let researchers specify how many cycles and cavities candidate networks must contain.
+
+## Install
+
+Use Python 3.11–3.13:
+
+```sh
+pip install hons
+```
+
+For plotting, run `pip install "hons[plot]"`.
+
+## NetworkX example
+
+The main demo starts with a generated NetworkX graph containing three connected structures and extra connections. Each node has an assigned numerical `weight` to threshold, and each edge has an entry value called `filtration`. In an application, you would supply a measured node or edge attribute, such as frequency or contact duration:
+
+```python
+import hons
+
+network = hons.example_network()
+selected = hons.threshold(
+    network,
+    node_attribute="weight",
+    lower=[0, 1, 2, 3, 4],
+    upper=[4, 5, 6, 7, 9],
+    filtration_range=(0, 1),
+    constraints=(50, 25),
+)
+
+print(network.number_of_nodes(), network.number_of_edges())    # 29 143
+print(selected.number_of_nodes(), selected.number_of_edges())  # 18 41
+```
+
+![Input network and selected network](https://raw.githubusercontent.com/rfunklab/hons/a763c0b43e692ad65491f555a7ab080b6846567b/docs/network_demo.png)
+
+Both objects are ordinary NetworkX graphs. The input remains unchanged, and the selected graph retains its node and edge attributes in their original units. Run `python examples/network_demo.py` from a source checkout to recreate the plot.
+
+The example selects nodes with `weight` between **4 and 7**, inclusive. The selected network has five positive-lifetime H1 features and three H2 features across its filtration. H1 features describe cycles; H2 features describe cavities. `constraints=(50, 25)` requires their counts to reach at least the 50th and 25th percentiles, respectively, among selectable candidate networks.
+
+## Choose candidate thresholds
+
+The `lower` and `upper` arrays define the search grid in the units of the attribute you want to threshold. The numbers above are choices for this small example. Choose bounds that cover the plausible cutoffs for your network; explicit lists, `numpy.linspace` and `numpy.geomspace` are all suitable ways to construct a grid. Grid range and spacing affect which settings are compared and which setting can be selected.
+
+Supply increasing arrays with at least two lower bounds and one upper bound. HONS evaluates every lower/upper combination. The smallest lower bound supplies a neighboring value for the score and is excluded from selection. Bounds are inclusive. A lower bound above its paired upper bound removes all nodes in node-filtering mode or all edges in edge-filtering mode.
+
+Use `node_attribute="name"` to select an induced subgraph, or `edge_attribute="name"` to filter edges while preserving all nodes. The input must be a simple, undirected NetworkX graph. HONS returns `None` when no candidate meets both feature-count constraints.
+
+## Specify the filtration
+
+A filtration describes the order in which connections enter the topology calculation. Each edge needs a finite numerical entry value: a time, a distance or another quantity appropriate to your application. Smaller values enter earlier. All vertices are present at the start, and a clique enters when its last edge enters. The attribute used to remove nodes or edges and the entry values used for persistence have separate roles.
+
+HONS accepts entry values in their original units and converts them internally to 0–1 for the persistence images. By default, the conversion uses the minimum and maximum edge values in the full input graph. Every candidate uses that same range. Set `filtration_range=(start, stop)` when you have a known observation window or want to use a fixed range across multiple input graphs. For example, use `filtration="first_seen", filtration_range=(1920, 2021)` for edges dated by first appearance. The demo explicitly uses its generating interval, `(0, 1)`.
+
+The fixed image grid and Gaussian width apply to this normalized scale. A change of units, with the range changed accordingly, preserves the calculation. A different definition of entry order can change the result. For a strength-based filtration in which stronger edges should enter earlier, use negative strength as the entry value. A zero-width normalization range maps entry values to zero. An empty input graph defaults to a 0–1 range.
+
+## Example application: scientific concepts
+
+The paper applies HONS to concepts that co-occur in scientific articles. In this application, nodes represent concepts, document frequency supplies the attribute to threshold, and an edge's first co-occurrence year supplies its entry value. `examples/concept_network.py` shows how to prepare generated article–concept records as an ordinary NetworkX graph and pass that graph to HONS. This example uses a fixed observation window across candidates. The paper's empirical analysis dates each retained network from its earliest retained concept; the replication repository preserves that preparation in the saved diagrams.
+
+| Example | Purpose | Command from a source checkout |
+| --- | --- | --- |
+| `network_demo.py` | Select from an existing graph and draw the before/after comparison. | `python examples/network_demo.py` |
+| `concept_network.py` | Prepare article–concept records for the same general API. | `python examples/concept_network.py` |
+
+The separate [hons-replication](https://github.com/rfunklab/hons-replication) repository reproduces calculations from the paper's saved persistence diagrams and demonstrates edge-weight thresholding on an open workplace contact network.
+
+## Inspect the calculation
+
+Set `return_details=True` to return `(selected, details)`. `details["grid"]` contains thresholds, network sizes, feature counts and scores; `details["filtration_range"]` records the range used for normalization. The dictionary also includes normalized persistence diagrams, image vectors and near-ties. The selected graph's `graph["hons"]` attribute records its bounds, score and feature counts.
+
+The calculation uses H1 and H2 persistence images, a 20 × 20 sampling grid per dimension, Gaussian standard deviation 0.1, lifetime weights and coefficients in Z/11Z. Essential features are included in selection; infinite deaths become 1.00001 for imaging. Neighboring image distances are divided by their parameter separations, averaged in each direction and combined by the Euclidean norm. Dense graphs can be expensive because computing H2 requires clique expansion through tetrahedra.
+
+For an existing grid of persistence diagrams, use `rho`, `objective` and `select` directly. Diagrams are pandas DataFrames with `dimension`, `birth` and `death` columns and must use a common normalized scale. Dictionary keys are `(upper_index, lower_index)`. The `persistence` helper accepts node identifiers and an edge-to-entry-value mapping; supply common `start` and `stop` bounds when comparing multiple networks. Exact minima follow sorted cell order, with near-ties reported within an absolute score tolerance of 1e-12.
+
+Run the tests from a source checkout with `python -m unittest discover -s tests`.
+
+## Paper and license
+
+Adam Schroeder, Russell Funk, Jingyi Guan, Taylor Okonek and Lori Ziegelmeier. *Higher-Order Network Structure Inference: A Topological Approach to Network Selection*.
+
+The MIT [license](LICENSE) applies to this repository's code, documentation and original assets. Contact Russell Funk at rfunk@umn.edu.

hons-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+hons.py,sha256=7BD_hDK28MPiSHTtniIZOn6z4OHaNf62g0keg4s4utk,13454
+hons-0.1.0.dist-info/licenses/LICENSE,sha256=4a42iuzERfJoaw2iKICy_Z41zigGNKnesZ96aWHP_7o,1072
+hons-0.1.0.dist-info/METADATA,sha256=UvfEcf5wMX6828biIxz9bjsueb82KXkDeu7OWe0np38,9386
+hons-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hons-0.1.0.dist-info/top_level.txt,sha256=83Bc8RaXitenSIh1V54pLPSo-OzEPScrwoNvbd16K_0,5
+hons-0.1.0.dist-info/RECORD,,

hons-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hons-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Russell J. Funk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hons-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hons

hons.py

@@ -0,0 +1,284 @@
+"""Select network thresholds using persistent homology."""
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+import pandas as pd
+
+# shared persistence-image settings
+RES = 20
+SIGMA = 0.1
+INF_REPLACEMENT = 1.00001
+IM_RANGE = [0.0, 1.0, 0.0, INF_REPLACEMENT]
+
+
+def _filtration_bounds(values, limits=None):
+    """Resolve one finite range covering all supplied edge entry values."""
+    values = np.asarray(list(values), dtype=float)
+    if not np.isfinite(values).all():
+        raise ValueError("Filtration values must be finite.")
+    if limits is None:
+        return (float(values.min()), float(values.max())) if len(values) else (0.0, 1.0)
+    limits = np.asarray(limits, dtype=float)
+    if limits.shape != (2,) or not np.isfinite(limits).all() or limits[1] < limits[0]:
+        raise ValueError("filtration_range must contain two finite bounds with start <= stop.")
+    start, stop = map(float, limits)
+    if np.any(values < start) or np.any(values > stop):
+        raise ValueError("Filtration values must fall within filtration_range.")
+    return start, stop
+
+
+def persistence(nodes, edges, start=None, stop=None, max_dim=2) -> pd.DataFrame:
+    """Compute positive-lifetime intervals through max_dim over Z/11Z.
+
+    edges maps node pairs to numerical entry values. Normalize the supplied
+    start/stop range to [0, 1], or infer bounds from the edge values when both
+    are omitted. Use the same bounds when comparing multiple networks.
+    All vertices enter at normalized zero. A constant range maps to zero.
+    Clique expansion supplies higher simplices; infinite deaths remain infinite.
+    """
+    import gudhi
+    if (start is None) != (stop is None):
+        raise ValueError("Supply both start and stop, or omit both.")
+    start, stop = _filtration_bounds(edges.values(), None if start is None else (start, stop))
+    idx = {c: k for k, c in enumerate(nodes)}
+    if len(idx) != len(nodes):
+        raise ValueError("Node identifiers must be unique.")
+    st = gudhi.SimplexTree()
+    for k in range(len(nodes)):
+        st.insert([k], 0.0)
+    span = stop - start
+    for (a, b), value in edges.items():
+        value = float(value)
+        if not np.isfinite(span):
+            entry = (value / 2 - start / 2) / (stop / 2 - start / 2)
+        else:
+            entry = (value - start) / span if span else 0.0
+        if not np.isfinite(entry):
+            raise ValueError("Normalized filtration values must be finite.")
+        st.insert([idx[a], idx[b]], entry)
+    st.expansion(max_dim + 1)
+    # include the top dimension when it is one of the requested dimensions
+    st.compute_persistence(homology_coeff_field=11, min_persistence=0,
+                           persistence_dim_max=st.dimension() <= max_dim)
+    rows = []
+    for d in range(max_dim + 1):
+        for birth, death in st.persistence_intervals_in_dimension(d):
+            rows.append((d, birth, death))
+    return pd.DataFrame(rows, columns=["dimension", "birth", "death"])
+
+
+def lifetimes(h: pd.DataFrame, dim: int) -> np.ndarray:
+    """Copy birth/death pairs, replacing infinite deaths by 1.00001 for imaging."""
+    d = h.loc[h["dimension"] == dim, ["birth", "death"]].to_numpy(dtype=float).copy()
+    if len(d) == 0:
+        return np.empty((0, 2))
+    d[:, 1][np.isinf(d[:, 1])] = INF_REPLACEMENT
+    return d
+
+
+def image(bd: np.ndarray) -> np.ndarray:
+    """Sample the lifetime-weighted Gaussian image on the fixed 20 by 20 grid.
+
+    Input rows are birth/death pairs with finite deaths. The output uses
+    y-major order and contains 400 values; an empty diagram gives zeros.
+    """
+    bd = np.asarray(bd, dtype=float)
+    if bd.size == 0:
+        return np.zeros(RES * RES)
+    if (bd.ndim != 2 or bd.shape[1] != 2 or not np.isfinite(bd).all()
+            or np.any(bd[:, 1] < bd[:, 0])):
+        raise ValueError("Supply finite birth/death pairs with death >= birth.")
+    b, d = bd[:, 0], bd[:, 1]
+    pts = np.column_stack([b, d - b])
+    w = d - b
+    xs = np.linspace(IM_RANGE[0], IM_RANGE[1], RES)
+    ys = np.linspace(IM_RANGE[2], IM_RANGE[3], RES)
+    out = np.zeros((RES, RES))
+    step = 20000
+    for s in range(0, len(pts), step):                       # chunked: bounded memory
+        P, W = pts[s:s + step], w[s:s + step]
+        X = P[:, 0][:, None, None] - xs[None, None, :]
+        Y = P[:, 1][:, None, None] - ys[None, :, None]
+        K = np.exp(-(X ** 2 + Y ** 2) / (2 * SIGMA ** 2)) / (2 * np.pi * SIGMA ** 2)
+        out += np.tensordot(W, K, 1)
+    return out.flatten()
+
+
+def rho(h: pd.DataFrame) -> np.ndarray:
+    """Concatenate the H1 and H2 persistence images into an 800-value vector."""
+    return np.concatenate([image(lifetimes(h, 1)), image(lifetimes(h, 2))])
+
+
+def objective(rho_by_cell: dict, lowers: np.ndarray, uppers: np.ndarray) -> dict:
+    """Score neighboring image differences per unit of threshold change.
+
+    Keys are (upper_index, lower_index). Threshold arrays must be strictly
+    increasing, and rho_by_cell must contain every grid cell. The first lower
+    column supplies neighbors but cannot be selected. Directional means are
+    combined using the Euclidean norm.
+    """
+    lowers, uppers = np.asarray(lowers, float), np.asarray(uppers, float)
+    if any(a.ndim != 1 or not np.isfinite(a).all() or np.any(np.diff(a) <= 0)
+           for a in (lowers, uppers)) or len(lowers) < 2 or len(uppers) < 1:
+        raise ValueError("Use increasing finite thresholds, with >=2 lower and >=1 upper values.")
+    n_i, n_j = len(uppers), len(lowers)
+    if set(rho_by_cell) != {(i, j) for i in range(n_i) for j in range(n_j)}:
+        raise ValueError("Images must contain the complete threshold grid.")
+    vectors = [np.asarray(v, float) for v in rho_by_cell.values()]
+    if any(v.ndim != 1 or v.shape != vectors[0].shape or not np.isfinite(v).all()
+           for v in vectors):
+        raise ValueError("Images must be finite vectors of equal length.")
+    def dist(a, b):
+        return float(np.linalg.norm(rho_by_cell[a] - rho_by_cell[b], ord=2))
+    out = {}
+    for i in range(n_i):
+        for j in range(1, n_j):
+            if (i, j) not in rho_by_cell:
+                continue
+            terms_l = [dist((i, j), (i, j - 1)) / abs(lowers[j] - lowers[j - 1])]
+            if j + 1 < n_j and (i, j + 1) in rho_by_cell:
+                terms_l.append(dist((i, j), (i, j + 1)) / abs(lowers[j + 1] - lowers[j]))
+            terms_u = []
+            if i - 1 >= 0 and (i - 1, j) in rho_by_cell:
+                terms_u.append(dist((i, j), (i - 1, j)) / abs(uppers[i] - uppers[i - 1]))
+            if i + 1 < n_i and (i + 1, j) in rho_by_cell:
+                terms_u.append(dist((i, j), (i + 1, j)) / abs(uppers[i + 1] - uppers[i]))
+            gl = sum(terms_l) / len(terms_l)
+            gu = sum(terms_u) / len(terms_u) if terms_u else 0.0
+            out[(i, j)] = float(np.linalg.norm([gl, gu], ord=2))
+    return out
+
+
+def select(mag: dict, f1: dict, f2: dict, delta1: float, delta2: float):
+    """Minimize the score subject to H1/H2 count-percentile constraints.
+
+    Percentiles range from 0 to 100 and use all selectable cells. Return the
+    minimum's cell and the cells within absolute score tolerance 1e-12 of it.
+    Exact minima use sorted cell order; an infeasible setting returns (None, []).
+    """
+    keys = sorted(mag)
+    if not keys:
+        raise ValueError("Supply at least one selectable cell.")
+    F1 = np.array([f1[k] for k in keys], float)
+    F2 = np.array([f2[k] for k in keys], float)
+    W = np.array([mag[k] for k in keys], float)
+    if not np.isfinite([F1, F2, W]).all() or np.any(F1 < 0) or np.any(F2 < 0):
+        raise ValueError("Scores and counts must be finite; counts must be nonnegative.")
+    d1, d2 = np.percentile(F1, delta1), np.percentile(F2, delta2)
+    feas = (F1 >= d1) & (F2 >= d2)
+    if not feas.any():
+        return None, []
+    Wm = np.where(feas, W, np.inf)
+    best = Wm.min()
+    ties = [keys[t] for t in np.flatnonzero(np.isclose(Wm, best, rtol=0, atol=1e-12))]
+    return keys[int(np.argmin(Wm))], ties
+
+
+def threshold(graph, *, lower, upper, node_attribute=None, edge_attribute=None,
+              filtration="filtration", filtration_range=None,
+              constraints=(50, 25), return_details=False):
+  """Select and return a thresholded NetworkX graph.
+
+  Choose one scalar node or edge attribute for the inclusive threshold band.
+  Edge entry values may use any finite numerical range. Normalize once using
+  filtration_range or the full input graph's observed range. Every candidate
+  uses those same bounds; all vertices enter at normalized zero.
+  The input graph is unchanged. Infeasible constraints return None.
+  With return_details=True, return (network, details), including the grid,
+  persistence diagrams and images used in the calculation.
+  """
+  import networkx as nx
+  if not isinstance(graph, nx.Graph) or graph.is_directed() or graph.is_multigraph():
+    raise ValueError("Supply a simple undirected NetworkX graph.")
+  if nx.number_of_selfloops(graph):
+    raise ValueError("Self-loops are not supported.")
+  if (node_attribute is None) == (edge_attribute is None):
+    raise ValueError("Choose exactly one node_attribute or edge_attribute.")
+  lower, upper = np.asarray(lower, float), np.asarray(upper, float)
+  if (lower.ndim != 1 or upper.ndim != 1 or len(lower) < 2 or len(upper) < 1
+      or not np.isfinite(lower).all() or not np.isfinite(upper).all()
+      or np.any(np.diff(lower) <= 0) or np.any(np.diff(upper) <= 0)):
+    raise ValueError("Supply increasing finite lower and upper arrays (at least 2 and 1 values).")
+  if len(constraints) != 2 or not np.isfinite(constraints).all() or any(
+      p < 0 or p > 100 for p in constraints):
+    raise ValueError("Supply two constraint percentiles between 0 and 100.")
+  attribute = node_attribute or edge_attribute
+  records = graph.nodes(data=True) if node_attribute else graph.edges(data=True)
+  for *_, data in records:
+    if attribute not in data or not np.isfinite(data[attribute]):
+      raise ValueError(f"Every selected element needs a finite {attribute!r} attribute.")
+  for _, _, data in graph.edges(data=True):
+    if filtration not in data:
+      raise ValueError(f"Every edge needs a {filtration!r} filtration value.")
+  limits = _filtration_bounds((d[filtration] for _, _, d in graph.edges(data=True)),
+                               filtration_range)
+
+  def candidate(lo, hi):
+    if node_attribute:
+      return graph.subgraph(n for n, d in graph.nodes(data=True)
+                            if lo <= d[attribute] <= hi).copy()
+    result = graph.copy()
+    result.remove_edges_from((a, b) for a, b, d in graph.edges(data=True)
+                             if not lo <= d[attribute] <= hi)
+    return result
+
+  images, diagrams, h1, h2, rows = {}, {}, {}, {}, []
+  for i, hi in enumerate(upper):
+    for j, lo in enumerate(lower):
+      cell = (i, j)
+      network = candidate(lo, hi)
+      edges = {(a, b): d[filtration] for a, b, d in network.edges(data=True)}
+      diagram = persistence(list(network), edges, *limits)
+      diagrams[cell], images[cell] = diagram, rho(diagram)
+      h1[cell] = int((diagram.dimension == 1).sum())
+      h2[cell] = int((diagram.dimension == 2).sum())
+      rows.append({"upper_index": i, "lower_index": j, "lower": lo, "upper": hi,
+                   "nodes": len(network), "edges": network.number_of_edges(),
+                   "H1": h1[cell], "H2": h2[cell]})
+  scores = objective(images, lower, upper)
+  cell, ties = select(scores, h1, h2, *constraints)
+  for row in rows:
+    key = (row["upper_index"], row["lower_index"])
+    row.update(selectable=key in scores, score=scores.get(key, np.nan))
+  network = None if cell is None else candidate(lower[cell[1]], upper[cell[0]])
+  if network is not None:
+    network.graph["hons"] = {"lower": float(lower[cell[1]]), "upper": float(upper[cell[0]]),
+                             "score": scores[cell], "H1": h1[cell], "H2": h2[cell]}
+  if return_details:
+    return network, {"cell": cell, "ties": ties, "grid": pd.DataFrame(rows),
+                     "images": images, "diagrams": diagrams, "scores": scores,
+                     "H1": h1, "H2": h2, "lower": lower, "upper": upper,
+                     "filtration_range": limits}
+  return network
+
+
+def example_network(seed=7):
+  """Create a small NetworkX example with cycles, cavities and extra connections.
+
+  Node 'weight' is the threshold attribute; edge 'filtration' gives entry
+  values in [0, 1]. All observations are generated, with no empirical records.
+  """
+  import networkx as nx
+  rng = np.random.default_rng(seed)
+  graph = nx.Graph()
+  for block in range(3):
+    base = 6 * block
+    for i in range(6):
+      graph.add_node(base + i, weight=float([4, 5, 6, 4, 5, 6][i]))
+    for a, b in itertools.combinations(range(6), 2):
+      if a // 2 != b // 2:
+        graph.add_edge(base + a, base + b, filtration=float(rng.uniform(.05, .35)))
+    graph.add_edge(base, base + 1, filtration=.8)
+  for a, b in [(0, 6), (6, 12)]:
+    graph.add_edge(a, b, filtration=.4)
+  for i in range(18, 26):
+    graph.add_node(i, weight=float(rng.choice([.5, 1.5, 2.5])))
+    for target in rng.choice(18, size=3, replace=False):
+      graph.add_edge(i, int(target), filtration=float(rng.uniform(.4, .7)))
+  for i in range(26, 29):
+    graph.add_node(i, weight=9.0)
+    for target in range(26):
+      graph.add_edge(i, target, filtration=float(rng.uniform(.85, 1)))
+  return graph