ampzip-engine 1.0.0b1__tar.gz

ampzip_engine-1.0.0b1/Cargo.lock

@@ -0,0 +1,200 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ampzip_engine"
+version = "1.0.0"
+dependencies = [
+ "blake2",
+ "pyo3",
+]
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"

ampzip_engine-1.0.0b1/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "ampzip_engine"
+version = "1.0.0"
+edition = "2021"
+description = "Spinor-helicity move-execution engine for AmpZip (PyO3)"
+
+[lib]
+name = "ampzip_engine"
+# rlib (alongside cdylib) lets `cargo test` build a test harness against the crate.
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+pyo3 = { version = "0.29.0" }
+# Dedup keys: blake2b-128 of the canonical string, byte-identical to what the search used to
+# compute in Python with hashlib (so checkpoints and run records stay comparable).
+blake2 = "0.10"
+
+[features]
+# `extension-module` tells pyo3 not to link libpython, since the host Python provides its
+# symbols. The wheel requires it and maturin enables it through pyproject.toml. It is left
+# off for `cargo test`, so the test binary links libpython and the pure-Rust unit tests run.
+extension-module = ["pyo3/extension-module"]

ampzip_engine-1.0.0b1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: ampzip-engine
+Version: 1.0.0b1
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Physics
+Summary: Move-execution engine of AmpLens (used by AmpZip): spinor-helicity identities, canonical rational functions, finite-field evaluation
+Author: Yifan Fei, Zhen Liu
+License-Expression: MIT
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/AmpLens/AmpLens

ampzip_engine-1.0.0b1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["maturin>=1.5,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "ampzip-engine"
+version = "1.0.0b1"
+description = "Move-execution engine of AmpLens (used by AmpZip): spinor-helicity identities, canonical rational functions, finite-field evaluation"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [
+  { name = "Yifan Fei" },
+  { name = "Zhen Liu" },
+]
+classifiers = [
+  "Programming Language :: Rust",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Scientific/Engineering :: Physics",
+]
+
+[project.urls]
+Homepage = "https://github.com/AmpLens/AmpLens"
+
+[tool.maturin]
+# The import name is the [lib] name in Cargo.toml, `ampzip_engine`. extension-module is
+# enabled for the wheel only and kept off for `cargo test`. abi3 gives one wheel per platform
+# for CPython 3.12 and later.
+features = ["pyo3/extension-module", "pyo3/abi3-py312"]
+exclude = ["target/**"]

ampzip_engine-1.0.0b1/src/eval.rs

@@ -0,0 +1,245 @@
+//! Exact evaluation of an `Ast` or `RatFn` over F_p at an on-shell point.
+//! Brackets are 2x2 minors of the spinors `lam`/`lamt`, matching
+//! `ampzip.verify.vals_from_point`. The finite-field verifier uses `eval_pair`
+//! through `Ast.eval_pair` to compare expressions without division.
+use crate::parse::Ast;
+use crate::poly::{Mono, Poly, RatFn};
+use std::collections::HashMap;
+
+/// Values of the named parameters at one evaluation point.
+pub(crate) type Params = HashMap<String, u64>;
+
+pub(crate) fn mulmod(a: u64, b: u64, p: u64) -> u64 {
+    ((a as u128 * b as u128) % p as u128) as u64
+}
+pub(crate) fn powmod(mut base: u64, mut e: u64, p: u64) -> u64 {
+    base %= p;
+    let mut r = 1u64 % p;
+    while e > 0 {
+        if e & 1 == 1 {
+            r = mulmod(r, base, p);
+        }
+        base = mulmod(base, base, p);
+        e >>= 1;
+    }
+    r
+}
+pub(crate) fn modinv(a: u64, p: u64) -> Result<u64, String> {
+    if a.is_multiple_of(p) {
+        return Err("inverse of 0 (degenerate point)".to_string());
+    }
+    Ok(powmod(a, p - 2, p))
+}
+/// A decimal integer of any length reduced mod p.
+pub(crate) fn big_mod(digits: &str, p: u64) -> u64 {
+    digits.bytes().fold(0u64, |acc, b| (mulmod(acc, 10, p) + (b - b'0') as u64) % p)
+}
+
+/// A square root of `a` mod the odd prime `p` by Tonelli-Shanks. The result depends only on
+/// `a` and `p`, so every occurrence of the same root agrees. Err when `a` has no root mod `p`.
+pub(crate) fn sqrt_mod(a: u64, p: u64) -> Result<u64, String> {
+    let a = a % p;
+    if a == 0 {
+        return Ok(0);
+    }
+    if p == 2 {
+        return Ok(a);
+    }
+    if powmod(a, (p - 1) / 2, p) != 1 {
+        return Err(format!("{} has no square root mod {}", a, p));
+    }
+    if p % 4 == 3 {
+        return Ok(powmod(a, (p + 1) / 4, p));
+    }
+    // p - 1 = q * 2^s with q odd; z is the smallest non-residue.
+    let mut q = p - 1;
+    let mut s_ = 0u32;
+    while q % 2 == 0 {
+        q /= 2;
+        s_ += 1;
+    }
+    let mut z = 2u64;
+    while powmod(z, (p - 1) / 2, p) != p - 1 {
+        z += 1;
+    }
+    let mut m = s_;
+    let mut c = powmod(z, q, p);
+    let mut t = powmod(a, q, p);
+    let mut r = powmod(a, (q + 1) / 2, p);
+    while t != 1 {
+        let mut i = 0u32;
+        let mut t2 = t;
+        while t2 != 1 {
+            t2 = mulmod(t2, t2, p);
+            i += 1;
+        }
+        let b = powmod(c, 1u64 << (m - i - 1), p);
+        m = i;
+        c = mulmod(b, b, p);
+        t = mulmod(t, c, p);
+        r = mulmod(r, b, p);
+    }
+    Ok(r)
+}
+
+fn param_value(name: &str, params: &Params) -> Result<u64, String> {
+    params.get(name).copied().ok_or_else(|| format!("no value supplied for parameter '{}'", name))
+}
+
+pub(crate) fn minor(square: bool, i: usize, j: usize, lam: &[Vec<u64>], lamt: &[Vec<u64>], p: u64) -> Result<u64, String> {
+    let v = if square { lamt } else { lam };
+    if i > v.len() || j > v.len() {
+        return Err(format!("index out of range ({},{})", i, j));
+    }
+    let (a0, a1) = (v[i - 1][0] % p, v[i - 1][1] % p);
+    let (b0, b1) = (v[j - 1][0] % p, v[j - 1][1] % p);
+    Ok((mulmod(a0, b1, p) + p - mulmod(a1, b0, p)) % p)
+}
+
+pub(crate) fn eval_ast(a: &Ast, lam: &[Vec<u64>], lamt: &[Vec<u64>], p: u64, params: &Params) -> Result<u64, String> {
+    match a {
+        Ast::Int(n) => Ok((((n % p as i64) + p as i64) % p as i64) as u64),
+        Ast::Big(d) => Ok(big_mod(d, p)),
+        Ast::ImagUnit => sqrt_mod(p - 1, p).map_err(|_| format!("I needs a prime p = 1 (mod 4); {} is not", p)),
+        Ast::Sqrt(q) => sqrt_mod(*q, p).map_err(|_| format!("sqrt({}) needs a prime where {} is a square; {} is not", q, q, p)),
+        Ast::Param(name) => param_value(name, params),
+        Ast::Bracket { square, i, j } => minor(*square, *i, *j, lam, lamt, p),
+        Ast::Neg(x) => Ok((p - eval_ast(x, lam, lamt, p, params)?) % p),
+        Ast::Add(xs) => {
+            let mut s = 0u64;
+            for x in xs {
+                s = (s + eval_ast(x, lam, lamt, p, params)?) % p;
+            }
+            Ok(s)
+        }
+        Ast::Mul(xs) => {
+            let mut s = 1u64 % p;
+            for x in xs {
+                s = mulmod(s, eval_ast(x, lam, lamt, p, params)?, p);
+            }
+            Ok(s)
+        }
+        Ast::Pow(b, e) => {
+            let bv = eval_ast(b, lam, lamt, p, params)?;
+            if *e >= 0 {
+                Ok(powmod(bv, *e as u64, p))
+            } else {
+                Ok(powmod(modinv(bv, p)?, (-*e) as u64, p))
+            }
+        }
+        Ast::OpaqueDen(x) => Ok(modinv(eval_ast(x, lam, lamt, p, params)?, p)?),
+    }
+}
+
+/// Value of an `Ast` at an on-shell point as a fraction `(num, den)` in F_p, with no division
+/// anywhere: sums cross-multiply, products multiply componentwise, a negative power or an
+/// `opaque_den` swaps the two. A vanishing `den` is returned as it is, and the caller treats
+/// the point as degenerate, as the verifier does.
+pub(crate) fn eval_pair(a: &Ast, lam: &[Vec<u64>], lamt: &[Vec<u64>], p: u64, params: &Params) -> Result<(u64, u64), String> {
+    let one = 1u64 % p;
+    match a {
+        Ast::Int(n) => Ok(((((n % p as i64) + p as i64) % p as i64) as u64, one)),
+        Ast::Big(_) | Ast::ImagUnit | Ast::Sqrt(_) | Ast::Param(_) => Ok((eval_ast(a, lam, lamt, p, params)?, one)),
+        Ast::Bracket { square, i, j } => Ok((minor(*square, *i, *j, lam, lamt, p)?, one)),
+        Ast::Neg(x) => {
+            let (n, d) = eval_pair(x, lam, lamt, p, params)?;
+            Ok(((p - n) % p, d))
+        }
+        Ast::Add(xs) => {
+            let (mut n, mut d) = (0u64, one);
+            for x in xs {
+                let (n2, d2) = eval_pair(x, lam, lamt, p, params)?;
+                n = (mulmod(n, d2, p) + mulmod(n2, d, p)) % p;
+                d = mulmod(d, d2, p);
+            }
+            Ok((n, d))
+        }
+        Ast::Mul(xs) => {
+            let (mut n, mut d) = (one, one);
+            for x in xs {
+                let (n2, d2) = eval_pair(x, lam, lamt, p, params)?;
+                n = mulmod(n, n2, p);
+                d = mulmod(d, d2, p);
+            }
+            Ok((n, d))
+        }
+        Ast::Pow(b, e) => {
+            let (n, d) = eval_pair(b, lam, lamt, p, params)?;
+            if *e >= 0 {
+                Ok((powmod(n, *e as u64, p), powmod(d, *e as u64, p)))
+            } else {
+                Ok((powmod(d, (-*e) as u64, p), powmod(n, (-*e) as u64, p)))
+            }
+        }
+        Ast::OpaqueDen(x) => {
+            let (n, d) = eval_pair(x, lam, lamt, p, params)?;
+            Ok((d, n))
+        }
+    }
+}
+
+/// Product of bracket minors `Π minor(bk)^e` over a monomial, mod p.
+fn eval_mono(m: &Mono, lam: &[Vec<u64>], lamt: &[Vec<u64>], p: u64) -> Result<u64, String> {
+    let mut acc = 1u64 % p;
+    for (bk, e) in m {
+        let v = minor(bk.square, bk.i as usize, bk.j as usize, lam, lamt, p)?;
+        acc = mulmod(acc, powmod(v, *e as u64, p), p);
+    }
+    Ok(acc)
+}
+
+/// `Σ coeff * eval_mono(mono)` over a polynomial, mod p.
+fn eval_poly(poly: &Poly, lam: &[Vec<u64>], lamt: &[Vec<u64>], p: u64) -> Result<u64, String> {
+    let mut acc = 0u64;
+    for (m, c) in poly {
+        let cm = (((*c % p as i128) + p as i128) % p as i128) as u64;
+        if cm == 0 {
+            continue;
+        }
+        acc = (acc + mulmod(cm, eval_mono(m, lam, lamt, p)?, p)) % p;
+    }
+    Ok(acc)
+}
+
+/// Exact evaluation of a `RatFn` over F_p: `eval_poly(num)` multiplied by the
+/// modular inverse of `eval_mono(den) * product(eval_poly(f) for f in den_opaque)`.
+/// This evaluates a resident `Expr` without parsing its string representation
+/// again and must agree with `eval_ast` on the same expression.
+pub(crate) fn eval_ratfn_modp(
+    rf: &RatFn,
+    lam: &[Vec<u64>],
+    lamt: &[Vec<u64>],
+    p: u64,
+) -> Result<u64, String> {
+    let num = eval_poly(&rf.num, lam, lamt, p)?;
+    if num == 0 || (rf.den.is_empty() && rf.den_opaque.is_empty()) {
+        return Ok(num);
+    }
+    let mut den = if rf.den.is_empty() { 1 % p } else { eval_mono(&rf.den, lam, lamt, p)? };
+    for s in &rf.den_opaque {
+        den = mulmod(den, eval_poly(s, lam, lamt, p)?, p);
+    }
+    Ok(mulmod(num, modinv(den, p)?, p))
+}
+
+/// Whether `I` occurs, the primes under square roots and the parameter names, each list
+/// sorted without duplicates.
+pub(crate) fn needs(a: &Ast) -> (bool, Vec<u64>, Vec<String>) {
+    fn walk(a: &Ast, imag: &mut bool, roots: &mut Vec<u64>, names: &mut Vec<String>) {
+        match a {
+            Ast::ImagUnit => *imag = true,
+            Ast::Sqrt(q) => roots.push(*q),
+            Ast::Param(n) => names.push(n.clone()),
+            Ast::Neg(x) | Ast::Pow(x, _) | Ast::OpaqueDen(x) => walk(x, imag, roots, names),
+            Ast::Add(xs) | Ast::Mul(xs) => xs.iter().for_each(|x| walk(x, imag, roots, names)),
+            Ast::Int(_) | Ast::Big(_) | Ast::Bracket { .. } => {}
+        }
+    }
+    let (mut imag, mut roots, mut names) = (false, Vec::new(), Vec::new());
+    walk(a, &mut imag, &mut roots, &mut names);
+    roots.sort_unstable();
+    roots.dedup();
+    names.sort();
+    names.dedup();
+    (imag, roots, names)
+}