nerdamer 1.1.13 → 2.0.0-rc.1

package/output/algebra/algorithms/gcd.js

@@ -0,0 +1,690 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zippelGCDMulti = zippelGCDMulti;
+const arith_1 = require("./arith");
+const MultiPoly_1 = require("./multiPoly/MultiPoly");
+const poly_1 = require("./poly");
+const rational_1 = require("./rational");
+const DEFAULT_ZIPPEL_MAX_TRIES = 32;
+const CANDIDATE_VERIFICATION_SAMPLES = 6;
+const CANDIDATE_VERIFICATION_SEED_BASE = 900000;
+const FALLBACK_SPECIALIZATION_ATTEMPTS = 8;
+const MAX_SCHEDULED_GRID_SAMPLES = 64;
+const FALLBACK_ATTEMPT_SEED_STRIDE = 1_000_000;
+const FALLBACK_ROUND_SEED_STRIDE = 100_000;
+const SUPERFLUOUS_VARIABLE_EVALUATION_PRIMES = [
+    17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n,
+];
+const INTERPOLATION_SAMPLE_PRIMES = [
+    2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n,
+];
+const MIN_INTERPOLATION_POINTS = 3;
+const MAX_INTERPOLATION_POINTS = 15;
+const RANDOM_64_BIT_MASK = (1n << 64n) - 1n;
+const RANDOM_32_BIT_SHIFT = 32n;
+const RANDOM_32_BIT_MASK = 0xffffffffn;
+const RANDOM_LCG_MULTIPLIER = 6364136223846793005n;
+const RANDOM_LCG_INCREMENT = 1442695040888963407n;
+const RANDOM_HASH_OFFSET = 1469598103934665603n;
+const RANDOM_HASH_PRIME = 1099511628211n;
+const RANDOM_HASH_SEED_XOR = 0x9e3779b97f4a7c15n;
+const RANDOM_EVAL_MIN_VALUE = 2n;
+const RANDOM_EVAL_VALUE_RANGE = 96n;
+/**
+ * Public API for multivariate integer GCD in the canonical `MultiPoly` representation.
+ */
+function zippelGCDMulti(f, g, vars, opts = {}) {
+    return zippelGCD(f, g, vars, opts);
+}
+/**
+ * Compute the greatest common divisor of two multivariate integer polynomials.
+ *
+ * @remarks
+ * This is a Zippel/Wang-style approach:
+ *  - reduce to modular images (Fp)
+ *  - evaluate/specialize variables to univariate instances
+ *  - lift/interpolate back to a multivariate gcd
+ */
+function zippelGCD(f, g, vars, opts = {}) {
+    if (vars.length === 0) {
+        throw new Error('zippelGCD: no variables');
+    }
+    const fNorm = (0, poly_1.mvNormalize)(f);
+    const gNorm = (0, poly_1.mvNormalize)(g);
+    // Handle zero cases up front
+    if (fNorm.terms.size === 0 && gNorm.terms.size === 0) {
+        return MultiPoly_1.MultiPoly.zero();
+    }
+    if (fNorm.terms.size === 0) {
+        return normalizeSignLex(gNorm, vars);
+    }
+    if (gNorm.terms.size === 0) {
+        return normalizeSignLex(fNorm, vars);
+    }
+    // Remove coefficient content first
+    const F = (0, poly_1.mvDivideByCoeffContent)(fNorm);
+    const G = (0, poly_1.mvDivideByCoeffContent)(gNorm);
+    const content = (0, arith_1.gcd)(F.content, G.content);
+    // OPTIMIZATION: Detect and substitute out variables that appear in only one polynomial.
+    // Such variables cannot appear in the GCD (since the GCD must divide both polynomials).
+    // We substitute them with primes, then drop those variables and recurse.
+    {
+        const fPrimMP0 = new MultiPoly_1.MultiPoly(F.primitive.terms);
+        const gPrimMP0 = new MultiPoly_1.MultiPoly(G.primitive.terms);
+        const activeInF = fPrimMP0.variables();
+        const activeInG = gPrimMP0.variables();
+        const superfluousVars = [];
+        for (let i = 0; i < vars.length; i++) {
+            const inF = activeInF.has(i);
+            const inG = activeInG.has(i);
+            if (inF !== inG) {
+                superfluousVars.push({ idx: i, name: vars[i] });
+            }
+        }
+        if (superfluousVars.length > 0) {
+            let fReducedMP = fPrimMP0;
+            let gReducedMP = gPrimMP0;
+            const varsReduced = [...vars];
+            for (let i = 0; i < superfluousVars.length; i++) {
+                const { idx } = superfluousVars[i];
+                const prime = SUPERFLUOUS_VARIABLE_EVALUATION_PRIMES[i % SUPERFLUOUS_VARIABLE_EVALUATION_PRIMES.length];
+                fReducedMP = (0, poly_1.substituteVarIndex)(fReducedMP, idx, prime);
+                gReducedMP = (0, poly_1.substituteVarIndex)(gReducedMP, idx, prime);
+            }
+            const sortedByIdxDesc = [...superfluousVars].sort((a, b) => b.idx - a.idx);
+            for (const { idx } of sortedByIdxDesc) {
+                fReducedMP = (0, poly_1.removeVarIndex)(fReducedMP, idx);
+                gReducedMP = (0, poly_1.removeVarIndex)(gReducedMP, idx);
+                varsReduced.splice(idx, 1);
+            }
+            // Reduced to constants?
+            //
+            // IMPORTANT:
+            // At this point these constants are evaluation artifacts produced by substituting
+            // variables that occur in only one input. Their numeric gcd is NOT, in general,
+            // the polynomial gcd. Example:
+            //   gcd(x+z, y+1) should be 1, but gcd((x+17), 18) can be some accidental integer.
+            //
+            // So when everything has been reduced away, the only safe gcd to return here is
+            // the coefficient content gcd (or 1 for primitive inputs), not gcd(fConst, gConst).
+            if (varsReduced.length === 0) {
+                return MultiPoly_1.MultiPoly.constant(content === 0n ? 1n : content);
+            }
+            const fReducedMV = fReducedMP;
+            const gReducedMV = gReducedMP;
+            let reducedMainVar = opts.mainVar ?? vars[0];
+            if (!varsReduced.includes(reducedMainVar)) {
+                reducedMainVar = varsReduced[0];
+            }
+            const reducedGcd = zippelGCD(fReducedMV, gReducedMV, varsReduced, {
+                ...opts,
+                mainVar: reducedMainVar,
+            });
+            let outMP = reducedGcd.clone();
+            const outVars = [...varsReduced];
+            const sortedByIdxAsc = [...superfluousVars].sort((a, b) => a.idx - b.idx);
+            for (const { idx, name } of sortedByIdxAsc) {
+                outMP = (0, poly_1.addVarIndex)(outMP, idx);
+                outVars.splice(idx, 0, name);
+            }
+            let result = outMP;
+            if (content !== 1n && content !== 0n) {
+                result = (0, poly_1.scalePoly)(result, content);
+            }
+            return normalizeSignLex((0, poly_1.mvNormalize)(result), vars);
+        }
+    }
+    const mainVar = opts.mainVar ?? vars[0];
+    const maxTries = opts.maxTries ?? DEFAULT_ZIPPEL_MAX_TRIES;
+    const fPrimMP = new MultiPoly_1.MultiPoly(F.primitive.terms);
+    const gPrimMP = new MultiPoly_1.MultiPoly(G.primitive.terms);
+    // 1) Find a "good" specialization to get a correct univariate gcd in mainVar
+    let baseValues = null;
+    let hBase = null;
+    const gcdDegCounts = new Map();
+    let degFMain = -1;
+    let degGMain = -1;
+    for (let t = 0; t < maxTries; t++) {
+        const values = randomEvalPoint(vars, mainVar, t);
+        const fu = evalToUnivariate(fPrimMP, vars, mainVar, values);
+        const gu = evalToUnivariate(gPrimMP, vars, mainVar, values);
+        if (uniIsZeroBig(fu) || uniIsZeroBig(gu)) {
+            continue;
+        }
+        const dF = fu.length - 1;
+        const dG = gu.length - 1;
+        if (degFMain < 0) {
+            degFMain = dF;
+            degGMain = dG;
+        }
+        if (dF !== degFMain || dG !== degGMain) {
+            continue;
+        }
+        try {
+            const hu = (0, poly_1.zNormalizePrimitiveSign)((0, poly_1.zGcdFull)(fu, gu)).primitive;
+            const hdeg = hu.length - 1;
+            if (hdeg <= 0) {
+                continue;
+            }
+            const prev = gcdDegCounts.get(hdeg) ?? 0;
+            const next = prev + 1;
+            gcdDegCounts.set(hdeg, next);
+            if (next >= 2 && (!hBase || hdeg > hBase.length - 1)) {
+                baseValues = values;
+                hBase = (0, poly_1.zNormalizePrimitiveSign)(hu).primitive;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (!baseValues || !hBase) {
+        if (opts.throwOnBudget) {
+            const degrees = {};
+            for (const [deg, cnt] of gcdDegCounts.entries()) {
+                degrees[String(deg)] = cnt;
+            }
+            throw new arith_1.GcdBudgetExceededError('zippelGCD: could not find a good specialization point within budget', {
+                stage: 'base-specialization',
+                vars: [...vars],
+                mainVar,
+                maxTries,
+                degFMain,
+                degGMain,
+                gcdDegreeHistogram: degrees,
+            });
+        }
+        return MultiPoly_1.MultiPoly.constant(content === 0n ? 1n : content);
+    }
+    const mainIdx = vars.indexOf(mainVar);
+    const otherVars = vars.filter(v => v !== mainVar);
+    const hDeg = hBase.length - 1;
+    function sameUni(a, b) {
+        const aa = (0, poly_1.zNormalizePrimitiveSign)(a).primitive;
+        const bb = (0, poly_1.zNormalizePrimitiveSign)(b).primitive;
+        if (aa.length !== bb.length) {
+            return false;
+        }
+        for (let i = 0; i < aa.length; i++) {
+            if (aa[i] !== bb[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function verifyCandidate(Hcand) {
+        for (let k = 0; k < CANDIDATE_VERIFICATION_SAMPLES; k++) {
+            const values = randomEvalPoint(vars, mainVar, CANDIDATE_VERIFICATION_SEED_BASE + k);
+            const fu = evalToUnivariate(fPrimMP, vars, mainVar, values);
+            const gu = evalToUnivariate(gPrimMP, vars, mainVar, values);
+            if (uniIsZeroBig(fu) || uniIsZeroBig(gu)) {
+                continue;
+            }
+            const hu = (0, poly_1.zNormalizePrimitiveSign)((0, poly_1.zGcdFull)(fu, gu)).primitive;
+            if (hu.length - 1 !== hDeg) {
+                return false;
+            }
+            const Hu = evalToUnivariate(Hcand, vars, mainVar, values);
+            if (!sameUni(Hu, hu)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    let best = null;
+    for (let attempt = 0; attempt < FALLBACK_SPECIALIZATION_ATTEMPTS; attempt++) {
+        const coeffPolys = new Array(hDeg + 1);
+        for (let d = 0; d <= hDeg; d++) {
+            coeffPolys[d] = MultiPoly_1.MultiPoly.zero();
+        }
+        // Each sampled point produces the complete univariate GCD. Reuse that result for
+        // every coefficient instead of recomputing the same GCD hDeg + 1 times.
+        const gcdSampleSets = new Map();
+        for (let d = 0; d <= hDeg; d++) {
+            let polyDmv = null;
+            for (let r = 0; r < 4 && !polyDmv; r++) {
+                let gcdSamples = gcdSampleSets.get(r);
+                if (!gcdSamples) {
+                    gcdSamples = sampleGcdAcrossPoints(F.primitive, G.primitive, vars, mainVar, Math.min(maxTries * (r + 1), MAX_SCHEDULED_GRID_SAMPLES), attempt * FALLBACK_ATTEMPT_SEED_STRIDE + r * FALLBACK_ROUND_SEED_STRIDE, opts.gridMap);
+                    gcdSampleSets.set(r, gcdSamples);
+                }
+                const samples = gcdSamples.map(sample => ({
+                    values: sample.values,
+                    y: d < sample.coefficients.length ? sample.coefficients[d] : 0n,
+                }));
+                try {
+                    polyDmv = interpolateCoeffAsMV(vars, otherVars, samples);
+                }
+                catch {
+                    polyDmv = null;
+                }
+            }
+            if (!polyDmv) {
+                throw new Error('zippelGCD: coefficient interpolation failed (non-integer)');
+            }
+            coeffPolys[d] = polyDmv.clone();
+        }
+        let Hmp = MultiPoly_1.MultiPoly.zero();
+        for (let d = 0; d <= hDeg; d++) {
+            if (coeffPolys[d].terms.size === 0) {
+                continue;
+            }
+            if (d === 0) {
+                Hmp = (0, poly_1.addPoly)(Hmp, coeffPolys[d]);
+                continue;
+            }
+            const dense = new Array(vars.length).fill(0);
+            dense[mainIdx] = d;
+            const mon = new MultiPoly_1.MultiPoly();
+            mon.terms.set((0, poly_1.denseToKey)(dense), 1n);
+            Hmp = (0, poly_1.addPoly)(Hmp, (0, poly_1.mulPoly)(coeffPolys[d], mon));
+        }
+        if (content !== 1n && content !== 0n) {
+            Hmp = (0, poly_1.scalePoly)(Hmp, content);
+        }
+        Hmp = (0, poly_1.mvNormalize)(Hmp);
+        Hmp = stripParamFactorFromMainVarCoeffsMP(Hmp, vars, mainVar);
+        let H = Hmp.clone();
+        H = normalizeSignLex(H, vars);
+        best = H;
+        if (verifyCandidate(H)) {
+            return H;
+        }
+    }
+    return best ? best : (0, poly_1.mvNormalize)(MultiPoly_1.MultiPoly.zero());
+}
+function sampleGcdAcrossPoints(f, g, vars, mainVar, maxTries, seedOffset, gridMap) {
+    const out = [];
+    const otherVars = vars.filter(v => v !== mainVar);
+    function maxDegInVar(p, v) {
+        const idx = vars.indexOf(v);
+        if (idx < 0) {
+            return 0;
+        }
+        let m = 0;
+        for (const k of p.terms.keys()) {
+            const exp = (0, MultiPoly_1.keyToExp)(k);
+            const d = exp.get(idx) ?? 0;
+            if (d > m) {
+                m = d;
+            }
+        }
+        return m;
+    }
+    function pointsForVar(v) {
+        const fromMap = gridMap?.[v];
+        if (fromMap && fromMap.length) {
+            return fromMap.slice();
+        }
+        // Use small primes as evaluation points to minimize gcd issues.
+        // When evaluating ax² - b at points where gcd(a,b) > 1, the univariate
+        // GCD content varies, breaking interpolation. Using primes helps avoid this.
+        if (otherVars.length && v === otherVars[0]) {
+            const bound = Math.min(maxDegInVar(f, v), maxDegInVar(g, v));
+            const n = Math.min(Math.max(bound + 1, MIN_INTERPOLATION_POINTS), MAX_INTERPOLATION_POINTS); // cap to avoid combinatorial blowup
+            return INTERPOLATION_SAMPLE_PRIMES.slice(0, n);
+        }
+        return INTERPOLATION_SAMPLE_PRIMES.slice(0, MIN_INTERPOLATION_POINTS);
+    }
+    let expectedDegF = -1;
+    let expectedDegG = -1;
+    let expectedDegH = -1;
+    // Build a small cartesian grid over otherVars, capped by maxTries.
+    const cur = {};
+    function rec(i, budget) {
+        if (budget.n <= 0) {
+            return;
+        }
+        if (i === otherVars.length) {
+            const values = { ...cur };
+            const fu = evalToUnivariate(f, vars, mainVar, values);
+            const gu = evalToUnivariate(g, vars, mainVar, values);
+            if (uniIsZeroBig(fu) || uniIsZeroBig(gu)) {
+                return;
+            }
+            const dF = fu.length - 1;
+            const dG = gu.length - 1;
+            // Prefer maximal degrees - degree drops indicate bad evaluation points
+            if (dF > expectedDegF || dG > expectedDegG) {
+                expectedDegF = Math.max(expectedDegF, dF);
+                expectedDegG = Math.max(expectedDegG, dG);
+                out.length = 0;
+                expectedDegH = -1;
+            }
+            if (expectedDegF < 0) {
+                expectedDegF = dF;
+                expectedDegG = dG;
+            }
+            if (dF !== expectedDegF || dG !== expectedDegG) {
+                return;
+            }
+            // Compute the GCD
+            const huFull = (0, poly_1.zGcdFull)(fu, gu);
+            const hdeg = huFull.length - 1;
+            // Prefer the *maximal* gcd degree seen so far.
+            if (expectedDegH < 0 || hdeg > expectedDegH) {
+                expectedDegH = hdeg;
+                out.length = 0;
+            }
+            if (hdeg !== expectedDegH) {
+                return;
+            }
+            out.push({ values, coefficients: huFull });
+            budget.n--;
+            return;
+        }
+        const v = otherVars[i];
+        for (const pt of pointsForVar(v)) {
+            cur[v] = pt;
+            rec(i + 1, budget);
+            if (budget.n <= 0) {
+                break;
+            }
+        }
+    }
+    rec(0, { n: maxTries });
+    // Fallback: if grid didn't produce enough, use independent random points.
+    for (let t = 0; out.length < Math.min(6, maxTries) && t < maxTries * 2; t++) {
+        const values = randomEvalPoint(vars, mainVar, seedOffset + 50000 + t);
+        const fu = evalToUnivariate(f, vars, mainVar, values);
+        const gu = evalToUnivariate(g, vars, mainVar, values);
+        if (uniIsZeroBig(fu) || uniIsZeroBig(gu)) {
+            continue;
+        }
+        const dF = fu.length - 1;
+        const dG = gu.length - 1;
+        if (dF > expectedDegF || dG > expectedDegG) {
+            expectedDegF = Math.max(expectedDegF, dF);
+            expectedDegG = Math.max(expectedDegG, dG);
+            out.length = 0;
+            expectedDegH = -1;
+        }
+        if (expectedDegF < 0) {
+            expectedDegF = dF;
+            expectedDegG = dG;
+        }
+        if (dF !== expectedDegF || dG !== expectedDegG) {
+            continue;
+        }
+        const hu = (0, poly_1.zGcdFull)(fu, gu);
+        const hdeg = hu.length - 1;
+        if (expectedDegH < 0 || hdeg > expectedDegH) {
+            expectedDegH = hdeg;
+            out.length = 0;
+        }
+        if (hdeg !== expectedDegH) {
+            continue;
+        }
+        out.push({ values, coefficients: hu });
+    }
+    if (out.length === 0) {
+        return [{ values: randomEvalPoint(vars, mainVar, 9999), coefficients: [] }];
+    }
+    return out;
+}
+// Dense variable-by-variable interpolation for coeff(otherVars).
+// This is the “practical” piece: it assumes low degrees and uses exact integer divisions.
+// For bigger/heavier cases, you’ll want modular interpolation instead.
+function interpolateCoeffAsMV(vars, otherVars, samples) {
+    // True nested interpolation over otherVars with rational intermediate coeffs.
+    function groupKey(rest, values) {
+        return rest.map(v => `${v}=${values[v] ?? 0n}`).join('|');
+    }
+    function recInterpolate(varsLeft, ss) {
+        if (varsLeft.length === 0) {
+            const p = zeroMVF(vars);
+            p.terms.set((0, poly_1.denseToKey)(new Array(vars.length).fill(0)), ss[0]?.y ?? (0, rational_1.rat)(0n));
+            return p;
+        }
+        const x = varsLeft[0];
+        const rest = varsLeft.slice(1);
+        const idx = vars.indexOf(x);
+        if (idx < 0) {
+            throw new Error('interpolateCoeffAsMV: missing var index');
+        }
+        // group by rest assignments
+        const groups = new Map();
+        for (const s of ss) {
+            const k = groupKey(rest, s.values);
+            const arr = groups.get(k) ?? [];
+            arr.push({ x: s.values[x] ?? 0n, y: s.y, values: s.values });
+            groups.set(k, arr);
+        }
+        // For each group, interpolate univariate in x to obtain coeffs (Rat[]) at that rest point.
+        // IMPORTANT: do this in two passes so early groups are padded if a later group increases max degree.
+        const groupUnis = [];
+        let maxDeg = 0;
+        for (const arr of groups.values()) {
+            arr.sort((a, b) => (a.x < b.x ? -1 : a.x > b.x ? 1 : 0));
+            const pts = arr.map(p => ({ x: p.x, y: p.y }));
+            const uni = (0, rational_1.interpolateUnivariateRat)(pts);
+            maxDeg = Math.max(maxDeg, uni.length - 1);
+            groupUnis.push({ values: arr[0].values, uni });
+        }
+        const coeffSamples = new Array(maxDeg + 1);
+        for (let d = 0; d <= maxDeg; d++) {
+            coeffSamples[d] = [];
+        }
+        for (const gu of groupUnis) {
+            for (let d = 0; d <= maxDeg; d++) {
+                coeffSamples[d].push({
+                    values: gu.values,
+                    y: d < gu.uni.length ? gu.uni[d] : (0, rational_1.rat)(0n),
+                });
+            }
+        }
+        let outF = zeroMVF(vars);
+        for (let d = 0; d < coeffSamples.length; d++) {
+            const sub = recInterpolate(rest, coeffSamples[d]);
+            outF = addMVF(outF, shiftMVF(sub, idx, d));
+        }
+        return outF;
+    }
+    const ssRat = samples.map(s => ({ values: s.values, y: (0, rational_1.rat)(s.y) }));
+    const polyF = recInterpolate(otherVars, ssRat);
+    return mvfToInt(polyF);
+}
+function zeroMVF(vars) {
+    return { vars, terms: new Map() };
+}
+function addMVF(a, b) {
+    const out = { vars: a.vars, terms: new Map(a.terms) };
+    (0, poly_1.mapCombineInPlace)(out.terms, b.terms, (x, y) => (0, rational_1.ratAdd)(x, y), v => v.n === 0n, () => (0, rational_1.rat)(0n));
+    return out;
+}
+function shiftMVF(p, varIdx, pow) {
+    const out = zeroMVF(p.vars);
+    for (const [k, c] of p.terms.entries()) {
+        const exp = (0, MultiPoly_1.keyToExp)(k);
+        exp.set(varIdx, (exp.get(varIdx) ?? 0) + pow);
+        out.terms.set((0, MultiPoly_1.expToKey)(exp), c);
+    }
+    return out;
+}
+function mvfToInt(p) {
+    const out = MultiPoly_1.MultiPoly.zero();
+    let lcmDen = 1n;
+    for (const c of p.terms.values()) {
+        if (c.n === 0n) {
+            continue;
+        }
+        const d = c.d < 0n ? -c.d : c.d;
+        lcmDen = (lcmDen / (0, arith_1.gcd)(lcmDen, d)) * d;
+    }
+    for (const [k, c] of p.terms.entries()) {
+        if (c.n === 0n) {
+            continue;
+        }
+        const scaled = (0, rational_1.ratMul)(c, (0, rational_1.rat)(lcmDen));
+        if (scaled.d !== 1n) {
+            throw new Error('interpolateCoeffAsMV: failed to clear denominators');
+        }
+        out.terms.set(k, scaled.n);
+    }
+    return (0, poly_1.mvNormalize)(out);
+}
+function randomEvalPoint(vars, mainVar, seed) {
+    const values = {};
+    let state = BigInt(seed) ^ RANDOM_HASH_SEED_XOR;
+    function nextU32() {
+        state = (state * RANDOM_LCG_MULTIPLIER + RANDOM_LCG_INCREMENT) & RANDOM_64_BIT_MASK;
+        return (state >> RANDOM_32_BIT_SHIFT) & RANDOM_32_BIT_MASK;
+    }
+    function hashVar(s) {
+        let h = RANDOM_HASH_OFFSET;
+        for (let i = 0; i < s.length; i++) {
+            h ^= BigInt(s.charCodeAt(i));
+            h *= RANDOM_HASH_PRIME;
+            h &= RANDOM_64_BIT_MASK;
+        }
+        return h;
+    }
+    for (const v of vars) {
+        if (v === mainVar) {
+            continue;
+        }
+        state ^= hashVar(v);
+        const r = nextU32();
+        values[v] = RANDOM_EVAL_MIN_VALUE + (r % RANDOM_EVAL_VALUE_RANGE);
+    }
+    return values;
+}
+// Treat H as a univariate in mainVar with coefficients in Z[otherVars].
+// Compute gcd of all coefficient-polynomials in otherVars and divide it out.
+// This removes spurious parameter-only scaling factors that survive specialization.
+function stripParamFactorFromMainVarCoeffsMP(H, vars, mainVar) {
+    const mainIdx = vars.indexOf(mainVar);
+    if (mainIdx < 0) {
+        return H;
+    }
+    const otherVars = vars.filter(v => v !== mainVar);
+    if (otherVars.length === 0) {
+        return H;
+    }
+    let maxDeg = 0;
+    for (const k of H.terms.keys()) {
+        const exp = (0, MultiPoly_1.keyToExp)(k);
+        const d = exp.get(mainIdx) ?? 0;
+        if (d > maxDeg) {
+            maxDeg = d;
+        }
+    }
+    const coeffs = new Array(maxDeg + 1);
+    for (let d = 0; d <= maxDeg; d++) {
+        coeffs[d] = MultiPoly_1.MultiPoly.zero();
+    }
+    for (const [k, c] of H.terms.entries()) {
+        const exp = (0, MultiPoly_1.keyToExp)(k);
+        const d = exp.get(mainIdx) ?? 0;
+        const expOther = new Map(exp);
+        expOther.delete(mainIdx);
+        const kk = (0, MultiPoly_1.expToKey)(expOther);
+        coeffs[d].terms.set(kk, (coeffs[d].terms.get(kk) ?? 0n) + c);
+    }
+    for (const p of coeffs) {
+        p.trim();
+    }
+    let Gc = null;
+    for (const cpoly of coeffs) {
+        if (cpoly.terms.size === 0) {
+            continue;
+        }
+        Gc = Gc ? zippelGCDMulti(Gc, cpoly, vars, { mainVar: otherVars[0], maxTries: 24 }) : cpoly;
+        if (Gc.terms.size !== 0) {
+            const gcn = (0, poly_1.mvNormalizePrimitiveSignLex)(Gc).primitive;
+            if (gcn.terms.size === 1 && (gcn.terms.get('') ?? 0n) === 1n) {
+                Gc = gcn;
+                break;
+            }
+        }
+    }
+    if (!Gc) {
+        return H;
+    }
+    Gc = (0, poly_1.mvNormalizePrimitiveSignLex)(Gc).primitive;
+    if (Gc.terms.size === 0) {
+        return H;
+    }
+    if (Gc.terms.size === 1 && (Gc.terms.get('') ?? 0n) === 1n) {
+        return H;
+    }
+    const qCoeffs = [];
+    for (const cpoly of coeffs) {
+        if (cpoly.terms.size === 0) {
+            qCoeffs.push(cpoly);
+            continue;
+        }
+        const q = (0, poly_1.mvExactDiv)(cpoly, Gc);
+        if (!q) {
+            return H;
+        }
+        qCoeffs.push(q);
+    }
+    const Hq = MultiPoly_1.MultiPoly.zero();
+    for (let d = 0; d < qCoeffs.length; d++) {
+        const q = qCoeffs[d];
+        if (q.terms.size === 0) {
+            continue;
+        }
+        for (const [kk, c] of q.terms.entries()) {
+            const exp = (0, MultiPoly_1.keyToExp)(kk);
+            const expFull = new Map(exp);
+            if (d !== 0) {
+                expFull.set(mainIdx, d);
+            }
+            const kfull = (0, MultiPoly_1.expToKey)(expFull);
+            Hq.terms.set(kfull, (Hq.terms.get(kfull) ?? 0n) + c);
+        }
+    }
+    Hq.trim();
+    return Hq;
+}
+// ---------------------------
+// Evaluation to univariate
+// ---------------------------
+function evalToUnivariate(p, vars, mainVar, values) {
+    const mainIdx = vars.indexOf(mainVar);
+    if (mainIdx < 0) {
+        throw new Error(`evalToUnivariate: main var ${mainVar} not in vars`);
+    }
+    let deg = 0;
+    for (const k of p.terms.keys()) {
+        const exp = (0, MultiPoly_1.keyToExp)(k);
+        deg = Math.max(deg, exp.get(mainIdx) ?? 0);
+    }
+    const coeffs = new Array(deg + 1).fill(0n);
+    for (const [k, c] of p.terms.entries()) {
+        const exp = (0, MultiPoly_1.keyToExp)(k);
+        const d = exp.get(mainIdx) ?? 0;
+        let m = 1n;
+        for (let i = 0; i < vars.length; i++) {
+            if (i === mainIdx) {
+                continue;
+            }
+            const vname = vars[i];
+            const val = values[vname];
+            if (val === undefined) {
+                throw new Error(`evalToUnivariate: missing value for ${vname}`);
+            }
+            m *= (0, arith_1.pow)(val, BigInt(exp.get(i) ?? 0));
+        }
+        coeffs[d] += c * m;
+    }
+    while (coeffs.length > 1 && coeffs[coeffs.length - 1] === 0n) {
+        coeffs.pop();
+    }
+    return coeffs;
+}
+function uniIsZeroBig(a) {
+    return a.length === 0 || (a.length === 1 && a[0] === 0n);
+}
+function normalizeSignLex(p, vars) {
+    if (p.terms.size === 0) {
+        return p;
+    }
+    const lt = (0, poly_1.leadTermLex)(p, vars.length);
+    if (!lt || lt.coeff >= 0n) {
+        return p;
+    }
+    return (0, poly_1.scalePoly)(p, -1n);
+}