fix(math): chip-firing lint (unused vars, formatting, variable naming)

Author: morluto

src/jacobian/math/chip_firing/_models.py

@@ -21,7 +21,7 @@ def _validate_divisor(
 ) -> None:
     if len(divisor) != len(vertices):
         raise ValueError(f"{label} length must match vertex count")
-    if any(abs(c) >= 10 ** MAX_COEFFICIENT_DIGITS for c in divisor):
+    if any(abs(c) >= 10**MAX_COEFFICIENT_DIGITS for c in divisor):
         raise ValueError(f"{label} coefficients exceed the digit bound")
 
 
@@ -132,7 +132,7 @@ def require_valid_request(self) -> Self:
             raise ValueError("divisor length must match vertex count")
         if len(self.firing_vector) != n:
             raise ValueError("firing vector length must match vertex count")
-        if any(abs(c) >= 10 ** MAX_COEFFICIENT_DIGITS for c in self.firing_vector):
+        if any(abs(c) >= 10**MAX_COEFFICIENT_DIGITS for c in self.firing_vector):
             raise ValueError("firing vector coefficients exceed the digit bound")
         return self
 

src/jacobian/math/chip_firing/_operations.py

@@ -93,9 +93,7 @@ def compute_reduced_laplacian(
     lap = full.laplacian
     sink_idx = vertices.index(request.sink)
     nonsink = [i for i in range(n) if i != sink_idx]
-    reduced = tuple(
-        tuple(lap[i][j] for j in nonsink) for i in nonsink
-    )
+    reduced = tuple(tuple(lap[i][j] for j in nonsink) for i in nonsink)
     return ReducedLaplacianResult(
         vertices=vertices,
         sink=request.sink,
@@ -187,7 +185,6 @@ def compute_stabilize(request: StabilizeRequest) -> StabilizeResult:
     """Stabilize a sink configuration and return the odometer."""
     sc = request.configuration
     vertices = sc.graph.vertices
-    n = len(vertices)
     sink_idx = vertices.index(sc.sink)
     adj = _adjacency(sc.graph)
     degrees = _degrees(sc.graph)
@@ -204,13 +201,13 @@ def compute_parallel_step(request: ParallelStepRequest) -> ParallelStepResult:
     """One simultaneous legal firing step on all unstable nonsink vertices."""
     sc = request.configuration
     vertices = sc.graph.vertices
-    n = len(vertices)
     sink_idx = vertices.index(sc.sink)
     adj = _adjacency(sc.graph)
     degrees = _degrees(sc.graph)
     config = list(sc.configuration)
-    fired = [v for i, v in enumerate(vertices)
-             if i != sink_idx and config[i] >= degrees[i]]
+    fired = [
+        v for i, v in enumerate(vertices) if i != sink_idx and config[i] >= degrees[i]
+    ]
     next_config = list(config)
     for v in fired:
         vi = vertices.index(v)
@@ -319,9 +316,7 @@ def _smith_normal_form_diagonal(
     cols = len(matrix[0]) if matrix else 0
     if rows == 0 or cols == 0:
         return ()
-    source = sympy.Matrix(
-        [[int(value) for value in row] for row in matrix]
-    )
+    source = sympy.Matrix([[int(value) for value in row] for row in matrix])
     diagonal, _left, _right = smith_normal_decomp(source, domain=sympy.ZZ)
     result = []
     for i in range(min(rows, cols)):
@@ -353,9 +348,7 @@ def _critical_group_factors(
 
 def compute_critical_group(request: CriticalGroupRequest) -> CriticalGroupResult:
     """Compute the critical group via SNF of the reduced Laplacian."""
-    nonsink_labels, invariant = _critical_group_factors(
-        request.graph, request.sink
-    )
+    nonsink_labels, invariant = _critical_group_factors(request.graph, request.sink)
     order = 1
     for d in invariant:
         order *= d
@@ -378,9 +371,7 @@ def compute_abel_jacobi(request: AbelJacobiRequest) -> AbelJacobiResult:
     n = len(vertices)
     sink_idx = vertices.index(request.sink)
     nonsink = [i for i in range(n) if i != sink_idx]
-    nonsink_labels, invariant = _critical_group_factors(
-        request.graph, request.sink
-    )
+    nonsink_labels, invariant = _critical_group_factors(request.graph, request.sink)
     nonsink_div = [request.divisor[i] for i in nonsink]
     # The coordinates: nonsink_div mod the invariant factors.
     # Only non-unit, non-zero factors matter for the quotient group.

src/jacobian/math/chip_firing/_tools.py

@@ -112,8 +112,7 @@ def _op[RequestT: StrictModel, ResultT: StrictModel](
         examples=(
             example(
                 "path_graph_3_sink_a",
-                "Compute the reduced Laplacian of a path graph with sink "
-                "at vertex a.",
+                "Compute the reduced Laplacian of a path graph with sink at vertex a.",
                 {"graph": _GRAPH, "sink": "a"},
             ),
         ),
@@ -153,8 +152,7 @@ def _op[RequestT: StrictModel, ResultT: StrictModel](
         examples=(
             example(
                 "fire_e_a",
-                "Fire the unit vector e_a on a path graph; degree is "
-                "preserved.",
+                "Fire the unit vector e_a on a path graph; degree is preserved.",
                 {
                     "graph": _GRAPH,
                     "divisor": [3, 0, 1],
@@ -178,8 +176,7 @@ def _op[RequestT: StrictModel, ResultT: StrictModel](
         examples=(
             example(
                 "path_graph_3_sink_a",
-                "Stabilize a path graph configuration with sink at "
-                "vertex a.",
+                "Stabilize a path graph configuration with sink at vertex a.",
                 {"configuration": _SINK_CONFIG},
             ),
         ),
@@ -265,8 +262,7 @@ def _op[RequestT: StrictModel, ResultT: StrictModel](
         examples=(
             example(
                 "path_graph_3",
-                "Compute the canonical divisor of a path graph on 3 "
-                "vertices.",
+                "Compute the canonical divisor of a path graph on 3 vertices.",
                 {"graph": _GRAPH},
             ),
         ),
@@ -286,8 +282,7 @@ def _op[RequestT: StrictModel, ResultT: StrictModel](
         examples=(
             example(
                 "triangle_sink_a",
-                "Compute the critical group of a triangle graph with "
-                "sink at vertex a.",
+                "Compute the critical group of a triangle graph with sink at vertex a.",
                 {
                     "graph": {
                         "vertices": ["a", "b", "c"],

tests/math/chip_firing/test_chip_firing.py

@@ -63,9 +63,7 @@ def test_path_graph_sink_a(self) -> None:
         assert result.reduced_laplacian == ((2, -1), (-1, 1))
 
     def test_triangle_sink_b(self) -> None:
-        result = compute_reduced_laplacian(
-            ReducedLaplacianRequest(graph=C3, sink="b")
-        )
+        result = compute_reduced_laplacian(ReducedLaplacianRequest(graph=C3, sink="b"))
         assert result.reduced_laplacian == ((2, -1), (-1, 2))
 
     def test_invalid_sink(self) -> None:
@@ -133,7 +131,9 @@ def test_firing_vector_composition(self) -> None:
         )
         composed = compute_fire_vector(
             FireVectorRequest(
-                graph=GRAPH, divisor=div, firing_vector=[f1[i] + f2[i] for i in range(3)]
+                graph=GRAPH,
+                divisor=div,
+                firing_vector=[f1[i] + f2[i] for i in range(3)],
             )
         )
         assert r2.fired_divisor == composed.fired_divisor
@@ -162,9 +162,7 @@ def test_stabilization_is_stable(self) -> None:
     def test_stabilization_idempotence(self) -> None:
         sc = SinkConfiguration(graph=GRAPH, sink="a", configuration=[0, 5, 0])
         r1 = compute_stabilize(StabilizeRequest(configuration=sc))
-        sc2 = SinkConfiguration(
-            graph=GRAPH, sink="a", configuration=list(r1.stable)
-        )
+        sc2 = SinkConfiguration(graph=GRAPH, sink="a", configuration=list(r1.stable))
         r2 = compute_stabilize(StabilizeRequest(configuration=sc2))
         assert r1.stable == r2.stable
         assert r2.total_firings == 0
@@ -274,11 +272,11 @@ def test_triangle(self) -> None:
         assert result.order == 3
 
     def test_cycle_c4(self) -> None:
-        C4 = {
+        c4 = {
             "vertices": ["a", "b", "c", "d"],
             "edges": [["a", "b"], ["b", "c"], ["c", "d"], ["d", "a"]],
         }
-        result = compute_critical_group(CriticalGroupRequest(graph=C4, sink="a"))
+        result = compute_critical_group(CriticalGroupRequest(graph=c4, sink="a"))
         assert result.invariant_factors == (1, 1, 4)
         assert result.order == 4
 
@@ -288,14 +286,18 @@ def test_tree_is_trivial(self) -> None:
         assert result.order == 1
 
     def test_complete_k4(self) -> None:
-        K4 = {
+        k4 = {
             "vertices": ["a", "b", "c", "d"],
             "edges": [
-                ["a", "b"], ["a", "c"], ["a", "d"],
-                ["b", "c"], ["b", "d"], ["c", "d"],
+                ["a", "b"],
+                ["a", "c"],
+                ["a", "d"],
+                ["b", "c"],
+                ["b", "d"],
+                ["c", "d"],
             ],
         }
-        result = compute_critical_group(CriticalGroupRequest(graph=K4, sink="a"))
+        result = compute_critical_group(CriticalGroupRequest(graph=k4, sink="a"))
         assert result.order == 16
 
     def test_order_matches_spanning_tree_count(self) -> None:
@@ -314,17 +316,17 @@ def count_spanning_trees(vertices, edges):
             minor = Matrix([row[: n - 1] for row in lap[: n - 1]])
             result = compute_critical_group(
                 CriticalGroupRequest(
-                    graph={'vertices': vertices, 'edges': [list(e) for e in edges]},
+                    graph={"vertices": vertices, "edges": [list(e) for e in edges]},
                     sink=vertices[0],
                 )
             )
             return result, int(minor.det())
 
         for vertices, edges in [
-            (['a', 'b', 'c'], [('a', 'b'), ('b', 'c'), ('a', 'c')]),
+            (["a", "b", "c"], [("a", "b"), ("b", "c"), ("a", "c")]),
             (
-                ['a', 'b', 'c', 'd'],
-                [('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'a')],
+                ["a", "b", "c", "d"],
+                [("a", "b"), ("b", "c"), ("c", "d"), ("d", "a")],
             ),
         ]:
             res, trees = count_spanning_trees(vertices, edges)
@@ -369,8 +371,14 @@ def test_laplacian_equivariance(self) -> None:
         assert r1.laplacian == r2.laplacian
 
     def test_critical_group_relabelling(self) -> None:
-        graph1 = {"vertices": ["a", "b", "c"], "edges": [["a", "b"], ["b", "c"], ["a", "c"]]}
-        graph2 = {"vertices": ["x", "y", "z"], "edges": [["x", "y"], ["y", "z"], ["x", "z"]]}
+        graph1 = {
+            "vertices": ["a", "b", "c"],
+            "edges": [["a", "b"], ["b", "c"], ["a", "c"]],
+        }
+        graph2 = {
+            "vertices": ["x", "y", "z"],
+            "edges": [["x", "y"], ["y", "z"], ["x", "z"]],
+        }
         r1 = compute_critical_group(CriticalGroupRequest(graph=graph1, sink="a"))
         r2 = compute_critical_group(CriticalGroupRequest(graph=graph2, sink="x"))
         assert r1.invariant_factors == r2.invariant_factors