holonomy-lib 0.8.0__py3-none-any.whl

holonomy_lib/topology/persistent_homology.py

@@ -0,0 +1,301 @@
+# SPDX-License-Identifier: FSL-1.1-ALv2
+# Copyright 2026 Synoros
+
+"""Persistent homology of Vietoris-Rips filtrations.
+
+For a point cloud `X`, the Vietoris-Rips filtration is the family of
+simplicial complexes `{VR(X, r) : r ≥ 0}` indexed by scale `r`. As
+`r` grows, simplices are born; the persistent-homology pipeline
+tracks which topological features (connected components, loops,
+voids, ...) survive across scales.
+
+This module exports a single public function
+
+  persistence_diagrams(points_or_distances, max_dim=2, max_radius=inf,
+      input_is_distance=False, reduction_backend="python")
+      → (diagrams, masks)
+
+where `diagrams[k]` is a `(B, max_pairs_k, 2)` batched padded tensor
+of `(birth, death)` pairs for the k-th persistence diagram, and
+`masks[k]` is the matching `(B, max_pairs_k)` validity mask. Bars
+that survive to the end of the filtration have `death = +inf`. With a finite
+`max_radius` the filtration ends at that radius, so bars still alive there
+get `death = +inf` as well.
+
+Two computational paths:
+
+  H₀: sequential host union-find on sorted filtration edges, dispatched
+  per batch member. All components are born at zero; each merge records
+  one death and every remaining component gets a `(0, +inf)` bar.
+
+  H_{1..max_dim}: Z/2 left-to-right reduction of the boundary
+  matrix in filtration order (Edelsbrunner-Letscher-Zomorodian
+  2002), via `_reduction.reduce_filtration`. Sequential within one
+  filtration. Simplex enumeration is batched across point clouds, but the
+  public function runs one reduction per batch element.
+
+References:
+  Edelsbrunner, H., Letscher, D., Zomorodian, A. (2002). Topological
+    persistence and simplification. Discrete & Computational
+    Geometry 28:511-533. Foundational PH paper.
+  Cohen-Steiner, D., Edelsbrunner, H., Harer, J. (2007). Stability
+    of persistence diagrams. Discrete & Computational Geometry
+    37(1):103-120. Stability under perturbation of input data.
+  Edelsbrunner, H., Harer, J. (2010). Computational Topology: An
+    Introduction. AMS. Reference textbook.
+  Bauer, U. (2021). Ripser: efficient computation of Vietoris-Rips
+    persistence barcodes. J. Appl. Comput. Topology 5:391-423.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import torch
+
+from holonomy_lib.simplicial import (
+    SparseSimplicialComplex,
+    pairwise_distances,
+    vietoris_rips_dense,
+)
+from holonomy_lib.topology._filtration import build_filtration
+from holonomy_lib.topology._reduction import reduce_filtration
+
+
+def persistence_diagrams(
+    points_or_distances: torch.Tensor,
+    max_dim: int = 2,
+    max_radius: float = float("inf"),
+    input_is_distance: bool = False,
+    reduction_backend: Literal["python", "torch"] = "python",
+) -> tuple[list[torch.Tensor], list[torch.Tensor]]:
+    """Persistence diagrams for dims 0..max_dim of a Vietoris-Rips filtration.
+
+    Args:
+      points_or_distances: either `(B, n, d)` point clouds or
+        `(B, n, n)` distance matrices. Set `input_is_distance=True`
+        for the latter.
+      max_dim: highest dim to compute. Common choices: 1 (clusters +
+        loops) or 2 (clusters + loops + voids).
+      max_radius: build the filtration only up to this scale. Bars
+        born after this radius are not recorded, and bars still alive at
+        this radius get `death = +inf`. Default `+inf` builds the full
+        filtration.
+      input_is_distance: if True, `points_or_distances` is read as a
+        distance matrix directly; otherwise pairwise Euclidean
+        distances are computed.
+      reduction_backend: `"python"` (default; CPython set columns)
+        or `"torch"` (LongTensor columns on the filtration's device).
+        See `_reduction.reduce_filtration` for the tradeoff.
+
+    Returns:
+      `(diagrams, masks)` where:
+        diagrams[k]: `(B, max_pairs_k, 2)` float Tensor of
+          `(birth, death)` pairs. Bars surviving to infinity have
+          `death = +inf`.
+        masks[k]: `(B, max_pairs_k)` bool Tensor; True for real
+          pairs, False for padding.
+
+      Both lists have length `max_dim + 1`. H_0 retains one bar per input
+      vertex, including zero-length bars when coincident vertices merge.
+      Higher-dimensional diagrams omit zero-length bars.
+
+    Notes:
+      Cost is dominated by the matrix reduction for `max_dim ≥ 1`:
+      O(B · m³) worst case where `m` is the number of simplices in
+      the filtration, but typically much faster due to sparsity. For
+      large point clouds, lower `max_radius` or `max_dim` to keep
+      the simplex count manageable.
+
+      Simplex construction is batched. Z/2 pivot reduction and H_0 union-find
+      are sequential within each filtration: every pivot or component merge
+      depends on previous ones. Ragged filtrations are dispatched separately.
+      Python reduction is an explicit host boundary; torch reduction keeps
+      columns on device but synchronizes for dependent pivot decisions. Bar
+      coordinates are returned without an autograd connection to the inputs.
+
+      Comparison vs `ripser`: tie-breaking on equal birth/death
+      values may differ; the persistence diagrams agree under
+      bottleneck distance.
+
+    References:
+      Edelsbrunner-Letscher-Zomorodian (2002).
+      Cohen-Steiner-Edelsbrunner-Harer (2007) stability.
+    """
+    if points_or_distances.ndim != 3:
+        raise ValueError(
+            f"points_or_distances must be 3-D (B, ...); got "
+            f"{tuple(points_or_distances.shape)}"
+        )
+    if not points_or_distances.is_floating_point():
+        raise ValueError("points_or_distances must have real floating dtype")
+    if max_dim < 0:
+        raise ValueError(f"max_dim must be >= 0, got {max_dim}")
+    if max_radius < 0:
+        raise ValueError(f"max_radius must be >= 0, got {max_radius}")
+    if reduction_backend not in ("python", "torch"):
+        raise ValueError(f"unknown reduction_backend={reduction_backend!r}")
+    B = points_or_distances.shape[0]
+
+    if input_is_distance:
+        if points_or_distances.shape[-1] != points_or_distances.shape[-2]:
+            raise ValueError(
+                f"input_is_distance=True requires (B, n, n); got "
+                f"{tuple(points_or_distances.shape)}"
+            )
+        distances = points_or_distances
+    else:
+        distances = pairwise_distances(points_or_distances)
+
+    # pairs_per_batch_per_dim[b][k] collects the (birth, death) pairs of batch
+    # member b in dimension k.
+    pairs_per_batch_per_dim: list[list[list[tuple[float, float]]]] = [
+        [[] for _ in range(max_dim + 1)] for _ in range(B)
+    ]
+
+    # All batch members share one tensorized simplex enumeration. The reduction
+    # is sequential, so it runs once per member on that member's filtration.
+    complexes = vietoris_rips_dense(
+        distances, max_radius=max_radius, max_dim=max_dim + 1,
+    ) if max_dim >= 1 else None
+    for b in range(B):
+        d_b = distances[b]
+
+        # H_0: union-find on sorted filtration edges.
+        h0_pairs = _persistent_h0(d_b, max_radius)
+        pairs_per_batch_per_dim[b][0] = h0_pairs
+
+        # H_{1..max_dim}: build the VR complex and reduce its boundary matrix.
+        # With max_dim == 0 there is no complex, so only union-find runs.
+        # Otherwise the reduction runs on whatever simplices exist, and a
+        # dimension with none adds no bars, so small clouds need no extra guard.
+        if complexes is not None:
+            complex = SparseSimplicialComplex(
+                {k: table[b][complexes.valid_mask[k][b]]
+                 for k, table in complexes.simplices_by_dim.items()},
+                n_vertices=complexes.n_vertices, device=complexes.device,
+            )
+            filt = build_filtration(d_b, complex)
+            pairs_by_dim = reduce_filtration(filt, backend=reduction_backend)
+            # H_0 already came from union-find, so only dims 1..max_dim are
+            # taken from this reduction.
+            for k in range(1, max_dim + 1):
+                pairs_per_batch_per_dim[b][k] = pairs_by_dim.get(k, [])
+
+    # Pad per-dim into batched tensors.
+    diagrams: list[torch.Tensor] = []
+    masks: list[torch.Tensor] = []
+    for k in range(max_dim + 1):
+        max_pairs_k = max(
+            len(pairs_per_batch_per_dim[b][k]) for b in range(B)
+        ) if B > 0 else 0
+        # No member has a bar in this dimension. Return an empty (B, 0, 2)
+        # tensor so callers can index every dimension the same way.
+        if max_pairs_k == 0:
+            diagrams.append(
+                torch.zeros(B, 0, 2, dtype=distances.dtype,
+                             device=distances.device)
+            )
+            masks.append(
+                torch.zeros(B, 0, dtype=torch.bool, device=distances.device)
+            )
+            continue
+        diag = torch.zeros(
+            B, max_pairs_k, 2,
+            dtype=distances.dtype, device=distances.device,
+        )
+        # counts[b] is how many real pairs member b has in this dimension.
+        counts = [len(member[k]) for member in pairs_per_batch_per_dim]
+        # One host-to-device copy per dimension. Pairs are flattened in batch
+        # order, so each (birth, death) stays whole.
+        values = torch.tensor(
+            [pair for member in pairs_per_batch_per_dim for pair in member[k]],
+            dtype=distances.dtype, device=distances.device,
+        )
+        count_tensor = torch.tensor(counts, device=distances.device)
+        # Row b's first counts[b] slots are real and the rest are padding.
+        positions = torch.arange(max_pairs_k, device=distances.device)
+        mask = positions < count_tensor[:, None]
+        # Boolean-mask assignment fills the True slots row by row, which matches
+        # the batch-order flattening of `values`.
+        diag[mask] = values
+        diagrams.append(diag)
+        masks.append(mask)
+
+    return diagrams, masks
+
+
+# ============================================================
+# H_0 via batched union-find on sorted filtration edges
+# ============================================================
+
+
+def _persistent_h0(
+    distances: torch.Tensor, max_radius: float,
+) -> list[tuple[float, float]]:
+    """Persistent H_0 for a single distance matrix.
+
+    Takes an `(n, n)` distance matrix and the radius cap. Returns `n`
+    `(birth, death)` pairs, one per vertex. Every component is born at 0.
+    Each union-find merge kills one component at that edge length. A graph
+    that is connected at the cap leaves one component alive to infinity, and
+    a disconnected one leaves one essential bar per component. Edges are
+    copied to the host in one bulk transfer. Union-find runs sequentially
+    because each merge changes the partition that later edges see.
+    """
+    n = distances.shape[0]
+    if n == 0:
+        return []
+    if n == 1:
+        # Single vertex: one infinite bar.
+        return [(0.0, float("inf"))]
+
+    # Strictly upper-triangular edges (i, j) with i < j and d <= max_radius.
+    iu, ju = torch.triu_indices(n, n, offset=1, device=distances.device)
+    edge_lengths = distances[iu, ju]
+    if max_radius != float("inf"):
+        keep = edge_lengths <= max_radius
+        iu, ju, edge_lengths = iu[keep], ju[keep], edge_lengths[keep]
+
+    # Sort edges by length. The stable sort breaks ties by upper-triangle
+    # order, so the barcode is the same on every run.
+    sort_idx = torch.argsort(edge_lengths, stable=True)
+    sorted_u = iu[sort_idx].tolist()
+    sorted_v = ju[sort_idx].tolist()
+    sorted_lengths = edge_lengths[sort_idx].tolist()
+
+    # Disjoint-set union with path compression + union-by-rank.
+    parent = list(range(n))
+    rank = [0] * n
+
+    def find(x: int) -> int:
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]  # path compression
+            x = parent[x]
+        return x
+
+    pairs: list[tuple[float, float]] = []
+    for u, v, length in zip(sorted_u, sorted_v, sorted_lengths, strict=True):
+        ru, rv = find(u), find(v)
+        if ru == rv:
+            continue
+        # All vertices are born at zero, so either representative gives
+        # the same barcode. Rank only keeps the parent trees shallow.
+        if rank[ru] < rank[rv]:
+            parent[ru] = rv
+        elif rank[ru] > rank[rv]:
+            parent[rv] = ru
+        else:
+            parent[rv] = ru
+            rank[ru] += 1
+        # A successful merge kills one zero-born connected component.
+        pairs.append((0.0, length))
+
+    # Components that never merged survive to infinity. For a graph connected
+    # at the cap, that is one component.
+    n_merged = len(pairs)
+    n_surviving = n - n_merged
+    for _ in range(n_surviving):
+        pairs.append((0.0, float("inf")))
+
+    return pairs

holonomy_lib-0.8.0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: holonomy-lib
+Version: 0.8.0
+Summary: Batched PyTorch primitives for Riemannian geometry, spectral graph theory, discrete curvature, topology, and tensor decompositions.
+Author: Synoros
+License-Expression: FSL-1.1-ALv2
+Project-URL: Homepage, https://github.com/Synoros-io/holonomy_lib
+Project-URL: Repository, https://github.com/Synoros-io/holonomy_lib
+Project-URL: Issues, https://github.com/Synoros-io/holonomy_lib/issues
+Keywords: pytorch,differential-geometry,riemannian-manifolds,hyperbolic-geometry,riemannian-optimization,spectral-graph-theory,graph-laplacian,magnetic-laplacian,heat-kernel,diffusion-maps,effective-resistance,ricci-curvature,ricci-flow,cellular-sheaves,simplicial-complex,hodge-laplacian,persistent-homology,topological-data-analysis,information-geometry,tensor-decomposition,numerical-linear-algebra
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: torch>=2.2
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.11.2
+Provides-Extra: comparison
+Requires-Dist: pymanopt; extra == "comparison"
+Requires-Dist: geoopt; extra == "comparison"
+Requires-Dist: geomstats; extra == "comparison"
+Requires-Dist: autograd; extra == "comparison"
+Requires-Dist: tensorly; extra == "comparison"
+Requires-Dist: networkx; extra == "comparison"
+Requires-Dist: gudhi; extra == "comparison"
+Requires-Dist: ripser; extra == "comparison"
+Requires-Dist: GraphRicciCurvature; extra == "comparison"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: scipy-stubs; extra == "dev"
+Dynamic: license-file
+
+# holonomy_lib
+
+Geometry, graph and topology primitives for PyTorch. Most functions take a batch
+of inputs (a leading batch dimension) and run on the device and dtype you pass in.
+
+## Install
+
+Python 3.12 or later. Install PyTorch for your hardware first, using the
+[PyTorch selector](https://pytorch.org/get-started/locally/), then:
+
+```bash
+pip install holonomy-lib
+```
+
+## Example
+
+Effective resistance between the ends of a three-node path and of a triangle,
+computed as one batch:
+
+```python
+import torch
+from holonomy_lib.spectral import effective_resistance
+
+device = "cuda" if torch.cuda.is_available() else "cpu"  # ROCm builds also use "cuda"
+adjacency = torch.tensor([
+    [[0, 1, 0], [1, 0, 1], [0, 1, 0]],  # path 0-1-2
+    [[0, 1, 1], [1, 0, 1], [1, 1, 0]],  # triangle
+], dtype=torch.float64, device=device)
+
+R = effective_resistance(adjacency)
+print(R.shape)        # torch.Size([2, 3, 3])
+print(R[:, 0, 2])     # tensor([2.0000, 0.6667], dtype=torch.float64)
+```
+
+## What's in it
+
+[CONTENTS.md](https://github.com/Synoros-io/holonomy_lib/blob/master/CONTENTS.md) lists every function with its signature and the
+paper it implements.
+
+| Subpackage | Contents |
+|---|---|
+| `manifolds` | Fixed-rank, SPD, Lorentz, Lorentzian, stereographic and product manifolds; model-space volumes. |
+| `optimization` | Riemannian SGD. |
+| `hyperbolic` | Fréchet means, manifold-aware inner products, hyperbolic heat kernels. |
+| `lie` | SO(3) exponential and logarithm, rotations, real spherical harmonics. |
+| `info_geometry` | Bregman and KL divergences, Fisher information, natural gradients. |
+| `tensor_calculus` | Mode unfolding, mode products, HOSVD. |
+| `algebra` | Truncated SVD, dense and sparse eigensolvers, conjugate gradient, LSQR. |
+| `convex` | Regularized least squares. |
+| `spectral` | Graph Laplacians, embeddings, heat diffusion, effective resistance, spectral dimension. |
+| `discrete_geometry` | Ollivier and Forman curvature, Ricci flow with surgery. |
+| `sheaf` | Graph sheaves, coboundaries, sheaf Laplacians and their spectra. |
+| `simplicial` | Dense and sparse simplicial complexes, boundary operators, Vietoris-Rips. |
+| `topology` | Hodge Laplacians, Betti numbers, persistent homology. |
+
+## Explorer
+
+`holonomy-explorer` opens a local page that runs the library live: curvature
+and diffusion on graphs, geodesics as curvature passes through zero,
+persistent homology of point clouds, and batch-size timings on your hardware.
+Options: `--device`, `--dtype`, `--port`, `--no-browser`.
+
+![The explorer's graph view](https://raw.githubusercontent.com/Synoros-io/holonomy_lib/master/docs/explorer.png)
+
+## Experimental
+
+`holonomy_lib.experimental` holds two unfinished pieces that are not part of
+the stable API:
+
+- `hyperbolic_laplacian_eigenmaps`: nothing in its objective keeps nodes apart,
+  so an embedding can collapse to a point.
+- `HeterogeneousKappaManifold`: a curvature per point. Its `dissimilarity` is
+  not a metric.
+
+## Limits
+
+- Use `float64` when accuracy matters.
+- Sparse eigensolvers, sparse simplicial complexes and sheaves handle one
+  instance at a time. Sparse eigensolvers are not differentiable.
+- Persistent homology runs its reduction one batch member at a time on the CPU.
+- Ollivier curvature uses entropy-regularized transport, so it is close to the
+  exact value rather than equal to it, and it warns if the solver did not
+  converge. Edge weights act as both lengths and random-walk weights.
+- Gradients through `cg` can be wrong when it converges in very few iterations.
+- Effective resistance and commute time are `inf` between disconnected components.
+
+## Development
+
+```bash
+uv sync --extra dev
+python -m pytest -q
+python -m ruff check src/ tests/
+python -m mypy src/
+python tools/audit.py src/holonomy_lib --strict
+```
+
+[CONVENTIONS.md](https://github.com/Synoros-io/holonomy_lib/blob/master/CONVENTIONS.md) has the coding and numerical rules;
+[CHANGELOG.md](https://github.com/Synoros-io/holonomy_lib/blob/master/CHANGELOG.md) has the release history.
+
+## Citation
+
+```bibtex
+@software{holonomy_lib,
+  author = {John Vaught},
+  title = {holonomy\_lib: Batched PyTorch primitives for geometry and topology},
+  version = {0.8.0},
+  year = {2026},
+  url = {https://github.com/Synoros-io/holonomy_lib},
+}
+```
+
+Please also cite the papers named in the docstrings of the functions you use.
+
+## License
+
+[FSL-1.1-ALv2](https://github.com/Synoros-io/holonomy_lib/blob/master/LICENSE.md). You can use and modify it freely; competing
+commercial use is reserved to Synoros. Each release becomes Apache-2.0 two
+years after it ships. Releases up to 0.7.0 remain AGPL-3.0-or-later. For other
+terms, contact [contact@synoros.io](mailto:contact@synoros.io).

holonomy_lib-0.8.0.dist-info/RECORD

@@ -0,0 +1,82 @@
+holonomy_explorer/__init__.py,sha256=TbPP-kKgdgN9bxB_XvZOmHg13uDwgdJw33PRD5FuEeU,70
+holonomy_explorer/__main__.py,sha256=J8vfIKNMtZ9CyTFEJpcCOQnOUyN3nYZ6DyxaiFT2IDM,2759
+holonomy_explorer/batching.py,sha256=k8jCkk6YBHxzuAmnuQRAECTTPM1pCqV18QonrHVUZMw,6720
+holonomy_explorer/common.py,sha256=MnyVIinZkxvPFjA9bzMrdFsRqZctFhV4jxLqcjK807U,6749
+holonomy_explorer/curvature.py,sha256=PojOi0VGM_XTde8KrAxygvmOFoXpQIc8CEgUhgkSGHw,5837
+holonomy_explorer/datasets.py,sha256=E8ELvVSrTLKtwtgt5WSycajH1iXAJ_tF8Mu4gt1lT7c,10152
+holonomy_explorer/graphs.py,sha256=W8ubZde8XMOzocRcWnVcgSghyMFuhTchJB3EKUUQ3mM,11740
+holonomy_explorer/server.py,sha256=es-4SkL2WLPWV-v0KBn-lVkaN7dk3K3-67zc-789sEY,7687
+holonomy_explorer/topology.py,sha256=6c0Avw4dpqwXgivugCDw0b7V_rYv4DaVSCOqOo_H22w,4769
+holonomy_explorer/static/app.js,sha256=IZABPlg9iPjvFBbATyrKzycsO_aLO2V66zrUYR3VWOI,31163
+holonomy_explorer/static/charts.js,sha256=_kq6QJjf19qRBrJGPF9zRXcr_9zjptoziQaBglOH0T4,6711
+holonomy_explorer/static/index.html,sha256=igEQMy8IDD9-6_nDNSNvYwwtiNTOB8imz34G84tnPRo,2571
+holonomy_explorer/static/layout.js,sha256=8lGLY3kO8gDPXHvS1veEbW3lki0FPkpGV6XyIEM-_sI,4689
+holonomy_explorer/static/style.css,sha256=52OPsb7buVqhHVNiVKxE94rmaMO1R-0ykQVn3wWWnyU,10208
+holonomy_explorer/static/view.js,sha256=FZA6WGFq8FkGMzoGxJBQsHq8s0gvwnYP2QBo-Jcuqw8,10630
+holonomy_lib/__init__.py,sha256=_J5vdotTpz2rDD8pdM9MlVxjiTEE1ov9RUcEpY3z0d4,327
+holonomy_lib/_graph_utils.py,sha256=wTkJZeAEQJ_Q1f9SDgRxi_TtPw4ZpoHyddGIjT5CFo4,1899
+holonomy_lib/_quadrature.py,sha256=nrh6oAS8hItOUPEjHjJ3jN9nfvMhZEQIbUJkH0myaPY,2820
+holonomy_lib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+holonomy_lib/algebra/__init__.py,sha256=1uzdf2qHyq-r7WZ80xMTFS2FjwQf9dBu7CZFfTlGiFA,1516
+holonomy_lib/algebra/eigsh_sparse.py,sha256=0t-GcNel1rL_wb60o8-G61zBooXoNeBNE2TRpo1URYE,10737
+holonomy_lib/algebra/lanczos.py,sha256=v-iQlTDdahoeY1LifzIk8W1U46XV-NxDVwMOABaWLms,17002
+holonomy_lib/algebra/linear.py,sha256=SV9Tb6F6dhE9pout4FDIDAbeHVxMCnjt68v4e9llvkk,7555
+holonomy_lib/algebra/solvers.py,sha256=1o9d_yRVVEMdLtQJsOYNMWXvNMxt4mZJFGCU76vuw08,24104
+holonomy_lib/convex/__init__.py,sha256=-rRTZPEGDVCvMm1S5-dVrXcJ_3lU_6hR7ioCaHmX5co,1138
+holonomy_lib/convex/least_squares.py,sha256=DkxmDqJNbegrOfyB45JDfJXU0MqrvziFVVE9g_bBvIo,7609
+holonomy_lib/discrete_geometry/__init__.py,sha256=6ZaTTMbdSKDALMdYawUsLs7bnt-M-o62gfO3fqutOTU,1277
+holonomy_lib/discrete_geometry/forman.py,sha256=O8A_0amiRlnQ3gt1FygEz40GszgnKAkm8rsNpgM7bWA,10567
+holonomy_lib/discrete_geometry/ricci.py,sha256=BhJmyACa0M7Aqcj97GYTRdgmyb_rwL7ySRTp1bXYXGQ,39850
+holonomy_lib/experimental/__init__.py,sha256=p8WqCl2OWfRHt9iVvHZm0HN2eQn1sXl7dp7LXM-i1DQ,477
+holonomy_lib/experimental/heterogeneous_kappa.py,sha256=6-QHmB4rNCALuL2MxYzZ2oLqua-hkh9Qo_uVCsuStQ4,15282
+holonomy_lib/experimental/laplacian_eigenmaps.py,sha256=fGqmoqMIbeJuZndS62r2wPnN5n8bfUZWS9d615n2ghk,8733
+holonomy_lib/hyperbolic/__init__.py,sha256=0g8V___z89RsjwLbXda4gkZ1_ko8WOXQk7ffRQbR5j0,944
+holonomy_lib/hyperbolic/frechet_mean.py,sha256=qw1C0KcSUNLesFLnUu-zoHtTyfj4O28WM5KwFy-kFQA,19281
+holonomy_lib/hyperbolic/heat_kernel.py,sha256=RWmQpOqIxcNmn1R9DN-3X-UKGLLtb2-2KvQG_Lo1EhA,25248
+holonomy_lib/hyperbolic/manifold_inner.py,sha256=9ax5jeu_NaLNvyyGMhvcPQBAwl0XvJ3W7AR_lwQa8WY,3301
+holonomy_lib/info_geometry/__init__.py,sha256=T0d6Ie8d7aUlfuCMtmzflDd4DLRKdOkbzF4Jb_uLO64,2533
+holonomy_lib/info_geometry/divergences.py,sha256=fE3Xc6DBfFQVnbIojTTw97i2xY_TSGENVbdgWD4CElA,8577
+holonomy_lib/info_geometry/fisher.py,sha256=qOgmQnmKs8ldMBOalCQddgJkBm-9BS6RINZqu6U-81U,7067
+holonomy_lib/lie/__init__.py,sha256=Vw2iSSqMFgjZeURD1isMW1LjlZ4uLaVwQ70ENrRstLU,2409
+holonomy_lib/lie/so3.py,sha256=CmA1ULGgMiXyPGOaMbGNfFwYqlNgsiiHPzxC29ebmns,15503
+holonomy_lib/lie/spherical_harmonics.py,sha256=9Ggx8OHFUgLW3IgiY6dojmhCJqTL4AAvxOyHfVsV-Ew,7299
+holonomy_lib/manifolds/__init__.py,sha256=tCGwNUA-qlSCAxwSvVebUjAUpIFqNy8H7P7AGiAzUeY,2237
+holonomy_lib/manifolds/comparison.py,sha256=VmvqxupDTYMxmPbgdhhcSvZCu69mV6FRwAiscYVrpMQ,15380
+holonomy_lib/manifolds/fixed_rank.py,sha256=3tk3fhdbtlIzG04qef22QxYUi1NV1m7tlsfmHZGy0Y4,19485
+holonomy_lib/manifolds/lorentz.py,sha256=lL7KP0B2MxVhPheLcEwFsK34aSoebw-OYLn9jcCXJhE,29004
+holonomy_lib/manifolds/lorentzian.py,sha256=s4LNUUxefxJLsIHDcCHEcr9rvlzb7NojOOHevdrASwI,21944
+holonomy_lib/manifolds/product.py,sha256=9xK3ailR5tKBgckW3SvMtFeA-ZZzfJVjhBnTCgR10Oc,16635
+holonomy_lib/manifolds/spd.py,sha256=quOFTz_FVTjJt2TgRJ-p30Hxz03fIzotlsDSFAW5PGo,21834
+holonomy_lib/manifolds/stereographic.py,sha256=XS1di52kWnl0Rp8IbeETUg0hSvlYnPQhLWrBL2_oBiU,31047
+holonomy_lib/optimization/__init__.py,sha256=Km60vtVvlDrkHqanRysA0lkMDxwnsvvgG1IRsxA92oA,1639
+holonomy_lib/optimization/base.py,sha256=-e2DUkvbIqZi3Hazz9m2Yc08CVOQSK5QJu4WScXUSXA,2434
+holonomy_lib/optimization/sgd.py,sha256=hxuBGB_TCup_KW8axB9ADHiMzRzGIxPmCUUIaXN7Du4,4116
+holonomy_lib/sheaf/__init__.py,sha256=hoHivoy_zqUOC0PuJnuzm1CPPcFxLwW1bZKvBvBN2Xw,3185
+holonomy_lib/sheaf/graph_sheaf.py,sha256=FElURHbnqXZrFEJmmaA6C4HYXimGAFA0LMcDNWCULkU,15423
+holonomy_lib/sheaf/laplacian.py,sha256=_18wabK8tfSBnBagquYNaUQeAjlWSrrDy1MfApyqSts,23144
+holonomy_lib/simplicial/__init__.py,sha256=ImONeXhqF3jQjNwpJGJ79oW9dPIDA9iwO1FmpypEok0,1933
+holonomy_lib/simplicial/_face_lookup.py,sha256=BIAPUeqJKgNTO6N4YF-4pBolodGmjz-IsrUbEWTcbC8,3801
+holonomy_lib/simplicial/complex.py,sha256=RESjE1EslkYfqzGwl35uEJTK6K75MUSFVwgpdIdvvgY,6887
+holonomy_lib/simplicial/sparse_complex.py,sha256=_F7V2Nt7xWs_f_rW906MsrCyiF_ouH2Ai6XSCqjVdro,5552
+holonomy_lib/simplicial/vietoris_rips.py,sha256=PQjlukGWoOOyZ9sI6OLlLjKVvRwI5kJAqsPHvkFimas,12133
+holonomy_lib/spectral/__init__.py,sha256=CyHxGWo3DB4VT4QpJHm4w-8GmJb95H_Ed6A16NwZy8c,2581
+holonomy_lib/spectral/diffusion_map.py,sha256=Zdzr0Y5jTao5lJTaeAMEkivsros-P3UZl_qX4Rha6ic,7799
+holonomy_lib/spectral/effective_resistance.py,sha256=vu9Tyzk5si-FiI7ORpzLDazhh9AtsIXe7JMjU5AsFH8,9202
+holonomy_lib/spectral/embedding.py,sha256=zOqUMUZjsv2rZlFrxw7ZMMpFDOzOrBDozc1cKAxZTvk,5613
+holonomy_lib/spectral/heat_kernel.py,sha256=d7V2-ovSpw3Na-DRIC7AaGDn7EhHFhhYQmiMB4o3vjY,10252
+holonomy_lib/spectral/laplacian.py,sha256=0wD4r6Mp2CR6BDwY_PGKEFG9n7eQh_MdfiCrc5SSIpE,17776
+holonomy_lib/spectral/magnetic.py,sha256=OSoH68ONc_0mOLKnRb-hk5axdBDMJv-IxCfCUM1-mCU,14360
+holonomy_lib/spectral/spectral_dimension.py,sha256=Qf-hF_wqZ0QTZR-uHBHJIBVgtqJJfs6s8pxJdRoc3-E,4810
+holonomy_lib/tensor_calculus/__init__.py,sha256=aa9Cr-Ye36PMUdRhCjaklbjPr1skdk8_K5YfI7n7ogc,654
+holonomy_lib/tensor_calculus/decomposition.py,sha256=aX_Wglha1ZcrK-9fn6UXDJHdJ2OO6LPe9qoJseURTr8,7795
+holonomy_lib/topology/__init__.py,sha256=_F6hKEBLSnRgfXB6qKq6E8T5GaFCqKZdunGrdiwVo6s,978
+holonomy_lib/topology/_filtration.py,sha256=sYhq28chXVtnQQGuEWi4pJtlvFuvVZHSPSex2ejBYlo,5875
+holonomy_lib/topology/_reduction.py,sha256=6MS6S4wHZIgQRAx6OVk0xu7MhDKFVl_xPO6bXyq-edI,10442
+holonomy_lib/topology/hodge.py,sha256=sEuORngp21M4TyZiVz1hZmcaIvJFKUn7Y7pzHs7JthY,9714
+holonomy_lib/topology/persistent_homology.py,sha256=J-pyKA-kUVmEvYlvBTgQQdc-NVSl9GGfjDbpAfVlgt8,12733
+holonomy_lib-0.8.0.dist-info/licenses/LICENSE.md,sha256=-VpEBq5bW92sgS2cMsqa_s9oSKcPt5VXYQB0RLXQ0s4,3739
+holonomy_lib-0.8.0.dist-info/METADATA,sha256=RTDbUKKihUFxAEkfwXMzYmuLFO7nvaxaB3FnOOEeDZc,6822
+holonomy_lib-0.8.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+holonomy_lib-0.8.0.dist-info/entry_points.txt,sha256=DHAZ9YwjmV1pfrfQELNg7JnepSdBE63efm4z1owaa_4,70
+holonomy_lib-0.8.0.dist-info/top_level.txt,sha256=8CFDkax9Y2qRF7jqMxpEzk53ODPnQdBmG1MuGQVj5c8,31
+holonomy_lib-0.8.0.dist-info/RECORD,,

holonomy_lib-0.8.0.dist-info/WHEEL

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

holonomy_lib-0.8.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+holonomy-explorer = holonomy_explorer.__main__:main

holonomy_lib-0.8.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 Synoros
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

holonomy_lib-0.8.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+holonomy_explorer
+holonomy_lib