Rename confusing variables

Author: RotemKalisch

ramanujantools/asymptotics/reducer.py

@@ -223,22 +223,24 @@ def shear(self) -> None:
         Used when the leading matrix is nilpotent, this shifts the polynomial degrees
         of the variables to expose the hidden sub-exponential growths.
         """
-        g = self._compute_shear_slope()
+        slope = self._compute_shear_slope()
 
-        if g == sp.S.Zero:
+        if slope == sp.S.Zero:
             self._check_eigenvalue_blindness(self.M.coeffs[0][0, 0])
             self._is_reduced = True
             return
 
-        if not g.is_integer:
-            g, b = g.as_numer_denom()
-            self.M, self.S_total = self.M.ramify(b), self.S_total.ramify(b)
-            self.p *= b
-            self.precision *= b
+        shift, ramification = slope.as_numer_denom()
+        self.M, self.S_total = (
+            self.M.ramify(ramification),
+            self.S_total.ramify(ramification),
+        )
+        self.p *= ramification
+        self.precision *= ramification
 
-        true_valid_precision, max_shift = self._check_shear_truncation(g)
+        true_valid_precision, max_shift = self._check_shear_truncation(shift)
 
-        logger.debug(f"SHEAR: Computed slope {g=}. Max shift: {max_shift=} terms.")
+        logger.debug(f"SHEAR: Computed shift {shift=}. Max shift: {max_shift=} terms.")
         if max_shift > 0:
             padded_coeffs = (
                 self.S_total.coeffs + [Matrix.zeros(self.dim, self.dim)] * max_shift
@@ -252,12 +254,12 @@ def shear(self) -> None:
             f"Remaining buffer: {self.S_total.precision - max_shift}"
         )
 
-        S_sym = Matrix.diag(*[t ** (i * g) for i in range(self.dim)])
+        S_sym = Matrix.diag(*[t ** (i * shift) for i in range(self.dim)])
         S_series = SeriesMatrix.from_matrix(S_sym, n, self.p, self.S_total.precision)
 
         self.S_total = self.S_total * S_series
 
-        self.M, h = self.M.shear_coboundary(g, true_valid_precision)
+        self.M, h = self.M.shear_coboundary(shift, true_valid_precision)
         self.precision = true_valid_precision
 
         if h != 0:
@@ -310,11 +312,11 @@ def _compute_shear_slope(self) -> sp.Rational:
 
         p1, p2 = lower_hull[0], lower_hull[1]
         steepest_slope = sp.Rational(p2[1] - p1[1], p2[0] - p1[0])
-        g = -steepest_slope
+        slope = -steepest_slope
 
         logger.debug(f"NEWTON: Lower hull points: {lower_hull}")
-        logger.debug(f"NEWTON: Computed slope {g=}")
-        return max(sp.S.Zero, g)
+        logger.debug(f"NEWTON: Computed {slope=}")
+        return max(sp.S.Zero, slope)
 
     def _check_eigenvalue_blindness(self, exp_base: sp.Expr) -> None:
         """

ramanujantools/asymptotics/series_matrix.py

@@ -244,22 +244,25 @@ def _shear_row_corrections(self, g: int) -> list[list[sp.Expr]]:
         return row_corrections
 
     def shear_coboundary(
-        self, g: sp.Rational | int, target_precision: int | None = None
+        self, shift: sp.Integer | int, target_precision: int | None = None
     ) -> tuple[SeriesMatrix, int]:
         """
         Applies a shearing transformation S(t) to the series to expose sub-exponential
-        growth, where $S(t) = diag(1, t^g, t^{2g}, \\dots)$.
+        growth, where $S(t) = diag(1, t^a, t^{2a}, \\dots)$ and $a$ is the shift parameter.
 
         Args:
-            g: The shear slope.
+            shift: Represents a in the above description.
             target_precision: If provided, truncates the resulting series to this length,
                               saving heavy CAS simplification on discarded tail terms.
 
         Returns:
             A tuple containing the sheared SeriesMatrix and the integer `h` representing
             the overall degree shift (used to adjust the global factorial power).
         """
-        row_corrections = self._shear_row_corrections(g)
+        if not shift.is_integer:
+            raise ValueError(f"{shift=} must be an integer!")
+
+        row_corrections = self._shear_row_corrections(shift)
         power_dict = {}
 
         for m in range(self.precision):
@@ -269,13 +272,13 @@ def shear_coboundary(
                     if val_M == sp.S.Zero:
                         continue
 
-                    shift = int((j - i) * g)
+                    current = (j - i) * shift
                     for c in range(self.precision):
                         val_C = row_corrections[i][c]
                         if val_C == sp.S.Zero:
                             continue
 
-                        power = m + c + shift
+                        power = m + c + current
                         if power not in power_dict:
                             power_dict[power] = Matrix.zeros(*self.shape)
                         power_dict[power][i, j] += val_C * val_M