foxmath 0.1.1__tar.gz → 0.2.0__tar.gz

{foxmath-0.1.1/src/foxmath.egg-info → foxmath-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxmath
-Version: 0.1.1
+Version: 0.2.0
 Summary: Minimalist CLI for math & cryptography exploration 🦊
 Author-email: Abhrankan Chakrabarti <abhrankan@gmail.com>
 License: MIT
@@ -27,11 +27,12 @@ Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
 
 ## Features
 - Legendre symbol
-- Catalan-inspired π approximation
+- Euler/Hermann Machin-like π approximation
 - Elliptic curve point addition (over finite fields)
-- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd)
+- Chinese Remainder Theorem solver (handles non-coprime moduli)
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt)
 - JSON output mode
-- Coming soon: CRT, continued fractions, challenge mode, more curves
+- Coming soon: continued fractions, challenge mode, more curves
 
 ## Installation
 
@@ -49,24 +50,50 @@ pip install -e .
 ## Usage Examples
 
 ```bash
-# Basic
 foxmath pi --terms 200
+```
+```
+π ≈ 3.1415926535897932384626433832795028841971693993752  (200 terms)
+```
+
+```bash
 foxmath legendre 5 17
+```
+```
+Legendre (5/17) = -1
+```
 
+```bash
 # Symlinks (optional)
 foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
+```
+```
+Result point: (14, 2)
+```
 
-# JSON output
-foxmath pi --terms 100 --json
+```bash
+# Chinese Remainder Theorem
+foxmath crt --r 2 3 2 --m 3 5 7
+```
+```
+x ≡ 23 (mod 105)
 ```
 
-### Example Output
+```bash
+# JSON output
+foxmath pi --terms 100 --json
 ```
-π ≈ 3.1415926535897932384626433832795028841971693993751  (200 terms)
+```json
+{
+  "tool": "foxmath",
+  "command": "pi",
+  "terms": 100,
+  "approx": "3.1415926535897932384626433832795028841971693993752"
+}
 ```
 
 ## Why FoxMath?
-Because math and cryptography are more fun when you can play with them instantly in the terminal — with the same reliability as FoxPipe and fox-vault.
+Because math and cryptography are more fun when you can play with them instantly in the terminal — with the same reliability as [FoxPipe](https://github.com/foxhackerzdevs/FoxPipe) and [fox-vault](https://github.com/foxhackerzdevs/fox-vault).
 
 **Simple. Practical. Reliable.**
 

{foxmath-0.1.1 → foxmath-0.2.0}/README.md

@@ -8,11 +8,12 @@ Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
 
 ## Features
 - Legendre symbol
-- Catalan-inspired π approximation
+- Euler/Hermann Machin-like π approximation
 - Elliptic curve point addition (over finite fields)
-- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd)
+- Chinese Remainder Theorem solver (handles non-coprime moduli)
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt)
 - JSON output mode
-- Coming soon: CRT, continued fractions, challenge mode, more curves
+- Coming soon: continued fractions, challenge mode, more curves
 
 ## Installation
 
@@ -30,24 +31,50 @@ pip install -e .
 ## Usage Examples
 
 ```bash
-# Basic
 foxmath pi --terms 200
+```
+```
+π ≈ 3.1415926535897932384626433832795028841971693993752  (200 terms)
+```
+
+```bash
 foxmath legendre 5 17
+```
+```
+Legendre (5/17) = -1
+```
 
+```bash
 # Symlinks (optional)
 foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
+```
+```
+Result point: (14, 2)
+```
 
-# JSON output
-foxmath pi --terms 100 --json
+```bash
+# Chinese Remainder Theorem
+foxmath crt --r 2 3 2 --m 3 5 7
+```
+```
+x ≡ 23 (mod 105)
 ```
 
-### Example Output
+```bash
+# JSON output
+foxmath pi --terms 100 --json
 ```
-π ≈ 3.1415926535897932384626433832795028841971693993751  (200 terms)
+```json
+{
+  "tool": "foxmath",
+  "command": "pi",
+  "terms": 100,
+  "approx": "3.1415926535897932384626433832795028841971693993752"
+}
 ```
 
 ## Why FoxMath?
-Because math and cryptography are more fun when you can play with them instantly in the terminal — with the same reliability as FoxPipe and fox-vault.
+Because math and cryptography are more fun when you can play with them instantly in the terminal — with the same reliability as [FoxPipe](https://github.com/foxhackerzdevs/FoxPipe) and [fox-vault](https://github.com/foxhackerzdevs/fox-vault).
 
 **Simple. Practical. Reliable.**
 

{foxmath-0.1.1 → foxmath-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "foxmath"
-version = "0.1.1"
+version = "0.2.0"
 description = "Minimalist CLI for math & cryptography exploration 🦊"
 readme = "README.md"
 license = {text = "MIT"}
@@ -31,3 +31,4 @@ foxmath = "foxmath.foxmath:main"
 foxmath-legendre = "foxmath.foxmath:main"
 foxmath-pi = "foxmath.foxmath:main"
 foxmath-ecadd = "foxmath.foxmath:main"
+foxmath-crt = "foxmath.foxmath:main"

{foxmath-0.1.1 → foxmath-0.2.0}/src/foxmath/foxmath.py

@@ -27,7 +27,7 @@ def _arctan_series(inv_n: Decimal, terms: int) -> Decimal:
         total += sign * inv_n**(2 * k + 1) / (2 * k + 1)
     return total
 
-def catalan_pi_approx(terms: int = 100) -> Decimal:
+def euler_hermann_pi_approx(terms: int = 100) -> Decimal:
     """
     Fast-converging π approximation via the Euler/Hermann Machin-like
     identity: pi/4 = arctan(1/2) + arctan(1/3).
@@ -54,6 +54,48 @@ def ec_point_add(x1, y1, x2, y2, a, p):
     y3 = (lam * (x1 - x3) - y1) % p
     return x3, y3
 
+def _extended_gcd(a: int, b: int):
+    """Returns (g, x, y) such that a*x + b*y == g == gcd(a, b)."""
+    old_r, r = a, b
+    old_s, s = 1, 0
+    old_t, t = 0, 1
+    while r != 0:
+        q = old_r // r
+        old_r, r = r, old_r - q * r
+        old_s, s = s, old_s - q * s
+        old_t, t = t, old_t - q * t
+    return old_r, old_s, old_t
+
+def _combine_crt(r1: int, m1: int, r2: int, m2: int):
+    """Combine x≡r1 (mod m1) and x≡r2 (mod m2) into a single x≡r (mod lcm(m1,m2))."""
+    g, p, _ = _extended_gcd(m1, m2)
+    if (r2 - r1) % g != 0:
+        raise ValueError(
+            f"No solution exists: moduli {m1} and {m2} are inconsistent "
+            f"for remainders {r1} and {r2}."
+        )
+    lcm = m1 // g * m2
+    x = (r1 + (r2 - r1) // g * p % (m2 // g) * m1) % lcm
+    return x, lcm
+
+def crt_solve(remainders, moduli):
+    """
+    Chinese Remainder Theorem, generalized to non-pairwise-coprime moduli.
+    Returns (x, m) such that x is the unique solution mod m = lcm(moduli),
+    or raises ValueError if the system is inconsistent.
+    """
+    if len(remainders) != len(moduli):
+        raise ValueError("remainders and moduli must have the same length")
+    if not remainders:
+        raise ValueError("need at least one congruence")
+    if any(m <= 0 for m in moduli):
+        raise ValueError("all moduli must be positive")
+
+    r, m = remainders[0] % moduli[0], moduli[0]
+    for ri, mi in zip(remainders[1:], moduli[1:]):
+        r, m = _combine_crt(r, m, ri % mi, mi)
+    return r, m
+
 # ------------------- CLI -------------------
 
 def get_command():
@@ -92,7 +134,7 @@ def main():
     leg.add_argument("p", type=int, help="Odd prime p")
 
     # Pi
-    pi_cmd = subparsers.add_parser("pi", help="Catalan-inspired π approximation")
+    pi_cmd = subparsers.add_parser("pi", help="Euler/Hermann Machin-like π approximation")
     pi_cmd.add_argument("--terms", type=int, default=100)
 
     # Elliptic curve add
@@ -104,6 +146,11 @@ def main():
     ec.add_argument("--a", type=int, default=-3, help="Curve parameter a")
     ec.add_argument("--p", type=int, required=True, help="Prime modulus")
 
+    # Chinese Remainder Theorem
+    crt = subparsers.add_parser("crt", help="Solve a system of congruences x = r (mod m)")
+    crt.add_argument("--r", type=int, nargs="+", required=True, help="Remainders, e.g. --r 2 3 2")
+    crt.add_argument("--m", type=int, nargs="+", required=True, help="Moduli, e.g. --m 3 5 7")
+
     args = parser.parse_args(argv)
 
     result = {"tool": "foxmath"}
@@ -112,17 +159,26 @@ def main():
         if cmd == "legendre" or args.command == "legendre":
             ls = legendre_symbol(args.a, args.p)
             result.update({"command": "legendre", "a": args.a, "p": args.p, "value": ls})
-            print(f"Legendre ({args.a}/{args.p}) = {ls}")
+            if not json_output:
+                print(f"Legendre ({args.a}/{args.p}) = {ls}")
 
         elif cmd == "pi" or args.command == "pi":
-            approx = catalan_pi_approx(args.terms)
+            approx = euler_hermann_pi_approx(args.terms)
             result.update({"command": "pi", "terms": args.terms, "approx": str(approx)})
-            print(f"π ≈ {approx}  ({args.terms} terms)")
+            if not json_output:
+                print(f"π ≈ {approx}  ({args.terms} terms)")
 
         elif cmd == "ecadd" or args.command == "ecadd":
             x3, y3 = ec_point_add(args.x1, args.y1, args.x2, args.y2, args.a, args.p)
             result.update({"command": "ecadd", "result": (x3, y3)})
-            print(f"Result point: ({x3}, {y3})")
+            if not json_output:
+                print(f"Result point: ({x3}, {y3})")
+
+        elif cmd == "crt" or args.command == "crt":
+            x, m = crt_solve(args.r, args.m)
+            result.update({"command": "crt", "r": args.r, "m": args.m, "x": x, "mod": m})
+            if not json_output:
+                print(f"x ≡ {x} (mod {m})")
 
     except Exception as e:
         print(f"Error: {e}", file=sys.stderr)

{foxmath-0.1.1 → foxmath-0.2.0/src/foxmath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxmath
-Version: 0.1.1
+Version: 0.2.0
 Summary: Minimalist CLI for math & cryptography exploration 🦊
 Author-email: Abhrankan Chakrabarti <abhrankan@gmail.com>
 License: MIT
@@ -27,11 +27,12 @@ Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
 
 ## Features
 - Legendre symbol
-- Catalan-inspired π approximation
+- Euler/Hermann Machin-like π approximation
 - Elliptic curve point addition (over finite fields)
-- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd)
+- Chinese Remainder Theorem solver (handles non-coprime moduli)
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt)
 - JSON output mode
-- Coming soon: CRT, continued fractions, challenge mode, more curves
+- Coming soon: continued fractions, challenge mode, more curves
 
 ## Installation
 
@@ -49,24 +50,50 @@ pip install -e .
 ## Usage Examples
 
 ```bash
-# Basic
 foxmath pi --terms 200
+```
+```
+π ≈ 3.1415926535897932384626433832795028841971693993752  (200 terms)
+```
+
+```bash
 foxmath legendre 5 17
+```
+```
+Legendre (5/17) = -1
+```
 
+```bash
 # Symlinks (optional)
 foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
+```
+```
+Result point: (14, 2)
+```
 
-# JSON output
-foxmath pi --terms 100 --json
+```bash
+# Chinese Remainder Theorem
+foxmath crt --r 2 3 2 --m 3 5 7
+```
+```
+x ≡ 23 (mod 105)
 ```
 
-### Example Output
+```bash
+# JSON output
+foxmath pi --terms 100 --json
 ```
-π ≈ 3.1415926535897932384626433832795028841971693993751  (200 terms)
+```json
+{
+  "tool": "foxmath",
+  "command": "pi",
+  "terms": 100,
+  "approx": "3.1415926535897932384626433832795028841971693993752"
+}
 ```
 
 ## Why FoxMath?
-Because math and cryptography are more fun when you can play with them instantly in the terminal — with the same reliability as FoxPipe and fox-vault.
+Because math and cryptography are more fun when you can play with them instantly in the terminal — with the same reliability as [FoxPipe](https://github.com/foxhackerzdevs/FoxPipe) and [fox-vault](https://github.com/foxhackerzdevs/fox-vault).
 
 **Simple. Practical. Reliable.**
 

{foxmath-0.1.1 → foxmath-0.2.0}/src/foxmath.egg-info/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 foxmath = foxmath.foxmath:main
+foxmath-crt = foxmath.foxmath:main
 foxmath-ecadd = foxmath.foxmath:main
 foxmath-legendre = foxmath.foxmath:main
 foxmath-pi = foxmath.foxmath:main

{foxmath-0.1.1 → foxmath-0.2.0}/tests/test_cli.py

@@ -38,6 +38,15 @@ class TestJsonFlag(unittest.TestCase):
         self.assertEqual(code, 0)
         self.assertNotIn("{", out)
 
+    def test_json_output_is_pure_json_no_preamble(self):
+        # Regression check: --json used to still print the human-readable
+        # line first, breaking anything piping stdout into a JSON parser.
+        code, out, err = run("pi", "--terms", "20", "--json")
+        self.assertEqual(code, 0)
+        import json
+        parsed = json.loads(out)  # raises if there's any leading text
+        self.assertEqual(parsed["command"], "pi")
+
 
 class TestSymlinkInvocation(unittest.TestCase):
     def setUp(self):
@@ -70,6 +79,12 @@ class TestSymlinkInvocation(unittest.TestCase):
         self.assertEqual(code, 0)
         self.assertIn("Result point:", out)
 
+    def test_crt_symlink(self):
+        script = self._make_symlink_script("foxmath-crt")
+        code, out, err = run("--r", "2", "3", "2", "--m", "3", "5", "7", script=script)
+        self.assertEqual(code, 0)
+        self.assertIn("x ≡ 23 (mod 105)", out)
+
     def test_symlink_with_json(self):
         script = self._make_symlink_script("foxmath-legendre")
         code, out, err = run("2", "7", "--json", script=script)
@@ -89,6 +104,24 @@ class TestNormalUsage(unittest.TestCase):
         self.assertEqual(code, 1)
         self.assertIn("point at infinity", err)
 
+    def test_crt(self):
+        code, out, err = run("crt", "--r", "2", "3", "2", "--m", "3", "5", "7")
+        self.assertEqual(code, 0)
+        self.assertIn("x ≡ 23 (mod 105)", out)
+
+    def test_crt_json_is_pure_json(self):
+        code, out, err = run("crt", "--r", "2", "3", "2", "--m", "3", "5", "7", "--json")
+        self.assertEqual(code, 0)
+        import json
+        parsed = json.loads(out)
+        self.assertEqual(parsed["x"], 23)
+        self.assertEqual(parsed["mod"], 105)
+
+    def test_crt_inconsistent_system_errors(self):
+        code, out, err = run("crt", "--r", "1", "2", "--m", "4", "6")
+        self.assertEqual(code, 1)
+        self.assertIn("inconsistent", err)
+
 
 if __name__ == "__main__":
     unittest.main()

{foxmath-0.1.1 → foxmath-0.2.0}/tests/test_foxmath.py

@@ -12,7 +12,7 @@ from decimal import Decimal
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "src")))
 
-from foxmath.foxmath import legendre_symbol, catalan_pi_approx, ec_point_add
+from foxmath.foxmath import legendre_symbol, euler_hermann_pi_approx, ec_point_add, crt_solve
 
 # Reference pi digits (mpmath, 250 dps of working precision), "3" + fractional digits.
 PI_REFERENCE = Decimal(
@@ -47,16 +47,16 @@ class TestLegendreSymbol(unittest.TestCase):
             legendre_symbol(3, 1)
 
 
-class TestCatalanPiApprox(unittest.TestCase):
+class TestEulerHermannPiApprox(unittest.TestCase):
     def test_converges_to_pi(self):
         # Regression check: this used to converge to 16*arctan(1/2) =~ 7.418,
         # not pi, due to a double-counted scaling factor.
-        approx = catalan_pi_approx(100)
+        approx = euler_hermann_pi_approx(100)
         self.assertLess(abs(approx - PI_REFERENCE), Decimal("1e-40"))
 
     def test_more_terms_is_more_accurate(self):
-        err_10 = abs(catalan_pi_approx(10) - PI_REFERENCE)
-        err_50 = abs(catalan_pi_approx(50) - PI_REFERENCE)
+        err_10 = abs(euler_hermann_pi_approx(10) - PI_REFERENCE)
+        err_50 = abs(euler_hermann_pi_approx(50) - PI_REFERENCE)
         self.assertLess(err_50, err_10)
 
 
@@ -82,5 +82,38 @@ class TestECPointAdd(unittest.TestCase):
             ec_point_add(3, 6, 3, self.P - 6, self.A, self.P)
 
 
+class TestCRT(unittest.TestCase):
+    def test_classic_coprime_case(self):
+        x, m = crt_solve([2, 3, 2], [3, 5, 7])
+        self.assertEqual((x, m), (23, 105))
+        self.assertEqual(x % 3, 2)
+        self.assertEqual(x % 5, 3)
+        self.assertEqual(x % 7, 2)
+
+    def test_non_coprime_consistent(self):
+        x, m = crt_solve([2, 2], [4, 6])
+        self.assertEqual((x, m), (2, 12))
+
+    def test_non_coprime_inconsistent_raises(self):
+        with self.assertRaises(ValueError):
+            crt_solve([1, 2], [4, 6])
+
+    def test_single_congruence(self):
+        self.assertEqual(crt_solve([5], [11]), (5, 11))
+
+    def test_mismatched_lengths_raises(self):
+        with self.assertRaises(ValueError):
+            crt_solve([2, 3], [3, 5, 7])
+
+    def test_empty_raises(self):
+        with self.assertRaises(ValueError):
+            crt_solve([], [])
+
+    def test_negative_remainder_normalized(self):
+        x, m = crt_solve([-1, 3], [5, 7])
+        self.assertEqual(x % 5, 4)  # -1 mod 5 == 4
+        self.assertEqual(x % 7, 3)
+
+
 if __name__ == "__main__":
     unittest.main()