foxmath 0.1.0__tar.gz

foxmath-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abhrankan Chakrabarti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

foxmath-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: foxmath
+Version: 0.1.0
+Summary: Minimalist CLI for math & cryptography exploration 🦊
+Author-email: Abhrankan Chakrabarti <abhrankan@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Abhrankan-Chakrabarti/foxmath
+Project-URL: Repository, https://github.com/Abhrankan-Chakrabarti/foxmath
+Keywords: math,cryptography,cli,number-theory,elliptic-curves
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# FoxMath 🦊
+
+**Minimalist CLI for math & cryptography exploration.**
+
+One binary. Clean output. Zero footguns. Educational by design.
+
+Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
+
+## Features
+- Legendre symbol
+- Catalan-inspired π approximation
+- Elliptic curve point addition (over finite fields)
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd)
+- JSON output mode
+- Coming soon: CRT, continued fractions, challenge mode, more curves
+
+## Installation
+
+```bash
+pip install foxmath
+```
+
+Or from source:
+```bash
+git clone https://github.com/Abhrankan-Chakrabarti/foxmath.git
+cd foxmath
+pip install -e .
+```
+
+## Usage Examples
+
+```bash
+# Basic
+foxmath pi --terms 200
+foxmath legendre 5 17
+
+# Symlinks (optional)
+foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
+
+# JSON output
+foxmath pi --terms 100 --json
+```
+
+### Example Output
+```
+π ≈ 3.1415926535897932384626433832795028841971693993751  (200 terms)
+```
+
+## 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.
+
+**Simple. Practical. Reliable.**
+
+## License
+MIT © Abhrankan Chakrabarti
+
+---
+
+**Star if you find it useful!** Issues and PRs welcome.

foxmath-0.1.0/README.md

@@ -0,0 +1,59 @@
+# FoxMath 🦊
+
+**Minimalist CLI for math & cryptography exploration.**
+
+One binary. Clean output. Zero footguns. Educational by design.
+
+Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
+
+## Features
+- Legendre symbol
+- Catalan-inspired π approximation
+- Elliptic curve point addition (over finite fields)
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd)
+- JSON output mode
+- Coming soon: CRT, continued fractions, challenge mode, more curves
+
+## Installation
+
+```bash
+pip install foxmath
+```
+
+Or from source:
+```bash
+git clone https://github.com/Abhrankan-Chakrabarti/foxmath.git
+cd foxmath
+pip install -e .
+```
+
+## Usage Examples
+
+```bash
+# Basic
+foxmath pi --terms 200
+foxmath legendre 5 17
+
+# Symlinks (optional)
+foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
+
+# JSON output
+foxmath pi --terms 100 --json
+```
+
+### Example Output
+```
+π ≈ 3.1415926535897932384626433832795028841971693993751  (200 terms)
+```
+
+## 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.
+
+**Simple. Practical. Reliable.**
+
+## License
+MIT © Abhrankan Chakrabarti
+
+---
+
+**Star if you find it useful!** Issues and PRs welcome.

foxmath-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "foxmath"
+version = "0.1.0"
+description = "Minimalist CLI for math & cryptography exploration 🦊"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Abhrankan Chakrabarti", email = "abhrankan@gmail.com"}
+]
+keywords = ["math", "cryptography", "cli", "number-theory", "elliptic-curves"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Security :: Cryptography",
+]
+requires-python = ">=3.8"
+dependencies = []  # Pure stdlib for now
+
+[project.urls]
+"Homepage" = "https://github.com/Abhrankan-Chakrabarti/foxmath"
+"Repository" = "https://github.com/Abhrankan-Chakrabarti/foxmath"
+
+[project.scripts]
+foxmath = "foxmath.foxmath:main"

foxmath-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

foxmath-0.1.0/src/foxmath/foxmath.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+FoxMath — Minimalist math & crypto explorer 🦊
+One binary. Clean. Educational. Safe.
+"""
+
+import argparse
+import sys
+import json
+from decimal import Decimal, getcontext
+from pathlib import Path
+
+# ------------------- Math Functions -------------------
+
+def legendre_symbol(a: int, p: int) -> int:
+    """Compute Legendre symbol (a/p)"""
+    if p < 2 or p % 2 == 0:
+        raise ValueError("p must be an odd prime")
+    res = pow(a, (p - 1) // 2, p)
+    return 1 if res == 1 else (-1 if res == p - 1 else 0)
+
+def _arctan_series(inv_n: Decimal, terms: int) -> Decimal:
+    """arctan(1/n) via its Taylor series, evaluated to `terms` terms. `inv_n` is 1/n."""
+    total = Decimal(0)
+    for k in range(terms):
+        sign = Decimal(-1) ** k
+        total += sign * inv_n**(2 * k + 1) / (2 * k + 1)
+    return total
+
+def catalan_pi_approx(terms: int = 100) -> Decimal:
+    """
+    Fast-converging π approximation via the Euler/Hermann Machin-like
+    identity: pi/4 = arctan(1/2) + arctan(1/3).
+    """
+    getcontext().prec = 50
+    s = _arctan_series(Decimal(1) / 2, terms) + _arctan_series(Decimal(1) / 3, terms)
+    return 4 * s
+
+def ec_point_add(x1, y1, x2, y2, a, p):
+    """Simple elliptic curve point addition over finite field y² = x³ + a x + b (mod p)"""
+    if x1 % p == x2 % p and (y1 + y2) % p == 0:
+        raise ValueError(
+            "Result is the point at infinity (P + (-P)); this simplified "
+            "implementation has no way to represent it."
+        )
+    if x1 == x2 and y1 == y2:
+        # Doubling
+        lam = (3 * x1**2 + a) * pow(2 * y1, -1, p) % p
+    else:
+        lam = (y2 - y1) * pow(x2 - x1, -1, p) % p
+    x3 = (lam**2 - x1 - x2) % p
+    y3 = (lam * (x1 - x3) - y1) % p
+    return x3, y3
+
+# ------------------- CLI -------------------
+
+def get_command():
+    """Support symlinks: foxmath-legendre, foxmath-pi, etc."""
+    name = Path(sys.argv[0]).stem.lower()
+    if name.startswith("foxmath-"):
+        return name.split("-", 1)[1]
+    return None
+
+def main():
+    cmd = get_command()
+
+    # Handle --json independently of argparse subparser scoping: a subparser's
+    # own default for a same-named flag silently overwrites whatever the
+    # parent parser already parsed for it, so --json only ever worked in one
+    # position when defined via argparse directly. Strip it out manually
+    # instead, so it works before or after the subcommand.
+    argv = sys.argv[1:]
+    json_output = "--json" in argv
+    argv = [a for a in argv if a != "--json"]
+
+    if cmd:
+        # Symlink invocation (e.g. `foxmath-legendre 2 7`): argparse's
+        # subparsers positional still expects a command-name token next,
+        # so without this it tries to match the first real argument
+        # (e.g. "2") against {legendre,pi,ecadd} and fails. Inject the
+        # detected command so it parses exactly as if typed explicitly.
+        argv = [cmd] + argv
+
+    parser = argparse.ArgumentParser(description="FoxMath — Math & Crypto Explorer 🦊")
+    subparsers = parser.add_subparsers(dest="command", required=not cmd)
+
+    # Legendre
+    leg = subparsers.add_parser("legendre", help="Legendre symbol (a/p)")
+    leg.add_argument("a", type=int, help="Integer a")
+    leg.add_argument("p", type=int, help="Odd prime p")
+
+    # Pi
+    pi_cmd = subparsers.add_parser("pi", help="Catalan-inspired π approximation")
+    pi_cmd.add_argument("--terms", type=int, default=100)
+
+    # 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")
+
+    args = parser.parse_args(argv)
+
+    result = {"tool": "foxmath"}
+
+    try:
+        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}")
+
+        elif cmd == "pi" or args.command == "pi":
+            approx = catalan_pi_approx(args.terms)
+            result.update({"command": "pi", "terms": args.terms, "approx": str(approx)})
+            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})")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if json_output:
+        print(json.dumps(result, indent=2))
+
+if __name__ == "__main__":
+    main()

foxmath-0.1.0/src/foxmath.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: foxmath
+Version: 0.1.0
+Summary: Minimalist CLI for math & cryptography exploration 🦊
+Author-email: Abhrankan Chakrabarti <abhrankan@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Abhrankan-Chakrabarti/foxmath
+Project-URL: Repository, https://github.com/Abhrankan-Chakrabarti/foxmath
+Keywords: math,cryptography,cli,number-theory,elliptic-curves
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# FoxMath 🦊
+
+**Minimalist CLI for math & cryptography exploration.**
+
+One binary. Clean output. Zero footguns. Educational by design.
+
+Built with curiosity — for students, tinkerers, and crypto/math enthusiasts.
+
+## Features
+- Legendre symbol
+- Catalan-inspired π approximation
+- Elliptic curve point addition (over finite fields)
+- Symlink-friendly (foxmath-legendre, foxmath-pi, foxmath-ecadd)
+- JSON output mode
+- Coming soon: CRT, continued fractions, challenge mode, more curves
+
+## Installation
+
+```bash
+pip install foxmath
+```
+
+Or from source:
+```bash
+git clone https://github.com/Abhrankan-Chakrabarti/foxmath.git
+cd foxmath
+pip install -e .
+```
+
+## Usage Examples
+
+```bash
+# Basic
+foxmath pi --terms 200
+foxmath legendre 5 17
+
+# Symlinks (optional)
+foxmath-ecadd --x1 1 --y1 2 --x2 3 --y2 4 --p 17
+
+# JSON output
+foxmath pi --terms 100 --json
+```
+
+### Example Output
+```
+π ≈ 3.1415926535897932384626433832795028841971693993751  (200 terms)
+```
+
+## 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.
+
+**Simple. Practical. Reliable.**
+
+## License
+MIT © Abhrankan Chakrabarti
+
+---
+
+**Star if you find it useful!** Issues and PRs welcome.

foxmath-0.1.0/src/foxmath.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/foxmath/__init__.py
+src/foxmath/foxmath.py
+src/foxmath.egg-info/PKG-INFO
+src/foxmath.egg-info/SOURCES.txt
+src/foxmath.egg-info/dependency_links.txt
+src/foxmath.egg-info/entry_points.txt
+src/foxmath.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_foxmath.py

foxmath-0.1.0/src/foxmath.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

foxmath-0.1.0/src/foxmath.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+foxmath = foxmath.foxmath:main

foxmath-0.1.0/src/foxmath.egg-info/top_level.txt

@@ -0,0 +1 @@
+foxmath

foxmath-0.1.0/tests/test_cli.py

@@ -0,0 +1,94 @@
+"""
+End-to-end tests for foxmath's CLI, run as a subprocess to match real
+usage (including simulated symlink invocation).
+"""
+import subprocess
+import sys
+import os
+import shutil
+import tempfile
+import unittest
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "src", "foxmath"))
+SCRIPT = os.path.join(ROOT, "foxmath.py")
+
+
+def run(*args, script=SCRIPT):
+    result = subprocess.run(
+        [sys.executable, script, *args],
+        capture_output=True, text=True, timeout=15,
+    )
+    return result.returncode, result.stdout, result.stderr
+
+
+class TestJsonFlag(unittest.TestCase):
+    def test_json_after_subcommand(self):
+        # This is the exact usage shown in the README's own example.
+        code, out, err = run("legendre", "2", "7", "--json")
+        self.assertEqual(code, 0)
+        self.assertIn('"value": 1', out)
+
+    def test_json_before_subcommand(self):
+        code, out, err = run("--json", "legendre", "2", "7")
+        self.assertEqual(code, 0)
+        self.assertIn('"value": 1', out)
+
+    def test_no_json_flag_omits_json_block(self):
+        code, out, err = run("legendre", "2", "7")
+        self.assertEqual(code, 0)
+        self.assertNotIn("{", out)
+
+
+class TestSymlinkInvocation(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def _make_symlink_script(self, name):
+        path = os.path.join(self.tmpdir, f"{name}.py")
+        shutil.copy(SCRIPT, path)
+        return path
+
+    def test_legendre_symlink(self):
+        script = self._make_symlink_script("foxmath-legendre")
+        code, out, err = run("2", "7", script=script)
+        self.assertEqual(code, 0)
+        self.assertIn("Legendre (2/7) = 1", out)
+
+    def test_pi_symlink(self):
+        script = self._make_symlink_script("foxmath-pi")
+        code, out, err = run("--terms", "10", script=script)
+        self.assertEqual(code, 0)
+        self.assertIn("π ≈", out)
+
+    def test_ecadd_symlink(self):
+        script = self._make_symlink_script("foxmath-ecadd")
+        code, out, err = run("--x1", "3", "--y1", "6", "--x2", "3", "--y2", "6",
+                              "--a", "2", "--p", "97", script=script)
+        self.assertEqual(code, 0)
+        self.assertIn("Result point:", out)
+
+    def test_symlink_with_json(self):
+        script = self._make_symlink_script("foxmath-legendre")
+        code, out, err = run("2", "7", "--json", script=script)
+        self.assertEqual(code, 0)
+        self.assertIn('"value": 1', out)
+
+
+class TestNormalUsage(unittest.TestCase):
+    def test_pi(self):
+        code, out, err = run("pi", "--terms", "50")
+        self.assertEqual(code, 0)
+        self.assertIn("3.14159265358979", out)
+
+    def test_ecadd_point_at_infinity_errors_clearly(self):
+        code, out, err = run("ecadd", "--x1", "3", "--y1", "6",
+                              "--x2", "3", "--y2", "91", "--a", "2", "--p", "97")
+        self.assertEqual(code, 1)
+        self.assertIn("point at infinity", err)
+
+
+if __name__ == "__main__":
+    unittest.main()

foxmath-0.1.0/tests/test_foxmath.py

@@ -0,0 +1,86 @@
+"""
+Unit tests for foxmath's core functions, checked against independently
+verifiable reference values (known Legendre symbols, math.pi, and
+on-curve checks for elliptic curve arithmetic) rather than against the
+module's own prior output.
+"""
+import sys
+import os
+import math
+import unittest
+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
+
+# Reference pi digits (mpmath, 250 dps of working precision), "3" + fractional digits.
+PI_REFERENCE = Decimal(
+    "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803"
+    "4825342117067982148086513282306647093844609550582231725359408128481117450284102701938521"
+    "1055596446229489549303819644288"
+)
+
+
+class TestLegendreSymbol(unittest.TestCase):
+    def test_known_quadratic_residues_mod_7(self):
+        # Squares mod 7: {1, 4, 2}
+        self.assertEqual(legendre_symbol(1, 7), 1)
+        self.assertEqual(legendre_symbol(2, 7), 1)
+        self.assertEqual(legendre_symbol(4, 7), 1)
+
+    def test_known_non_residues_mod_7(self):
+        self.assertEqual(legendre_symbol(3, 7), -1)
+        self.assertEqual(legendre_symbol(5, 7), -1)
+        self.assertEqual(legendre_symbol(6, 7), -1)
+
+    def test_multiple_of_p_is_zero(self):
+        self.assertEqual(legendre_symbol(7, 7), 0)
+        self.assertEqual(legendre_symbol(14, 7), 0)
+
+    def test_rejects_even_p(self):
+        with self.assertRaises(ValueError):
+            legendre_symbol(3, 8)
+
+    def test_rejects_p_less_than_2(self):
+        with self.assertRaises(ValueError):
+            legendre_symbol(3, 1)
+
+
+class TestCatalanPiApprox(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)
+        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)
+        self.assertLess(err_50, err_10)
+
+
+class TestECPointAdd(unittest.TestCase):
+    # Curve y^2 = x^3 + 2x + 3 (mod 97); (3, 6) is on this curve
+    # since 6^2=36 and 3^3+2*3+3=36.
+    A, P = 2, 97
+
+    def _on_curve(self, x, y):
+        return (y * y - (x ** 3 + self.A * x + 3)) % self.P == 0
+
+    def test_doubling_stays_on_curve(self):
+        x3, y3 = ec_point_add(3, 6, 3, 6, self.A, self.P)
+        self.assertTrue(self._on_curve(x3, y3))
+
+    def test_distinct_point_addition_stays_on_curve(self):
+        # Another point on the same curve: (80, 10) = 2*(3,6) from above.
+        x3, y3 = ec_point_add(3, 6, 80, 10, self.A, self.P)
+        self.assertTrue(self._on_curve(x3, y3))
+
+    def test_point_plus_negation_raises_clear_error(self):
+        with self.assertRaises(ValueError):
+            ec_point_add(3, 6, 3, self.P - 6, self.A, self.P)
+
+
+if __name__ == "__main__":
+    unittest.main()