import { Q } from "./Rationals"; import { MPoly, Monom } fro...

Prompt

import { Q } from "./Rationals"; import { MPoly, Monom } from "./MultivariatePoly"; function monomTotalDegree(e: Monom): number { return e.reduce((a, b) => a + b, 0); } function monomLexCmp(a: Monom, b: Monom): number { for (let i = 0; i < Math.max(a.length, b.length); i++) { const ai = i < a.length ? a[i] : 0; const bi = i < b.length ? b[i] : 0; if (ai !== bi) return bi - ai; } return 0; } function monomGrlexCmp(a: Monom, b: Monom): number { const da = monomTotalDegree(a); const db = monomTotalDegree(b); if (da !== db) return db - da; return monomLexCmp(a, b); } function monomGrevlexCmp(a: Monom, b: Monom): number { const da = monomTotalDegree(a); const db = monomTotalDegree(b); if (da !== db) return db - da; for (let i = a.length - 1; i >= 0; i--) { const ai = a[i]; const bi = b[i]; if (ai !== bi) return ai - bi; } return 0; } export type MonomOrder = "lex" | "grlex" | "grevlex"; export function monomCmp(a: Monom, b: Monom, order: MonomOrder): number { if (order === "lex") return monomLexCmp(a, b); if (order === "grlex") return monomGrlexCmp(a, b); return monomGrevlexCmp(a, b); } function monomLCM(a: Monom, b: Monom, n: number): Monom { const r: number[] = []; for (let i = 0; i < n; i++) { r.push(Math.max(i < a.length ? a[i] : 0, i < b.length ? b[i] : 0)); } return r; } function monomDiv(a: Monom, b: Monom, n: number): Monom { const r: number[] = []; for (let i = 0; i < n; i++) { r.push((i < a.length ? a[i] : 0) - (i < b.length ? b[i] : 0)); } return r; } function monomIsDivisibleBy(a: Monom, b: Monom): boolean { for (let i = 0; i < Math.max(a.length, b.length); i++) { const ai = i < a.length ? a[i] : 0; const bi = i < b.length ? b[i] : 0; if (ai < bi) return false; } return true; } export function leadingTerm(p: MPoly, order: MonomOrder): { e: Monom; c: Q } | null { if (p.isZero()) return null; let bestE: Monom | null = null; let bestC: Q = Q.zero; for (const [k, v] of p.terms) { const e = MPoly.parseKey(k, p.nVars); if (bestE === null || monomCmp(e, bestE, order) < 0) { bestE = e; bestC = v; } } return { e: bestE!, c: bestC }; } export function polyNormalize(p: MPoly): MPoly { const lt = leadingTerm(p, "grevlex"); if (!lt) return p; const inv = lt.c.inv(); return p.mulScalar(inv); } export function sPoly(f: MPoly, g: MPoly, order: MonomOrder): MPoly { const ltf = leadingTerm(f, order); const ltg = leadingTerm(g, order); if (!ltf || !ltg) return MPoly.zero(f.nVars, f.vars); const n = f.nVars; const lcm = monomLCM(ltf.e, ltg.e, n); const ef = monomDiv(lcm, ltf.e, n); const eg = monomDiv(lcm, ltg.e, n); const cf = ltg.c; const cg = ltf.c; let fTerm = f; for (let i = 0; i < n; i++) { for (let j = 0; j < ef[i]; j++) { fTerm = fTerm.mul(MPoly.var(n, i, f.vars)); } } fTerm = fTerm.mulScalar(cf); let gTerm = g; for (let i = 0; i < n; i++) { for (let j = 0; j < eg[i]; j++) { gTerm = gTerm.mul(MPoly.var(n, i, g.vars)); } } gTerm = gTerm.mulScalar(cg); return fTerm.sub(gTerm); } export function divide(p: MPoly, divisors: MPoly[], order: MonomOrder): { quotients: MPoly[]; remainder: MPoly; } { const n = p.nVars; const vars = p.vars; const qs = divisors.map(() => MPoly.zero(n, vars)); let r = MPoly.zero(n, vars); let h = p; const divLTs = divisors.map((d) => leadingTerm(d, order)); let guard = 0; while (!h.isZero() && guard < 100000) { guard++; const lth = leadingTerm(h, order)!; let divided = false; for (let i = 0; i < divisors.length; i++) { const ltd = divLTs[i]; if (!ltd) continue; if (monomIsDivisibleBy(lth.e, ltd.e)) { const e = monomDiv(lth.e, ltd.e, n); const c = lth.c.mul(ltd.c.inv()); const term = MPoly.fromMonom(n, e, c, vars); qs[i] = qs[i].add(term); let prod = divisors[i]; for (let k = 0; k < n; k++) { for (let j = 0; j < e[k]; j++) { prod = prod.mul(MPoly.var(n, k, vars)); } } prod = prod.mulScalar(c); h = h.sub(prod); divided = true; break; } } if (!divided) { const monomPoly = MPoly.fromMonom(n, lth.e, lth.c, vars); r = r.add(monomPoly); h = h.sub(monomPoly); } } return { quotients: qs, remainder: r }; } export function groebnerBasis(F: MPoly[], order: MonomOrder = "grevlex", maxSteps = 2000): MPoly[] { const n = F[0]?.nVars ?? 0; if (n === 0) return []; let G: MPoly[] = F.filter((f) => !f.isZero()).map((f) => polyNormalize(f)); const pairs: [number, number][] = []; for (let i = 0; i < G.length; i++) { for (let j = i + 1; j < G.length; j++) { pairs.push([i, j]); } } let steps = 0; while (pairs.length > 0 && steps < maxSteps) { steps++; const [i, j] = pairs.shift()!; const f = G[i]; const g = G[j]; const sp = sPoly(f, g, order); const { remainder } = divide(sp, G, order); if (!remainder.isZero()) { const nrm = polyNormalize(remainder); if (nrm.isOne()) { return [MPoly.one(n, F[0]?.vars)]; } for (let k = 0; k < G.length; k++) { pairs.push([k, G.length]); } G.push(nrm); } } return G; } export function reduceGroebnerBasis(G: MPoly[], order: MonomOrder): MPoly[] { let result: MPoly[] = []; const current = G.slice(); for (let i = 0; i < current.length; i++) { const others = [...current.slice(0, i), ...current.slice(i + 1)]; const { remainder } = divide(current[i], others, order); if (!remainder.isZero()) { result.push(polyNormalize(remainder)); } } let changed = true; while (changed) { changed = false; for (let i = 0; i < result.length; i++) { const others = [...result.slice(0, i), ...result.slice(i + 1)]; const { remainder } = divide(result[i], others, order); if (remainder.isZero()) { result = [...result.slice(0, i), ...result.slice(i + 1)]; changed = true; break; } const lt = leadingTerm(remainder, order); if (lt && !lt.c.isOne()) { result[i] = remainder.mulScalar(lt.c.inv()); } else { result[i] = remainder; } } } return result; } 1. Silent loss of data in divide: When the 100000-iteration limit is reached with h still nonzero, h is discarded. The returned result can violate p = Σ(quotient[i] × divisor[i]) + remainder, corrupting downstream Gröbner-basis calculations. 2. Uncertified output from groebnerBasis: Reaching maxSteps with pending pairs silently returns a potentially incomplete, non-Gröbner generating set. No completion status distinguishes this from success. Nonpositive or NaN budgets can bypass pair processing entirely. 3. Ideal destruction in reduceGroebnerBasis: The initial pass reduces every polynomial against the unchanged original list. Mutually redundant generators can therefore all disappear. For example, [x, x] becomes []; the valid Gröbner basis [x, x+y, y] becomes [y] under lex order. 4. Incomplete interreduction: reduceGroebnerBasis sets changed only when deleting a polynomial, not when replacing one with a different nonzero remainder. For incomplete/non-Gröbner input, later replacements can make earlier entries reducible without triggering another pass. For example, [x³+2x+1, x²+1] produces [x+1, 1] rather than . 5. Incorrect zero-variable case: groebnerBasis treats nVars === 0 like empty input. A nonempty zero-variable input containing a nonzero constant generates the unit ideal and should yield , not []. 6. Broken grevlex comparison for unequal lengths: monomGrevlexCmp traverses only a.length and does not zero-pad either operand. Equal-degree monomials of different lengths can produce incorrect comparisons or NaN; for example, comparing against produces NaN, while reversing them produces 0.[0][1] 7. Order-normalization inconsistency: polyNormalize always uses "grevlex", regardless of the order requested by groebnerBasis. Consequently, lex/grlex results need not be monic in their selected order. This is a normalization issue; nonzero scalar rescaling alone does not invalidate a Gröbner basis. 8. Unchecked polynomial-ring compatibility: The routines do not explicitly require matching nVars, variable names, and variable ordering. Exponent construction uses one operand’s arity, so incompatible inputs can truncate exponents, misinterpret variables, or fail downstream unless MPoly enforces compatibility. 9. Unsafe total-degree arithmetic: monomTotalDegree uses JavaScript number addition without checking exactness. Total degrees above Number.MAX_SAFE_INTEGER can be rounded—even when every individual exponent is a safe integer—producing incorrect grlex/grevlex ordering. 10. Expensive monomial multiplication: sPoly and divide construct monomial multiples through repeated single-variable multiplications, repeatedly allocating variable polynomials and intermediate products. Work scales with exponent sums, allowing a single iteration to consume excessive resources despite the outer iteration limits. 11. Expensive pair management: Eagerly constructing all pairs requires quadratic storage in the basis size, and repeated pairs.shift() calls can require linear-time dequeues. Initial pair construction occurs before the maxSteps check, so that limit does not bound setup costs. 12. Repeated full-term scans: leadingTerm scans and reparses every term on each division iteration. Even divide(p, [], order) repeatedly scans the shrinking polynomial, performing quadratic term-selection work for inputs completed before the cutoff. 13. Conditional type-import compilation error: If Monom is a type-only export and verbatimModuleSyntax is enabled, importing it through import { MPoly, Monom } fails; it requires a type-only import. 14. Conditional indexed-access compilation errors: With strictNullChecks and noUncheckedIndexedAccess enabled, accesses such as a[i], b[i], ef[i], qs[i], divisors[i], G[i], and current[i] remain potentially undefined. Their arithmetic, method calls, and argument uses cause compilation errors. 15. groebnerBasis, unit-ideal shortcut (inconsistency): The shortcut only applies to S-polynomial remainders. Constants or duplicates in the input are not handled: - returns.[1][2][3] - [x, 5] returns [x, 1] instead of . - Duplicates are kept and later trigger bug #1. 16. monomDiv (no validation): Nothing guards against negative exponents, so it returns an invalid monomial when b ∤ a. 17. monomCmp, exported (API hazard): The comparator contract is inverted: a negative result means a is the larger monomial. This is undocumented, the opposite of the usual convention, and easy to misuse (e.g. with sort). 18. monomCmp (no validation): Unknown order values silently fall back to grevlex; there is no exhaustive check. 19. sPoly, exported (non-standard definition): It returns LC(f)·LC(g)·S(f,g) instead of the standard S-polynomial. 20. reduceGroebnerBasis (unchecked assumptions): - It silently assumes G is already a Gröbner basis for the same order, with no validation. - order has no default, while groebnerBasis defaults to "grevlex", which invites mismatched orders. 21. reduceGroebnerBasis (non-canonical output): The output is not sorted, so the unique reduced basis comes out in an input-dependent order. 22. reduceGroebnerBasis (redundant work): const current = G.slice() is a pointless copy, since current is never mutated. The first-loop polyNormalize is wasted work because elements are re-normalized later. 23. groebnerBasis (lint): let G is never reassigned and should be const (prefer-const). 24. groebnerBasis, F?.vars (unnecessary / possible type error): The optional chaining is unnecessary because F must exist at that point. Under noUncheckedIndexedAccess the type is string[] | undefined, which may be incompatible with MPoly.one. 25. leadingTerm, Q.zero (possible type error): Q.zero is used as a property, while MPoly.zero()/MPoly.one() are called as methods. If Q.zero is a method, this is a type error. The initial value is dead anyway. 26. Implicit MPoly assumptions (possible runtime errors): p.terms must be an iterable Map, and zero coefficients must never be stored. Otherwise: - isZero() may never become true. - leadingTerm can return a 0 coefficient, so inv() divides by zero. - divide may spin until the guard. 27. Performance, wasted work in divide: It computes quotients that no caller uses. The remainder is built with repeated single-term add/sub, which is quadratic. 28. Performance, pair handling: There are no Buchberger criteria (coprime leading monomials, chain criterion), causing many useless S-polynomial reductions. 29. Performance, reduceGroebnerBasis restarts: It restarts the whole pass after every removal, giving a quadratic number of divisions. 30. Lint, non-null assertions: bestE!, pairs.shift()! and leadingTerm(h, order)! violate no-non-null-assertion. 31. No validation that monomial exponents are nonnegative safe integers. 32. Negative, fractional, NaN, Infinity, or sparse exponents can break comparisons, divisibility, and multiplication loops. 33. sPoly(0, g) returns zero using f’s ring metadata, not necessarily g’s. 34. cf / cg are named backwards: cf = ltg.c (LC of g) and cg = ltf.c (LC of f). Send back the complete code with all the fixes. Fix each of the listed errors one by one, making sure to actually correct them so that there are 0 errors remaining. Keep the original imports, since the files exist. Write out every single character; do not abbreviate anything. Fix every error. There must be exactly one file. Do not write anything else; just output the complete code, and it must not contain any comments. Never, under any circumstances, use simplified, substitute, dummy, simulated, or fake code. Write the entire file as complete, unabridged, production-ready code in a single code block. It must be 100% error-free, a complete, error-free file, and must be submitted as a downloadable file. These requirements are mandatory and must be strictly adhered to. If no list of errors is provided, you must find all the errors and fix them. If there were comments in the original code, delete them. And most importantly: YOU MUST NEVER SIMPLIFY!