Merge pull request #125 from RamanujanMachine/refactor/pcf-is-linear-recurrence

refactor/pcf-is-linear-recurrence

Author: RotemKalisch

ramanujantools/cmf/cmf.py

@@ -428,8 +428,8 @@ def walk(  # noqa: F811
         r"""
         Returns a list of trajectorial walk multiplication matrices in the desired depths.
 
-        The walk operation is defined as $\prod_{i=0}^{n-1}M(s_0 + i \cdot t_0, ..., s_k + i \cdot t_k)$,
-        where `M=trajectory_matrix(trajectory, start)`, and `n / size(trajectory)` (L1 size - total amount of steps)
+        The walk operation is defined as $\prod_{i=0}^{n-1}M_{s, t}(n)$,
+        where M is `trajectory_matrix(trajectory, start)`, s is `start` and t is `trajectory`.
 
         Args:
             trajectory: A dict containing the amount of steps in each direction.

ramanujantools/cmf/known_cmfs_test.py

@@ -29,7 +29,7 @@ def test_cmf_zeta3():
 
 def test_apery():
     cmf = known_cmfs.zeta3()
-    pcf = cmf.trajectory_matrix({x: 1, y: 1}, {x: 0, y: 0}).as_pcf().pcf
+    pcf = PCF(cmf.trajectory_matrix({x: 1, y: 1}, {x: 0, y: 0})).deflate_all()
     # This is Apery's PCF
     assert pcf == PCF(34 * n**3 + 51 * n**2 + 27 * n + 5, -(n**6))
 

ramanujantools/limit.py

@@ -148,7 +148,7 @@ def walk_to_limit(
             initial_values: The initial values matrix, defaults to $e_1$ and $e_2$.
             final_projection: The final projection matrix, defaults to $e_{-1}$ and $e_{-1}$.
         """
-        previous_values = [depth - 1 for depth in iterations]
+        previous_values = [max(depth - 1, 0) for depth in iterations]
         walk_iterations = sorted(list(set(iterations + previous_values)))
         walk_matrices = walk_function(walk_iterations)
 

ramanujantools/linear_recurrence.py

@@ -143,10 +143,9 @@ def parameters(self) -> set[sp.Symbol]:
 
     def normalize(self) -> LinearRecurrence:
         """
-        Normalizes the recurrence
+        Normalizes the recurrence, setting the leading coefficient to 1 by inflating it.
         """
-        relation = [p * self.denominator_lcm / self.gcd for p in self.relation]
-        return LinearRecurrence(relation).simplify()
+        return self.inflate(self.relation[0]).simplify()
 
     def simplify(self) -> LinearRecurrence:
         """
@@ -155,9 +154,10 @@ def simplify(self) -> LinearRecurrence:
         relation = [p * self.denominator_lcm / self.gcd for p in self.relation]
         return LinearRecurrence([sp.factor(p.simplify()) for p in relation])
 
+    @batched("iterations")
     def limit(
-        self, iterations: int | list[int], start=0, initial_values: Matrix = None
-    ) -> Limit:
+        self, iterations: Batchable[int], start=0, initial_values: Matrix = None
+    ) -> Batchable[Limit]:
         r"""
         Returns the Limit matrix of the recursion up to a certain depth
         """

ramanujantools/linear_recurrence_test.py

@@ -154,7 +154,7 @@ def test_gamma():
     )
 
     unfolded = inflated.unfold_poly(n)
-    pcf = unfolded.recurrence_matrix.as_pcf().pcf
+    pcf = PCF(unfolded.recurrence_matrix).deflate_all()
     assert PCF(-2 * (n + 2), -((n + 1) ** 2)) == pcf
 
 

ramanujantools/matrix.py

@@ -343,20 +343,6 @@ def walk_function(iterations):
             iterations, walk_function, initial_values, final_projection
         )
 
-    def as_pcf(self, deflate_all=True):
-        """
-        Converts a `Matrix` to an equivalent `PCF`
-
-        Args:
-            deflate_all: if `True`, the function will also deflate the returned PCF to the fullest.
-        Returns:
-            a `PCFFRomMatrix` object, containing a `PCF` whose limit is equal to
-            a mobius transform of the original `Matrix`.
-        """
-        from ramanujantools.pcf import PCFFromMatrix
-
-        return PCFFromMatrix(self.as_polynomial(), deflate_all)
-
     @staticmethod
     def poincare_poly(poly: sp.PurePoly) -> sp.PurePoly:
         """

ramanujantools/matrix_test.py

@@ -178,7 +178,7 @@ def test_as_companion_smaller_recursion():
     assert companion.is_companion()
     assert 2 == companion.rows
     # This is Apery's PCF
-    assert companion.as_pcf().pcf == PCF(34 * n**3 + 51 * n**2 + 27 * n + 5, -(n**6))
+    assert PCF(34 * n**3 + 51 * n**2 + 27 * n + 5, -(n**6)) == PCF(companion)
 
 
 def test_companion_coboundary_two_variables():

ramanujantools/pcf/__init__.py

@@ -1,5 +1,4 @@
 from .pcf import PCF
-from .pcf_from_matrix import PCFFromMatrix
 from .hypergeometric import (
     HypergeometricLimit,
     Hypergeometric1F1Limit,
@@ -8,7 +7,6 @@
 
 __all__ = [
     "PCF",
-    "PCFFromMatrix",
     "HypergeometricLimit",
     "Hypergeometric1F1Limit",
     "Hypergeometric2F1Limit",

ramanujantools/pcf/hypergeometric.py

@@ -15,14 +15,14 @@ def HypergeometricLimit(pcf: PCF):
         (1, 1): Hypergeometric1F1Limit,
         (1, 2): Hypergeometric2F1Limit,
     }
-    if pcf.degree() not in supported_degrees:
+    if pcf.degrees() not in supported_degrees:
         raise ValueError(
             (
-                "Attempted to evaluate hypergeometric limit of {} of degree {}. "
+                "Attempted to evaluate hypergeometric limit of {} of degrees {}. "
                 "Supported degrees are {}"
-            ).format(pcf, pcf.degree(), supported_degrees.keys())
+            ).format(pcf, pcf.degrees(), supported_degrees.keys())
         )
-    return supported_degrees[pcf.degree()](pcf)
+    return supported_degrees[pcf.degrees()](pcf)
 
 
 class HypLimitInterface: