foxmath 0.2.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxmath
-Version: 0.2.0
+Version: 0.4.0
 Summary: Minimalist CLI for math & cryptography exploration 🦊
 Author-email: Abhrankan Chakrabarti <abhrankan@gmail.com>
 License: MIT
@@ -28,11 +28,13 @@ Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
 ## Features
 - Legendre symbol
 - Euler/Hermann Machin-like π approximation
-- Elliptic curve point addition (over finite fields)
+- Elliptic curve point addition (over finite fields), including
+  named curves (secp256k1) with on-curve result validation
 - Chinese Remainder Theorem solver (handles non-coprime moduli)
-- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt)
+- Continued fraction expansion and convergents
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt, foxmath-cf)
 - JSON output mode
-- Coming soon: continued fractions, challenge mode, more curves
+- Coming soon: challenge mode
 
 ## Installation
 
@@ -71,6 +73,15 @@ foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
 Result point: (14, 2)
 ```
 
+```bash
+# Named curve (secp256k1) — computes 2G by default
+foxmath ecadd --curve secp256k1
+```
+```
+Result point: (89565891926547004231252920425935692360644145829622209833684329913297188986597, 12158399299693830322967808612713398636155367887041628176798871954788371653930)
+  ✓ on curve
+```
+
 ```bash
 # Chinese Remainder Theorem
 foxmath crt --r 2 3 2 --m 3 5 7
@@ -79,6 +90,17 @@ foxmath crt --r 2 3 2 --m 3 5 7
 x ≡ 23 (mod 105)
 ```
 
+```bash
+# Continued fraction expansion + convergents
+foxmath cf --num 355 --den 113
+```
+```
+[3; 7, 16]
+  3/1
+  22/7
+  355/113
+```
+
 ```bash
 # JSON output
 foxmath pi --terms 100 --json

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

@@ -9,11 +9,13 @@ Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
 ## Features
 - Legendre symbol
 - Euler/Hermann Machin-like π approximation
-- Elliptic curve point addition (over finite fields)
+- Elliptic curve point addition (over finite fields), including
+  named curves (secp256k1) with on-curve result validation
 - Chinese Remainder Theorem solver (handles non-coprime moduli)
-- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt)
+- Continued fraction expansion and convergents
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt, foxmath-cf)
 - JSON output mode
-- Coming soon: continued fractions, challenge mode, more curves
+- Coming soon: challenge mode
 
 ## Installation
 
@@ -52,6 +54,15 @@ foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
 Result point: (14, 2)
 ```
 
+```bash
+# Named curve (secp256k1) — computes 2G by default
+foxmath ecadd --curve secp256k1
+```
+```
+Result point: (89565891926547004231252920425935692360644145829622209833684329913297188986597, 12158399299693830322967808612713398636155367887041628176798871954788371653930)
+  ✓ on curve
+```
+
 ```bash
 # Chinese Remainder Theorem
 foxmath crt --r 2 3 2 --m 3 5 7
@@ -60,6 +71,17 @@ foxmath crt --r 2 3 2 --m 3 5 7
 x ≡ 23 (mod 105)
 ```
 
+```bash
+# Continued fraction expansion + convergents
+foxmath cf --num 355 --den 113
+```
+```
+[3; 7, 16]
+  3/1
+  22/7
+  355/113
+```
+
 ```bash
 # JSON output
 foxmath pi --terms 100 --json

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

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

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

@@ -54,6 +54,28 @@ def ec_point_add(x1, y1, x2, y2, a, p):
     y3 = (lam * (x1 - x3) - y1) % p
     return x3, y3
 
+# Named curve presets: a, b, p, and the standard generator point G (if defined).
+CURVES = {
+    "secp256k1": {
+        "a": 0,
+        "b": 7,
+        "p": 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F,
+        "gx": 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
+        "gy": 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
+    },
+    "toy97": {  # small curve for quick hand-checkable examples: y^2 = x^3 + 2x + 3 (mod 97)
+        "a": 2,
+        "b": 3,
+        "p": 97,
+        "gx": 3,
+        "gy": 6,
+    },
+}
+
+def is_on_curve(x: int, y: int, a: int, b: int, p: int) -> bool:
+    """Check y^2 = x^3 + a*x + b (mod p)."""
+    return (y * y - (x ** 3 + a * x + b)) % p == 0
+
 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
@@ -96,6 +118,38 @@ def crt_solve(remainders, moduli):
         r, m = _combine_crt(r, m, ri % mi, mi)
     return r, m
 
+def continued_fraction(num: int, den: int, max_terms: int = 100):
+    """
+    Continued fraction expansion [a0; a1, a2, ...] of num/den via the
+    Euclidean algorithm. Terminates naturally for any rational input.
+    """
+    if den == 0:
+        raise ValueError("denominator cannot be zero")
+    cf = []
+    n, d = num, den
+    while d != 0 and len(cf) < max_terms:
+        a = n // d
+        cf.append(a)
+        n, d = d, n - a * d
+    return cf
+
+def cf_convergents(cf):
+    """
+    Convergents (p_n, q_n) of a continued fraction, via the standard
+    recurrence h_n = a_n*h_(n-1) + h_(n-2), same for k_n, with
+    h_(-2)=0, h_(-1)=1, k_(-2)=1, k_(-1)=0.
+    """
+    convergents = []
+    h2, h1 = 0, 1
+    k2, k1 = 1, 0
+    for a in cf:
+        h = a * h1 + h2
+        k = a * k1 + k2
+        convergents.append((h, k))
+        h2, h1 = h1, h
+        k2, k1 = k1, k
+    return convergents
+
 # ------------------- CLI -------------------
 
 def get_command():
@@ -139,18 +193,26 @@ def main():
 
     # Elliptic curve add
     ec = subparsers.add_parser("ecadd", help="Elliptic curve point addition")
-    ec.add_argument("--x1", type=int, required=True)
-    ec.add_argument("--y1", type=int, required=True)
-    ec.add_argument("--x2", type=int, required=True)
-    ec.add_argument("--y2", type=int, required=True)
-    ec.add_argument("--a", type=int, default=-3, help="Curve parameter a")
-    ec.add_argument("--p", type=int, required=True, help="Prime modulus")
+    ec.add_argument("--curve", choices=sorted(CURVES.keys()),
+                     help="Named curve (provides a, b, p, and generator G)")
+    ec.add_argument("--x1", type=int, help="Defaults to G's x if --curve is given")
+    ec.add_argument("--y1", type=int, help="Defaults to G's y if --curve is given")
+    ec.add_argument("--x2", type=int, help="Defaults to (x1,y1) if omitted (i.e. doubling)")
+    ec.add_argument("--y2", type=int, help="Defaults to (x1,y1) if omitted (i.e. doubling)")
+    ec.add_argument("--a", type=int, help="Curve parameter a (overrides --curve if given)")
+    ec.add_argument("--p", type=int, help="Prime modulus (overrides --curve if given)")
 
     # 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")
 
+    # Continued fractions
+    cf_cmd = subparsers.add_parser("cf", help="Continued fraction expansion and convergents")
+    cf_cmd.add_argument("--num", type=int, required=True, help="Numerator")
+    cf_cmd.add_argument("--den", type=int, required=True, help="Denominator")
+    cf_cmd.add_argument("--terms", type=int, default=100, help="Max terms to expand")
+
     args = parser.parse_args(argv)
 
     result = {"tool": "foxmath"}
@@ -169,10 +231,41 @@ def main():
                 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)})
+            a, b = args.a, None
+            p = args.p
+            x1, y1 = args.x1, args.y1
+
+            if args.curve:
+                preset = CURVES[args.curve]
+                a = preset["a"] if a is None else a
+                p = preset["p"] if p is None else p
+                b = preset["b"]
+                if x1 is None:
+                    x1, y1 = preset["gx"], preset["gy"]
+            elif a is None:
+                a = -3  # historical default for manual (non-curve) mode
+
+            if a is None or p is None or x1 is None or y1 is None:
+                raise ValueError(
+                    "Provide --curve NAME, or at least --p --x1 --y1 manually "
+                    "(--a defaults to -3 if omitted)."
+                )
+
+            x2 = x1 if args.x2 is None else args.x2
+            y2 = y1 if args.y2 is None else args.y2
+
+            x3, y3 = ec_point_add(x1, y1, x2, y2, a, p)
+            result.update({
+                "command": "ecadd", "curve": args.curve,
+                "p1": [x1, y1], "p2": [x2, y2], "result": (x3, y3),
+            })
+            if b is not None:
+                result["result_on_curve"] = is_on_curve(x3, y3, a, b, p)
             if not json_output:
                 print(f"Result point: ({x3}, {y3})")
+                if b is not None:
+                    status = "✓ on curve" if result["result_on_curve"] else "✗ NOT on curve"
+                    print(f"  {status}")
 
         elif cmd == "crt" or args.command == "crt":
             x, m = crt_solve(args.r, args.m)
@@ -180,6 +273,18 @@ def main():
             if not json_output:
                 print(f"x ≡ {x} (mod {m})")
 
+        elif cmd == "cf" or args.command == "cf":
+            cf = continued_fraction(args.num, args.den, args.terms)
+            convs = cf_convergents(cf)
+            result.update({
+                "command": "cf", "num": args.num, "den": args.den,
+                "cf": cf, "convergents": convs,
+            })
+            if not json_output:
+                print(f"[{cf[0]}; {', '.join(str(a) for a in cf[1:])}]")
+                for p, q in convs:
+                    print(f"  {p}/{q}")
+
     except Exception as e:
         print(f"Error: {e}", file=sys.stderr)
         sys.exit(1)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxmath
-Version: 0.2.0
+Version: 0.4.0
 Summary: Minimalist CLI for math & cryptography exploration 🦊
 Author-email: Abhrankan Chakrabarti <abhrankan@gmail.com>
 License: MIT
@@ -28,11 +28,13 @@ Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
 ## Features
 - Legendre symbol
 - Euler/Hermann Machin-like π approximation
-- Elliptic curve point addition (over finite fields)
+- Elliptic curve point addition (over finite fields), including
+  named curves (secp256k1) with on-curve result validation
 - Chinese Remainder Theorem solver (handles non-coprime moduli)
-- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt)
+- Continued fraction expansion and convergents
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd, foxmath-crt, foxmath-cf)
 - JSON output mode
-- Coming soon: continued fractions, challenge mode, more curves
+- Coming soon: challenge mode
 
 ## Installation
 
@@ -71,6 +73,15 @@ foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
 Result point: (14, 2)
 ```
 
+```bash
+# Named curve (secp256k1) — computes 2G by default
+foxmath ecadd --curve secp256k1
+```
+```
+Result point: (89565891926547004231252920425935692360644145829622209833684329913297188986597, 12158399299693830322967808612713398636155367887041628176798871954788371653930)
+  ✓ on curve
+```
+
 ```bash
 # Chinese Remainder Theorem
 foxmath crt --r 2 3 2 --m 3 5 7
@@ -79,6 +90,17 @@ foxmath crt --r 2 3 2 --m 3 5 7
 x ≡ 23 (mod 105)
 ```
 
+```bash
+# Continued fraction expansion + convergents
+foxmath cf --num 355 --den 113
+```
+```
+[3; 7, 16]
+  3/1
+  22/7
+  355/113
+```
+
 ```bash
 # JSON output
 foxmath pi --terms 100 --json

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

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

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

@@ -85,6 +85,12 @@ class TestSymlinkInvocation(unittest.TestCase):
         self.assertEqual(code, 0)
         self.assertIn("x ≡ 23 (mod 105)", out)
 
+    def test_cf_symlink(self):
+        script = self._make_symlink_script("foxmath-cf")
+        code, out, err = run("--num", "355", "--den", "113", script=script)
+        self.assertEqual(code, 0)
+        self.assertIn("[3; 7, 16]", out)
+
     def test_symlink_with_json(self):
         script = self._make_symlink_script("foxmath-legendre")
         code, out, err = run("2", "7", "--json", script=script)
@@ -104,6 +110,29 @@ class TestNormalUsage(unittest.TestCase):
         self.assertEqual(code, 1)
         self.assertIn("point at infinity", err)
 
+    def test_ecadd_curve_secp256k1_defaults_to_doubling_generator(self):
+        code, out, err = run("ecadd", "--curve", "secp256k1")
+        self.assertEqual(code, 0)
+        self.assertIn("89565891926547004231252920425935692360644145829622209833684329913297188986597", out)
+        self.assertIn("on curve", out)
+
+    def test_ecadd_curve_manual_a_override(self):
+        # --a explicitly provided should override the curve preset's a.
+        code, out, err = run("ecadd", "--curve", "toy97", "--a", "2")
+        self.assertEqual(code, 0)
+
+    def test_ecadd_no_args_at_all_errors_clearly(self):
+        code, out, err = run("ecadd")
+        self.assertEqual(code, 1)
+        self.assertIn("Error", err)
+
+    def test_ecadd_backward_compatible_manual_call(self):
+        # Original documented usage: --a omitted, defaults to -3.
+        code, out, err = run("ecadd", "--x1", "1", "--y1", "2",
+                              "--x2", "3", "--y2", "4", "--p", "17")
+        self.assertEqual(code, 0)
+        self.assertIn("Result point: (14, 2)", out)
+
     def test_crt(self):
         code, out, err = run("crt", "--r", "2", "3", "2", "--m", "3", "5", "7")
         self.assertEqual(code, 0)
@@ -122,6 +151,25 @@ class TestNormalUsage(unittest.TestCase):
         self.assertEqual(code, 1)
         self.assertIn("inconsistent", err)
 
+    def test_cf(self):
+        code, out, err = run("cf", "--num", "355", "--den", "113")
+        self.assertEqual(code, 0)
+        self.assertIn("[3; 7, 16]", out)
+        self.assertIn("355/113", out)
+
+    def test_cf_json_is_pure_json(self):
+        code, out, err = run("cf", "--num", "355", "--den", "113", "--json")
+        self.assertEqual(code, 0)
+        import json
+        parsed = json.loads(out)
+        self.assertEqual(parsed["cf"], [3, 7, 16])
+        self.assertEqual(parsed["convergents"][-1], [355, 113])
+
+    def test_cf_zero_denominator_errors(self):
+        code, out, err = run("cf", "--num", "5", "--den", "0")
+        self.assertEqual(code, 1)
+        self.assertIn("Error", err)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -12,7 +12,10 @@ 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, euler_hermann_pi_approx, ec_point_add, crt_solve
+from foxmath.foxmath import (
+    legendre_symbol, euler_hermann_pi_approx, ec_point_add, crt_solve,
+    continued_fraction, cf_convergents, CURVES, is_on_curve,
+)
 
 # Reference pi digits (mpmath, 250 dps of working precision), "3" + fractional digits.
 PI_REFERENCE = Decimal(
@@ -115,5 +118,62 @@ class TestCRT(unittest.TestCase):
         self.assertEqual(x % 7, 3)
 
 
+class TestContinuedFractions(unittest.TestCase):
+    def test_classic_pi_approximation(self):
+        cf = continued_fraction(355, 113)
+        self.assertEqual(cf, [3, 7, 16])
+        convs = cf_convergents(cf)
+        self.assertEqual(convs, [(3, 1), (22, 7), (355, 113)])
+
+    def test_convergents_reduce_to_final_fraction(self):
+        cf = continued_fraction(19, 7)
+        convs = cf_convergents(cf)
+        self.assertEqual(convs[-1], (19, 7))
+
+    def test_negative_numerator(self):
+        cf = continued_fraction(-19, 7)
+        convs = cf_convergents(cf)
+        self.assertEqual(convs[-1], (-19, 7))
+
+    def test_zero_denominator_raises(self):
+        with self.assertRaises(ValueError):
+            continued_fraction(5, 0)
+
+    def test_randomized_against_fractions_module(self):
+        import random
+        from fractions import Fraction
+        random.seed(42)
+        for _ in range(200):
+            n = random.randint(-10000, 10000)
+            d = random.randint(1, 10000)
+            cf = continued_fraction(n, d)
+            convs = cf_convergents(cf)
+            expected = Fraction(n, d)
+            self.assertEqual(convs[-1], (expected.numerator, expected.denominator))
+
+
+class TestNamedCurves(unittest.TestCase):
+    def test_secp256k1_generator_is_on_curve(self):
+        c = CURVES["secp256k1"]
+        self.assertTrue(is_on_curve(c["gx"], c["gy"], c["a"], c["b"], c["p"]))
+
+    def test_secp256k1_doubling_matches_known_value(self):
+        # Cross-checked independently against the `ecdsa` library's
+        # SECP256k1.generator * 2.
+        c = CURVES["secp256k1"]
+        x2, y2 = ec_point_add(c["gx"], c["gy"], c["gx"], c["gy"], c["a"], c["p"])
+        self.assertEqual(
+            x2, 89565891926547004231252920425935692360644145829622209833684329913297188986597
+        )
+        self.assertEqual(
+            y2, 12158399299693830322967808612713398636155367887041628176798871954788371653930
+        )
+        self.assertTrue(is_on_curve(x2, y2, c["a"], c["b"], c["p"]))
+
+    def test_toy97_generator_is_on_curve(self):
+        c = CURVES["toy97"]
+        self.assertTrue(is_on_curve(c["gx"], c["gy"], c["a"], c["b"], c["p"]))
+
+
 if __name__ == "__main__":
     unittest.main()