regfans 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

regfans/fan.py

@@ -45,7 +45,7 @@ class Fan:
     function.
 
     This class is *not* intended to be called directly. Instead, it is meant to
-    be called through VectorConfiguration.subdivide.
+    be called through VectorConfiguration.triangulate.
 
     **Arguments:**
     - `vc`:      The ambient vector configuration that this fan is over.
@@ -139,8 +139,8 @@ class Fan:
             f"A "
             + fine_str
             + regular_str
-            + f" {subdivision_str} of "
-            + repr(self._vc)
+            + f" {subdivision_str} of a"
+            + repr(self._vc)[1:]
         )
 
     def __str__(self) -> str:
@@ -171,8 +171,8 @@ class Fan:
             f"A "
             + fine_str
             + regular_str
-            + f" {subdivision_str} of "
-            + str(self._vc)
+            + f" {subdivision_str} of a"
+            + str(self._vc)[1:]
         )
 
     def __hash__(self) -> int:
@@ -417,7 +417,7 @@ class Fan:
         """
         if not self.is_triangulation():
             # the following assumes simplicial cones
-            raise NotImplementedError
+            raise NotImplementedError("Not implemented for non-triangulations")
 
         # compute the facets as a map from facet labels to containing cones
         facets = dict()
@@ -534,7 +534,7 @@ class Fan:
         """
         **Description:**
         Return whether or not the fan also defines a (star) subdivision of the
-        underlying point configuration.
+        original underlying point configuration.
 
         **Arguments:**
         None.
@@ -545,7 +545,7 @@ class Fan:
         """
         if not self.is_regular():
             # could be checked by MaxMP but I have't implemented that...
-            raise NotImplementedError
+            raise NotImplementedError("Not implemented for irregular fans")
 
         # just check if central subdivision is a refinement
         H = self.secondary_cone_hyperplanes()
@@ -1040,7 +1040,7 @@ class Fan:
         # return
         if formal:
             # update neighb from being a tuple of cones to a formal Fan object
-            neighb = self.vc.subdivide(cells=neighb)
+            neighb = self.vc.triangulate(cells=neighb)
 
             # pass along circuit info to the neighbor
             neighb._circuits = self._circuits.copy()
@@ -1232,8 +1232,8 @@ class Fan:
         else:
             assert h_target is None
             if verbosity >= 0:
-                print("DIRECTIONS ARE HANDLED IN A VERY BAD WAY... ")
-                print("h_target = h_init+1000*direction...")
+                print("(Warning: directions are handled in a sub-optimal way...)")
+                print("(         one sets h_target = h_init+1000*direction...  )")
             direction = 1000*np.array(direction)
             h_target = h_init+direction
         direction_norm2 = np.dot(direction,direction)
@@ -1678,13 +1678,13 @@ def flip_subgraph(
         tri_init = seed
         labels = [
             {
-                "reg": tri_init.is_regular(),
+                "regular": tri_init.is_regular(),
                 "fine": tri_init.is_fine(),
-                "triang": tri_init.respects_ptconfig(),
+                "respects_ptconfig": tri_init.respects_ptconfig(),
             }
         ]
     else:
-        tri_init = seed.subdivide()
+        tri_init = seed.triangulate()
         if not tri_init.is_triangulation():
             print("ERROR: seed isn't triangulation! Quitting!")
             return
@@ -1697,9 +1697,9 @@ def flip_subgraph(
 
         labels = [
             {
-                "reg": True,
+                "regular": True,
                 "fine": tri_init.is_fine(),
-                "triang": True,
+                "respects_ptconfig": True,
             }
         ]
 
@@ -1751,17 +1751,17 @@ def flip_subgraph(
                     continue
 
                 # check various user-imposed restrictions
-                new_label = {"reg": None, "fine": None, "triang": None}
+                new_label = {"regular": None, "fine": None, "respects_ptconfig": None}
                 if compute_node_labels:
                     # compute regularity (/maybe check it)
                     # ------------------
                     if verbosity >= 2:
                         print("checking regularity...", end=" ")
-                    new_label["reg"] = neighb.is_regular()
+                    new_label["regular"] = neighb.is_regular()
                     if verbosity >= 2:
-                        print(new_label["reg"])
+                        print(new_label["regular"])
 
-                    if only_regular and not new_label["reg"]:
+                    if only_regular and not new_label["regular"]:
                         continue
 
                     # compute fineness (/maybe check it)
@@ -1779,25 +1779,25 @@ def flip_subgraph(
                     # -----------------
                     if verbosity >= 2:
                         print("checking PC triangulation...", end=" ")
-                    new_label["triang"] = neighb.respects_ptconfig()
+                    new_label["respects_ptconfig"] = neighb.respects_ptconfig()
                     if verbosity >= 2:
-                        print(new_label["triang"])
+                        print(new_label["respects_ptconfig"])
 
-                    if only_pc_triang and (not new_label["triang"]):
+                    if only_pc_triang and (not new_label["respects_ptconfig"]):
                         continue
                 else:
                     # lazily compute the labels
                     if only_regular:
-                        new_label["reg"] = neighb.is_regular()
-                        if not new_label["reg"]:
+                        new_label["regular"] = neighb.is_regular()
+                        if not new_label["regular"]:
                             continue
                     if only_fine:
                         new_label["fine"] = neighb.is_fine()
                         if not new_label["fine"]:
                             continue
                     if only_pc_triang:
-                        new_label["triang"] = neighb.respects_ptconfig()
-                        if not new_label["triang"]:
+                        new_label["respects_ptconfig"] = neighb.respects_ptconfig()
+                        if not new_label["respects_ptconfig"]:
                             continue
 
                 # this is a new triangulation!

regfans/util.py

@@ -28,6 +28,74 @@ import numpy as np
 from ortools.linear_solver import pywraplp
 from typing import Union
 
+# basic math
+# ----------
+def gcd(vals: list[float], max_denom: float=10**6) -> float:
+    """
+    **Description:**
+    Computes the 'GCD' of a collection of floating point numbers.
+    This is the smallest number, g, such that g*values is integral.
+
+    This is computed by
+        1) converting `values` to be rational [n0/d0, n1/d1, ...],
+        2) computing the LCM, l, of [d0, d1, ...],
+        3) computing the GCD, g', of [l*n0/d0, l*n1/d1, ...], and then
+        4) returning g=g'/l.
+
+    **Arguments:**
+    - `vals`:      The numbers to compute the GCD of.
+    - `max_denom`: Assert |di| <= max_denom
+
+    **Returns:**
+    The minimum number g' such that g'*vals is integral.
+    """
+    # compute the rational representation
+    rat   = [fractions.Fraction(v).limit_denominator(max_denom) for v in vals]
+    numer = [r.numerator   for r in rat]
+    denom = [r.denominator for r in rat]
+
+    # get the relevant LCM, GCD
+    l     = functools.reduce(math.lcm, denom)
+    gprime= functools.reduce(math.gcd, [n*(l//d) for n,d in zip(numer,denom)])
+
+    # return the GCD
+    if gprime%l == 0:
+        # integral
+        return gprime//l
+    else:
+        return gprime/l
+
+def primitive(vec: list[float], max_denom=10**10):
+    """
+    **Description:**
+    Computes the primitive vector associated to the input ray {c*vec: c>=0}.
+    Very similar to the gcd function.
+
+    This is equivalent to
+        vec/gcd(vec)
+    but just uses a rational representation.
+
+    **Arguments:**
+    - `vec`:       A vector defining the ray {c*vec: c>=0}
+    - `max_denom`: Assert |di| <= max_denom
+
+    **Returns:**
+    The primitive vector along the ray.
+    """
+    # compute the rational representation
+    rat   = [fractions.Fraction(v).limit_denominator(max_denom) for v in vec]
+    numer = [r.numerator   for r in rat]
+    denom = [r.denominator for r in rat]
+
+    # get the LCM of the denominators
+    l     = functools.reduce(math.lcm, denom)
+
+    # get the integral vector and scale it to be primitive
+    prim  = [n*(l//d) for n,d in zip(numer,denom)]
+    gprime= functools.reduce(math.gcd, prim)
+
+    return [x//gprime for x in prim]
+
 # basic geometry
 # --------------
 def lerp(p0: "ArrayLike", p1: "ArrayLike", t: float) -> "ArrayLike":
@@ -365,72 +433,3 @@ def find_interior_point(*,
     else:
         warnings.warn(f"Unexpected error")
         return None
-
-
-# basic math - UNUSED
-# ----------
-def gcd(vals: list[float], max_denom: float=10**6) -> float:
-    """
-    **Description:**
-    Computes the 'GCD' of a collection of floating point numbers.
-    This is the smallest number, g, such that g*values is integral.
-
-    This is computed by
-        1) converting `values` to be rational [n0/d0, n1/d1, ...],
-        2) computing the LCM, l, of [d0, d1, ...],
-        3) computing the GCD, g', of [l*n0/d0, l*n1/d1, ...], and then
-        4) returning g=g'/l.
-
-    **Arguments:**
-    - `vals`:      The numbers to compute the GCD of.
-    - `max_denom`: Assert |di| <= max_denom
-
-    **Returns:**
-    The minimum number g' such that g'*vals is integral.
-    """
-    # compute the rational representation
-    rat   = [fractions.Fraction(v).limit_denominator(max_denom) for v in vals]
-    numer = [r.numerator   for r in rat]
-    denom = [r.denominator for r in rat]
-
-    # get the relevant LCM, GCD
-    l     = functools.reduce(math.lcm, denom)
-    gprime= functools.reduce(math.gcd, [n*(l//d) for n,d in zip(numer,denom)])
-
-    # return the GCD
-    if gprime%l == 0:
-        # integral
-        return gprime//l
-    else:
-        return gprime/l
-
-def primitive(vec: list[float], max_denom=10**10):
-    """
-    **Description:**
-    Computes the primitive vector associated to the input ray {c*vec: c>=0}.
-    Very similar to the gcd function.
-
-    This is equivalent to
-        vec/gcd(vec)
-    but just uses a rational representation.
-
-    **Arguments:**
-    - `vec`:       A vector defining the ray {c*vec: c>=0}
-    - `max_denom`: Assert |di| <= max_denom
-
-    **Returns:**
-    The primitive vector along the ray.
-    """
-    # compute the rational representation
-    rat   = [fractions.Fraction(v).limit_denominator(max_denom) for v in vec]
-    numer = [r.numerator   for r in rat]
-    denom = [r.denominator for r in rat]
-
-    # get the LCM of the denominators
-    l     = functools.reduce(math.lcm, denom)
-
-    # get the integral vector and scale it to be primitive
-    prim  = [n*(l//d) for n,d in zip(numer,denom)]
-    gprime= functools.reduce(math.gcd, prim)
-
-    return [x//gprime for x in prim]

regfans/vectorconfig.py

@@ -29,6 +29,7 @@ import networkx as nx
 import numpy as np
 import scipy as sp
 import triangulumancer
+import warnings
 
 # local imports
 from . import util, circuits, fan
@@ -490,7 +491,7 @@ class VectorConfiguration:
             # could definitely be generalized to non-solid
             # likely just check if
             # len(dual_cone(self.vectors())) == 2*(ambient-dim)
-            raise NotImplementedError
+            raise NotImplementedError("Not implemented for non-solid VCs")
 
         return len(util.dual_cone(self.vectors())) == 0
 
@@ -677,12 +678,13 @@ class VectorConfiguration:
 
     # generating triangulations
     # =========================
-    def subdivide(
+    def triangulate(
         self,
         heights: "ArrayLike" = None,
         cells: "ArrayLike" = None,
         tol: float = 1e-14,
-        seed: int = 0,
+        backend: str = None,
+        check_heights: bool = True,
         verbosity: int = 0,
     ) -> "Fan":
         """
@@ -691,11 +693,14 @@ class VectorConfiguration:
         or by heights.
 
         **Arguments:**
-        - `heights`:   The heights to lift the vectors by.
-        - `cells`:     The cells to use in the triangulation.
-        - `backend`:   The lifting backend. Use 'qhull'.
-        - `tol`:       Numerical tolerance used.
-        - `verbosity`: The verbosity level. Higher is more verbose
+        - `heights`:       The heights to lift the vectors by.
+        - `cells`:         The cells to use in the triangulation.
+        - `tol`:           Numerical tolerance used for curing negative heights
+        - `backend`:       The lifting backend. Currently allowed to be "cgal"
+                           or "ppl".
+        - `check_heights`: Whether to check that the heights land in the
+                           secondary cone of the output triangulation.
+        - `verbosity`:     The verbosity level. Higher is more verbose
 
         **Returns:**
         The resultant subdivision.
@@ -709,13 +714,43 @@ class VectorConfiguration:
 
         # triangulate via heights
         # =======================
+        # flag as to whether the user didn't input heights
+        default_heights = (heights is None)
+
+        # check the backend
+        if backend is None:
+            if default_heights:
+                backend = "cgal"
+            else:
+                backend = "ppl"
+        else:
+            backend = backend.lower()
+            if backend not in ["cgal", "ppl"]:
+                raise ValueError(f"Unrecognized backend '{backend}'...")
+
+        # warning in case the user request PPL backend but gave no heights
+        if default_heights and (backend != "cgal"):
+            msg = "Non-cgal backends are not trustworthy for Deulaunay... "
+            msg += f"changing from '{backend}' to cgal..."
+            with warnings.catch_warnings():
+                warnings.simplefilter("always")
+                warnings.warn(msg)
+            backend = "cgal"
+
+        # allow small perturbations to the height of the origin to enforce that
+        # cgal gives a star triangulation
+        if backend == "cgal":
+            make_cgal_star = default_heights
+
         # (if no heights are provided, compute Delaunay triangulation)
         # (need to add noise to ensure it is a *triangulation* and not a
         #  subdivision)
         # (allow retrying in case the noise brings the heights outside the
         #  secondary fan... exceedingly unlikely though)
-        if heights is None:
+        if default_heights:
             heights = np.sum(self.vectors()*self.vectors(), axis=1)
+        else:
+            heights = np.array(heights)
 
         # ensure the heights are non-negative
         already_nonneg = all([h_i >= 0 for h_i in heights])
@@ -729,7 +764,7 @@ class VectorConfiguration:
             heights_new, res = sp.optimize.nnls(B.T, Bh)
             if res>tol:
                 print(f"Residuals {res} > tol {tol}...")
-                raise ValueError
+                raise ValueError("Invalid heights")
 
             # do the check
             if False: # too slow... instead just check if we found coeffs...
@@ -762,37 +797,98 @@ class VectorConfiguration:
             return self.subdivide(cells=[self.labels])
 
         # nonzero heights -> lift via a point configuration
-        pts = np.vstack( [np.zeros((1,self.dim), dtype=int), self.vectors()] )
-        pc  = triangulumancer.PointConfiguration(pts)
+        if backend == "cgal":
+            orig = np.zeros((1,self.ambient_dim),dtype=int)
+            pts  = np.vstack([orig, self.vectors()])
+            pc   = triangulumancer.PointConfiguration(pts)
+
+            if make_cgal_star:
+                # adjust heights for PC such that the triangulation is star...
+                # just ensure that 0 is in all simplices
+                #
+                # this should always be true by construction...
+                # but CGAL definitely perturbs heights a bit (e.g., lifting by
+                # heights = 0 doesn't lead to trivial subdivision)
+                #
+                # maybe this causes errors leading to non-star triangulations...
+                height_min = np.min(heights)
+                height_orig = -1e-6*height_min
+                while True:
+                    heights_pc  = np.concatenate(([height_orig], heights))
+                    simp_pcinds = pc.triangulate_with_heights(heights_pc).simplices()
+
+                    # lower the height of the origin if not star
+                    if not all([0 in simp for simp in simp_pcinds]):
+                        height_orig -= height_min
+                        continue
+
+                    # star :)
+                    break
+
+                # check that we didn't lower the height of origin a crazy amount
+                if (verbosity >= 1) and (height_orig < -np.min(heights)):
+                    msg = "Significantly lowered the height of the origin... "
+                    msg += "maybe something went wrong..."
+                    with warnings.catch_warnings():
+                        warnings.simplefilter("always")
+                        warnings.warn(msg)
+            else:
+                heights_pc  = np.concatenate(([0], heights))
+                simp_pcinds = pc.triangulate_with_heights(heights_pc).simplices()
 
-        # adjust heights for PC such that the triangulation is star...
-        # just ensure that 0 is in all simplices
-        #
-        # this should always be true by construction. Maybe perturbations of
-        # the heights in the various backend for odd heights like those which
-        # give subdivisions cause the origin to be skipped...
-        height_norm = np.linalg.norm(heights)
-        height_orig = -height_norm
-        while True:
-            heights_pc  = np.concatenate(([height_orig], heights))
-            simp_pcinds = pc.triangulate_with_heights(heights_pc).simplices()
-
-            # lower the height of the origin if not star
-            if not all([0 in simp for simp in simp_pcinds]):
-                height_orig -= height_norm
-                continue
+            # read the simplices as indices in the VC
+            if not all([0 in s for s in simp_pcinds]):
+                msg = "cgal didn't produce a star triangulation... "
+                msg += f"cells = {simp_pcinds} (0 corresponds to origin). "
+                msg += "maybe try PPL..."
+                raise ValueError(msg)
+            simp_vcinds = [[pti-1 for pti in s if pti!=0] for s in simp_pcinds]
 
-            # star :)
-            break
+        elif backend == "ppl":
+            # construct the rays of the lifted cone
+            lifted = np.hstack([heights.reshape(-1,1),self.vectors()])
+            lifted = np.array([util.primitive(v) for v in lifted]) # as integers
+
+            H      = np.array(util.dual_cone(lifted))
+            satd   = H@lifted.T
+
+            # read the simplices as indices in the VC
+            simp_vcinds = [np.where(facet==0)[0].tolist() for facet in satd]
 
         # read the simplices as labels
-        simp_vcinds = [[pti-1 for pti in s if pti!=0] for s in simp_pcinds]
         simp_labels = [[self.labels[vci] for vci in s] for s in simp_vcinds]
+        simp_labels = [sorted(simp) for simp in simp_labels]
+
+        # construct the fan
+        f = self.triangulate(cells=simp_labels)
 
-        return self.subdivide(cells=simp_labels)
+        # some sanity checks
+        if not f.is_triangulation():
+            if verbosity >= 1:
+                msg = "Upon lifting, a non-triangulation subdivision was "
+                msg += f"output...  (cells = {f.simplices()}) "
+                msg += "double check with another backend (PPL is preferable) "
+                msg += "OR perturb heights..."
+
+                with warnings.catch_warnings():
+                    warnings.simplefilter("always")
+                    warnings.warn(msg)
+        else:
+            # yes a triangulation...
+            # verify that the secondary cone contains the heights
+            if (not default_heights) and check_heights:
+                H = np.array(f.secondary_cone_hyperplanes())
+                dists = H@heights
+
+                if np.any((dists)<=0):
+                    msg = "Heights not contained in secondary cone... "
+                    msg += f"distances = {dists}..."
+                    raise Exception(msg)
+
+        return f
 
     # aliases
-    triangulate = subdivide
+    subdivide = triangulate
 
     def all_triangulations(
         self,
@@ -846,7 +942,8 @@ class VectorConfiguration:
         N: int = None,
         as_list: bool = False,
         attempts_per_triang: int = 1000,
-        backend: str = "qhull",
+        backend: str = None,
+        seed: int = 0,
         verbosity: int = 0,
     ) -> Generator["Fan"] | list["Fan"]:
         """
@@ -871,7 +968,9 @@ class VectorConfiguration:
                                 or as a generator.
         - `attempts_per_triang`:Quit if we can't generate a new triangulation
                                 after this many tries.
-        - `backend`:            The lifting backend.
+        - `backend`:            The lifting backend. See
+                                `VectorConfiguration.triangulate`.
+        - `seed`:               A random number seed.
         - `verbosity`:          The verbosity level. Higher is more verbose.
 
         **Returns:**
@@ -933,6 +1032,7 @@ class VectorConfiguration:
                 iterator = range(N)
 
             # generate the triangulations
+            np.random.seed(seed)
             for _ in iterator:
                 if method == "delaunay":
                     # generate triangulations near Delaunay
@@ -953,7 +1053,7 @@ class VectorConfiguration:
                     h = np.multiply(h, self._vector_norms)
 
                 try:
-                    t = self.subdivide(heights=h, backend=backend)
+                    t = self.triangulate(heights=h, backend=backend)
                 except sp.spatial.qhull.QhullError:
                     # QHull error :(
                     if verbosity >= 0:
@@ -1163,7 +1263,6 @@ class VectorConfiguration:
 
     def secondary_fan(self,
                       only_fine: bool=False,
-                      project_lineality: bool=False,
                       formal_fan: bool=False,
                       verbosity: int=0):
         """
@@ -1171,11 +1270,9 @@ class VectorConfiguration:
         Compute the secondary fan of the vector configuration.
 
         **Arguments:**
-        - `only_fine`:         Restrict to fine triangulations.
-        - `project_lineality`: Project out lineality space with the gale
-                               transform, mapping to the chamber complex.
-        - `formal_fan`:        Save as a formal Fan object.
-        - `verbosity`:         The verbosity level. Higher is more verbose
+        - `only_fine`:  Restrict to fine triangulations.
+        - `formal_fan`: Save as a formal Fan object.
+        - `verbosity`:  The verbosity level. Higher is more verbose
 
         **Returns:**
         The secondary fan triangulations.
@@ -1185,19 +1282,21 @@ class VectorConfiguration:
                                           only_fine=only_fine,
                                           verbosity=verbosity)
 
-        # compute all of the secondary cones
-        fan   = [fan.secondary_cone(project_lineality=project_lineality) for \
-                                                                fan in triangs]
+        # compute the (hyperplanes of the) secondary cones
+        fan = [fan.secondary_cone_hyperplanes() for fan in triangs]
 
         # map to a formal fan
         if formal_fan:
-            rays = np.array(list(
-                {tuple(r) for cone in fan for r in cone.rays()}
-            ))
-            vc = VectorConfiguration(rays)
+            fan_R    = [util.dual_cone(H) for H in fan]
+            all_rays = np.array(list({
+                 {tuple(r) for cone_R in fan for r in cone_R}
+            }))
+
+            # construct the VC
+            vc = VectorConfiguration(all_rays)
 
-            cones_as_labels = sorted([sorted(vc.vectors_to_labels(cone.rays()))\
-                                                            for cone in fan])
+            cones_as_labels = sorted([sorted(vc.vectors_to_labels(cone_R))\
+                                                        for cone_R in fan_R])
             fan = vc.subdivide(cells=cones_as_labels)
 
         return fan, triangs
@@ -1216,4 +1315,6 @@ class VectorConfiguration:
         **Returns:**
         The central fan.
         """
-        return self.subdivide(heights=[1 for _ in self.labels])
+        return self.subdivide(
+            heights=[1 for _ in self.labels],
+            check_heights=False)

regfans-0.0.5.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: regfans
+Version: 0.0.5
+Summary: Regular fans of vector configurations
+Author: Nate MacFadden
+License-Expression: GPL-3.0-or-later
+Project-URL: Repository, https://github.com/natemacfadden/regfans
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-flint
+Requires-Dist: ortools
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: triangulumancer
+Provides-Extra: test
+Requires-Dist: pplpy; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+![Fan flip graph](images/fan_flip_graph.png)
+
+# regfans
+Software for studying vector configurations defined over the lattice vectors. This includes
+- constructing regular triangulations (i.e., polyhedral fans) of such vector configurations via lifting,
+- constructing all (regular) triangulations via computation of flip graphs,
+- verification of various properties of the vector configuration/fan, and
+- efficient linear flipping.
+
+See [Triangulations: Structures for Algorithms and Applications](https://link.springer.com/book/10.1007/978-3-642-12971-1) by De Loera, Rambau, and Santos for a definitive resource on such topics.
+
+This package, `regfans`, was originally developed for constructing toric varieties in the work [Calabi-Yau Threefolds from Vex Triangulations](https://arxiv.org/abs/2512.14817). Said work was supported in part by NSF grant PHY-2309456. All toric-geometric computations are isolated to [CYTools](https://github.com/LiamMcAllisterGroup/cytools), which has an extension `vector_config` building off of `regfans`.
+
+## Installation
+`regfans` can be installed using either conda or pip. To install `regfans` using conda, please see/use the provided `environment.yml` file:
+```
+conda env create -f environment.yml
+conda activate regfans
+```
+To install `regfans` using pip, either run (to install the most recent release; also see [PyPI listing](https://pypi.org/project/regfans/))
+```
+pip install regfans
+```
+or (to install a local version)
+```
+pip install .
+```
+N.B.: many methods in `regfans` require computation of dual cones (i.e., the generators of a cone defined via hyperplanes or vice-versa). Currently, this requires [pplpy](https://pypi.org/project/pplpy/) which cannot be automatically installed via pip.
+
+## API
+
+See [api.md](documentation/api.md) for full API reference.
+
+(To update documentation, just run `pydoc-markdown; py documentation/clean_api.py`)
+
+## Tutorials
+
+See the [tutorials directory](tutorials/) for some commented example scripts showing how to construct a vector configuration, check properties of it, construct fans from it, and check the properties of said fans.

regfans-0.0.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+regfans/__init__.py,sha256=ySoKB1J2jeUD9oHoPqD2d-utSO-cqd9eI1dq4Q2SMBo,103
+regfans/circuits.py,sha256=5uLH8oQiAKe7UYl7sKvFpxMzNViP9tcLtqA91zbWduk,11244
+regfans/fan.py,sha256=w3VMzH1DxQq0qiC5Isi0vQUf3Ugc2C4mqcwrkgtGhyY,65043
+regfans/util.py,sha256=JeyaFZ2a5ujQNoQAgKUim9zo_Ot_QZZ04YnQaQU1y4Y,12923
+regfans/vectorconfig.py,sha256=F8UsQslI5GIX9N9eun3H8aNOcA84L_-Ok-HicY-q3Bw,45214
+regfans-0.0.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+regfans-0.0.5.dist-info/METADATA,sha256=fzmse5-x2yVA-CLlrCE01JatRbBoIa-SxVb3HMQeVhE,2797
+regfans-0.0.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+regfans-0.0.5.dist-info/top_level.txt,sha256=h_8B8JgprCNKyinFEG8XvWOLKDouj_vmktFOf6_7Q0Q,8
+regfans-0.0.5.dist-info/RECORD,,

{regfans-0.0.3.dist-info → regfans-0.0.5.dist-info}/WHEEL

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

regfans-0.0.3.dist-info/METADATA

@@ -1,37 +0,0 @@
-Metadata-Version: 2.4
-Name: regfans
-Version: 0.0.3
-Summary: Regular fans of vector configurations
-Author: Nate MacFadden
-License-Expression: GPL-3.0-or-later
-Project-URL: Repository, https://github.com/natemacfadden/regfans
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: <3.14,>=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: python-flint
-Requires-Dist: ortools
-Requires-Dist: networkx
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: triangulumancer
-Provides-Extra: test
-Requires-Dist: pplpy; extra == "test"
-Requires-Dist: pytest; extra == "test"
-Dynamic: license-file
-
-# vectorconfigurations
-Software for studying vector configurations and their triangulations. Originally developed for arXiv:2512.14817
-
-## Installation
-Computation of dual cones requires pplpy. Install via conda:
-```
-conda env create -f environment.yml
-conda activate regfans
-```
-## API Documentation
-
-See [API_DOC.md](API_DOC.md) for full API reference.
-
-(Developer note: update documentation simply by running `pydoc-markdown; py clean_API_DOC.py` in current directory)

regfans-0.0.3.dist-info/RECORD

@@ -1,10 +0,0 @@
-regfans/__init__.py,sha256=ySoKB1J2jeUD9oHoPqD2d-utSO-cqd9eI1dq4Q2SMBo,103
-regfans/circuits.py,sha256=5uLH8oQiAKe7UYl7sKvFpxMzNViP9tcLtqA91zbWduk,11244
-regfans/fan.py,sha256=dHLaDy00Qq0tWas6237vxyY88UiIo-4_3R7V7JllpY8,64783
-regfans/util.py,sha256=HdowruB_t37RWosu7XRVHjOdcxgyuxhR1YxdxUY1K94,12933
-regfans/vectorconfig.py,sha256=VUZpyzUjuMy9QCR3SayMwOE7Q-ve5V610kwQTDbl39Q,40932
-regfans-0.0.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-regfans-0.0.3.dist-info/METADATA,sha256=roRs3mohUPcBGDq358QHR26BlCO_EiZ-4OPdtEit8Rk,1154
-regfans-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-regfans-0.0.3.dist-info/top_level.txt,sha256=h_8B8JgprCNKyinFEG8XvWOLKDouj_vmktFOf6_7Q0Q,8
-regfans-0.0.3.dist-info/RECORD,,