Compute Engine Overrides

Overrides of compute-engine: audit (BL-389)

Scope: every place our code replaces, wraps, shadows or reimplements what compute-engine does ("compute-engine does X; we make it do Y"). A head compute-engine does not have is not an override and is left out, except where it duplicates one of its heads under another name.

Measured on the pinned compute-engine 0.186.0 and on 0.187.0 (installed under .scratch/ce187; the pin is unchanged). For each site: what bare compute-engine answers (bare.mjs), which reference examples change value with the site disabled (ablate.ts, 18,515 examples), and the commit that added it. The data and scripts stayed on the audit's build host, not in the repo.

Counts over the 435 override sites in the symbol packages, ce-patches, structures and formats:

Classification	Sites
Unwind, done in #1306	29
Unwind, listed (not removed)	2
Keep, take upstream	217
Keep, ours by design	170
Open decisions	17

Outside those sites: 49 LaTeX entries and read/write options (5 removed, 3 listed for removal, the |…| reader in flight on cardinality-by-type), 4 parseExpression passes, 27 compile, engine and option items, and 13 heads that duplicate a compute-engine head under a Wolfram name. Each has its own table below.

How the unwinds were checked: a wider input sweep with the site disabled (sweep.ts, up to 1,166 inputs per site), the owning packages' tests, vp check, and a re-evaluation of all 18,515 reference examples on the branch. It matches the baseline on 0.186; on 0.187 two slow examples flip across the 3-second budget and give their expected value when run alone. The sweep kept three candidates the first probes had marked redundant (StieltjesGamma(n, 1) for a symbolic n, Arccot(i), Conjugate of a matrix product), and found one where our wrapper was the bug: it left DirichletL(k, j, 1) unevaluated for 59 imprimitive characters that compute-engine answers.

Summary by kind

One row per kind of override. The per-site rows are in the appendix; a row's evidence adds up its sites' ablation runs (the reference examples that mention a head the site writes, re-evaluated with that site disabled).

Where	compute-engine does	We do	Classification	Measured	Upstream status
List-threading flags compute-engine already sets: analytic/declare.ts ×2, analytic/threading-113.ts, number-theory/declare.ts ×2, numerals/declare.ts, residues/declare.ts, residues/numerator-declare.ts	Declares these heads broadcastable: true itself (and Numerator/Denominator's surplus-operands exemption): Totient([2, 4, 6]) is [1, 2, 2] on a bare engine.	Set the same flag again through threadOverLists/extendHead. Removed for the 42 heads compute-engine flags; kept for Multinomial, PowerMod, PowerModList (not flagged natively) and for HarmonicNumber and KroneckerSymbol (ours).	Unwind (done)	probe-thread.mjs reads the native flag on both versions.8 sites; with a site disabled, 2 change 2 example values on 0.186 and 2 change 2 on 0.187	Nothing to file
Exact values and folds compute-engine already gives: analytic/closed-forms-113.ts ×2, analytic/constant-rounding.ts ×2, analytic/elementary-remaining.ts ×2, analytic/hyperbolic-exact.ts, analytic/special-functions-remaining.ts ×3, analytic/threading-113.ts, +4 files	Answers them: Floor(Pi^40), Max(Pi, E), Mod(Sqrt(28), 3), DirichletL(3, 2, 1), Arsech(1), Arcosh(1), Log(1/8, 2), Factorial2(-5), PolyLog(n, -1), LogGamma(PositiveInfinity), HurwitzZeta(2, 0.5), Stirling(3, 5), Totient(0), Totient(-12), GCD(20!, 10^100 + 3), Sort([]).	Wrapped the head to give the same value. Removed. Two removals change behaviour where ours was wrong: DirichletL(k, j, 1) now evaluates for an imprimitive real odd character (ours declined, 59 of 1,166 swept inputs), and LogGamma, BarnesG, LogBarnesG, DirichletEta, DirichletBeta at ComplexInfinity are compute-engine's NaN instead of our PositiveInfinity or 1.	Unwind (done)	sweep.ts and sweep2.ts, 1,964 inputs over the 12 analytic sites: no difference but the two named. The number-theory and Sort sites rest on the bare probes, the ablation and their packages' tests.17 sites; with a site disabled, 0 change 0 example values on 0.186 and 0 change 0 on 0.187	Nothing to file
Huge arguments of Sin, Cos, Tan, Sec, Csc, Cot: analytic/trig-reduction.ts	Reduces a huge exact or bignum argument mod 2π correctly: N(Sin(24^40)) is 0.400083152719766047070941915848 at 30 digits.	Reduced it ourselves in BigDecimal before the function ran (189 lines). Removed; tests/trig-reduction.test.ts stays and holds compute-engine to the values.	Unwind (done)	sweep.ts: 144 inputs, one differs in the 21st digit (compute-engine rounds it, ours truncated).1 site; with a site disabled, 0 change 0 example values on 0.186 and 0 change 0 on 0.187	Nothing to file
Writes that changed nothing: ce-patches/compute-engine/library/linear-algebra.ts, structures/carriers.ts, collections/list-heads.ts	MatrixRank is exact on integer and rational matrices (the 12 by 12 and 20 by 20 Hilbert matrices are regular); ContinuedFraction's evaluate is what runs; At is rerouted once already.	Replaced MatrixRank's evaluate with our exact elimination, reinstalled a carrier head's evaluate as a pass-through, and installed the At(Primes, n) reroute a second time. Removed; the MatrixRank JavaScript lowering stays.	Unwind (done)	3 sites; with a site disabled, 0 change 0 example values on 0.186 and 0 change 0 on 0.187	Nothing to file
Redundant, but not removed here: residues/mod-exact-constant.ts, collections/products.ts	A multi-clause Product with literal bounds evaluates natively; Mod of an exact constant answers for every exact modulus.	Product: nests the clauses, which also changes how a symbolic-bound product is held (two reference examples expect the nested form). Mod: ours adds only a float modulus (Mod(Pi, 1.5)).	Unwind (listed)	Removing the Product wrapper changes 2 example values, so it is listed, not done.2 sites; with a site disabled, 1 change 2 example values on 0.186 and 1 change 2 on 0.187	Nothing to file
ce-patches: ce-patches/compute-engine/library/integrate-polynomials.ts, ce-patches/compute-engine/library/linear-algebra.ts ×2, ce-patches/compute-engine/library/solve.ts ×2, ce-patches/compute-engine/library/special-functions.ts ×2, ce-patches/patches/agm-complex.ts, ce-patches/patches/iterator-upper-bound.ts ×2, +1 files	Integrate of a power of a polynomial stays unevaluated; Shape of a list of unknown applications is empty; Solve returns [] where complex solutions exist and ignores an Element domain; AGM and LerchPhi lose precision or decline at a float; Sum with a lone upper bound is not 1..n; MatrixRank has no JavaScript lowering.	One patch each, applied at run time and retired by tests/landed.test.ts once compute-engine ships it.	Keep, take upstream	11 sites; with a site disabled, 9 change 32 example values on 0.186 and 9 change 31 on 0.187	LerchPhi: CE#340 (closed, the patch's case still open); Zeta(0, a): CE#409 (closed, s = 0 still differs from Wolfram). The rest not filed
Numerics: N in doubles, or declining, at arguments it should answer: analytic/bessel-big.ts ×2, analytic/beta-continuation.ts, analytic/complex-arguments.ts ×2, analytic/dedekind-eta-big.ts, analytic/elliptic.ts ×3, analytic/float-in.ts ×3, +4 files	Evaluates in doubles whatever the precision asked (N(BesselJ(1, 1/3), 30) has 17 digits; incomplete elliptic integrals, ExpIntegralEi, BesselK, DedekindEta the same), gives NaN or declines at complex or non-integer arguments (HurwitzZeta(2i, 0), Beta(1+i, 2), BesselJ(0.5, 2)), and misses digits (LogGamma(-5/2)).	Arbitrary-precision kernels with error targets, each cross-checked against mpmath in its tests.	Keep, take upstream	18 sites; with a site disabled, 17 change 110 example values on 0.186 and 17 change 110 on 0.187	PR open: CE#550–555 / CE#557–562 (see the precision section)
Special functions: exact values and closed forms left unevaluated: analytic/closed-forms-113.ts ×13, analytic/constant-rounding.ts ×3, analytic/declare.ts ×2, analytic/elementary-special-values.ts ×5, analytic/hyperbolic-exact.ts, analytic/incomplete-symbolic.ts ×3, +3 files	evaluate leaves the call though N answers: PolyGamma(2, 3), Digamma(1/4), PolyLog(3, 1/2), Gamma(1/2), HurwitzZeta(2, 1/4), AiryAi(0), Sinh(Ln 2), Ln(-2), BetaRegularized(1/2, 2, 3), Hypergeometric1F1(a, a, z).	The closed form Wolfram gives (rational multiples of π, ζ, Catalan, logs), exact at exact operands and numeric under N.	Keep, take upstream	48 sites; with a site disabled, 37 change 179 example values on 0.186 and 37 change 179 on 0.187	PR open: CE#532–CE#537 (three pairs)
Elementary functions: parity, inverse compositions, values at infinities: analytic/elementary-remaining.ts ×18, analytic/inverse-compositions.ts, analytic/simplify-identities.ts, analytic/tagged-arithmetic.ts, analytic/trig-normalisation.ts ×2	Tan(-x), Cos(-x), Sin(Arcsin(x)), Cos(Arctan(x)), Cos(i t), Arccos(Cos(5)) stay as written; Tanh(ComplexInfinity) is a type error; Ln(ComplexInfinity) is ComplexInfinity; Simplify(Sin(x)/Cos(x)) is unchanged.	Folds them as Wolfram does (-Tan(x), x, 1/Sqrt(1+x^2), Cosh(t), 2π - 5, PositiveInfinity).	Keep, take upstream	23 sites; with a site disabled, 22 change 69 example values on 0.186 and 23 change 72 on 0.187	PR open: CE#564 / CE#565; part already native under simplify(); ComplexInfinity values and Arccot(-x) open decisions (see the section)
Calculus on native heads: analytic/derivatives.ts ×2, analytic/dobinski.ts, analytic/linear-algebra-113.ts, analytic/series-infinite.ts, analytic/trig-power-integrals.ts	D of Zeta, ErfInv, Beta stays an Apply(Derivative(…)); D(x^n, [x, 3]) is unevaluated; Sum(k^3/k!, k=1..∞) is unevaluated; Series at infinity substitutes the infinity; ∫ sin³x dx is unevaluated; MatrixRank of a symbolic matrix is unevaluated.	Derivative rules for those heads, higher-order D, Dobiński sums, expansions at infinity, power-of-trig integrals, generic symbolic rank.	Keep, take upstream	6 sites; with a site disabled, 6 change 55 example values on 0.186 and 6 change 56 on 0.187	PR open: CE#572–CE#581 (five pairs); ∂ₐ of two-argument Zeta an open decision
Special functions: argument shapes Wolfram takes and compute-engine rejects: analytic/generalized-special.ts ×10, analytic/threading-113.ts ×2	A type or arity error: Beta(1/2, 2, 3), Erf(0.1, 0.5), ErfInv(0.1, 0.5), PolyGamma(1), Gamma(2, 1, 3); Rationalize of an expression holding floats stays.	Widens the signature and answers the generalized (incomplete, two-point) form; the compile stance refuses the widened shapes.	Keep, take upstream	12 sites; with a site disabled, 11 change 47 example values on 0.186 and 11 change 47 on 0.187	PR open: CE#566 / CE#567; Beta(0, ∞), Erf parity and composition, Rationalize of floats and PolyLog(n, p, z) stay ours (see the section)
Integer functions: rational, negative, real and extra operands: number-theory/declare-widened.ts ×19, number-theory/declare.ts ×17	A type error or an unevaluated call: NextPrime(7/2), DivisorSigma(-1, 12), GCD(1/2, 1/3), IsSquareFree(6/35), FactorInteger(12/35), Mod(7, 5, 3), ExtendedGCD(12, 18, 27), CatalanNumber(1/2), Binomial(n, n-1), Fibonacci(10, x), BellNumber(5, x). Wrong: NextPrime(-10) is 2 and GCD(12, [3, 7, 40]) is 1.	The Wolfram value: extensions to rationals and negatives, the polynomial forms, the offset Mod, n-ary ExtendedGCD.	Keep, take upstream	36 sites; with a site disabled, 30 change 104 example values on 0.186 and 30 change 104 on 0.187	PR open: CE#542 / CE#543, CE#544 / CE#545
Digits: strings, negative bases, lengths, big integers: numerals/declare.ts ×9	FromDigits("1923") is a type error; a symbolic or negative base is unevaluated; IntegerString goes through a double and drifts past 2^53; a length or position argument is an unexpected-argument error.	String digits, exact big integers, the extra arguments.	Keep, take upstream	9 sites; with a site disabled, 9 change 30 example values on 0.186 and 9 change 30 on 0.187	PR open: CE#523 / CE#528 (past 2^53); CE#582 / CE#583 (any FromDigits base, the length and position arguments; stacked on CE#528); the string form is asked in CE#582 and stays ours meanwhile
Modular powers and CRT: rational bases, lists, a third argument: residues/declare.ts ×6, residues/residue-class-declare.ts	PowerMod(1/2, 2, 7) is a type error, PowerMod([2, 3], 5, 7) does not thread, ChineseRemainder(r, m, d) is an unexpected-argument error.	Widens them (the modular inverse for a rational base, threading, the offset form).	Keep, take upstream	7 sites; with a site disabled, 7 change 109 example values on 0.186 and 7 change 109 on 0.187	PR open: CE#546 / CE#547; Mod(m, n, d) a design question, CE#548
List heads: Wolfram forms and wrong answers: collections/arith-heads.ts ×2, collections/expression-ops.ts ×3, collections/infinite-products.ts, collections/list-functional.ts, collections/list-heads.ts ×8, collections/list-levels.ts ×9, +5 files	Type or arity errors on Wolfram's forms (First([], d), Mean of a matrix, Partition with an offset, Flatten(list, ∞), Count(list, x, level), Fold(f, list), Unique(list, test), Chop(x, tol), Map(f) as an operator, Min()), and wrong answers: Median([Pi, 1, 3]) is 3, Tabulate(f, 2, 2, 2) drops a dimension, All(matrix, f, 2) drops the level, Same(Reverse([1, 2]), [2, 1]) is False, Rationalize(0.1, 0) is 1/10.	The Wolfram form or the right value, falling through to native for everything it already answers.	Keep, take upstream	44 sites; with a site disabled, 39 change 173 example values on 0.186 and 39 change 174 on 0.187	PR open: CE#525 / CE#530, CE#538 / CE#539, CE#540 / CE#541
Distributions: statistics/distributions-6.ts, statistics/distributions.ts ×2	PDF(NormalDistribution(0, 1), 0.5) is half float, half exact (0.624…/Sqrt(Pi)); UniformDistribution([1, 3]) is unevaluated and its Mean an error.	A float in gives a float out; Wolfram's list form of UniformDistribution.	Keep, take upstream	3 sites; with a site disabled, 1 change 1 example value on 0.186 and 1 change 1 on 0.187	PR open: CE#568 / CE#569; discrete Quantile left out
Continued fractions of quadratic irrationals: modular/declare.ts ×2	ContinuedFraction(Sqrt(2)) is a fixed 20 terms; the periodic form does not read back.	The exact periodic expansion and its inverse.	Keep, take upstream	2 sites; with a site disabled, 2 change 21 example values on 0.186 and 2 change 21 on 0.187	PR open: CE#570 / CE#571; result type and negative reals open with compute-engine
Arithmetic and structure heads on our own value types: structures/algebra.ts, structures/carriers.ts ×2, structures/extend.ts ×2, structures/generic.ts ×6, hypercomplex/declare.ts ×9, analytic/declare-tagged-arithmetic.ts, +12 files	Add, Multiply, Power, Divide, Negate, Equal, Max, Min, Floor, Mod, GCD, Dot, Inverse, Element and the like are typed for numbers (and tensors) and reject or leave anything else.	One overload per carrier (multivectors, profinite and p-adic numbers, residue classes, Gaussian integers, intervals, modular matrices, finite sets), dispatched ahead of native, which still answers every number. The values are enumeratio's types; compute-engine has no reason to know them.	Keep, ours by design	86 sites; with a site disabled, 54 change 649 example values on 0.186 and 57 change 671 on 0.187	Not for upstream
PDF, CDF, Mean, Variance, Median, Random on our distributions: collections/list-frontier.ts, statistics/distributions-2.ts ×4, statistics/distributions-3.ts, statistics/distributions-4.ts ×4, statistics/distributions-6.ts ×6, statistics/distributions.ts ×4, +2 files	Answers its own distribution kinds and its own random stream.	Adds a branch per distribution kind we declare and falls back to native; Random draws from one seeded stream per engine over any registered domain (deterministic by default, a Wolfram-vocabulary convention).	Keep, ours by design	23 sites; with a site disabled, 21 change 182 example values on 0.186 and 21 change 184 on 0.187	Not for upstream
Collection heads on our lazy families, Associations and Wolfram call forms: collections/expression-ops.ts, collections/families/call-forms.ts ×3, collections/families/declare.ts, collections/list-functional.ts ×5, collections/list-heads.ts ×19, collections/list-ops-wolfram.ts ×3, +2 files	Length, First, Last, At, Sort, Take, Count, Permutations, Partition, Ordering are typed for its own collections.	Answers them for our carriers (an Association, a family past 2^53 members, UpTo(n), Key(k), any head's operands) and defers to native otherwise.	Keep, ours by design	34 sites; with a site disabled, 28 change 108 example values on 0.186 and 28 change 108 on 0.187	Not for upstream
Native heads applied to heads of ours: analytic/difference-root.ts ×2, analytic/differential-root.ts, analytic/generalized-special.ts ×2, analytic/inverse-erfc.ts, analytic/series-jacobi.ts, analytic/series-q-binomial.ts, +3 files	Apply, Series, Derivative, Solve, Erfc, PolyLog, BernoulliB know nothing of DifferenceRoot, DifferentialRoot, the Jacobi and q-series heads, DiracDelta, InverseErfc, the Nielsen polylogarithm or BernoulliPolynomial.	Routes the call to our head's own rule (the recurrence, the series table, the inverse).	Keep, ours by design	12 sites; with a site disabled, 12 change 67 example values on 0.186 and 12 change 69 on 0.187	Not for upstream
Digit and residue heads on our numeral systems and collections: numerals/declare.ts ×6, residues/declare.ts ×3	IntegerDigits, FromDigits, IntegerString take an integer base; MultiplicativeOrder and PrimitiveRootList take integers and list eagerly.	A numeral-system expression in the base slot; a lazy collection past the listing cap; the compile stance closes what compute-engine cannot lower.	Keep, ours by design	9 sites; with a site disabled, 7 change 106 example values on 0.186 and 7 change 106 on 0.187	Not for upstream
Histogram, About: formats/graphics.ts ×2, evaluation/about.ts ×2	Histogram(data) needs its bins; About describes its own definitions.	The one-argument Histogram stays a picture; About adds the manifest's keys.	Keep, ours by design	4 sites; with a site disabled, 3 change 7 example values on 0.186 and 3 change 7 on 0.187	Not for upstream
Mandelbrot and Julia: analytic/fractal.ts ×2	Ships both as a smooth escape-time value in [0, 1] with n required.	Redeclares both as the n-th complex iterate, n optional.	Open decisions	2 sites; with a site disabled, 1 change 1 example value on 0.186 and 1 change 1 on 0.187	Decision needed first
Speed-only kernels: number-theory/declare-fast-factorial.ts, number-theory/declare-fast-gcd.ts, number-theory/declare-fast-primes.ts ×2, number-theory/declare-fast-recurrence.ts	The same values by simpler loops (Factorial, GCD, Fibonacci, LucasL, NthPrime); PrimePi(10^8) throws a cancellation.	A product tree, Lehmer and Stein gcd, fast doubling, sieves and Deléglise–Rivat.	Open decisions	5 sites; with a site disabled, 2 change 7 example values on 0.186 and 2 change 7 on 0.187	Decision needed first
Wolfram conventions on compute-engine heads: analytic/closed-forms-113.ts, collections/list-heads.ts ×3, collections/list-levels.ts	Union of lists is a Set; Partition keeps a ragged remainder; Rank is tensor rank; Flatten takes no level permutation; FromContinuedFraction of symbols is unevaluated.	List in, list out; drops the remainder; Rank is Wolfram's ArrayDepth; Flatten regroups levels; a nested fraction, uncombined.	Open decisions	5 sites; with a site disabled, 5 change 26 example values on 0.186 and 5 change 26 on 0.187	Decision needed first
N as a correctly rounded value: analytic/correctly-rounded.ts	Evaluates at d digits and returns that; a double-only kernel returns a double whatever d.	Ziv's loop around every N(x, d): two precisions, agree or widen, decline when a kernel cannot back the digits.	Open decisions	1 site; with a site disabled, 1 change 16 example values on 0.186 and 1 change 16 on 0.187	Decision needed first
A float in gives a double out: analytic/float-in.ts	A 21-digit bignum for a double operand (LerchPhi(0.5, 2, 1)).	Rounds the answer to a double.	Open decisions	1 site; with a site disabled, 1 change 3 example values on 0.186 and 1 change 3 on 0.187	Decision needed first
Values that differ from both compute-engine and Wolfram: analytic/hyperbolic-half-period.ts, analytic/widened.ts ×2	Keeps the stray real part at fl(π/2)i; leaves Arcsin(2) and CatalanNumber(-1) unevaluated.	Snaps within 4 ulps of kπ/2; exact principal values outside the real domain; CatalanNumber(-1) = -1.	Open decisions	3 sites; with a site disabled, 3 change 38 example values on 0.186 and 3 change 38 on 0.187	Decision needed first

LaTeX dictionary and read/write options

Measured on the editor's route: every reference example is written as the editor shows it and read back, with one entry or option removed (latex-ablate.ts). "Written" counts examples whose LaTeX changes, "read" those that read back differently, "lost" those that stop round-tripping. 0.186 and 0.187 give the same counts for every row.

Where	compute-engine does	We do	Classification	Measured	Upstream status
LCM, MatrixRank, Zeta, Rational, Negate: frontend/src/conventional-latex.ts	Writes \operatorname{lcm}(4, 6), \operatorname{rank}(m), \zeta(s), -\frac{1}{2} and -\frac{3}{4}, and reads each back to the same expression.	Carried entries that wrote and read the same. Removed.	Unwind (done)	written 0, read 0, lost 0, gained 0	Nothing to file
Floor, Ceil, Arccsc: frontend/src/conventional-latex.ts	Writes \lfloor x\rfloor and keeps a step as \mathrm{floor}(226, 10); writes \mathrm{arccsc}(x). All read back.	The same brackets (a call spelled \mathrm{Floor}), and \operatorname{arccsc}. The reason in the code (the brackets dropped the step) no longer holds. Not removed: 50 written forms change, so the tex pins need UPDATE_FORMS=1.	Unwind (listed)	written 50, read 0, lost 0, gained 0	Nothing to file
|…| as Count for set heads: frontend/src/conventional-latex.ts (SET_HEADS)	Its canonical form reads Abs of a set-typed operand as Count, by type.	A hand-kept list of six set heads decides it in the non-canonical read. In flight on cardinality-by-type (BL-388), owned by another lane; not touched here.	Unwind (listed)	written 0, read 3, lost 3, gained 0	Nothing to file
Arcsec: frontend/src/conventional-latex.ts	Writes \mathrm{arcsec}(x), which its own parser reads as the arcsecond unit times x.	\operatorname{arcsec}(x), which reads back.	Keep, take upstream	written 29, read 29, lost 19, gained 0	CE#518 (open PR)
Equal after a factorial: frontend/src/conventional-latex.ts	Writes Equal(5!, 5) as 5!=5, which reads back as NotEqual(5, 5).	5! = 5.	Keep, take upstream	written 6, read 4, lost 3, gained 1	CE#518 (open PR)
Union, Intersection, SetMinus of three or more: frontend/src/conventional-latex.ts	a∪b∪c reads back nested, Union(a, Union(b, c)); a∖b∖c reads as a∖(b∖c), a different set.	Reads a chain as one n-ary head; brackets a left-nested SetMinus.	Keep, take upstream	written 4, read 11, lost 8, gained 0	Union and Intersection read back on compute-engine; A \setminus B \setminus C parses right-nested (a real loss): CE#584 / CE#585
Transpose, PolyLog, Derivative, Apply, primes: frontend/src/conventional-latex.ts	Transpose(a, perm) is written a^T; PolyLog(1, 2, 1) loses its third argument; Derivative(f, 4) is written f^{(4)} and reads as a power; f' reads as Prime(f).	Writes the call when the sign would drop an operand, and reads a prime on a symbol as Derivative(f, k).	Keep, take upstream	written 11, read 11, lost 11, gained 0	CE#517 (open issue), CE#518 (open PR: Transpose axes and Derivative orders)
Integrate of an integral: frontend/src/conventional-latex.ts	\int\int f dy dx reads as nested Integrates, and a nested one is written without brackets.	Reads a run of integrals as one n-ary Integrate; brackets a nested one.	Keep, ours by design	written 0, read 10, lost 5, gained 0	No loss on compute-engine (rechecked 2026-11-12); ours by design
Beta with three or four arguments: frontend/src/conventional-latex.ts	Writes \mathrm{B}(a, b) and reads it back, but \mathrm{B}(0.2, 0.5, 2, 3) does not read as Beta.	Reads \mathrm{B} applied to any arguments as Beta.	Keep, take upstream	written 0, read 3, lost 3, gained 0	Covered by CE#567 (argument shapes)
Erf, Erfc, Arccot, EulerGamma, Exp: frontend/src/conventional-latex.ts	Writes \mathrm{Erf}(x), \mathrm{arcctg}(x), \operatorname{EulerGamma} and \exp(2x) (but e^{x} for a symbol).	\operatorname{erf}, \operatorname{arccot}, \gamma, e^{2x}: the conventional spelling, which already parses.	Keep, ours by design	written 193, read 102, lost 39, gained 28	No loss on compute-engine (rechecked 2026-11-12); ours by design
Divide with a negative part; imaginary factors in Multiply and Add: frontend/src/conventional-latex.ts	Writes \frac{-1}{x} and (-\imaginaryI)x, a+(-\imaginaryI)b.	-\frac{1}{x}, -\imaginaryI x, a-\imaginaryI b.	Keep, ours by design	written 16, read 11, lost 0, gained 3	No loss on compute-engine (rechecked 2026-11-12); ours by design
MemberCall: frontend/src/conventional-latex.ts	Writes \mathrm{MemberCall}(\mathrm{enumeratio}, \mathrm{PolygonalNumber}, 4, 5), which does not read back.	\operatorname{enumeratio.PolygonalNumber}(4, 5).	Keep, ours by design	written 0, read 0, lost 0, gained 0	No loss on compute-engine (rechecked 2026-11-12); ours by design
ResidueClass and QuotientRing: symbols/arithmetic/residues (package notation)	Ships entries for both names; 14 examples holding a QuotientRing and 2 holding a ResidueClass do not round-trip through them.	The package's notation replaces them.	Keep, ours by design	written 26, read 16, lost 12, gained 2	Round-trips on compute-engine's own entries (\mathbb{Z}_{m} is its chosen spelling; a \pmod{n} reads as Mod(a, n)); ours by design: our infix \pmod at 244 reads a residue class, a different meaning
True and False: frontend/src/conventional-latex.ts	Writes \top and \bot.	Writes the words, as InputForm spells them; \top and \bot still read. A display choice for the editor.	Keep, ours by design	written 28, read 0, lost 0, gained 0	Not for upstream
Log, Log2, Log10, Lb, Square: frontend/src/conventional-latex.ts	Writes base-10 Log(x) as \log(x).	Every logarithm but the natural one names its base (\log_{10}(x)), because a bare \log reads as the natural log to most readers and to Wolfram; Square is written as the power it is.	Keep, ours by design	written 51, read 0, lost 0, gained 0	Not for upstream
{k→v} as a Dictionary; Dictionary written with braces: frontend/src/conventional-latex.ts (Set), frontend/src/latex.ts	Reads braces as a Set; writes \operatorname{Dictionary}(\operatorname{KeyValuePair}(…)).	A set whose every element is an arrow reads as a Dictionary, and one is written that way: notatio's display form.	Keep, ours by design	written 5, read 5, lost 5, gained 0	Not for upstream
EscapedText: frontend/src/conventional-latex.ts	Writes a bare string atom unescaped (\text{#} is a TeX error).	A private head that writes one escaped \text{…}. The escaping itself is an upstream candidate.	Keep, ours by design	written 0, read 0, lost 0, gained 0	Not filed
Unicode symbols: boxes/src/render/unicode-tex.ts, DisplayLatexSyntax	Writes and reads commands (\omega, \le).	Writes the UNICODE_TEX list as Unicode and reads it back as commands, where KaTeX, compute-engine and MathLive all read the character.	Keep, ours by design	written 1463, read 0, lost 0, gained 0	Not for upstream
Serialize options: radicals, all digits, raw boxing: frontend/src/latex.ts	Defaults: nested roots become powers, digits round to the working precision, boxing canonicalizes.	Passes rootStyle, digits: "max" and a non-canonical box through compute-engine's public options, so the editor shows text as written.	Keep, ours by design	written 1519, read 905, lost 728, gained 5 (0.187 differs)	Not for upstream
The editor's non-canonical read: frontend/src (parse with form: "InvisibleOperator")	ce.parse canonicalizes: 2 + 3 in ToBoxes(2 + 3) reads as 5, operands reorder.	Resolves invisible operators only, so what was typed is what is kept. notatio's editor read keeps text as written by design; a fully canonical read changes 1,158 of the examples' read-backs and a raw one 1,523.	Keep, ours by design	written 0, read 2681, lost 1872, gained 487	Not for upstream
TraditionalForm notation for native heads: symbols/analysis/analytic (package notation, 9 entries)	One LaTeX form per head.	A second, traditional form for display only.	Keep, ours by design	not ablated (a separate form, not the editor's)	Not for upstream

parseExpression passes

packages/formats/src/expression.ts runs these on top of compute-engine's parseEpsil. Probed on bare 0.186 and 0.187 (probe-parse.mjs); both versions answer the same.

Where	compute-engine does	We do	Classification	Measured	Upstream status
withoutProgramBlock: formats/src/expression.ts	parseEpsil("Block(a := 1, a)") is Block(Block(Assign(a, 1), a)): the outer Block is the program, the inner one the statement's own scope (compute-engine's design: parser.ts, commit 930b9cedc "single-block Epsil programs", asserted by its tests).	Drops the outer (program) one only when the program's one statement is itself a Block, so the statement's own scope stays; a cell holds one expression, not a program.	Keep (compute-engine's design; not upstream)	Probed on both versions.	Not filed
resolveRuleKeys: formats/src/expression.ts	resolveLibraryNames resolves isPrime(7) to IsPrime but leaves the key of isPrime -> Teal as written.	Resolves a rule's key too.	Keep, ours by design	Probed on both versions.	compute-engine's design: a rule key is a name, so resolving it would turn max -> 3 into Max -> 3; ours by design
rulesInCalls / ruleAsPair: formats/src/expression.ts	a -> b is KeyValuePair, which canonicalizes to a Tuple inside a call (f(x, Tuple(a, 1))) and so broadcasts.	A -> in a call's arguments is a Rule (an option); a pair inside a Dictionary stays. This is the rule in AGENTS.md ("Options are Rule").	Keep, ours by design	Probed on both versions.	Not for upstream, unless Epsil grows an option arrow
Statement and effect diagnostics: formats/src/expression.ts	Parses assignments, blocks, loops and Print as Epsil.	Reports them instead of evaluating: an attribute or a cell holds one expression (a cell may be one :=). One expression per attribute or cell is by design.	Keep, ours by design	No compute-engine behaviour is replaced.	Not for upstream

Compile targets, engine settings and internals

Where	compute-engine does	We do	Classification	Measured	Upstream status
compile: engine/src/compiled-target.ts:33 (At)	Lowers At to _SYS.atNumeric(list, i, type), which also counts a negative index from the end and answers NaN out of range (shipped 0.186 table, read, not probed: bare.mjs does not compile).	For a list at an integer index with pure operand text, emits (i >= 1 && i <= a.length ? a[i-1] : _SYS.atNumeric(...)), falling back to the stock call otherwise.	Keep, ours by design	Pure speed-up with identical results and the stock lowering as fallback; nothing wrong in CE. Could be offered upstream as an optimization but is not a correctness fix.	Not filed
compile: engine/src/compiled-bigint.ts:12 (Divide, Range, Length, Count)	Compiles integer arithmetic over doubles with a double _SYS (lines 27, 36, 110); past 2^53 it loses digits (shipped code, not probed).	Same CE compiler with integer literals emitted as bigint, our own bigint _SYS (bdiv, brange, pow, gcd, binomial, factorial with a 20,000 cap, floorMod, At), and Divide/Range rewritten before compile; a mixed double throws and reads as a decline.	Keep, ours by design	A different numeric domain (BigInt code generation) that CE has no target for; it reuses CE's compiler and declines by exception. Fragile coupling: text replaceAll on CE's generated source ('=== number', '_a.slice(') breaks silently if CE changes its emitter.	Not filed
compile: ce-patches/src/compute-engine/compilation/matrix-rank.ts:59 (MatrixRank)	Evaluates MatrixRank (bare 0.186 and 0.187: MatrixRank(1,2],[2,4) -> 1) but neither version's JavaScript table has a MatrixRank lowering, so an expression holding one does not compile.	Emits exact Bareiss elimination over BigInt for literal integer and rational matrices, a runtime kernel (a float tolerance only for non-integers) otherwise, and refuses symbolic entries. (The evaluate wrapper that came with it is removed on this branch.)	Keep, take upstream	CE has the head and no lowering; adding a JavaScript lowering is something CE would plausibly take. Already a ce-patch with a landed check.	Not filed
compile: ce-patches/src/compute-engine/library/special-functions.ts:125 (LerchPhi)	Ships its own lowerings: JavaScript _SYS.lerchPhi / _SYS.clerchPhi and GLSL _gpu_lerch_phi (read from the 0.186 and 0.187 tables); evaluates LerchPhi(0.5,2,1) -> 1.16448105293002501181 but leaves LerchPhi(2,2,1) unevaluated under evaluate() (N gives a complex value).	Replaces both with calls to our own kernels (_.__lp on the scope object, zetaGLSL lerchPhi(vec2..).x) that read only the real part.	Open decisions	Candidate to unwind to CE's lowering, but ours matches our evaluate (analytic continuation for |z| >= 1) and CE's compiled coverage was not measured against it. Options: (a) drop realCompile and compare on a grid with mpmath; (b) keep ours for z outside the unit disk only; (c) keep as is.	Not filed
compile: analysis/analytic/src/fractal.ts:71 (Mandelbrot, Julia)	Ships Mandelbrot(c, n) and Julia(z, c, n) as smooth escape-time values with its own JS (_SYS.mandelbrot) and GLSL (_fractal_mandelbrot) lowerings: bare 0.186 and 0.187 Mandelbrot(1,64) -> 0.05885745370802374, Mandelbrot(0.3+0.5i,64) -> 1 (inside), Mandelbrot(0.3) -> Error missing (n required).	Redeclares both heads as the n-th iterate of z^2 + c (a complex value, exterior blows up) with default n=64 and lowers them to _.__mb / _.__ju and zetaGLSL mandelbrot/julia.	Open decisions	Same head names with a different meaning from CE's (escape-time in [0,1] versus raw iterate), so evaluate and compile both diverge. Options: (a) rename ours (e.g. MandelbrotIterate), keep CE's heads; (b) adopt CE's semantics and drop ours; (c) keep the clash and document it.	Not filed
compile: ce-patches/src/compute-engine/compilation/glsl-complex.ts:171 (Add, Subtract, Multiply, Divide)	Its GLSL target is real-scalar (float) with only partial complex handling per head, and bakes numeric literals into source.	Lowers a whole expression to vec2 complex GLSL (cmul, cdiv, cpow, zetaGLSL kernels), with literals hoisted into uniform slots so a changing number re-uploads rather than recompiles.	Keep, ours by design	A different product (per-pixel complex portraits with a uniform-slot cache) that CE's GLSL target does not aim at; the file says it is deliberately not a second CE target.	Not filed
compile: frontend/src/plot-compile.ts:61 (Sum, Product, Random, (any head outside the GLSL fragment))	CE's GLSL lowering of a loop stops after 10,000 passes with NaN (the '_gpu_passes' guard).	Declines the whole shader (plot takes the CPU path) when canCompile fails or the preamble/code mentions _gpu_passes; prepends our zetaGLSL library via withGLSL so ours heads resolve.	Keep, ours by design	A fail-closed policy at the call site, using CE's target unmodified; no CE behavior is replaced.	Not filed
compile: frontend/src/plot-compile.ts:112	Infers an unknown's type from earlier use and keeps it, so an engine that boxed HurwitzZeta(x, y) once treats x as complex and the compile result depends on the order the page asked (comment; not probed).	Compiles in a scope where every free name is declared real.	Keep, ours by design	A plotting convention (variables are real), applied in a throwaway scope.	Not filed
compile: engine/src/compiled.ts:90	Returns code that reads locals its preamble declares, and does not export its runtime helpers (_SYS).	Wraps preamble plus code in an IIFE of _SYS and _; scrapes the per-engine _SYS from a function compiled on that engine (compileTyped(['Add','_h',1]).run.SYS); same trick duplicated in cli/src/textual.ts:72, components/src/plot-kernel.ts:70 and web prerender-markup.ts:67.	Keep, ours by design	Uses stock JavaScriptTarget; the only reach into CE is reading .run.SYS, which a public export of the helpers would remove. Candidate ask upstream: export _SYS.	Not filed
compile: engine/src/extend.ts:97 (every head a package wraps or replaces)	Treats a head whose evaluate/canonical/lazy/broadcastable/derivative/evaluateAsync differs from the library's as a user definition shadowing the library head and so compiles it without the built-in lowering (0.152 library-shadowing rule, per ce-internals.ts; not probed).	Reinstates the built-in lowering when a package says 'builtin', limits it to n operands ({upTo}), supplies a lowering of ours, or closes the head so it fails to compile; an unstated replacement closes the head.	Keep, ours by design	The machinery behind every per-head stance below. Reads CE internals (ce-internals.ts) pinned by tests/ce-internals.test.ts.	Not filed
compile: arithmetic/number-theory/src/declare-widened.ts:50 (about 170 sites: compile: 'builtin' (declare-widened.ts,…)	Native evaluate and lowering agree by construction.	Wraps evaluate and asserts the stock lowering is still right for every call.	Keep, ours by design	Not an override of CE's lowering: it keeps it. The risk is an assertion per head that nothing proves except web/.vitepress/data/compile-differential.test.ts samples (compiled vs .N(), closed heads must fail to compile). Worth a per-head audit where evaluate was widened (e.g. special-big,…	Not filed
compile: analysis/analytic/src/generalized-special.ts:137 (Beta, BetaRegularized, Erf, ErfInv)	Lowers the native arities only: e.g. Clamp(5) is an Error 'missing' in bare 0.186 and 0.187; the native lowering of Binomial/Factorial2/BesselJ takes real operands (_SYS.binomial, _IA.factorial2, _SYS.besselJ, read).	Compiles the native call shapes and throws for the widened ones (extra operand, one-argument form, non-integer or complex operand) rather than compile them wrongly.	Keep, ours by design	Fail-closed guards that follow each widening (the evaluate side is audited per head elsewhere); removing the widened evaluate removes the guard with it.	Not filed
compile: arithmetic/residues/src/declare.ts:58 (PowerMod, PowerModList, PrimitiveRootList,…)	Has no JavaScript lowering for the five residue heads (not found in the 0.186 table); the permutation and hypercomplex cases are our own value types.	Closes the head (compile throws), or refuses only when an operand is a hypercomplex generator or a permutation.	Keep, ours by design	Declining to compile our own carrier types, and heads CE cannot compile anyway; conservative.	Not filed
compile: analysis/analytic/src/special-functions.ts:39 (ChebyshevT, ChebyshevU, HermiteH, LaguerreL)	Does not declare these heads (only identity data mentions ChebyshevT; grep of both CE versions finds no definition or lowering).	Declares them and inlines the three-term recurrence for JavaScript (real x, order cap 1,000,000).	Keep, ours by design	Not an override: CE has no such head. Listed so the audit does not recount it.	Not filed
engine: engine/src/defaults.ts:16 (Round)	Rounds ties away from zero: bare 0.186 and 0.187 Round(5/2) -> 3, Round(2.5) -> 3, Round(-3.5) -> -4, Round(7/2) -> 4.	Sends a tie to the even neighbour (Round(5/2) -> 2), in evaluate, N and compiled code.	Keep, ours by design	Sets CE's own documented option, so not a monkey-patch; a Wolfram-vocabulary convention. The one persistent engine-setting write in packages/.	Not filed
engine: engine/src/purity.ts:103 (every head declared after setEngineDefaults)	From 0.174 does not memoize an operator that states no purity.	Adds pure: true to every plain operator definition that states none, unless named in IMPURE_HEADS, states purity/effects, or is an extend: true patch.	Open decisions	Instance-level monkey-patch of ce.declare with a hand-kept impure list; a head forgotten there is memoized wrongly. Options: (a) keep; (b) state pure per head (explicit, 1000s of edits); (c) ask CE for a default-purity engine option.	Not filed
engine: engine/src/modular.ts:169 (Mod)	Evaluates operands before the handler, so Mod(Fibonacci(1000000000), 1000) stays unevaluated in bare 0.186 and 0.187 (Mod(Factorial(100000), 1000003) answers 353746 after building the huge value, 5 s).	Computes Mod(head(args), m) from a registry of modular kernels plus ring operations without building head(args), then falls through to CE's evaluate.	Open decisions	Answers CE declines, but by patching a shared prototype of CE's internal node class, guarded by ce-internals.ts. Options: (a) keep; (b) propose a CE hook (a head's 'modular' evaluation or an evaluate-with-modulus context) and unwind; (c) drop and register Mod handling per head.	Not filed
engine: engine/src/random.ts:193 (Random)	Random() and Random(list) or Random(Interval) draw from its own stream (bare: Random(List(1,2,3)) -> 1, Random(Interval(0,1)) -> 0.848); Random(List(1,2,3), 3) is Error 'unexpected-argument'; no registered samplers; unseeded draws differ per run.	Draws from one mulberry32 stream per engine (seed 42 by default, SeedRandom restarts it, WithRandomSeed frames honored), adds count and shape arguments, samplers for distributions, bigint-uniform draws, and Wolfram spellings that rewrite to it.	Keep, ours by design	Determinism by default and our own domains are enumeratio conventions; the count/shape arm alone (Random(list, n)) is an upstream candidate.	Not filed
engine: engine/src/ce-internals.ts:15	Exposes none of these publicly (underscore members, context scope chain).	Reads them: canonicalCall (ce._fn; duplicated in residues/integer-mod.ts:29 and analytic/q-series.ts:192,224 instead of calling it), libraryOperator and shadowsLibrary (outermost scope), algebraic-numbers.ts:103 (_deadlineFrame), random.ts:37, census/engine.ts and owners/contributions and…	Open decisions	Each bump needs a re-check (CHECKED_COMPUTE_ENGINE test, 0.186.0). Options: (a) keep and consolidate the three raw _fn casts onto canonicalCall; (b) ask CE for public equivalents (canonical-call, binding enumeration, deadline query); (c) leave.	Not filed
engine: evaluation/evaluation/src/cooperative-evaluate.ts:72 (N)	Restores ce.precision after N(x, d) returns: bare 0.186 and 0.187 read 21 before and after N(Pi, 50).	Restores the precision after each evaluation, so a pooled worker or the next notebook cell does not run at d digits.	Keep, ours by design	A defensive restore around each isolated evaluation (it also covers an evaluation cancelled midway and our own kernels' precision writes). Its comment, which says compute-engine leaves the precision raised, is stale.	Not filed
engine: evaluation/evaluation/src/declare.ts:43 (Take, Drop, Solve, Range)	Native heads as shipped.	Applies every ce-patches patch not marked landed to every engine, whichever libraries it declares.	Keep, take upstream	Per-patch classification belongs to the ce-patches audit; this is the one place they are installed on all engines. The patch-landed probe builds a fresh ComputeEngine once per patch id.	Not filed
engine: arithmetic/residues/src/declare.ts:54 (PowerMod, PowerModList, PrimitiveRootList,…)	Declares these heads lazy with a canonical handler that type-checks operands (bare PowerMod(2,10,7) -> 2; PowerMod(1/2,3,7) -> Error incompatible-type for the rational base).	Removes laziness and the canonical handler so the widened signature types the operands, with operands evaluated up front.	Open decisions	Direct mutation of a CE definition outside extendHead/wrapOperator, so any CE-side invariant about lazy heads is bypassed. Options: (a) keep; (b) upstream a native rational-base PowerMod and unwind; (c) route through extendHead.	Not filed
engine: engine/src/apply-function.ts:99 (Apply, Function)	Apply of a Function literal threads over a list argument and gives a body operator only the bare parameter (bare: Apply(Function(_1+1,_1), List(1,2)) -> List(2,3); Apply(Function(D(_1,x),_1), x^2) -> 2x).	Substitutes arguments into the body, with capture-avoiding renames, and never threads over a list.	Keep, ours by design	A parallel helper, CE's Apply is untouched; the two can disagree for the same expression, which is a trap, not a patch.	Not filed
engine: engine/src/deadline.ts:21 (TimeConstrained, VerificationTest)	Has ce.withTimeLimit, which only reaches code that passes through the engine's frame.	Adds a cooperative deadline for bigint kernels with no boxed expressions; used together with ce.withTimeLimit.	Keep, ours by design	Independent of CE. Also in this group, not overrides: messages.ts (symbol-keyed channel on the engine), options.ts (reads Rule, KeyValuePair and the Tuple CE canonicalizes a symbol-keyed pair to), probe.ts (withAssumptions, nativeEvaluate).	Not filed
options: frontend/src/conventional-latex.ts:517 (LCM, MatrixRank, Erf, Erfc)	Per the file's own notes: writes LCM as \lcm and rank/erf as \operatorname forms that do not parse back, Equal as 5!=5 (reads back as 5 != 5), Union of three and Derivative with orders in a form that loses an argument, Li_s(z) dropping a third argument, a Russian arcctg, MemberCall as \mathrm{MemberCall}(...). Not probed:…	Replaces about 40 default entries with ones that read back exactly or follow conventional notation (sign in front of a fraction, named log base, floor brackets, e^{2x}).	Keep, take upstream	The round-trip losses (Equal, Union, Derivative, PolyLog, Integrate, Set, Apply, MemberCall) are CE serializer or parser bugs that CE would plausibly take; the notational conventions (Floor brackets, Log base, Square, truth values, sign-out) are ours. Split in follow-up; needs bare-CE LaTeX probes…	Not filed
options: frontend/src/conventional-latex.ts:578	Writes and reads LaTeX commands (\omega, \le).	Writes the UNICODE_TEX list as Unicode characters and reads them back as commands, on every route; every engine takes the merged dictionary (CE's, NOTATIO_LATEX, CONVENTIONAL_LATEX, BOXES_LATEX, package notation).	Keep, ours by design	A display convention; also a probeLanded() check creates a bare LatexSyntax to see whether CE parses blackboard sets itself.	Not filed
options: frontend/src/latex.ts:89 (Sqrt)	Default style turns \sqrt{2} into 2^{1/2} below the second nesting level (comment); .latex rounds to the working precision, so N(Pi,50) shows about 21 digits; a raw parse reads \Gamma(2.5) as Gamma times 2.5.	Keeps radicals, writes all digits, resolves invisible operators without canonicalizing, and boxes raw where the as-typed form is wanted.	Keep, ours by design	Per-call options passed to CE's public API, not overrides. No ComputeEngine constructor option other than latexSyntax is used; no ce.parse option beyond these; no prototype or Object.defineProperty on CE objects other than modular.ts.	Not filed

Heads we declare that compute-engine ships under another name

These are declared with their own evaluate under the Wolfram name although compute-engine has the same function under its own. None was changed here: turning one into an alias is a vocabulary decision (see Open decisions). RandomInteger, CubeRoot and FullSimplify already delegate.

Ours	compute-engine's	Declared at	Verdict	Difference
Total	Reduce / Sum	combinatorics/combinatorics/collections/src/list-functional.ts:392	duplicate	Same values as Sum(list) (and Reduce(list,Add)) on lists, matrices and symbols. Edge cases: Reduce of an empty list is Nothing (Sum gives 0, as ours does); ragged rows give a CE dimension Error where ours falls through to Add of the rows.
IntegerPart	Truncate	analysis/analytic/src/integer-fractional-part.ts:47	duplicate	Agrees with ours on every real input probed (rational, float, Pi, list). Only difference: ours truncates a concrete complex component-wise (Complex(2,3)); CE Truncate rejects complex.
EllipticTheta	JacobiTheta	analysis/analytic/src/theta.ts:141	duplicate	Same function reparameterized: CE JacobiTheta(a, z, tau) has z = u/pi and tau with q = exp(ipitau), so EllipticTheta(a,u,q) = JacobiTheta(a, u/pi, ln(q)/(i*pi)). CE does not take the nome directly. q=0, negative or exact-symbolic q and our precision guards (declineNome) are not exercised by CE;…
RandomInteger	Random	combinatorics/combinatorics/collections/src/list-frontier.ts:211	alias-already	Ours already evaluates Random on a Range; adds Wolfram argument shapes (n, {a,b}, count, dims).
AbsoluteTiming	Timing	combinatorics/combinatorics/collections/src/control.ts:502	duplicate	Same measurement and (seconds, value) order. CE returns a Tuple, ours a List; neither pins the time. Wolfram's Timing is CPU time and AbsoluteTiming wall time; CE's Timing implementation not read to see which clock it uses.
StringLength	Length	combinatorics/combinatorics/collections/src/expression-ops.ts:494	duplicate	Length of a string counts code points, the same as ours (emoji counts one). Ours only accepts a string; Length also applies to lists and collections.
ToCharacterCode	UnicodeScalars	combinatorics/combinatorics/collections/src/expression-ops.ts:535	duplicate	Identical outputs on the probed strings (our reference gives [97] for 'a', [65,66,67] for 'ABC').
FromCharacterCode	StringFrom	combinatorics/combinatorics/collections/src/expression-ops.ts:546	duplicate	The CE head is StringFrom, not CharacterFrom (the first-pass pair was wrong). Same answers for one code point and a list; edge cases (negative, > 0x10FFFF) not probed.
CubeRoot	Root	analysis/analytic/src/cube-root.ts:17	alias-already	Real domain only; adds series, derivative and piecewise integration (PiecewiseExpand has a CubeRoot cell).
SplitBy	ChunkBy	combinatorics/combinatorics/collections/src/list-ops-wolfram.ts:339	duplicate	None found on the reference examples. Argument order is the same (list, f).
BooleanConvert	ToCNF / ToDNF	combinatorics/combinatorics/collections/src/logic-frontier.ts:321	duplicate	Same normal forms on 2-ary inputs, operand order may differ. CE Equivalent takes two arguments (the 3-ary Equivalent reference row is an Error in CE). NNF is ours only (CE's ToCNF of an Implies happens to give the NNF).
FullSimplify	Simplify	analysis/analytic/src/full-simplify.ts:225	alias-already	Starts from Simplify and adds a wider rule set (the Sinh recognition CE does not do).
Array	Tabulate	combinatorics/combinatorics/collections/src/list-frontier.ts:317	unsure	1-D 1-based values agree. CE Tabulate is lazy and stays as Tabulate(...); Array is eager and takes dims lists, origins and a result head. Multi-dimensional Tabulate not probed.

Checked and found different in meaning or shape (not overrides): FractionalPart/Fract, UnitStep/Heaviside, HeavisideTheta/Heaviside, Piecewise/Which, Nest/Iterate, NestList/Iterate, MapThread/Zip, SeedRandom/WithRandomSeed, Switch/Match, With/Block, Association/Dictionary, PadLeft/PadStart, PadRight/PadEnd, ToString/String, Echo/Print, MatchQ/IsMatch, Surd/Root, FactorialPower/Pochhammer, DiagonalMatrix/Diagonal, Commonest/Mode, Split/ChunkBy, GatherBy/GroupBy, FirstPosition/IndexOf, ReplacePart/ReplaceAt, KroneckerSymbol/JacobiSymbol, Maximize/Supremum, Minimize/Infimum, Assuming/Assume, RealSign/Sign, RealAbs/Abs, DiscreteDelta/KroneckerDelta, Subsets/PowerSet, Tuples/CartesianProduct, SortBy/Sort (with key), StringTake/Take, BellNumbers/BellNumber, CatalanNumbers/CatalanNumber, LucasNumbers/Lucas / LucasL, PrimeNumbers/NthPrime, IsPrimePower/IsPerfectPower, PolynomialRoot/PolynomialRoots.

Wrong answers in compute-engine

The take-upstream items where compute-engine returns a wrong value rather than declining. These are the ones to file first.

• Solve(sin x == 2, x) -> List() and Solve(e^x == -1, x) -> List() (0.186, 0.187; both have complex solutions); Solve((x^2+1)^-2 == 0, x) stays unevaluated; Solve(sin x == 1/3, x) -> two 2Pit families and Solve(tan x == 1, x) -> Pi*t + Pi/4 with t an… (ce-patches/src/compute-engine/library/solve.ts:20)
• Shape of a nested list of applications of an unknown function is empty: Shape({{a(1), a(2)}}) -> Tuple() (0.186 and 0.187); the manifest's own fixed() input expects Tuple(1, 2). (ce-patches/src/compute-engine/library/linear-algebra.ts:39)
• Goes through a double and drifts: ['IntegerString',['Factorial',50],16] -> '49eebc961ed2780000...' (true value 49eebc961ed279b02b1e...), and a 30-digit integer in base 10 gives '1.2345678901234568e+29' (0.186 and 0.187). (arithmetic/numerals/src/declare.ts:444)
• Median(List(Pi,1,3)) -> 3 (0.186 and 0.187), but the median of 1, Pi, 3 is Pi. (combinatorics/combinatorics/collections/src/list-stats.ts:68)
• Tabulate(Add, 2, 2, 2) drops the third dimension (-> Tabulate(Add,2,2)); a dimension of 0 stays unevaluated (0.186 and 0.187). (combinatorics/combinatorics/collections/src/list-stats.ts:249)
• All(List(List(1,2),List(3,4)), IsInteger, 2) silently drops the third operand and answers All(list, IsInteger) (0.186 and 0.187). (combinatorics/combinatorics/collections/src/list-levels.ts:419)
• GCD(12, [3, 7, 40]) → 1 (0.186 and 0.187), not a list. (arithmetic/number-theory/src/declare-widened.ts:324)
• NextPrime(-10) → 2 (0.186 and 0.187). (arithmetic/number-theory/src/declare-widened.ts:76)
• FixedPoint(x -> (x+2/x)/2, 1.0) at precision 21 -> 1.4142135623730950488015625 (0.186 and 0.187), wrong from about the 20th digit (sqrt 2 = 1.41421356237309504880168872...). (combinatorics/combinatorics/collections/src/list-functional.ts:163)
• Same(Reverse(List(1,2)), List(2,1)) -> False (0.186 and 0.187): the operands are compared as written, unevaluated. (combinatorics/combinatorics/collections/src/expression-ops.ts:213)
• N(HurwitzZeta(2i, 0)) → NaN and HurwitzZeta(2i, -1) → NaN (0.186 and 0.187); evaluate stays symbolic. (analysis/analytic/src/float-in.ts:46)
• LaTeX: Equal(5!, 5) is written 5!=5 and reads back as NotEqual(5, 5); \mathrm{arcsec}(x) reads as the arcsecond unit; a∖b∖c reads as a∖(b∖c); Transpose(a, perm) and PolyLog(1, 2, 1) lose an operand when written.

Take upstream

One section per kind. Each section's status line says what has been posted. Each repro runs on bare compute-engine with node .scratch/audit/bare.mjs '<MathJSON>' and gives the same answer on 0.186 and 0.187 unless it says otherwise.

The patches in ce-patches

Eight patches, already laid out as in compute-engine (src/compute-engine/{numerics,library,compilation}) with tests written the way upstream's are. Each has a fixed() probe, so it retires itself when compute-engine ships the fix.

Repros:

• '["Integrate",["Power",["Add",1,"x",["Power","x",2]],2],["Limits","x",-1,1]]' -> CE: unevaluated Integrate (N gives 4.4 +- 4e-15 as a Measurement); should evaluate to 22/5 exactly. Fix: in Integrate's handler, retry on Expand(body) when the body is a polynomial of degree >= 2. (ce-patches/src/compute-engine/library/integrate-polynomials.ts:35)

• '["Shape",["List",["List",["a",1],["a",2]]]]' -> CE: Tuple(); should be Tuple(1, 2). Fix: fall back to the structural dimensions of nested Lists when the type has none. (ce-patches/src/compute-engine/library/linear-algebra.ts:39)

• Not probeable with bare.mjs (no compile). Repro: new JavaScriptTarget().compile(ce.box(['MatrixRank','m'])).success is false on CE; should compile. Fix: add a MatrixRank lowering to the JavaScript target. (ce-patches/src/compute-engine/library/linear-algebra.ts:62)

• '["Solve",["Equal",["Sin","x"],2],"x"]' -> CE: List(); should be unevaluated (complex solutions exist) or the complex roots. Also '["Solve",["Equal",["Power",["Add",["Power","x",2],1],-2],0],"x"]' -> CE: unevaluated; should be List(). (ce-patches/src/compute-engine/library/solve.ts:20)

• '["Solve",["Equal",["Power","x",2],"a"],["Element","x","RealNumbers"]]' -> CE: List(Sqrt(a), -Sqrt(a)); should stay unevaluated (a's sign unknown). System input -> CE: unevaluated; should be List(Tuple(3/2, 1/2)) filtered to integers, i.e. List() here (no integer solution). (ce-patches/src/compute-engine/library/solve.ts:174)

• '["Zeta",0,0]' '["Zeta",0,-1]' -> CE: -1/2 and 1/2; should be 1/2 and 3/2. Fix: keep the 0^0 term for s = 0, i.e. return 1/2 - a. (ce-patches/src/compute-engine/library/special-functions.ts:388)

• '["Zeta",2,-1]' -> CE evaluate: Zeta(2,-1); should be 1 + Pi^2/6. Fix: add the finite-sum identity for integer s >= 2 and integer a <= 0. (ce-patches/src/compute-engine/library/special-functions.ts:403)

• --precision=30 '["AGM",1,-10]' -> CE N: double-precision Complex (16 digits); should carry 30 digits. (ce-patches/src/patches/agm-complex.ts:30)

• '["Sum","k",["Limits","k","Nothing",3]]' -> CE: unevaluated; should be 6. (ce-patches/src/patches/iterator-upper-bound.ts:34)

• '["LerchPhi",-1,-1,0.5]' -> CE: unevaluated; should be 0. (ce-patches/src/patches/lerch-phi.ts:65)

• Zeta(0, a) breaks compute-engine's own Wolfram convention at s = 0: Zeta(0, 0) -> -1/2 and Zeta(0, -1) -> 1/2, where Wolfram gives Zeta[0, 0] = 1/2, Zeta[0, -1] = 3/2, Zeta[0, -2] = 5/2 (1/2 - a; checked 2026-11-12). Compute-engine's two-argument Zeta follows Wolfram's |n+a|^-s form on purpose (compute-engine PR #433, issue #428), which drops the (n+a)=0 term for s != 0; at s = 0 Wolfram keeps 1/2 - a. (ce-patches/src/compute-engine/library/special-functions.ts:388)

Proposed fix: send each patch as its own PR with its test file; Zeta(0, a) and Solve returning [] first, since they are wrong answers.

Checked on a fresh engine (CE upstream, 2026-11-12), one item on the first inventory is compute-engine's design, not a wrong answer, and its patch is to be retired rather than sent:

• Sum with no bounds runs k = 1..∞ (compute-engine ruling, 2026-10-20), so Sum(k^2) is PositiveInfinity; the iterator-upper-bound.ts:56 case overrides that ruling.

Also by design or correct on that check: Median(Pi, 1, 3) is 3; Same compares canonical forms without evaluating; GCD takes (any*); NextPrime(-10) follows compute-engine's definition; FixedPoint's first 21 digits are right; N(HurwitzZeta) giving NaN follows CE#355; the Epsil rule key is CE#435 (closed); the doubled Epsil Block is the program's scope around the statement's (commit 930b9cedc). What reproduces: IntegerString past 2^53, Tabulate and All/Any dropping a third operand, Shape of nested applications, Solve missing complex roots of sin and exp, and parseEpsil doubling a Block.

Status: LerchPhi cites CE#340, closed with this case still open. Zeta(0, a): issue CE#524, PR CE#529 (Zeta(2, -1) is not in it). Shape: issue CE#525, PR CE#530. Solve returning []: issue CE#526, no PR yet. The others are not filed. A ninth patch, stepped-iterator (a four-operand Limits steps a Sum or Product, BL-385), landed on main after the inventory and is not measured here.

Numerics that ignore the precision asked, or decline

compute-engine's kernels for the Bessel, Airy, elliptic, exponential-integral and Dedekind eta functions run on doubles: N(x, 30) returns 17 digits, without saying so. Several decline or return NaN at complex or non-integer arguments they could answer.

Repros:

• '["BesselJ",1,["Rational",1,3]]' --precision=30 ; CE gives 0.16436254381427073 (double); should give 30 correct digits. (analysis/analytic/src/bessel-big.ts:41)
• '["BesselJ",0.5,2]' ; CE leaves it unevaluated; should be sqrt(1/pi)*sin(2) = 0.5130 (J_{1/2}(x) = sqrt(2/(pi x)) sin x). (analysis/analytic/src/bessel-big.ts:58)
• '["BetaRegularized",2,2,3]' ; CE unevaluated; should be 8 (binomial tail polynomial). (analysis/analytic/src/beta-continuation.ts:90)
• '["Digamma",["Complex",1,1]]' ; compare the digits of N with an oracle. (analysis/analytic/src/complex-arguments.ts:13)
• '["Beta",["Complex",1,1],2]' ; CE stays Beta(1+i,2); should be Gamma(1+i)*Gamma(2)/Gamma(3+i) as a complex number. (analysis/analytic/src/complex-arguments.ts:25)
• '["N",["DedekindEta",["Complex",0.3,1]],40]' --no-n ; CE returns 16 digits; should return 40. (analysis/analytic/src/dedekind-eta-big.ts:55)
• '["EllipticE",0.5,0.3]' --precision=30 ; CE gives a 16-digit double; should give 30 digits. (analysis/analytic/src/elliptic.ts:205)
• '["EllipticF",0.5,0.3]' --precision=30 ; CE gives a 16-digit double; should give 30 digits. (analysis/analytic/src/elliptic.ts:219)
• '["EllipticPi",0.5,0.3]' --precision=30 ; CE gives a 17-digit double; should give 30 digits. (analysis/analytic/src/elliptic.ts:236)
• '["HurwitzZeta",["Complex",0,2],0]' → CE N: NaN; should stay unevaluated (or Indeterminate). Fix: return undefined from the Hurwitz kernel at a nonpositive-integer a with Re s = 0. (analysis/analytic/src/float-in.ts:46)
• and 8 more sites, in the appendix.

Proposed fix: for each head, either an arbitrary-precision kernel (ours are written against mpmath and could go up head by head) or, at the least, declining when the precision asked is past a double. A kernel that cannot vouch for its digits should leave the call unevaluated.

Status: PR open, posted 2026-11-12 as six pairs: elliptic F/E/Π CE#550 / CE#557; BetaRegularized outside [0, 1] and complex Beta CE#551 / CE#558; complex Zeta(s) through the vouched kernel CE#552 / CE#559; Bessel J/Y/I/K CE#553 / CE#560; DedekindEta CE#555 / CE#561; Airy, ExpIntegralEi and LogIntegral CE#554 / CE#562 (stacked on CE#560). Our N precision patches for these heads retire as each lands. Separately, CE#556: BigDecimal.precision is shared across engines.

Exact values of special functions

Under evaluate, compute-engine leaves a special function at an exact argument unevaluated even where a closed form is standard and N already gives the number. Wolfram returns the closed form.

Repros:

• '["PolyGamma",2,3]' --no-n ; CE unevaluated; should be 9/4 - 2*Zeta(3). (analysis/analytic/src/closed-forms-113.ts:50)
• '["Digamma",["Rational",1,4]]' --no-n ; CE unevaluated; should be -EulerGamma - Pi/2 - 3*Ln(2). (analysis/analytic/src/closed-forms-113.ts:188)
• '["PolyLog",3,["Rational",1,2]]' --no-n ; CE unevaluated; should be (7/8)Zeta(3) - Pi^2 Ln(2)/12 + Ln(2)^3/6. (analysis/analytic/src/closed-forms-113.ts:146)
• '["Gamma",["Rational",1,2]]' --no-n ; CE unevaluated; should be Sqrt(Pi). (analysis/analytic/src/declare.ts:164)
• ["AiryAi",0]: CE leaves it; should be 1/(3^(2/3) Gamma(2/3)). (analysis/analytic/src/special-values.ts:67)
• '["Sinh",["Ln",2]]' → CE evaluate unchanged; should be 3/4. Fix: rewrite f(Ln q) for exact rational q. (analysis/analytic/src/hyperbolic-exact.ts:68)
• ["Ln",-2]: evaluate leaves it; should be Ln(2) + i·π, as N already gives. (analysis/analytic/src/widened.ts:226)
• and 41 more sites, in the appendix.

Proposed fix: add the closed forms to each head's evaluate (integer and half-integer Gamma and PolyGamma, Digamma at rationals with small denominators by Gauss's theorem, PolyLog at 1/2 and ±1, the Airy values at 0, hyperbolics of logarithms). Each is a table or a short formula; ours cite DLMF.

Status: posted 2026-11-12 in three pairs: the Gamma family CE#532 / CE#535; PolyLog, Zeta, Lerch, incomplete Gamma, Beta, Airy and hypergeometric CE#533 / CE#536; hyperbolics of Ln(q) and Arsech CE#534 / CE#537. The PRs change seven compute-engine tests that pinned "stays symbolic"; each PR body lists them.

By compute-engine's design (its rulings; not sent): Ln of a negative exact number stays symbolic (exactness-regressions P0-18); PolyLog(-2, z) at a symbolic z; Arccsc(0) and Arcsec(0); GammaLn of a negative is ln|Γ| (CE#463).

Deferred for compute-engine's design call: values at i·t (the Multiply(Complex(0, 1), t) shape), IsOdd(Pi), Floor(Floor(x)), Max(x, x), Erf(i), half-integer Binomial, CatalanNumber and Pochhammer, and Arccot(1/2).

Parity, inverse compositions and infinities of elementary functions

Odd and even symmetry, f(f⁻¹(x)), cross compositions (Cos(Arctan(x))), imaginary arguments and the values at ComplexInfinity are not applied; one is a type error.

Repros:

• '["Tan",["Negate","x"]]' --no-n ; CE unevaluated; should be -Tan(x). (analysis/analytic/src/elementary-remaining.ts:60)
• '["Cos",["Negate","x"]]' --no-n ; CE unevaluated; should be Cos(x). (analysis/analytic/src/elementary-remaining.ts:70)
• '["Arccos",["Negate","x"]]' --no-n ; CE unevaluated; should be Pi - Arccos(x). (analysis/analytic/src/elementary-remaining.ts:79)
• '["Sin",["Arcsin","x"]]' --no-n ; CE unevaluated; should be x. (analysis/analytic/src/elementary-remaining.ts:103)
• '["Cos",["Arcsin","x"]]' --no-n ; CE unevaluated; should be Sqrt(1 - x^2). (analysis/analytic/src/elementary-remaining.ts:118)
• '["Cos",["Arctan","x"]]' --no-n ; CE unevaluated; should be 1/Sqrt(1 + x^2). (analysis/analytic/src/elementary-remaining.ts:126)
• '["Sin",["Arctan","x"]]' --no-n ; CE unevaluated; should be x/Sqrt(1 + x^2). (analysis/analytic/src/elementary-remaining.ts:135)
• '["Tan",["Arcsin","x"]]' --no-n ; CE unevaluated; should be x/Sqrt(1 - x^2). (analysis/analytic/src/elementary-remaining.ts:146)
• and 15 more sites, in the appendix.

Proposed fix: canonical-form rules for parity and f(f⁻¹(x)), and ComplexInfinity admitted by the hyperbolic signatures.

Status, 2026-11-12:

• PR open, issue CE#564 / PR CE#565: f(f⁻¹(x)), Arcsin(Sin(y)) at exact real y, Arcoth parity, the Arccos(-x) and Arcsec(-x) reflections, the Pythagorean cross compositions, imaginary arguments, sin/cos to tan and cosh² − sinh². The PR also fixes a stack overflow on compute-engine main, Arcsin(Sin(4)).simplify().
• Already native, but only under simplify(): parity of Tan, Cot, Csc, Arcsin, Arctan, Arccsc and the hyperbolics, Sin(x + kπ), sin² + cos², Arsech(1), Log(1/8, 2) and Ln(1/n). Ours fold them under evaluate(), so those sites unwind only where no example depends on the evaluate() fold.
• Open decision: values at ComplexInfinity (Tanh(~oo), Ln(~oo)). compute-engine leaves them out on purpose (comments in simplify-trig and simplify-hyperbolic); asked in CE#564. Ours stay until it answers.
• Open decision: Arccot(-x). compute-engine's real Arccot has range (0, π) but its complex kernel is odd; which convention is CE#563. Ours stay meanwhile.

Calculus

Derivatives of several special functions, higher-order D, a class of infinite sums, series at infinity and powers of trigonometric integrands are not evaluated.

Repros:

• '["D",["HarmonicNumber","z"],"z"]' --no-n ; CE gives Apply(Derivative(HarmonicNumber,1),z); should be PolyGamma(1, z+1). (analysis/analytic/src/derivatives.ts:145)
• '["D",["Power","x","n"],["List","x",3]]' --no-n ; CE unevaluated; should be n(n-1)(n-2) x^(n-3). (analysis/analytic/src/derivatives.ts:162)
• '["Sum",["Divide",["Power","k",3],["Factorial","k"]],["Limits","k",1,"PositiveInfinity"]]' ; CE unevaluated; should be 5*E. (analysis/analytic/src/dobinski.ts:36)
• '["MatrixRank",["List",["List","a","b"],["List","c","d"]]]' → CE unevaluated; Wolfram 2. (analysis/analytic/src/linear-algebra-113.ts:37)
• ["Series",["AiryAi","x"],"x",["DirectedInfinity",1],3] and ["Series",["Hypergeometric2F1",1,1,3,"x"],"x",1,3]: CE expands with f(∞) / Apply(Derivative(...)) terms; it should return the call unevaluated. Proposed fix: Series declines when the point is an infinity or f has a pole in a derivative at the point. (analysis/analytic/src/series-infinite.ts:45)
• --latex '\int \sin^3 x, dx': CE leaves Integrate; should be −cos x + cos³x/3. Fix: add the odd-power reduction to the integration rules. (analysis/analytic/src/trig-power-integrals.ts:97)

Proposed fix: derivative table entries for Zeta, HurwitzZeta, ErfInv, Beta, the orthogonal polynomials; D(f, [x, n]) by repeated differentiation; the rest are larger and would go as separate proposals.

Status, 2026-11-12:

• Series at infinity, PR open, issue CE#572 / PR CE#573: DirectedInfinity is read as ±∞; ComplexInfinity expands only when the ±∞ expansions agree and there is no branch point; a coefficient left as an unresolved library Derivative declines. Whether that decline is general or limited to a pole table is the maintainer's call.
• Derivatives, PR open, issue CE#574 / PR CE#575: closed-form partials for ErfInv, Beta, HurwitzZeta in a, LerchPhi, BarnesG, LogBarnesG, EllipticK/EllipticE and ClausenCl, and D(f, [x, n]) read as the order pair. HarmonicNumber's derivative is in CE#519.
• Open decision, ours stays: ∂ of two-argument Zeta(s, a) in a. compute-engine defines that Zeta as Σ|n + a|^-s, so Wolfram's −s ζ(s + 1, a) is wrong there for a < 0.
• Dobiński sums, PR open, issue CE#576 / PR CE#577: Σ P(k) r^k / k! (Touchard).
• Integrals of sin^m x cos^n x, PR open, issue CE#578 / PR CE#579; the output form of the even-even cases is the maintainer's call.
• Symbolic MatrixRank, PR open, issue CE#580 / PR CE#581: generic rank by sampling. compute-engine leaves symbolic determinants undetermined on purpose (a comment in its source), so if the maintainer declines, ours stays.

Argument shapes on special functions

Wolfram's incomplete and generalized forms (Beta(z, a, b), Erf(z0, z1), Gamma(a, z0, z1), PolyGamma(z)) are arity errors.

Repros:

• '["Beta",["Rational",1,2],2,3]' → CE error; should be 11/192 (Wolfram). Fix: add 3- and 4-argument signatures and evaluate B_z via BetaRegularized·Beta. (analysis/analytic/src/generalized-special.ts:81)
• '["Beta","a",1]' → CE unevaluated; should be 1/a. And '["Beta",0,"PositiveInfinity"]' → CE NaN; should be ComplexInfinity. (analysis/analytic/src/generalized-special.ts:83)
• '["BetaRegularized",0.2,0.5,2,3]' → CE error; should be BetaRegularized(0.5,2,3) − BetaRegularized(0.2,2,3). (analysis/analytic/src/generalized-special.ts:147)
• '["BetaRegularized",0.2,0.5,2,3]' → CE error; should be the difference of two native calls. (analysis/analytic/src/generalized-special.ts:149)
• '["Erf",0.1,0.5]' → CE error; should be Erf(0.5)−Erf(0.1). (analysis/analytic/src/generalized-special.ts:174)
• '["Erf",["Negate","x"]]' '["Erf",["ErfInv","x"]]' → CE unevaluated; should be -Erf(x) and x. (analysis/analytic/src/generalized-special.ts:176)
• and 6 more sites, in the appendix.

Proposed fix: widen each signature and add the generalized evaluation; ours reduce to the existing kernels.

Status, 2026-11-12:

• PR open, issue CE#566 / PR CE#567: Beta(z, a, b) and Beta(z0, z1, a, b), BetaRegularized(z0, z1, a, b), Erf(z0, z1) and ErfInv(z0, z), Gamma(a, z0, z1) and GammaRegularized(a, z0, z1), PolyGamma(z) as PolyGamma(0, z). The PR also makes the compile targets decline these shapes; today JavaScript drops the extra operands (Erf(x, y) compiles as erf(x)).
• Not sent, ours stay where examples rely on them: Beta(0, ∞) (compute-engine rules it NaN in betaValueAtInfinity); Erf(-x) and Erf(ErfInv(x)) (a simplification question, not a call shape); Rationalize of an expression holding floats (compute-engine types its result rational); PolyLog(n, p, z) (ours by design).

Integer functions

The integer functions accept only positive integers. Wolfram extends most of them to negatives, rationals and reals, and adds an offset or a polynomial argument. Two answers are wrong: NextPrime(-10) is 2 (Wolfram: -7) and GCD(12, [3, 7, 40]) is 1 instead of threading.

Repros:

• '["NextPrime",-10]' -> 2; should be -7. Fix: for n < -2 return -(largest prime < -n). (arithmetic/number-theory/src/declare-widened.ts:76)
• '["GCD",12,["List",3,7,40]]' -> 1; should be [3,1,4]. (arithmetic/number-theory/src/declare-widened.ts:324)
• '["DivisorSigma",-1,12]' -> CE unevaluated; should be 7/3. Fix: for k < 0 evaluate σ_{-k}(n)/n^{-k}. (arithmetic/number-theory/src/declare-widened.ts:55)
• '["GCD",["Rational",1,2],["Rational",1,3]]' -> unevaluated; should be 1/6. (arithmetic/number-theory/src/declare-widened.ts:175)
• '["IsSquareFree",["Rational",6,35]]' -> Error; should be True. (arithmetic/number-theory/src/declare-widened.ts:217)
• '["Mod",7,5,3]' -> Error; should be 7 (x ≡ 7 mod 5 with 3 <= x < 8). (arithmetic/number-theory/src/declare-widened.ts:349)
• '["ExtendedGCD",12,18,27]' -> Error; should be a Tuple with g = 3 and Bezout coefficients. (arithmetic/number-theory/src/declare-widened.ts:401)
• '["Binomial","n",["Subtract","n",1]]' -> unevaluated; should be n. (arithmetic/number-theory/src/declare.ts:269)
• '["Fibonacci",10,"x"]' -> Error; should be x^9 + 8x^7 + 21x^5 + 20x^3 + 5x. (arithmetic/number-theory/src/declare.ts:489)
• '["IsSquareFree",["Multiply",{"num":"2305843009213693951"},{"num":"618970019642690137449562111"}]]' -> throws; should be True. (arithmetic/number-theory/src/declare-widened.ts:241)
• and 26 more sites, in the appendix.

Proposed fix: widen the signatures and add the extensions; fix NextPrime below 2 and GCD/LCM over a list operand.

Status: posted 2026-11-12: NextPrime, DivisorSigma, FactorInteger, IsSquareFree, CatalanNumber on rationals and negatives CE#542 / CE#543; n-ary ExtendedGCD, Fibonacci(n, x), BellNumber(n, x), symbolic Binomial(n, n-1) CE#544 / CE#545.

By compute-engine's design (its rulings; not sent): GCD and LCM of rationals stay symbolic; CarmichaelLambda(n) for n ≤ 0. Deferred: DivisorSigma with a symbolic k.

Digits

IntegerString loses digits past 2^53; FromDigits takes no string and no symbolic or negative base; the length and position arguments are missing.

Repros:

• ['FromDigits',{'str':'ff'},16] -> should be 255; ['FromDigits',{'str':'1923'}] -> 1923 (arithmetic/numerals/src/declare.ts:339)
• ['FromDigits',['List',1,2,3],'x'] -> should be x^2+2x+3 (arithmetic/numerals/src/declare.ts:356)
• ['FromDigits',['List',1,1,0],-2] -> should be 2 (arithmetic/numerals/src/declare.ts:378)
• ['IntegerString',{'num':'123456789012345678901234567890'},10] -> should be '123456789012345678901234567890' (CE: '1.2345678901234568e+29'); ['IntegerString',['Factorial',50],16] -> '49eebc961ed279b02b1ef4f28d19a84f5973a1d2c7800000000000' (arithmetic/numerals/src/declare.ts:444)
• ['IntegerString',5,2,8] -> should be '00000101' (arithmetic/numerals/src/declare.ts:456)
• ['DigitSum',1234,10,2] -> should be 3 (1+2) (arithmetic/numerals/src/declare.ts:497)
• and 3 more sites, in the appendix.

Proposed fix: use bigint arithmetic in IntegerString; accept a string in FromDigits; add the optional arguments.

Status: IntegerString and DigitsFrom past 2^53: issue CE#523, PR CE#528. FromDigits in any base and the IntegerString/DigitCount/DigitSum length and position arguments: issue CE#582, PR CE#583, stacked on CE#528. The string form was left out (a string arm in the slot broke compute-engine's parameter inference for user functions); CE#582 asks how compute-engine would want it, and until then it is ours.

Modular powers and the Chinese remainder

PowerMod and PowerModList are lazy with a canonical handler that rejects a rational base and a list; ChineseRemainder has no offset.

Repros:

• ['PowerMod',['Rational',1,2],2,7] -> should be 2 (the inverse of 2 squared is 1/4 = 2 mod 7) (arithmetic/residues/src/declare.ts:56)
• ['PowerMod',['Rational',1,2],2,7] -> 2; ['PowerMod',3,0,-5] -> 1 (as Wolfram) (arithmetic/residues/src/declare.ts:59)
• ['PowerModList',['List',2,3],2,7] -> should be 4],[2 (arithmetic/residues/src/declare.ts:99)
• ['PowerModList',['List',2,3],2,7] -> should be 4],[2 (arithmetic/residues/src/declare.ts:100)
• ['PowerMod',['Rational',1,2],2,7] -> should be 2 (arithmetic/residues/src/declare.ts:115)
• and 2 more sites, in the appendix.

Proposed fix: a rational base as the modular inverse, broadcastable: true, and the third argument. With that, our removal of their laziness (residues/src/declare.ts:54, a Needs-Dean item) goes away.

Status: posted 2026-11-12: PowerMod with a rational base and threading over lists, ChineseRemainder(r, m, d) CE#546 / CE#547; the Mod(m, n, d) offset as a design question only, CE#548.

By compute-engine's design (its ruling; not sent): PowerMod with a negative modulus.

List heads

Wrong answers (Median of non-literal numbers, Tabulate in three dimensions, All/Any with a level, Same on unevaluated operands, Rationalize(x, 0), FixedPoint past double precision) and Wolfram call forms that are type errors.

Repros:

• ["Median",["List","Pi",1,3]] -> CE 3; should be Pi. Fix: compare elements by numeric value and return the exact middle element. (combinatorics/combinatorics/collections/src/list-stats.ts:68)
• ["Tabulate","Add",2,2,2] -> CE Tabulate(Add,2,2) (third dimension dropped); should be a 2x2x2 array. Fix: keep all dimensions. (combinatorics/combinatorics/collections/src/list-stats.ts:249)
• ["All",["List",["List",1,2],["List",3,4]],"IsInteger",2] -> CE drops the 2; should test the level-2 elements. Fix: honor or reject the third operand. (combinatorics/combinatorics/collections/src/list-levels.ts:419)
• ["Same",["Reverse",["List",1,2]],["List",2,1]] -> CE False; should be True. Fix: evaluate operands before comparing. (combinatorics/combinatorics/collections/src/expression-ops.ts:213)
• ["Rationalize",0.1,0] -> CE 1/10; Wolfram Rationalize[0.1,0] = 3602879701896397/36028797018963968. Fix: when the tolerance is exactly 0, convert the double exactly. (combinatorics/combinatorics/collections/src/arith-heads.ts:53)
• ["FixedPoint",["Function",["Divide",["Add","x",["Divide",2,"x"]],2],"x"],1.0] (N at default precision) -> CE 1.4142135623730950488015625; should be 1.41421356237309504880. Fix: iterate with guard digits and round the result. (combinatorics/combinatorics/collections/src/list-functional.ts:163)
• ["First",["List"],0] -> CE: Error unexpected-argument; should be 0 (combinatorics/combinatorics/collections/src/list-heads.ts:228)
• ["Mean",["List",["List",1,2],["List",3,4]]] -> CE: Error; should be List(2,3) (combinatorics/combinatorics/collections/src/list-heads.ts:310)
• ["Flatten",["List",["List",1,["List",2]],3],"PositiveInfinity"] -> CE Error; should be [1,2,3]. Fix: accept PositiveInfinity as depth. (combinatorics/combinatorics/collections/src/list-levels.ts:321)
• ["Fold","Add",["List",1,2,3]] -> CE Error missing; should be 6. Fix: treat a two-argument Fold as seeded by First. (combinatorics/combinatorics/collections/src/list-stats.ts:200)
• ["Apply",["Map","Negate"],["List",1,2]] -> CE Error missing; should be [-1,-2]. Fix: allow a one-operand Map/Filter/Fold as a curried callee. (combinatorics/combinatorics/collections/src/operator-forms.ts:22)
• ["Min"] -> CE Error missing; should be PositiveInfinity (and ["Max"] NaN should be NegativeInfinity). (combinatorics/combinatorics/collections/src/rounding-heads.ts:59)
• and 32 more sites, in the appendix.

Proposed fix: the wrong answers one PR each; the call forms batched per head, each a signature widening plus a branch.

Status: Tabulate in three dimensions and All/Any with a third operand: issue CE#525, PR CE#530 (with Shape). Also posted 2026-11-12: the call forms (First/Last with a default, Flatten to infinite depth, unseeded Fold, Count with a level, Unique with a test) CE#538 / CE#539; Chop with a tolerance and Rationalize(x, 0) CE#540 / CE#541.

By compute-engine's design (its rulings; not sent): statistics of a matrix (statistics take collection<number>, CE-13); Min() and Max() with no arguments are NaN. Deferred for a design call: the operator forms Map(f) and Filter(p) (Apply reads an expression callee as a function literal), Partition with an overhang or UpTo, and At with a Span.

Distributions

A float argument gives a half-exact result, and UniformDistribution has no list form.

Repros:

• ["PDF",["NormalDistribution",0.0,1],["Rational",1,2]] -> CE exact expression; should be a float, 0.3520653267642995. Fix: apply N when any operand is a float. (combinatorics/statistics/src/distributions-6.ts:922)
• ["Mean",["UniformDistribution",["List",1,3]]] -> CE Error missing; should be 2. Fix: normalize the list and zero-argument forms to (min, max). (combinatorics/statistics/src/distributions.ts:153)
• ["Mean",["UniformDistribution",["List",1,3]]] -> CE Error missing; should be 2. (combinatorics/statistics/src/distributions.ts:158)

Proposed fix: numericize when an operand is a float (a float operand gives a float result); accept UniformDistribution([a, b]).

Status, 2026-11-12: PR open, issue CE#568 / PR CE#569. A float operand gives a float result for PDF, CDF, Quantile, Mean, Variance and SD; at a float point a discrete distribution follows Wolfram (CDF reads the floor and stays exact, PDF is exact 0 off the integers); UniformDistribution([a, b]) and UniformDistribution() are accepted. A discrete Quantile stays unevaluated, left out of the PR.

Continued fractions

A quadratic irrational has a periodic expansion; compute-engine returns 20 terms of it.

Repros:

• '["ContinuedFraction","ExponentialE",40]' -> CE: 19 terms with a wrong last term; should be {2,1,2,1,1,4,1,1,6,1,1,8,1,1,10,1,1,12,1,1,14,...} (40 terms). Fix: compute at enough precision with an agreement check and stop or decline otherwise. (groups/modular/src/declare.ts:602)
• '["FromContinuedFraction",["List",1,["List",2]]]' -> CE: unevaluated; should be Sqrt(2). (groups/modular/src/declare.ts:634)

Proposed fix: return the periodic form (pre-period and period) and read it back in FromContinuedFraction.

Status, 2026-11-12: PR open, issue CE#570 / PR CE#571: the periodic form for quadratic irrationals (Sqrt(23) gives [4, [1, 3, 1, 8]]), FromContinuedFraction reading it back, and exactly n verified terms for E and Pi, or a decline. Open with compute-engine: the result type, and negative reals, where compute-engine keeps its floor expansion and Wolfram gives signed terms; ours stay where examples rely on signed terms.

LaTeX round trips

The serializer writes forms the parser reads as something else, or that drop an operand. These are the entries in the LaTeX table marked take upstream.

Repros:

• ce.box(["Equal", ["Factorial", 5], 5]).latex is 5!=5; ce.parse("5!=5") is NotEqual(5, 5). Write a space or a thin space after a postfix ! before =.
• ["Arcsec", "x"] is written \mathrm{arcsec}(x), read as InvisibleOperator(__unit__ arcsec, x). Write \operatorname{arcsec}, or read \mathrm{arcsec} followed by arguments as the function.
• ["Union", "a", "b", "c"] is written a\cup b\cup c, read as Union(a, Union(b, c)); ["SetMinus", "a", "b", "c"] reads as SetMinus(a, SetMinus(b, c)), a different set. Read a chain of one associative sign as one n-ary head, and bracket a left-nested SetMinus.
• ["Transpose", "a", "p"] is written a^T; ["PolyLog", 1, 2, 1] as \operatorname{Li}_{1}(2); ["Derivative", "f", 4] as f^{(4)}, read as a power. Write the call when the sign cannot carry every operand.
• ["MemberCall", "enumeratio", "PolygonalNumber", 4, 5] is written as \mathrm{MemberCall}(…), which does not read back. Write \operatorname{ns.Name}(args).
• ["Arccot", "x"] is written \mathrm{arcctg}(x), "EulerGamma" as \operatorname{EulerGamma}, ["Erf", "x"] as \mathrm{Erf}(x). Write \operatorname{arccot}, \gamma, \operatorname{erf}, which already parse.

Proposed fix: one PR for the serializer, in the spirit of CE#518.

Status: CE#517 (open issue) describes the lost operands; CE#518 (open PR) fixes Transpose axes and Derivative orders, and now also 5!=5 and \mathrm{arcsec}. Rechecked 2026-11-12 on compute-engine's own entries: n-ary Union and Intersection, a nested Integrate, the Erf/Arccot/EulerGamma/Exp spellings, a Divide with a negative part and MemberCall all read back, so ours are by design. \mathrm{B} with three or four arguments goes with CE#567. One real loss remains: A \setminus B \setminus C parses right-nested ({1,2,3,4}∖{2}∖{4} gives {1,3,4}): issue CE#584, PR CE#585.

Epsil: the doubled Block and unresolved rule keys

Two reads that parseExpression corrects after parseEpsil.

Repros:

• parseEpsil("Block(a := 1, a)")[0] is Block(Block(Assign(a, 1), a)). This is compute-engine's design (the outer Block is the program, the inner one the statement's scope; commit 930b9cedc), not a bug; withoutProgramBlock drops only the program's Block and keeps the statement's.
• resolveLibraryNames turns isPrime(7) into IsPrime(7) but leaves f(x, isPrime -> Teal) with the key isPrime.

Proposed fix: walk a KeyValuePair's key in resolveLibraryNames. The doubled Block stays as compute-engine has it.

Status, 2026-11-12: not sent. Both are compute-engine's design: a rule key is a name, and resolving it would turn max -> 3 into Max -> 3. Ours stays by design.

Small asks that would let us drop reads of internals

Three places reach into compute-engine because a public equivalent is missing.

Repros:

• engine/src/compiled.ts:90 scrapes the JavaScript target's _SYS helpers from a compiled function's .run.SYS. Ask: export them.
• engine/src/extend.ts:97 reinstates the built-in lowering after a package wraps a head's evaluate, because compute-engine then treats the head as a user definition that does not compile. Ask: a declared way to say "this wrapper keeps the head's lowering".
• engine/src/modular.ts:169 patches the node class's prototype so Mod(Fibonacci(10^9), 1000) is computed without building the operand. Ask: a per-head hook for evaluating under a modulus (it is also a Needs-Dean item).

Proposed fix: raise them together as one design issue; each removes a version-pinned read in engine/src/ce-internals.ts.

Status: CE#527.

Open decisions

Mandelbrot and Julia: same names, different functions

compute-engine ships Mandelbrot(c, n) and Julia(z, c, n) as a smooth escape-time value in [0, 1], with JavaScript and GLSL lowerings. We redeclare both as the n-th complex iterate with n optional, and replace both lowerings (analytic/src/fractal.ts:67, :74). One reference example (Mandelbrot) depends on ours.

Options:

1. Rename ours (MandelbrotIterate, JuliaIterate) and let compute-engine's heads through.
2. Adopt compute-engine's meaning and drop ours; the plots that colour by iterate would colour by escape time.
3. Keep the shadowing.

Recommendation: rename ours. A name that means two things depending on which library loaded is the costliest kind of override, and the rename is mechanical.

Speed-only kernels

Factorial (product tree), GCD (Stein and Lehmer), Fibonacci/LucasL (fast doubling), NthPrime and PrimePi (sieves, Deléglise–Rivat) return what compute-engine returns, faster. PrimePi also answers past 10^7 iterations, where compute-engine throws. Disabling four of the five changes no example value.

Options:

1. Offer them upstream; they are self-contained and compute-engine is where the math should live.
2. Keep them as ours.
3. Drop the four that only change speed and keep PrimePi.

Recommendation: offer upstream, PrimePi first (it fixes a thrown cancellation), and keep them until they land. They cost little on a bump because they call no internals.

Wolfram conventions on compute-engine heads

Five sites change what a compute-engine head returns to match Wolfram: Union of lists gives a sorted list (compute-engine: a Set), Partition drops a ragged remainder (compute-engine keeps it), Rank is ArrayDepth (compute-engine: tensor rank), Flatten takes a level permutation, and FromContinuedFraction of symbols expands to a nested fraction, which matches neither system's combined ratio. 26 example values depend on them.

Options:

1. Keep all five: the vocabulary is Wolfram's.
2. Give the differing behaviour its Wolfram name (ArrayDepth) or an option, and restore compute-engine's on the shared name.
3. Propose the Wolfram behaviour upstream behind options.

Recommendation: keep Union and Partition (the examples and the oracle rows follow Wolfram), move Rank to ArrayDepth since compute-engine's Rank is a different, legitimate function, and settle FromContinuedFraction with the oracle: it is the one that disagrees with Wolfram too.

N as a correctly rounded value

analytic/src/correctly-rounded.ts:193 replaces N: Ziv's loop evaluates at two precisions and widens until they agree, uses certified enclosures where a head has them, and declines when a double-only kernel cannot back the digits asked. Sixteen example values depend on it. It exists because compute-engine's N(x, d) returns whatever its kernel produced: a wrong last digit (N(DirichletBeta(2), 40)) or a double (N(BesselJ(1, 2), 30)).

Options:

1. Keep it as a layer over every N.
2. Send the per-head fixes upstream (the precision section above) and shrink the loop as they land.
3. Make it opt-in.

Recommendation: keep it and do the second. It is the project's numerics rule (decline rather than answer wrong), and it only gets cheaper as kernels are fixed upstream.

A float in gives a double out

For a double operand compute-engine returns a 21-digit bignum whose extra digits are padding (LerchPhi(0.5, 2, 1)). analytic/src/float-in.ts:29 rounds such answers to a double, for LerchPhi and the Jacobi heads.

Options:

1. Keep the rule as ours.
2. Propose it upstream as a general rule for float operands.
3. Drop it and show the padded digits.

Recommendation: keep, and raise it upstream as a question rather than a PR: it is a design call for the maintainer, and compute-engine's result is not wrong.

Values that differ from both compute-engine and Wolfram

Three sites answer where both systems hold or differ: within 4 ulps of kπ/2 the hyperbolics snap the argument to the exact multiple (hyperbolic-half-period.ts:56), so the result is the value at π/2 and not at the double given; exact principal values outside the real domain (Arcsin(2), widened.ts:284), which Wolfram leaves unevaluated; CatalanNumber(-1) = -1 (widened.ts:156), which follows one oracle against two. 38 example values depend on them.

Options:

1. Keep each.
2. Fall back to compute-engine's behaviour (unevaluated, stray real part).
3. Keep the exact forms, drop the snapping.

Recommendation: drop the snapping (it changes the correct value of the input, against the numerics rule), keep the exact principal values, and leave CatalanNumber at negative integers in triage with the oracle rows: it is a judgment, not a convention.

Every head pure by default

engine/src/purity.ts:103 patches ce.declare on the instance so every operator that states no purity is pure: true, except a hand-kept list of impure heads. compute-engine from 0.174 does not memoize an operator that states none. A head missing from the list is memoized wrongly.

Options:

1. Keep the default and the list.
2. State pure on each definition and remove the patch.
3. Ask compute-engine for a library-level default.

Recommendation: state it per definition. It is a mechanical change across the symbol packages, it removes a monkey-patch of ce.declare, and the list is the same kind of hand-kept table as the set-head list BL-388 removes. Not measured on 0.187.

Reads and writes of compute-engine internals

engine/src/ce-internals.ts reads underscore members and the scope chain; engine/src/modular.ts:169 patches the node prototype for Mod; residues/src/declare.ts:54 removes lazy and the canonical handler from PowerMod and the other residue heads by direct mutation; ce-patches/…/special-functions.ts:125 replaces compute-engine's own JavaScript and GLSL lowerings of LerchPhi with ours. Each is pinned to 0.186.0 by tests/ce-internals.test.ts and has to be rechecked on every bump. Three files cast to _fn directly instead of calling canonicalCall.

Options:

1. Keep them, and route the three raw casts through canonicalCall.
2. Ask compute-engine for the public equivalents (the small-asks section) and remove them as they land.
3. Drop the Mod fast path and the LerchPhi lowering and accept compute-engine's.

Recommendation: the first now and the second as one design issue. The LerchPhi lowering needs a measurement first: ours matches our evaluate past |z| ≥ 1, and compute-engine's compiled coverage there was not compared.

Wolfram names for functions compute-engine already has

Total (Sum/Reduce), IntegerPart (Truncate), EllipticTheta (JacobiTheta), AbsoluteTiming (Timing), StringLength (Length), ToCharacterCode (UnicodeScalars), FromCharacterCode (StringFrom), SplitBy (ChunkBy) and BooleanConvert (ToCNF/ToDNF) each have their own TypeScript evaluate that computes what the compute-engine head computes. They agree on every reference example; the edge cases differ (an empty list, a complex operand, a tuple against a list).

Options:

1. Define each as an alias in Epsil that calls the compute-engine head, keeping the Wolfram name.
2. Keep the separate implementations.
3. Drop the Wolfram names where compute-engine's exists.

Recommendation: the first, head by head, with the reference examples as the check. It keeps the vocabulary and moves the math to compute-engine. It is not done here because the edge cases need an oracle row each before the implementation changes.

No longer needed on 0.187 but still needed on 0.186

None found. Every site whose ablation differs between the two versions (29 sites) differs by one to three examples that time out or reorder terms, not by compute-engine answering what the override adds; the LaTeX and parse probes are identical on both versions. 0.187's breaking changes (boxing no longer declares symbols, compile() typing its inputs, branch assignment) do not retire an override; they are a porting cost on the overrides that read compute-engine internals (engine/src/ce-internals.ts, engine/src/extend.ts, engine/src/purity.ts).

Out of scope, noticed on the way

• Removing a wrapper changes which package a head's record says it overrides. node packages/census/scripts/type-records.ts rewrote seven records' typed rows (Factorial2, MatrixRank, Mod, BarnesG, DirichletBeta, DirichletEta, DirichletL); those edits are in the unwind commits. With them the lazy resolver no longer loads analytic for an expression whose only analytic head is BarnesG, DirichletEta, DirichletBeta or DirichletL; manifest/tests/resolve.test.ts used BarnesG as its example of a native head we override and now uses LogGamma.
• isPositiveInfinity in analytic/src/special-functions-remaining.ts (isInfinity && re > 0) also accepts ComplexInfinity, so HarmonicNumber(ComplexInfinity) is PositiveInfinity. The same predicate made the five removed wrappers answer there.
• The comment above the precision restore in evaluation/src/cooperative-evaluate.ts:56 says compute-engine's N(x, d) leaves ce.precision at d. Bare 0.186 and 0.187 restore it (21 before and after N(Pi, 50)). The restore is still a reasonable guard; the comment is stale.
• analytic/tests/trig-reduction.test.ts now tests compute-engine alone. It could move to ce-patches/tests as a landed check or be dropped once the reference examples' known values cover the same inputs.
• number-theory's threadOverLists call names KroneckerSymbol, which modular declares. The flag belongs with the declaration; today it works only because of the order the libraries load in.
• engine/src/apply-function.ts substitutes into a Function body with its own rules and never threads, while compute-engine's Apply threads over a list. The two can disagree on the same expression.
• frontend/tests/conventional-latex.test.ts still lists LCM, MatrixRank and Zeta cases; they pass against compute-engine's own entries and now act as a check on it.
• The ablation's 3-second budget makes a few slow examples (Series at infinity, NExpectation) flip to a timeout from run to run; they are noise in the per-site counts, not changes.

Appendix: every override site

One row per site the inventory found (inventory.json): a write to a compute-engine head's definition by wrapOperator, widenSignature, extendHead, defineOverload, threadOverLists, declareCompile or a direct assignment. "Examples" is the ablation: example values changed / examples re-evaluated with the site disabled, on 0.186 and on 0.187 (+ marks a run cut at its time budget).

ce-patches

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
compute-engine/library/integrate-polynomials.ts:35 (direct)	Integrate	Leaves an Integrate of a power of a polynomial past linear unevaluated: Integrate((1+x+x^2)^2, x from -1 to 1).evaluate() -> Integrate(...) unchanged (0.186 and 0.187); (x^2+1)^2 indefinite also stays Integrate.	Retries the native handler on the Expand of a polynomial integrand (degree >= 2) when the first call returns an Integrate, so the integral is computed.	Keep, take upstream.	2/57 / 1/57	ea3dcb069 chore: compute-engine 0.170 (#1090)
compute-engine/library/linear-algebra.ts:39 (direct)	Shape	Shape of a nested list of applications of an unknown function is empty: Shape({{a(1), a(2)}}) -> Tuple() (0.186 and 0.187); the manifest's own fixed() input expects Tuple(1, 2).	When the operand's type carries no dimensions, falls back to the nested List's own structure and answers Tuple(1, 2).	Keep, take upstream.	1/15 / 1/15	ea3dcb069 chore: compute-engine 0.170 (#1090)
compute-engine/library/linear-algebra.ts:58 (direct)	MatrixRank	Already exact for a matrix of rationals: MatrixRank(Hilbert 12x12 rationals).evaluate() -> 12 and the 20x20 -> 20 (0.186 and 0.187); only .N() gives 10 and 17 (entries turned to doubles).	Takes an exact (Bareiss) path for an all-integer-or-rational matrix and answers ce.number(rank); anything else goes to native.	Unwind (done).Removed: MatrixRank keeps compute-engine's evaluate.	0/28 / 0/28	7b80bb695 ce-patches: MatrixRank compiles, and the alternating sign matrix rank…
compute-engine/library/linear-algebra.ts:62 (declareCompile)	MatrixRank	Not probed (bare.mjs does not compile); the comment and the patch's fixed() state that the JavaScript target has no lowering for MatrixRank.	Supplies a JavaScript lowering (exact Bareiss elimination over integers and rationals, relative-tolerance floating elimination for non-integers).	Keep, take upstream.	0/28 / 0/28	7b80bb695 ce-patches: MatrixRank compiles, and the alternating sign matrix rank…
compute-engine/library/solve.ts:20 (direct)	Solve	Solve(sin x == 2, x) -> List() and Solve(e^x == -1, x) -> List() (0.186, 0.187; both have complex solutions); Solve((x^2+1)^-2 == 0, x) stays unevaluated; Solve(sin x == 1/3, x) -> two 2Pit families and Solve(tan x == 1, x) -> Pi*t + Pi/4 with t an…	Declines (returns unevaluated) where an empty list is not proved, answers List() where it is provably empty (never-zero residual, sqrt(x) == -1), and declines a bare-unknown trig equation that yields principal solutions.	Keep, take upstream.	9/35 / 9/35	84a02ef70 fix: Solve of an identity, Take/Drop with a negative count, log combination…
compute-engine/library/solve.ts:174 (direct)	Solve	Solve(x^2 == a, Element(x, RealNumbers)) -> [Sqrt(a), -Sqrt(a)] unfiltered, and a system with Element-domained unknowns (Solve({x+y==2, x-y==1}, Element(x,Integers), Element(y,Integers))) stays unevaluated (0.186, 0.187).	Tests each solution against its unknown's domain, keeps members, drops non-members, declines when membership is undecided, and solves a system over the complexes first then filters tuple by tuple.	Keep, take upstream.	1/35 / 1/35	5c1162bfd fix: Solve filters by domain; polynomial powers integrate (#673)
compute-engine/library/special-functions.ts:388 (wrapOperator)	Zeta	Drops the (n+a)=0 term at s = 0: Zeta(0, 0) -> -1/2 and Zeta(0, -1) -> 1/2 (0.186, 0.187); the formula 1/2 - a gives 1/2 and 3/2. The manifest's fixed() expects Zeta(0,0).re === 0.5, which fails.	For the two-operand Zeta(0, a) answers 1/2 - a (DLMF 25.11.13), exact for evaluate and N; Wolfram agrees (Zeta[0, 0] = 1/2, Zeta[0, -1] = 3/2).	Keep, take upstream (compute-engine's Wolfram convention, broken at s = 0).	2/130 / 2/130	08860455e fix(oracle): triage the 2026-10-04 Plausible findings (#624)	CE#409
compute-engine/library/special-functions.ts:403 (wrapOperator)	Zeta	Zeta(2, -1).evaluate() stays Zeta(2, -1) while its N() answers 2.64493406684822643647 (0.186, 0.187); the manifest's fixed() expects an evaluated value.	Answers the exact closed form Zeta(s, -n) = zeta(s) + sum j^-s (1 + pi^2/6 for Zeta(2,-1)) on evaluate; a numeric request still goes to the native kernel.	Keep, take upstream.	5/130 / 5/130	b01ce28d4 fix: exact Zeta(s, -n), one measured-tolerance rule, patch probes run once…	CE#409
patches/agm-complex.ts:30 (wrapOperator)	AGM	At a negative argument with more digits than a double, N hands back the double: precision 30, AGM(1, -10).N() -> Complex(-2.462181891100573, 2.098317353043635) (0.186, 0.187); evaluate stays AGM(1, -10).	Runs the same recurrence in BigDecimals on the same branch (limit from above the negative real axis) so N has the requested digits.	Keep, take upstream.	6/7 / 6/7	a87db2f5a feat(ce-patches): AGM at arbitrary precision off the positive reals (BL-312)…
patches/iterator-upper-bound.ts:34 (direct)	Sum, Product	A single upper bound is not read as 1..n: Sum(k, Limits(k, Nothing, 3)).evaluate() stays unevaluated (0.186, 0.187); the manifest's fixed() expects 6.	Rewrites Limits(k, Nothing, n) to Limits(k, 1, n) at canonicalization so Sum and Product run from 1, as Wolfram's {k, n} does.	Keep, take upstream.	2/93 / 2/93	ea3dcb069 chore: compute-engine 0.170 (#1090)
patches/iterator-upper-bound.ts:56 (direct)	Sum, Product	Sum over an index with no bounds sums to infinity: Sum(k^2, k).evaluate() -> PositiveInfinity and Sum(k, k) -> PositiveInfinity (0.186, 0.187); but Product(2^k, k) and Sum(3 q^(2k) + 5, k) stay unevaluated.	Holds evaluate and evaluateAsync (unevaluated) whenever an index is Limits(k, Nothing, Nothing).	Retire (compute-engine's 2026-10-20 ruling: no bounds runs k = 1..∞).	0/93 / 0/93	106382fd5 fix: correctness batch 7 (partial holds aren't agreement; Product with a…
patches/lerch-phi.ts:65 (wrapOperator)	LerchPhi	Exact zero at a rational argument but not a float one: LerchPhi(-1, -1, 1/2) -> 0 yet LerchPhi(-1, -1, 0.5) stays unevaluated (0.186, 0.187); LerchPhi(0, 2.976, -2.664) -> -0.05400 - 0.004079i, which matches the principal-branch a^-s (so the principal-branch…	Answers where native declines (zeros on the unit circle at a float argument), takes the principal branch for Phi(0, s, a) at a negative a, and declines an imaginary part that is rounding noise.	Keep, take upstream.	4/415 / 4/415	074f6389a chore(deps): compute-engine 0.141 (#448)	CE#340

formats

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
graphics.ts:178 (widenSignature)	Histogram	Histogram requires bins: Histogram({1,2,2,3}) -> Error(missing) (0.186, 0.187); Histogram({1,2,2,3,4}, 3) -> {(1,1),(2,2),(3,2)}.	Widens the signature to take bins as optional so the one-argument Wolfram call boxes.	Keep, ours by design.	2/3 / 2/3	8fe675d7e fix: retire redeclarations CE now ships; TeX prints math symbols; Lehmer codes…
graphics.ts:179 (wrapOperator)	Histogram	With two arguments Histogram computes bins (see above); with one it is an Error(missing) bare.	For a single argument evaluates to nothing (stays as written, a picture); two arguments go to native.	Keep, ours by design.	2/3 / 2/3	8fe675d7e fix: retire redeclarations CE now ships; TeX prints math symbols; Lehmer codes…

structures

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
algebra.ts:57 (wrapOperator)	Element	Not probed for an algebra (bare CE has none); Element(3, Integers) -> True and Element(Tuple(1,2), Integers) -> False natively.	For a non-symbol-unknown second operand tries our HasElement protocol and answers its True/False verdict, else the native handler.	Keep, ours by design.	11/89 / 11/89	9b94c86e6 Structures: algebras as a protocol; floors after Mathlib (#364)
carriers.ts:155 (direct)	ContinuedFraction	Native ContinuedFraction takes a real: ContinuedFraction(7/3) -> {2, 3}; ContinuedFraction({1,2,3}) -> {{1},{2},{3}} (0.186, 0.187).	Intersects the signature with our carrier clause (list) -> continued_fraction so a list of integers is a typed ContinuedFraction value.	Keep, ours by design.	0/28 / 0/28	8785f11c3 refactor: domains retires; carriers move to structures and their owning packages
carriers.ts:156 (direct)	ContinuedFraction	Native evaluate is what runs: ContinuedFraction(7/3) -> {2, 3}.	Replaces evaluate with a function that only calls the captured existing evaluate (a pass-through); only the signature at line 155 changes behavior.	Unwind (done).Removed: a carrier constructor leaves the head's evaluate alone.	0/28 / 0/28	ea3dcb069 chore: compute-engine 0.170 (#1090)
carriers.ts:233 (direct)	Element	Native Element(3, Integers) -> True; it knows nothing about our carriers' plural type-space names.	Answers True for a value of the matching carrier, False for a value of another carrier of ours, else defers to native.	Keep, ours by design.	0/89 / 0/89	ea3dcb069 chore: compute-engine 0.170 (#1090)
extend.ts:91 (defineOverload)	Reverse, Complement, Inverse	Reverse({1,2,3}).evaluate() stays Reverse({1,2,3}), Complement({1,2}) reports an incompatible-type error (set vs list), and Inverse of a 2x2 integer matrix -> {{-2,1},{3/2,-1/2}} (0.186, 0.187).	Adds one overload row per carrier type (its permutation, set, etc.) whose evaluate calls the owning package's handler, keeping the native row.	Keep, ours by design.	22/29 / 22/29	84a02ef70 fix: Solve of an identity, Take/Drop with a negative count, log combination…
extend.ts:124 (extendHead)	Reverse, Complement	Native collection heads materialize through their collection handlers when the head has no evaluate; bare Reverse({1,2,3}).evaluate() stays unevaluated.	Wraps the dispatcher so that when it declines and materialization is requested, the call's own elements are returned as a List.	Keep, ours by design.	0/24 / 0/24	8447ba0b5 refactor(engine): extend-based widening; declaration order no longer matters…
generic.ts:138 (widenSignature)	Max	Max of strings stays unevaluated and Min(Complex(1,2), 3) -> Min(3, 1+2i) (0.186, 0.187); the native signature is real-only so other values error.	Widens Min and Max to (any*) -> any so a non-number value boxes.	Keep, ours by design.	2/47 / 2/47	b77ed5d12 Structures: heads require structure, types provide it (#356)
generic.ts:139 (widenSignature)	Floor, Ceil, Round	Floor(Complex(2.5,3.7)) -> Error(incompatible-type, real expected, got complex) and likewise Ceil and Round (0.186, 0.187).	Widens the signature to (any, any?) -> any so non-real structured values box and reach our handlers.	Keep, ours by design.	8/187 / 8/187	b77ed5d12 Structures: heads require structure, types provide it (#356)
generic.ts:147 (wrapOperator)	Min, Max	Max of two strings stays Max('a','b') unevaluated; Min(Complex(1,2), 3) stays unevaluated (0.186, 0.187).	For structured (non-real, no unknowns) operands compares them through GreatestLowerBound/LeastUpperBound or Compare, or componentwise in a product order; real operands keep the native path.	Keep, ours by design.	0/78 / 0/78	b77ed5d12 Structures: heads require structure, types provide it (#356)
generic.ts:159 (wrapOperator)	Clamp	Clamp of strings -> Error(incompatible-type, real expected, got string) (0.186, 0.187).	Clamp(x, lo, hi) = Max(lo, Min(x, hi)) in any lattice, for structured operands.	Keep, ours by design.	0/18 / 0/18	b77ed5d12 Structures: heads require structure, types provide it (#356)
generic.ts:174 (wrapOperator)	Floor, Ceil	Floor(Complex(2.5,3.7)) and Ceil -> Error(incompatible-type) (0.186, 0.187).	For a structured operand floors or ceilings coordinate by coordinate in a product order, by an integer floor ring, or to the neighbouring tick of a floor order.	Keep, ours by design.	8/149 / 8/149	b77ed5d12 Structures: heads require structure, types provide it (#356)
generic.ts:182 (wrapOperator)	Round	Round(Complex(2.5,3.7)) -> Error(incompatible-type) (0.186, 0.187).	Rounds to the nearest tick (ties to the even tick when ticks have parity, Wolfram's rule), Mathlib round in a floor ring, or coordinatewise in a product order.	Keep, ours by design.	1/41 / 1/41	b77ed5d12 Structures: heads require structure, types provide it (#356)

algebras/hypercomplex

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
declare.ts:77 (extendHead)	Expand	Treats a generator as a plain symbol: Expand((1 + i_1)(1 + i_1)) -> i_1^2 + 2 i_1 + 1, with i_1^2 not reduced (0.186, 0.187).	When an operand contains a generator, puts it in blade normal form (i_1^2 -> -1 and the like) through the multivector arithmetic.	Keep, ours by design.	1/25 / 0/25	6b9a8b360 refactor: arithmetic and algebra libraries reach compute-engine through the…
declare.ts:103 (direct)	InvisibleOperator	Canonicalizes e_2 e_1 (LaTeX e_2e_1) to Multiply(e_1, e_2): the commutative sort loses the anticommuting sign (0.186; 0.187 not separately read).	Rewrites an anticommuting juxtaposition written out of blade order to NonCommutativeMultiply so the sign survives.	Keep, ours by design.	0/0 / 0/0	f2183bf84 enumeratio.dev
declare.ts:158 (defineOverload)	Add	Add(1, 2 i_1, i_1 i_1) -> i_1^2 + 2 i_1 + 1: generators are plain symbols (0.186, 0.187).	When an operand reaches a generator symbol, adds as multivectors and returns the blade normal form.	Keep, ours by design.	1/1889 / 2/1888	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:170 (defineOverload)	Multiply	Multiply(i_1, i_1) -> i_1^2, with no reduction to -1 (0.186, 0.187).	Multiplies multivectors in the algebra when the operands commute; declines an unordered non-commuting product.	Keep, ours by design.	3/1942 / 1/1941	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:186 (defineOverload)	Negate	Negate(1 + i_1) -> -i_1 - 1 (plain symbols), which agrees with scaling by -1 (0.186, 0.187).	When an operand has a generator, scales the multivector by -1 and returns its normal form.	Keep, ours by design.	0/789 / 0/788	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:196 (defineOverload)	Power	Power(i_1, 2) stays i_1^2 with no reduction (0.186, 0.187).	For an integer exponent raises the multivector to that power, giving the algebra's value (i_1^2 -> -1).	Keep, ours by design.	2/1493 / 1/1492	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:215 (defineOverload)	Divide	Divide(1, 1 + i_1) stays Divide(1, i_1 + 1) (0.186, 0.187).	Multiplies by the multivector inverse where it exists and returns its blade form.	Keep, ours by design.	0/782 / 2/781	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:228 (wrapOperator)	Conjugate	Conjugate(1 + i_1) stays Conjugate(i_1 + 1) (0.186, 0.187).	Maps every generator to its negative, giving the algebra's conjugate.	Keep, ours by design.	0/24 / 0/24	f2183bf84 enumeratio.dev
declare.ts:249 (wrapOperator)	Norm	Norm(1 + i_1) -> Abs(i_1 + 1), treating i_1 as a plain symbol (0.186, 0.187).	Returns the algebra norm (determinant of multiplication by z, commuting families only).	Keep, ours by design.	5/6 / 5/6	f2183bf84 enumeratio.dev

analysis/analytic

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
bessel-big.ts:41 (wrapOperator)	BesselI, BesselJ	Evaluates in doubles whatever the precision: N(BesselJ(1,1/3), 30) -> 0.16436254381427073, a 17-digit double (0.186 and 0.187).	Integer order, real x, digits past a double: sums the 0F1 series in BigDecimal (DLMF 10.2.2, 10.25.2) and declines when it cannot vouch for the digits.	Keep, take upstream.	6/22 / 6/22	5e486d18b fix(analytic): triage batch 19 (transforms and special-function leftovers)…
bessel-big.ts:58 (wrapOperator)	BesselI, BesselJ	Declines a non-integer order: BesselJ(0.5, 2) stays BesselJ(0.5,2) under evaluate and N (0.186 and 0.187).	For real order not an integer and x > 0, N evaluates (x/2)^v * 0F1Regularized(v+1; -x^2/4) (our Hypergeometric0F1Regularized), with digits; compiles only for integer order.	Keep, take upstream.	0/22 / 0/22	a8f2aa35f fix(analytic): triage batch 21 (analytic and number-theory leftovers) (#788)
beta-continuation.ts:90 (wrapOperator)	BetaRegularized	Leaves x outside [0,1] unevaluated: BetaRegularized(2,2,3) and BetaRegularized(1.5,2,3) stay as is under evaluate and N (0.186 and 0.187).	For integer a, b >= 1 and rational or finite-double x outside [0,1], returns the exact polynomial value (I_2(2,3) = 8); for b a positive integer up to 30 and real x > 1, the finite sum in doubles.	Keep, take upstream.	2/26 / 2/26	755ee47cc feat(analytic,collections): close 27 more aspirational reference examples (#179)
closed-forms-113.ts:50 (wrapOperator)	PolyGamma	Evaluates PolyGamma(n, m) at integer m only numerically: PolyGamma(2,3) stays under evaluate, N gives -0.1541138 (0.186 and 0.187).	Exact closed form (-1)^(n+1) n! (zeta(n+1) - sum_{k<m} k^(-n-1)) for order 1..40 and integer shift 1..32 (DLMF 5.15.2).	Keep, take upstream.	9/78 / 9/78	f0cc52ccc fix: review batch 3 — analytic numerics (#692)
closed-forms-113.ts:82 (wrapOperator)	GammaLn	Leaves GammaLn(5) unevaluated under evaluate; N gives 3.178053830347946 (0.186 and 0.187).	GammaLn(n) = Ln((n-1)!) at an exact positive integer.	Keep, take upstream.	2/27 / 2/27	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:103 (wrapOperator)	HurwitzZeta	Folds HurwitzZeta(s, 1/2) only for integer s: (3, 1/2) -> 7*Zeta(3), (2,1/2) -> Pi^2/2; HurwitzZeta(3/2, 1/2) stays unevaluated (0.186 and 0.187).	HurwitzZeta(s, 1/2) = (2^s - 1) Zeta(s) for any non-symbol s.	Keep, take upstream.	0/228 / 0/228	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:126 (wrapOperator)	HurwitzZeta	Leaves HurwitzZeta(2, 1/4) unevaluated; N gives 17.19732915 (0.186 and 0.187).	HurwitzZeta(2, 1/4) = Pi^2 + 8 CatalanConstant.	Keep, take upstream.	1/228 / 1/228	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:146 (wrapOperator)	PolyLog	Leaves PolyLog(3, 1/2) unevaluated; N gives 0.5372131936 (0.186 and 0.187).	Li_3(1/2) = (7/8)zeta(3) - (pi^2 ln2)/12 + (ln^3 2)/6.	Keep, take upstream.	1/131 / 1/131	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:168 (wrapOperator)	PolyLog	Leaves PolyLog(2, 2) unevaluated; N gives Complex(2.4674011, -2.1775861) (0.186 and 0.187).	Li_2(2) = pi^2/4 - ipiln2.	Keep, take upstream.	1/131 / 1/131	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:188 (wrapOperator)	Digamma	Leaves Digamma(1/4) unevaluated; N gives -4.2274535334 (0.186 and 0.187).	Gauss's digamma theorem at denominators 3 and 4 (psi(1/4), psi(3/4), psi(1/3), psi(2/3)) in EulerGamma, Pi, Ln.	Keep, take upstream.	3/35 / 3/35	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:223 (wrapOperator)	PolyGamma	Leaves PolyGamma(1, 1/4) unevaluated; N gives 17.1973291545 (0.186 and 0.187).	psi'(1/4) = Pi^2 + 8G and psi'(3/4) = Pi^2 - 8G.	Keep, take upstream.	1/78 / 1/78	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:257 (wrapOperator)	PolyGamma	PolyGamma(0, 1/4) stays unevaluated; N gives -4.2274535 (0.186 and 0.187); no connection to Digamma's exact values.	Routes PolyGamma(0, z) through Digamma and returns its closed form where Digamma has one, else native.	Keep, take upstream.	2/78 / 2/78	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:272 (wrapOperator)	StieltjesGamma	Already folds a = 1: StieltjesGamma(1, 1) evaluates to StieltjesGamma(1) (0.186 and 0.187).	StieltjesGamma(n, 1) -> StieltjesGamma(n).	Keep, take upstream.A wider sweep shows compute-engine folds StieltjesGamma(n, 1) only for a literal n; a symbolic n stays as written (0.186 and 0.187).	0/29 / 0/29	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:284 (wrapOperator)	BetaRegularized	BetaRegularized(1/2, 2, 3) stays unevaluated under evaluate; N gives 0.6875 (0.186 and 0.187).	Exact rational I_x(a,b) = sum_{j=a}^{a+b-1} C(a+b-1,j) x^j (1-x)^(a+b-1-j) at rational x in (0,1) and integers a, b in [1,200].	Keep, take upstream.	1/26 / 1/26	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:335 (wrapOperator)	Gamma, GammaRegularized	Gamma(2, x) and Gamma(3, 5) stay unevaluated (N gives 0.2493 for Gamma(3,5)); GammaRegularized(2, x) stays; GammaRegularized(3, 2) already evaluates to 5/e^2 (0.186 and 0.187).	Finite closed form Gamma(n, x) = (n-1)! e^-x sum_{k<n} x^k/k! and Q(n, x) for integer n in 1..64, any x including symbolic.	Keep, take upstream.	2/146 / 2/145	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:376 (wrapOperator)	LogGamma	LogGamma(3/2) stays unevaluated; N gives -0.12078 and N(LogGamma(-3/2)) gives Complex(0.8600, -6.2832) (0.186 and 0.187).	Exact LogGamma at half-integers: Ln(Gamma(x)) for positive, Ln|Gamma(x)| - kipi for negative (matches the native N value).	Keep, take upstream.	2/26 / 2/26	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:434 (wrapOperator)	FromContinuedFraction	FromContinuedFraction([a,b,c]) stays unevaluated under evaluate and N (0.186 and 0.187).	Expands a flat list with at least one symbol to the nested a + 1/(b + 1/c), left uncombined.	Open decisions.	2/14 / 2/14	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:463 (wrapOperator)	Mod	Already folds an exact irrational against a numeric modulus: Mod(Sqrt(28), 3) -> -3 + 2Sqrt(7); Mod(Sqrt(2), 1/2) -> -1 + Sqrt(2); Mod(3Pi, 2) -> -8 + 3*Pi (0.186 and 0.187).	x - floor(x/m)*m with the floor found from the double approximation, with a 1e-6 margin from boundaries.	Unwind (done).Removed: Mod of an exact irrational and L(1, chi) are compute-engine's.	0/143 / 0/143	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
closed-forms-113.ts:498 (wrapOperator)	DirichletL	Already folds L(1, chi) for real odd characters: DirichletL(3,2,1) -> Sqrt(3)/9Pi, (4,2,1) -> Pi/4, (7,4,1) -> Sqrt(7)/7Pi, (11,6,1) -> Sqrt(11)/11*Pi; k = 15 folds too; other indices stay unevaluated (0.186 and 0.187).	-pi/k^(3/2) * sum a*chi(a) for real odd characters mod k <= 1000, cross-checked against native numerics to 1e-9.	Unwind (done).Removed: Mod of an exact irrational and L(1, chi) are compute-engine's.	0/34 / 0/34	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
complex-arguments.ts:13 (wrapOperator)	Digamma	Under N or a float operand, Digamma(1+i) gives Complex(0.0946503206224758, 1.0766740474685808); exact Digamma(Complex(1,1)) stays unevaluated under evaluate (0.186 and 0.187).	With a float operand or N, evaluates psi(z) on the package's complex double kernel.	Keep, take upstream.	1/35 / 1/35	755ee47cc feat(analytic,collections): close 27 more aspirational reference examples (#179)
complex-arguments.ts:25 (wrapOperator)	Beta	Declines complex arguments: N(Beta(1+i, 2)) stays Beta(Complex(1.0,1.0), 2) (0.186 and 0.187).	Under N or a float operand, exp(lnGamma(a) + lnGamma(b) - lnGamma(a+b)) in doubles.	Keep, take upstream.	1/27 / 1/27	755ee47cc feat(analytic,collections): close 27 more aspirational reference examples (#179)
constant-rounding.ts:88 (wrapOperator)	Floor, Ceil, Round	Floor(Floor(x)), Round(Round(x)), Ceil(Ceil(x)) for symbolic x stay nested (0.186 and 0.187); Floor(Floor(Pi)) folds to 3.	Floor(Floor(x)) = Floor(x) (returns the inner call), same for Ceil and Round.	Keep, take upstream.	3/187 / 3/187	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
constant-rounding.ts:99 (wrapOperator)	Floor, Ceil, Round	Already folds exact constants: Floor(Pi) -> 3, Ceil(Pi+E) -> 6, Round(Pi^40) -> 76912142205157127257, Floor(E^100) -> a 44-digit integer, Floor(Ln(10)) -> 2 (0.186 and 0.187).	Evaluates the constant at digits(integer part)+15 (at most 60) and rounds, declining within 1e-6 of a breakpoint.	Unwind (done).Removed: rounding and extrema of exact constants are compute-engine's.	0/187 / 0/187	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
constant-rounding.ts:123 (wrapOperator)	Max, Min	Max(x, x), Min(x, x), Max(x, x, x) stay unevaluated (0.186 and 0.187).	Returns the argument when all arguments are identical.	Keep, take upstream.	2/78 / 2/78	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
constant-rounding.ts:132 (wrapOperator)	Max, Min	Already compares exact constants: Max(Pi, E) -> Pi, Min(List(Pi,3,E)) -> E, Max(Pi+1, 2E) -> 2E, Min(Ln3, GoldenRatio) -> Ln3 (0.186 and 0.187).	Compares the numeric values of a pool containing a constant and keeps the exact winner.	Unwind (done).Removed: rounding and extrema of exact constants are compute-engine's.	0/78 / 0/78	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
constant-rounding.ts:163 (wrapOperator)	IsOdd	IsOdd(Pi) stays unevaluated under evaluate (N gives False); IsOdd(Sqrt(2)) already gives False; IsOdd(Pi+1) stays (0.186 and 0.187).	IsOdd of a non-integer exact constant is False.	Keep, take upstream.	1/22 / 1/22	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
correctly-rounded.ts:193 (direct)	N	Evaluates at d digits and returns that: N(DirichletBeta(2), 40) -> ...1107741 where a one-off mpmath check gives ...1107742 (40 digits); N(BesselJ(1,2), 30) -> 0.5767248077568736, a double (0.186 and 0.187).	Ziv's loop (evaluate at d+2g and d+g, round both, widen g until they agree), certified enclosures where a head has them, and declines (x stays) when a double-only head cannot back the digits; restores ce.precision.	Open decisions.	16/1807 / 16/1807	c6f8f0bd7 feat(analytic): correctly rounded N(x, d); arbitrary-precision LerchPhi,…
declare-tagged-arithmetic.ts:97 (direct)	Interval	Types Interval(a, b) as set, so Add(Interval(1,2), 3) is an incompatible-type error under evaluate and N (0.186 and 0.187).	Sets Interval's type to any so numeric heads and set operations both accept it.	Keep, ours by design.	68/86 / 68/86	77e940da1 chore: compute-engine 0.148; four patches retire, two narrow (#676)
declare.ts:161 (widenSignature)	Gamma, GammaRegularized	Rejects a third argument: Gamma(2,1,3) -> Error unexpected-argument (0.186 and 0.187).	Widens the signature to accept (s, z0, z1).	Keep, take upstream.	0/146 / 0/145	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
declare.ts:162 (threadOverLists)	Gamma, GammaRegularized	Already threads over lists: GammaRegularized([1,2], 1) -> [1/e, 2/e]; Gamma([3,4], 1) -> [Gamma(3,1), Gamma(4,1)]; Gamma([1,2]) -> [1,1] (0.186 and 0.187).	Sets broadcastable on Gamma and GammaRegularized.	Unwind (done).Removed: thread only HarmonicNumber.	0/146 / 0/145	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
declare.ts:164 (wrapOperator)	Gamma, GammaRegularized	Gamma(1/2), Gamma(5/2), Gamma(1, x) stay unevaluated; Gamma(5) -> 24; three arguments error; complex Q is real-only (0.186 and 0.187).	Adds the three-argument difference, Gamma(1, z) = e^-z, exact integer and half-integer Gamma(x), complex-argument Q(s, z) = Gamma(s,z)/Gamma(s), and Q for non-integer real s at z < 0.	Keep, take upstream.	37/146 / 37/145	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
declare.ts:175 (threadOverLists)	Binomial, Pochhammer, BernoulliB, Erf, Erfc, +2	Already threads over lists for all seven: Erf([0,1]) -> [0, Erf(1)]; Binomial([3,4],2) -> [3,6]; Pochhammer([1,2],2) -> [2,6]; BernoulliB([2,4]) -> [1/6,-1/30]; ErfInv, Erfc, BetaRegularized([0.5,0.2],2,3) -> [0.6875,0.1808] (0.186 and 0.187).	Sets broadcastable on these heads.	Unwind (done).Removed: thread only HarmonicNumber.	0/273 / 1/273	011102b5c refactor(upstream): #340 special functions become for-compute-engine patches…
dedekind-eta-big.ts:55 (wrapOperator)	DedekindEta	Runs on doubles: N(DedekindEta(0.3+i), 40) -> Complex(0.7678448651091705, 0.05906109778250378); at Re tau = 1e20 the phase is rounded away (0.186 and 0.187).	q-series (Euler pentagonal) in BigDecimal with Re tau reduced mod 24 exactly; declines for Im tau < 0.05.	Keep, take upstream.	3/5 / 3/5	c2d188517 fix(analytic): Airy, EllipticK, DedekindEta and 1F1/2F1 agree with Wolfram…
derivatives.ts:145 (wrapOperator)	Derivative	D of HarmonicNumber, ErfInv, HermiteH, LaguerreL, Zeta, HurwitzZeta (in a), Beta stays Apply(Derivative(...)); LogGamma' -> Digamma and PolyLog' -> PolyLog(s-1,z)/z already work (0.186 and 0.187).	A table of partials, returning the Function body (HurwitzZeta, Zeta, LerchPhi in a; LogGamma, HarmonicNumber, BarnesG/LogBarnesG, Beta, ErfInv, ErfcInv, PolyLog, HermiteH, LaguerreL, Gudermannian, ClausenCl, plus order…	Keep, take upstream.	3/60 / 3/60	8fe675d7e fix: retire redeclarations CE now ships; TeX prints math symbols; Lehmer codes…
derivatives.ts:162 (direct)	D	D(Power(x, n), [x, 3]) and D(Sin(x), [x, 2]) stay unevaluated; D of a head outside CE's table returns an unevaluated Apply(Derivative(...)) that one evaluate() does not resolve (0.186 and 0.187).	Closed form for higher-order D of powers, and iterates D to a fixpoint so Derivative's hook runs.	Keep, take upstream.	26/89 / 26/89	ea3dcb069 chore: compute-engine 0.170 (#1090)
difference-root.ts:378 (wrapOperator)	Apply	Holds Apply(callee, arg) when the callee is a reduction CE cannot type: Apply(Apply(f, x), 3) stays unevaluated; DifferenceRootReduce itself is not a CE head (0.186 and 0.187).	Applies the Root(fn) a DifferenceRootReduce/DifferentialRootReduce returns to the argument, so DifferenceRootReduce(f(n), n)(20) evaluates.	Keep, ours by design.	2/95 / 2/95	302f55e6a chore: compute-engine 0.152 (#895)	CE#426
difference-root.ts:510 (wrapOperator)	Apply	DifferenceRoot is not a CE head; Apply of it stays unevaluated (DifferenceRootReduce(Factorial(n), n) stays, 0.186 and 0.187).	Runs the stored recurrence forward from the nearest initial condition in exact arithmetic.	Keep, ours by design.	5/95 / 5/95	8fe675d7e fix: retire redeclarations CE now ships; TeX prints math symbols; Lehmer codes…
differential-root.ts:472 (direct)	Apply	DifferentialRoot is not a CE head; DifferentialRootReduce(Exp(x), x) stays as a call (0.186 and 0.187).	Evaluates DifferentialRoot(fn)(x) by a power-series solution of the ODE from its initial conditions.	Keep, ours by design.	2/95 / 2/95	ea3dcb069 chore: compute-engine 0.170 (#1090)
dobinski.ts:36 (direct)	Sum	Sum(k^3/k!, k=1..Infinity) stays unevaluated under evaluate and N gives the double 13.591409142296198 (0.186 and 0.187); Sum(1/k!, k=0..Infinity) -> E.	Returns BellNumber(n)*E for k^n/k! from 0 or 1 to infinity.	Keep, take upstream.	1/52 / 1/52	ea3dcb069 chore: compute-engine 0.170 (#1090)
elementary-remaining.ts:60 (wrapOperator)	Tan, Cot, Csc, Arcsin, Arctan, +4	Odd functions of a negated symbol stay: Tan(-x), Cot(-x), Csc(-x), Arcsin(-x), Arctan(-x), Sinh(-x), Tanh(-x), Arcoth(-x), Arcsch(-x) all unevaluated (0.186 and 0.187).	f(-x) -> -f(x).	Keep, take upstream.	11/439 / 12/439	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:70 (wrapOperator)	Cos, Sec, Cosh	Cos(-x), Sec(-x), Cosh(-x) stay unevaluated (0.186 and 0.187).	f(-x) -> f(x).	Keep, take upstream.	3/294 / 3/294	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:79 (wrapOperator)	Arccos	Arccos(-x) stays unevaluated (0.186 and 0.187).	Arccos(-x) -> Pi - Arccos(x).	Keep, take upstream.	1/46 / 1/46	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:103 (wrapOperator)	Sin, Cos, Tan, Sinh	Sin(Arcsin(x)), Cos(Arccos(x)), Tan(Arctan(x)), Sinh(Arsinh(x)) stay unevaluated (0.186 and 0.187).	f(f^-1(x)) -> x.	Keep, take upstream.	4/507 / 4/507	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:118 (wrapOperator)	Cos	Cos(Arcsin(x)) stays unevaluated (0.186 and 0.187).	Cos(Arcsin(x)) -> Sqrt(1 - x^2).	Keep, take upstream.	1/198 / 1/198	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:126 (wrapOperator)	Cos	Cos(Arctan(x)) stays unevaluated (0.186 and 0.187).	Cos(Arctan(x)) -> 1/Sqrt(1 + x^2).	Keep, take upstream.	1/198 / 1/198	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:135 (wrapOperator)	Sin	Sin(Arctan(x)) stays unevaluated (0.186 and 0.187).	Sin(Arctan(x)) -> x/Sqrt(1 + x^2).	Keep, take upstream.	1/247 / 1/247	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:146 (wrapOperator)	Tan	Tan(Arcsin(x)) stays unevaluated (0.186 and 0.187).	Tan(Arcsin(x)) -> x/Sqrt(1 - x^2).	Keep, take upstream.	1/93 / 1/93	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:162 (wrapOperator)	Cos	Cos(it) stays unevaluated (0.186 and 0.187); CE already folds Sin(it) per the file's own comment.	Cos(i*t) -> Cosh(t).	Keep, take upstream.	1/198 / 1/198	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:170 (wrapOperator)	Tan	Tan(i*t) stays unevaluated (0.186 and 0.187).	Tan(it) -> iTanh(t).	Keep, take upstream.	1/93 / 1/93	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:189 (wrapOperator)	Arccos	Arccos(Cos(5)) and Arccos(Cos(y)) stay unevaluated (0.186 and 0.187).	For real finite y in [-pi, 3pi], Arccos(Cos(y)) -> y, 2pi - y, y - 2*pi or -y by window.	Keep, take upstream.	2/46 / 2/46	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:257 (wrapOperator)	TrigToExp	TrigToExp(Arcsin(x)), Arctan, Arcoth, Arcsch return the input unchanged (0.186 and 0.187).	Logarithmic forms: Arcsin -> -i ln(ix + sqrt(1-x^2)), Arctan, Arcoth, Arcsch.	Keep, take upstream.	6/23 / 6/23	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:275 (widenSignature)	Tanh	Tanh(ComplexInfinity) is an Error incompatible-type (signature 'complex | quantity | signed_infinity') (0.186 and 0.187).	Widens the signature to accept ComplexInfinity so the evaluate can answer.	Keep, take upstream.	1/48 / 1/48	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:277 (wrapOperator)	Tanh	Tanh(ComplexInfinity) -> incompatible-type Error (0.186 and 0.187).	Returns NaN.	Keep, take upstream.	1/48 / 1/48	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:293 (wrapOperator)	Arsech	Already folds Arsech(1) -> 0 (0.186 and 0.187).	Arsech(1) -> 0.	Unwind (done).Removed: drop exact values compute-engine already folds.	0/18 / 0/18	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:301 (wrapOperator)	Arsech	Arsech(2) stays unevaluated under evaluate; N gives Complex(0, 1.0471975511965976) (0.186 and 0.187).	For exact rational x > 1, Arsech(x) -> i*Arccos(1/x).	Keep, take upstream.	3/18 / 3/18	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:328 (wrapOperator)	Ln	Ln(ComplexInfinity) -> ComplexInfinity (0.186 and 0.187).	Ln(ComplexInfinity) -> PositiveInfinity.	Keep, take upstream.	2/228 / 2/228	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:341 (wrapOperator)	Ln	Ln(1/3) stays unevaluated; N gives -1.0986122886681096914 (CE does fold Ln(1000) -> 3 Ln(10)) (0.186 and 0.187).	Ln(1/n) -> -Ln(n) for exact integer n > 1.	Keep, take upstream.	3/228 / 3/228	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:401 (wrapOperator)	Log	Log(ComplexInfinity) and Log(ComplexInfinity, 2) -> ComplexInfinity (0.186 and 0.187).	+Infinity.	Keep, take upstream.	3/77 / 3/77	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-remaining.ts:409 (wrapOperator)	Log	Already folds the reciprocal of a base power: Log(1/8, 2) -> -3; Log(1/100) -> -2; Log(1024, 2) -> 10 (0.186 and 0.187).	Log(1/q, base) = -k when q = base^k, one- or two-argument.	Unwind (done).Removed: drop exact values compute-engine already folds.	0/77 / 0/77	496906df8 feat(analytic): elementary parity, compositions, TrigToExp forms and log folds…
elementary-special-values.ts:51 (wrapOperator)	Sinh, Cosh, Tanh, Csch, Sech, +1	Hyperbolic functions at it stay unevaluated: Sinh(it), Cosh(it), Tanh, Csch, Sech, Coth; Sinh(iPi) also stays (0.186 and 0.187).	Rewrites through the circular function: Sinh(it) = i sin t, Cosh(it) = cos t, Tanh = i tan t, and reciprocals.	Keep, take upstream.	44/204 / 44/204	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
elementary-special-values.ts:70 (wrapOperator)	Coth, Csch	Coth(2pii) and Csch(i*pi) stay unevaluated (0.186 and 0.187).	ComplexInfinity at ikpi.	Keep, take upstream.	0/30 / 0/30	3827e9623 fix(analytic): series at hyperbolic poles; Zeta's Laurent terms (#727)
elementary-special-values.ts:87 (wrapOperator)	Ln	Ln(i) stays unevaluated (both Complex(0,1) and ImaginaryUnit) (0.186 and 0.187).	Ln(i) -> i*Pi/2.	Keep, take upstream.	2/228 / 2/228	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
elementary-special-values.ts:112 (wrapOperator)	Arccot	Already has the special-angle table: Arccot(1) -> Pi/4, Arccot(0) -> Pi/2, Arccot(-1) -> 3Pi/4, Arccot(Sqrt(3)) -> Pi/6, Arccot(1/Sqrt(3)) -> Pi/3; Arccot(1/2) stays (0.186 and 0.187).	Falls through to native, then for any argument where Arctan folds, Pi/2 - Arctan(x).	Keep, take upstream.compute-engine's Arccot table matches ours on 21 of 22 swept arguments; Arccot(i) stays unevaluated natively where ours gives ComplexInfinity.	0/13 / 0/13	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
elementary-special-values.ts:133 (wrapOperator)	Arccsc, Arcsec	Arccsc(0) and Arcsec(0) stay unevaluated (0.186 and 0.187).	ComplexInfinity.	Keep, ours by design (compute-engine's ruling, 2026-11-12).	11/66 / 11/66	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
elliptic.ts:205 (wrapOperator)	EllipticE	Incomplete EllipticE(0.5, 0.3) answers a double at any precision: 0.4939911447289685 with precision 30 (0.186 and 0.187).	Real operands, digits past a double: BigDecimal Carlson kernel (incompleteEllipticEBig), else native.	Keep, take upstream.	1/37 / 1/37	4b04e43b5 fix(analytic): triage batch 17; BigO emits as O[x]^n (#719)
elliptic.ts:219 (wrapOperator)	EllipticF	EllipticF(0.5, 0.3) answers 0.5061402119623554, a double, at precision 30 (0.186 and 0.187).	Real operands, digits past a double: BigDecimal kernel (incompleteEllipticFBig), complex result when needed.	Keep, take upstream.	1/15 / 1/15	e2d93b0e2 fix(analytic): more heads keep their digits past a double (#744)
elliptic.ts:236 (wrapOperator)	EllipticPi	EllipticPi(0.5, 0.3) and EllipticPi(0.5, 0.4, 0.3) answer doubles (2.4612553522724236, 0.4141517368244767) at precision 30 (0.186 and 0.187).	Real operands, digits past a double: BigDecimal Carlson R_F/R_J (ellipticPiBig), else native.	Keep, take upstream.	2/15 / 2/15	4b04e43b5 fix(analytic): triage batch 17; BigO emits as O[x]^n (#719)
float-in.ts:29 (wrapOperator)	LerchPhi	Returns a 21-digit bignum for a double operand: LerchPhi(0.5,2,1) → 1.16448105293002501181 (0.186 and 0.187), the last digits padding not accuracy.	Boxes the double operands and rounds the answer to a double (doublesForFloats), leaving NaN unevaluated; the same wrapper covers the Jacobi heads.	Open decisions.	3/415 / 3/415	f0cc52ccc fix: review batch 3 — analytic numerics (#692)
float-in.ts:46 (wrapOperator)	HurwitzZeta	N(HurwitzZeta(2i, 0)) → NaN and HurwitzZeta(2i, -1) → NaN (0.186 and 0.187); evaluate stays symbolic.	Declines (returns undefined) at Re s = 0, s ≠ 0, a a nonpositive integer, so the call stays unevaluated.	Keep, take upstream.	2/228 / 2/228	f0cc52ccc fix: review batch 3 — analytic numerics (#692)
float-in.ts:77 (wrapOperator)	Zeta	Evaluates complex-s Zeta with its double kernel: Zeta(1/2+400i) → 0.04146321761779217+0.08910657532392262i (0.186 and 0.187); the file measured it 6e-13 relative off mpmath (not re-measured here).	Routes a complex s through the bignum Euler–Maclaurin kernel rounded once to a double pair; leaves an explicit precision past a double to native.	Keep, take upstream.	5/130 / 5/130	f0cc52ccc fix: review batch 3 — analytic numerics (#692)
float-in.ts:88 (wrapOperator)	HurwitzZeta	Evaluates complex s or a with its double kernel: HurwitzZeta(1/2+400i, 1.5) → -1.0774326899677644-0.9724144164812601i (0.186 and 0.187); file measured 6e-13 relative error off mpmath for the Zeta case.	Routes complex s or a through the bignum Euler–Maclaurin kernel rounded once to a double pair.	Keep, take upstream.	56/228 / 56/228	f0cc52ccc fix: review batch 3 — analytic numerics (#692)
fractal.ts:67 (direct)	Mandelbrot	CE ships Mandelbrot with signature (complex, integer) -> real: a smooth escape-time value, 1 inside the set, in [0,1) outside, and n is required: Mandelbrot(-1,2) → 1, Mandelbrot(3,64) → 0.0336, Mandelbrot(c) → missing-argument error (0.186 and 0.187).	Redeclares Mandelbrot as (number, number?) -> number returning the n-th complex iterate of z→z²+c from 0 (n default 64, capped 512, stops past |z|²>1e12): Mandelbrot(-1,2) → 0.0 (reference example), Mandelbrot(1,5) →…	Open decisions.	1/1 / 1/1	f2183bf84 enumeratio.dev
fractal.ts:74 (direct)	Julia	CE ships Julia with signature (complex, complex, integer) -> real, a smooth escape-time value: Julia(0.1, -0.8+0.156i, 64) → 1; Julia(z, c) without n is a missing-argument error (0.186 and 0.187).	Redeclares Julia as (number, number, number?) -> number returning the n-th complex iterate from z with c held fixed (n default 64), with JS (__ju) and GLSL real kernels.	Open decisions.	0/0 / 0/0	f2183bf84 enumeratio.dev
generalized-special.ts:81 (widenSignature)	Beta	Beta is two-argument only: Beta(1/2,2,3) and Beta(0.2,0.5,2,3) → unexpected-argument error (0.186 and 0.187).	Widens the signature to (number, number, number?, number?) so Beta[z,a,b] and Beta[z0,z1,a,b] are accepted.	Keep, take upstream.	3/27 / 3/27	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
generalized-special.ts:83 (wrapOperator)	Beta	Beta(0,∞) → NaN, Beta(a,1) and Beta(a,3) stay symbolic, 3/4-argument calls error (0.186 and 0.187).	Answers Beta(0,∞)=ComplexInfinity, Beta(a,1)=1/a, Beta(a,n)=(n-1)!/(a(a+1)…) for n 2..10, exact rational B_z(a,b) for integer a,b, and the incomplete/generalized forms via BetaRegularized.	Keep, take upstream.	6/27 / 6/27	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
generalized-special.ts:147 (widenSignature)	BetaRegularized	BetaRegularized takes three arguments: BetaRegularized(0.2,0.5,2,3) → unexpected-argument error (0.186 and 0.187); the 3-argument call works (0.5,2,3 → 0.6875).	Widens the signature to accept a fourth argument.	Keep, take upstream.	1/26 / 1/26	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
generalized-special.ts:149 (wrapOperator)	BetaRegularized	Errors on the four-argument call (0.186 and 0.187), as above.	Evaluates I_{z1}(a,b) − I_{z0}(a,b) through the native three-argument handler; compile builtin only up to 3 operands.	Keep, take upstream.	1/26 / 1/26	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
generalized-special.ts:174 (widenSignature)	Erf	Erf is one-argument: Erf(0.1,0.5) → unexpected-argument error (0.186 and 0.187).	Widens the signature to (number, number?) for Wolfram's Erf[z0,z1].	Keep, take upstream.	4/36 / 4/36	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
generalized-special.ts:176 (wrapOperator)	Erf	Erf(-x) and Erf(ErfInv(x)) stay symbolic; Erf(ComplexInfinity) is an incompatible-type error (0.186 and 0.187).	Erf(z0,z1)=Erf(z1)−Erf(z0), Erf(-x)=-Erf(x), Erf(ErfInv x)=x, and Erf(ComplexInfinity)=NaN (declined: direction-dependent).	Keep, take upstream.	8/36 / 8/36	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
generalized-special.ts:212 (widenSignature)	ErfInv	ErfInv takes one argument: ErfInv(0.1,0.5) → unexpected-argument error (0.186 and 0.187).	Widens the signature to (number, number?) for the two-argument inverse.	Keep, take upstream.	8/33 / 8/33	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
generalized-special.ts:214 (wrapOperator)	ErfInv	ErfInv(-x) stays symbolic and the two-argument call errors (0.186 and 0.187).	ErfInv(z0,z)=ErfInv(z+Erf(z0)) and ErfInv(-x)=-ErfInv(x).	Keep, take upstream.	7/33 / 7/33	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
generalized-special.ts:247 (widenSignature)	PolyGamma	PolyGamma requires two arguments: PolyGamma(1) → missing-argument error, and a complex z is an incompatible-type error (0.186 and 0.187).	Widens the signature to (number, number?) so PolyGamma(z) is allowed.	Keep, take upstream.	4/78 / 4/78	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
generalized-special.ts:248 (wrapOperator)	PolyGamma	Errors on PolyGamma(1) (0.186 and 0.187).	Evaluates PolyGamma(z) as Digamma(z), falling back to PolyGamma(0,z) native; compile refuses a one-operand call.	Keep, take upstream.	4/78 / 4/78	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
generalized-special.ts:340 (widenSignature)	PolyLog	PolyLog takes two arguments: PolyLog(2,2,0.5) → unexpected-argument error (0.186 and 0.187).	Widens the signature to (number, number, number?) for Nielsen's generalized polylogarithm.	Keep, ours by design.	3/131 / 3/131	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
generalized-special.ts:342 (wrapOperator)	PolyLog	Three-argument PolyLog is an unexpected-argument error, including S_{n,1}(z)=Li_{n+1}(z) and S_{1,p}(1)=ζ(p+1) (0.186 and 0.187).	Applies the p=1, S_{1,p}(1) and S_{2,2}(1)=π⁴/360 identities, else tanh-sinh quadrature of the defining integral for real z ≤ 1 (double digits only, declines for complex z).	Keep, ours by design.	3/131 / 3/131	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
huge-arguments.ts:46 (wrapOperator)	LogGamma, GammaLn, LogBarnesG	LogGamma/GammaLn(1e400) evaluate N to 9.20034037197618273607e+402 but stay symbolic under evaluate(); LogBarnesG(1e400) and LogBarnesG(1e300) stay unevaluated even under N (0.186 and 0.187).	For a real operand past a double's range, evaluates the Stirling series (lnΓ) or the ln G(z+1) asymptotic series at the engine's precision with guard digits.	Keep, take upstream.	3/69 / 3/69	755ee47cc feat(analytic,collections): close 27 more aspirational reference examples (#179)
hyperbolic-exact.ts:52 (wrapOperator)	Arcosh	Arcosh(1) → 0 on both evaluate and N (0.186 and 0.187).	Returns 0 at an exact integer 1.	Unwind (done).Removed: drop exact values compute-engine already folds.	0/23 / 0/23	755ee47cc feat(analytic,collections): close 27 more aspirational reference examples (#179)
hyperbolic-exact.ts:68 (wrapOperator)	Sinh, Cosh, Tanh, Coth, Sech, +1	Hyperbolics of Ln(q) stay symbolic under evaluate(): Sinh(Ln 2) → Sinh(Ln 2), Tanh(Ln 3) → Tanh(Ln 3), while N gives 0.75 and 0.8 (0.186 and 0.187).	Folds each to its rational in q: sinh(ln q)=(q−1/q)/2, tanh=(q−1/q)/(q+1/q), etc.	Keep, take upstream.	4/204 / 4/204	755ee47cc feat(analytic,collections): close 27 more aspirational reference examples (#179)
hyperbolic-half-period.ts:56 (wrapOperator)	Sinh, Cosh, Tanh, Coth, Sech, +1	Sinh(0.5+1.5707963267948966i) → 3.19e-17+1.1276259652063807i; Csch of the same → 2.51e-17−0.886818883970074i (0.186 and 0.187); the stray real part is the correct value for the double fl(π/2).	Within 4 ulps of kπ/2 it snaps y to kπ/2 and uses the exact real/imaginary table, so the stray real part is 0.	Open decisions.	7/204 / 7/204	f0cc52ccc fix: review batch 3 — analytic numerics (#692)
incomplete-symbolic.ts:36 (wrapOperator)	Gamma	Gamma(2,z) and Gamma(1/2,z) stay symbolic (N leaves Gamma(0.5,z)), Gamma(2,1) evaluate() stays symbolic though N gives 0.7357588823428846 (0.186 and 0.187).	Gamma(2,z)=(1+z)e^{−z} and Gamma(1/2,z)=√π·Erfc(√z) for any z, symbolic or numeric.	Keep, take upstream.	1/110 / 1/109	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
incomplete-symbolic.ts:69 (wrapOperator)	HurwitzZeta	HurwitzZeta(s,1/2) stays symbolic for symbolic s (N leaves HurwitzZeta(s,0.5)), while HurwitzZeta(2,1/2) → π²/2 already (0.186 and 0.187).	Rewrites ζ(s,1/2) as (2^s−1)ζ(s) for any s, symbolic or numeric.	Keep, take upstream.	1/228 / 1/228	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
incomplete-symbolic.ts:98 (wrapOperator)	LerchPhi	LerchPhi(z,s,1) with symbolic z, s stays unevaluated; numeric LerchPhi(0.5,2,1) works (0.186 and 0.187).	After native declines, rewrites Φ(z,s,1) as PolyLog(s,z)/z.	Keep, take upstream.	4/415 / 4/415	aec6e0835 feat(analytic): incomplete gamma/beta/erf identities, zeta family, generalized…
inverse-compositions.ts:52 (direct)	Sin, Cos, Sec, Csc, Coth, +3	Head(InverseHead(z)) stays unfolded in canonical, evaluate and N for symbolic z, and for numeric: Sin(Arcsin(5)) → Sin(Arcsin(5)) with N giving 5−3.0e-16i; Cosh(Arcosh z) and Tanh(Artanh z) also unfolded (0.186 and 0.187).	Replaces each canonical handler so head(inverse(z)) canonicalizes straight to z, for every complex z.	Keep, take upstream.	7/573 / 7/573	15631867a fix(analytic): Sin(Arcsin z) folds for every z; CatalanNumber at negative…
inverse-erfc.ts:40 (wrapOperator)	Erfc	CE has no InverseErfc; Erfc(InverseErfc(x)) and Erfc(ErfInv(x)) stay unevaluated (0.186 and 0.187).	Folds Erfc(InverseErfc(x)) to x.	Keep, ours by design.	2/36 / 2/36	f06bb00c1 feat(analytic): 25 analytic backlog heads (real/elementary, q-series and…
lambert-w.ts:86 (wrapOperator)	LambertW	Native N already gives other branches: LambertW(1,1) → -1.5339133197935744+4.375185153061898i, LambertW(1,2) → -2.401585104868003+10.77629951611507i, and LambertW(-0.2,-1) → -2.5426413577735264; exact folds are missing: LambertW(e) and LambertW(2e²) stay…	Adds exact folds (0, e→1, -1/e→-1, n·e^n, -ln(k)/k) and a Halley iteration for branches k≠0,-1; compile only up to one operand.	Keep, take upstream.	6/12 / 6/12	f06bb00c1 feat(analytic): 25 analytic backlog heads (real/elementary, q-series and…
linear-algebra-113.ts:37 (wrapOperator)	MatrixRank	MatrixRank of a,b],[c,d stays unevaluated on evaluate and N (0.186 and 0.187).	Returns n for a square matrix of n² pairwise-distinct symbols (generic rank, by the Leibniz formula).	Keep, take upstream.	3/28 / 3/28	183dc123f feat(analytic): MatrixExp rotations and MatrixExp(A, v); generic symbolic…
precision-113.ts:91 (wrapOperator)	LogGamma	LogGamma(-5/2) → -0.056243716497675456−9.42477796076938i (0.186 and 0.187) while ln|Γ(-5/2)| at 30 digits is -0.0562437164976740506725945300977: the real part is off by ~1.4e-15.	For a negative real off the poles recomputes Re via a 40-digit shift recurrence, with Im = π⌊x⌋; rounds float operands to a double; recovers an overflowed native result with the log-space series.	Keep, take upstream.	6/26 / 6/26	c7aefc55b fix(analytic): HarmonicNumber(z, 1), LogGamma overflow, Rationalize tolerance…
precision-113.ts:211 (wrapOperator)	Rationalize	Rationalize(Pi, 0.001) → 333/106 and Rationalize(3.14159, 0.001) → 333/106 (the nearest continued-fraction convergent, 0.186 and 0.187).	Returns the simplest rational (smallest denominator) in [x−tol, x+tol], by Stern–Brocot search in exact arithmetic: 201/64 for π, 0.001.	Keep, take upstream.	2/24 / 2/24	c7aefc55b fix(analytic): HarmonicNumber(z, 1), LogGamma overflow, Rationalize tolerance…
series-infinite.ts:45 (extendHead)	Series	At DirectedInfinity(1) the Taylor rule substitutes the infinity into f and its derivatives (Series(AiryAi(x), x, DirectedInfinity(1), 3) → Add(… AiryAi(DirectedInfinity(1)) … Power(x − DirectedInfinity(1), 3)), 0.186 and 0.187); at PositiveInfinity it stays…	Returns the asymptotic series in 1/x when series-asymptotic.ts has one, declines (stays Series) at any DirectedInfinity and at a non-terminating 2F1 at 1, and remembers declined Taylor attempts.	Keep, take upstream.	19/177 / 20/177	c2d188517 fix(analytic): Airy, EllipticK, DedekindEta and 1F1/2F1 agree with Wolfram…
series-jacobi.ts:43 (extendHead)	Series	Jacobi heads are not CE heads; Series(JacobiCN(u,m), m, 0, 3) gets CE's Taylor fallback with Apply(Derivative(JacobiCN,0,k),u,0) terms (0.186 and 0.187).	Series of a Jacobi function in m at 0 and the Laurent series in u of ns/cs/ds at u = 0 from jacobi-m-series.ts and jacobi-laurent.ts, falling through to native otherwise.	Keep, ours by design.	22/177 / 23/177	db458cc6d feat(analytic): Jacobi derivatives in u for every pq head and in m (#775)
series-q-binomial.ts:168 (extendHead)	Series	QBinomial and QFactorial are not CE heads; Series(QBinomial(4,2,q), q, 0, 3) gets the Taylor fallback with Apply(Derivative(QBinomial,0,0,k),4,2,0) terms (0.186 and 0.187).	Exact power series in q (including q^(1/D) for rational arguments, BigO tail, zero or pole detection) from qSeries, falling through to native otherwise.	Keep, ours by design.	9/177 / 10/177	67925e299 fix(analytic): QBinomial's √q series; symbolic q-analogs are canonical (#748)
signals.ts:623 (direct)	Derivative	HeavisideTheta, Ramp and UnitBox are not CE heads; Derivative(HeavisideTheta(x)) → Function(Block(0), x) (0.186 and 0.187), i.e. an unknown head differentiates as a constant.	Returns the Function for DiracDelta, the Piecewise for Ramp' and UnitBox' (any order) from a table, otherwise calls native.	Keep, ours by design.	2/60 / 2/60	ea3dcb069 chore: compute-engine 0.170 (#1090)
simplify-identities.ts:126 (direct)	Simplify	Simplify(Sin(x)/Cos(x)) → Divide(Sin x, Cos x); Simplify(Cosh² − Sinh²) → Cosh² − Sinh²; Simplify(1 + 1/GoldenRatio − GoldenRatio) stays 1 − GoldenRatio + 1/GoldenRatio (0.186 and 0.187).	After native Simplify, rewrites sin/cos (and the cos/sin, hyperbolic) quotients to Tan/Cot/Tanh/Coth, folds cosh² − sinh² = 1, and collapses an expression in rationals and GoldenRatio that is rational.	Keep, take upstream.	6/32 / 6/32	ea3dcb069 chore: compute-engine 0.170 (#1090)
solve-inverse-heads.ts:44 (extendHead)	Solve	CubeRoot and InverseErfc are not CE heads; Solve(CubeRoot(x) == 2, x) stays unevaluated (0.186 and 0.187).	When native declines, substitutes y for the single invertible head, solves for y, and maps each real root through the inverse (y³, Erfc(y)).	Keep, ours by design.	2/35 / 2/35	a8f2aa35f fix(analytic): triage batch 21 (analytic and number-theory leftovers) (#788)
special-big.ts:214 (wrapOperator)	AiryAi, AiryBi, ExpIntegralEi, LogIntegral	N at precision 40 carries only double digits: N(ExpIntegralEi(2)) → 4.95423435600189, N(LogIntegral(3)) → 2.163588594667192, AiryAi(1.5) → 0.07174949700810541 (0.186 and 0.187).	For a finite real operand and a request past double digits, computes the value in BigDecimal to ce.precision digits, else defers to native.	Keep, take upstream.	9/33 / 9/33	8baf16251 triage (#552): N past a double's digits for Airy, Bessel, Ei, li and Argument;…
special-big.ts:232 (wrapOperator)	BesselK, BesselY	N at precision 40 carries only double digits: BesselK(2, 3.5) → 0.032307121699467825, BesselY(2, 3.5) → 0.045371437729179925 (0.186 and 0.187).	For an integer order and a positive real argument, computes K_n and Y_n in BigDecimal to ce.precision digits (with K_{-n}=K_n, Y_{-n}=(-1)^n Y_n), else defers to native.	Keep, take upstream.	4/16 / 4/16	8baf16251 triage (#552): N past a double's digits for Airy, Bessel, Ei, li and Argument;…
special-functions-remaining.ts:33 (wrapOperator)	BarnesG, LogBarnesG, LogGamma	Already returns PositiveInfinity for the argument PositiveInfinity: LogGamma(PositiveInfinity), BarnesG(PositiveInfinity), LogBarnesG(PositiveInfinity) → PositiveInfinity (0.186 and 0.187).	Returns PositiveInfinity at a positive infinite operand (the same loop also covers HarmonicNumber, which CE does not have).	Unwind (done).Removed: drop exact values compute-engine already folds (HarmonicNumber keeps its limit).	0/73 / 0/73	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:43 (wrapOperator)	DirichletEta, DirichletBeta	Already returns 1 at PositiveInfinity: DirichletEta(PositiveInfinity) → 1, DirichletBeta(PositiveInfinity) → 1 (0.186 and 0.187).	Returns 1 at a positive infinite operand.	Unwind (done).Removed: drop exact values compute-engine already folds.	0/42 / 0/42	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:74 (wrapOperator)	Zeta	Zeta(3, 1/2) → 7·Zeta(3) and Zeta(2.5, 1/2) → 6.2471106 (both correct); Zeta(2+i, 1/2) evaluate stays Zeta(Complex(2,1), 1/2) though N works (0.186 and 0.187).	For a non-symbol s and a = 1/2, returns (2^s − 1)·Zeta(s).	Keep, take upstream.	0/130 / 0/130	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:97 (wrapOperator)	LerchPhi	LerchPhi(1/2,1,1) evaluate stays unevaluated; N → 1.386294361119890618 (correct) (0.186 and 0.187).	Returns the exact 2·Ln(2) at z=1/2, s=1, a=1.	Keep, take upstream.	0/415 / 0/415	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:116 (wrapOperator)	LerchPhi	LerchPhi(-1, 3, 1/2) evaluate stays unevaluated; N → 7.751569170074954 (a double) (0.186 and 0.187).	Returns 2^s · DirichletBeta(s) for z = −1, a = 1/2, any s.	Keep, take upstream.	2/415 / 2/415	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:137 (wrapOperator)	PolyLog	Already applies it: PolyLog(n, −1) → (2^(−n+1) − 1)·Zeta(n) for a symbolic n (0.186 and 0.187).	Returns (2^(1−n) − 1)·Zeta(n) for a symbolic n and z = −1.	Unwind (done).Removed: drop exact values compute-engine already folds.	0/131 / 0/131	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:157 (wrapOperator)	PolyLog	PolyLog(−2, z) stays unevaluated (0.186 and 0.187).	Returns z(1+z)/(1−z)^3.	Keep, take upstream.	4/131 / 4/131	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:178 (wrapOperator)	Erf	Erf(ImaginaryUnit) evaluate stays Erf(Complex(0,1)); N → Complex(0, 1.65042575879754287603) (0.186 and 0.187).	Returns i·Erfi(1).	Keep, take upstream.	1/36 / 1/36	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:190 (wrapOperator)	Erfc	Erfc(Negate(x)) stays Erfc(−x) (0.186 and 0.187).	Returns 2 − Erfc(x) for a structural Negate.	Keep, take upstream.	2/36 / 2/36	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:210 (wrapOperator)	BetaRegularized	BetaRegularized(x,1,1) stays unevaluated (0.186 and 0.187).	Returns x for a = b = 1 (excluding Interval, CenteredInterval and Around x).	Keep, take upstream.	1/26 / 1/26	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:218 (wrapOperator)	BetaRegularized	BetaRegularized(x,3,1) stays unevaluated (0.186 and 0.187).	Returns x^a for b = 1.	Keep, take upstream.	1/26 / 1/26	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:226 (wrapOperator)	BetaRegularized	BetaRegularized(x,1,3) stays unevaluated (0.186 and 0.187).	Returns 1 − (1−x)^b for a = 1.	Keep, take upstream.	2/26 / 2/26	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:248 (wrapOperator)	Digamma	Digamma(1/2) evaluate stays; N → −1.96351002602142347944 (correct) (0.186 and 0.187).	Returns −EulerGamma − 2·Ln 2.	Keep, take upstream.	0/35 / 0/35	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:266 (wrapOperator)	PolyGamma	PolyGamma(1, 1/2) evaluate stays; N → 4.9348022005 (= π²/2) (0.186 and 0.187).	Returns π²/2 for order 1 at 1/2.	Keep, take upstream.	1/78 / 1/78	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-functions-remaining.ts:289 (wrapOperator)	PolyGamma	PolyGamma(3, 5) evaluate stays; N → 0.0214278281927550750219 (0.186 and 0.187).	For 1 ≤ m ≤ 64 and 2 < n ≤ 200, returns (−1)^(m+1) m! (Zeta(m+1) − Σ_{k<n} k^−(m+1)).	Keep, take upstream.	0/78 / 0/78	c3872cc56 feat(analytic): remaining special-function closed forms and limits (#152)
special-values.ts:67 (wrapOperator)	AiryAi, AiryAiPrime, AiryBi, AiryBiPrime	AiryAi(0) and AiryBiPrime(0) evaluate stays unevaluated; N → 0.3550280538878172, 0.4482883573538264 (doubles) (0.186 and 0.187).	At an exact 0 returns the DLMF 9.2.3-4 closed forms in Gamma(1/3), Gamma(2/3).	Keep, take upstream.	6/20 / 6/20	c2d188517 fix(analytic): Airy, EllipticK, DedekindEta and 1F1/2F1 agree with Wolfram…
special-values.ts:77 (wrapOperator)	Apply	Apply(Derivative(EllipticK,1), 0) stays unevaluated (0.186 and 0.187); EllipticK itself is a CE head.	For Apply(Derivative(EllipticK, n), 0) with an exact integer n ≥ 1, returns (π/2)·((1/2)_n)²/n!.	Keep, take upstream.	0/95 / 0/95	0bc66c570 fix(analytic): EllipticK Taylor coefficients at 0, no Taylor series of 2F1 at…
special-values.ts:86 (wrapOperator)	Hypergeometric1F1	Hypergeometric1F1(a,a,z) stays unevaluated (0.186 and 0.187).	Returns Exp(z) when the first two parameters are the same.	Keep, take upstream.	2/7 / 2/7	c2d188517 fix(analytic): Airy, EllipticK, DedekindEta and 1F1/2F1 agree with Wolfram…
special-values.ts:94 (wrapOperator)	Hypergeometric2F1	Hypergeometric2F1(a,b,b,z) stays unevaluated (0.186 and 0.187).	Returns (1−z)^(−a) when c equals a or b.	Keep, take upstream.	2/13 / 2/13	c2d188517 fix(analytic): Airy, EllipticK, DedekindEta and 1F1/2F1 agree with Wolfram…
tagged-arithmetic.ts:58 (defineOverload)	Negate, Add, Multiply, Divide, Power, +42	Rejects an Interval operand with a type error: Add(Interval(1,2), 3) → Error(incompatible-type, 'number', 'set') (0.186 and 0.187).	Adds table rows that dispatch a call with an Interval, CenteredInterval or Around operand to our interval and error-propagation arithmetic.	Keep, ours by design.	196/4977 / 199/4976	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
tagged-arithmetic.ts:60 (defineOverload)	Multiply	Multiply(Exp(a), Exp(b)) → Multiply(Power(E,a), Power(E,b)), uncombined (0.186 and 0.187); equal exponents or numeric exponents combine.	A second row, gated on two Power(ExponentialE, _) factors, combines them to e^(a+b) (exp-combine.ts).	Keep, take upstream.	0/1942 / 2/1941	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
threading-113.ts:56 (threadOverLists)	HurwitzZeta, StieltjesGamma, DirichletCharacter, DirichletL	Already declares broadcastable: true on all four in 0.186 (read from the bundle); HurwitzZeta([2,3], 1/2) → List(π²/2, 7·Zeta(3)), DirichletCharacter(5,2,[1,2]) → [1, i], StieltjesGamma and DirichletL thread too (0.186 and 0.187).	Sets broadcastable: true on the four heads (the call also names HarmonicNumber, which is ours and does not thread natively).	Unwind (done).Removed: thread only HarmonicNumber (HarmonicNumber keeps the flag).	1/306 / 0/306	637084b84 style: print width 120, repo-wide (#213)
threading-113.ts:67 (wrapOperator)	HurwitzZeta	HurwitzZeta(2, 0.5) evaluate already returns the number 4.93480220054467930942, same as N (0.186 and 0.187); HurwitzZeta([2,3], 0.5) threads too.	Forces numericApproximation when an operand is a float and evaluate would otherwise not go numeric.	Unwind (done).Removed: thread only HarmonicNumber.	0/228 / 0/228	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
threading-113.ts:86 (widenSignature)	Rationalize	Rationalize(List(0.5,0.25)) → List(1/2,1/4) already; Rationalize(Add(0.5,x)) stays Rationalize(x + 0.5) (0.186 and 0.187).	Widens the signature to (value, number?) -> value so a symbolic expression with floats reaches evaluate.	Keep, take upstream.	0/24 / 0/24	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
threading-113.ts:87 (wrapOperator)	Rationalize	Same as the signature site: a list is rationalized natively, a symbolic expression with floats is left alone (0.186 and 0.187).	rationalizeDeep: walks a list or a non-closed expression, rationalizing every inexact closed leaf with native and rebuilding.	Keep, take upstream.	1/24 / 1/24	2715c956a feat(analytic): #113 threading and special-function closed forms (#133)
trig-normalisation.ts:126 (wrapOperator)	Sin	Sin(3π) → 0, but Sin(−x), Sin(x+π), Sin(i·x), Sin(Arccos x) all stay unevaluated (0.186 and 0.187).	Applies parity, sin(x + kπ) = (−1)^k sin x, sin(i t) = i sinh t, and sin(arccos x) = √(1 − x²).	Keep, take upstream.	7/247 / 7/247	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
trig-normalisation.ts:139 (wrapOperator)	Arcsin	Arcsin(Sin(2)) stays unevaluated; N → 1.14159265358979323846 (= π − 2, correct) (0.186 and 0.187).	For a real literal y in (−π, π], returns y, π − y or −π − y (the principal branch).	Keep, take upstream.	3/55 / 3/55	88f0358eb feat(analytic): elementary special values, trig normalisation, rounding of…
trig-power-integrals.ts:97 (direct)	Integrate	Indefinite ∫ sin³x dx stays unevaluated; the definite ∫₀¹ sin³x dx evaluates natively to 2/3 − 3/8·Cos(−1) − 3/8·Cos(1) + 1/24·Cos(−3) + 1/24·Cos(3), unsimplified (0.186 and 0.187).	For c·sinᵐ(u)·cosⁿ(u) with linear u and m or n odd, returns the polynomial antiderivative (definite as the difference at the limits), else native.	Keep, take upstream.	3/57 / 3/57	ea3dcb069 chore: compute-engine 0.170 (#1090)
trig-reduction.ts:170 (wrapOperator)	Sin, Cos, Tan, Sec, Csc, +1	N reduces a huge argument correctly at every probed precision: N(Sin(24^40)) at 30 digits → 0.400083152719766047070941915848, N(Cos(10^60)) → −0.557182948248566708973, Cot(10^50+1), Sec(10^40/3), Csc(7^70) all match mpmath to 21 digits (0.186 and 0.187); at…	Reduces an exact or bignum argument mod 2π in BigDecimal before the circular function runs.	Unwind (done).Removed: huge trigonometric arguments are compute-engine's.	0/566 / 0/566	624f6aa28 fix(analytic): exact argument reduction for trig of huge arguments (#176)
widened.ts:122 (widenSignature)	Conjugate	Conjugate(Transpose(m)) with m undeclared holds as Conjugate(Transpose(m)), canonical included, no type error (0.186 and 0.187); signature is (T) -> T where T: number.	Widens the signature to (value) -> value so a non-number operand reaches evaluate, and only what may be a number goes to native.	Keep, take upstream.Conjugate(Dot(a, b)) is an incompatible-type Error natively (0.186 and 0.187); Conjugate(Transpose(m)) alone is not.	0/24 / 0/24	6992cc55e fix(analytic): more integral transforms in closed form; Conjugate of a…
widened.ts:124 (widenSignature)	CatalanNumber	CatalanNumber(1/2) boxes to Error(incompatible-type, 'integer', 'rational<0.5..0.5>') (0.186 and 0.187).	Widens the signature to (number) -> number when the operand may be an integer, so half-integers reach evaluate.	Keep, take upstream.	1/34 / 1/34	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
widened.ts:127 (wrapOperator)	Binomial, Beta, CatalanNumber	Binomial(1/2,1) and Beta(1/2,1/2) evaluate stay unevaluated (N → 0.5 and π, doubles); CatalanNumber(3/2) is a type error (0.186 and 0.187).	For integer or half-integer rational operands (at least one half), returns the exact Γ-ratio c·√π^h.	Keep, take upstream.	8/151 / 8/151	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
widened.ts:156 (wrapOperator)	CatalanNumber	CatalanNumber(−1) and CatalanNumber(−2) stay unevaluated (0.186 and 0.187).	Returns −1 at n = −1 and 0 at every n ≤ −2.	Open decisions.	10/34 / 10/34	15631867a fix(analytic): Sin(Arcsin z) folds for every z; CatalanNumber at negative…
widened.ts:172 (wrapOperator)	Factorial2	Already folds negative odd arguments: Factorial2(−3) → −1, Factorial2(−5) → 1/3, Factorial2(−7) → −1/15 (0.186 and 0.187).	Returns (−1)^k/(2k−1)!! for n = −2k−1 by the downward recurrence.	Unwind (done).Removed: drop exact values compute-engine already folds.	0/19 / 0/19	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
widened.ts:189 (widenSignature)	BernoulliB	BernoulliB(3, x) → Error(unexpected-argument, 'x'); BernoulliB(4) → −1/30 (0.186 and 0.187). CE's BernoulliB is the one-argument number.	Widens the signature to (integer, number?) so a second argument is accepted.	Keep, ours by design.	10/37 / 10/37	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
widened.ts:191 (wrapOperator)	BernoulliB	BernoulliB(3, x) is an unexpected-argument error; BernoulliB(4) alone is fine (0.186 and 0.187).	Rewrites every two-operand BernoulliB(n, x) to BernoulliPolynomial(n, x) and evaluates it.	Keep, ours by design.	5/37 / 5/37	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
widened.ts:204 (wrapOperator)	Digamma	Digamma(5) evaluate stays Digamma(5); N → 1.50611766843180047273 (0.186 and 0.187).	For a positive integer n returns HarmonicNumber(n−1) − EulerGamma (evaluated, or N() under numeric).	Keep, take upstream.	5/35 / 5/35	d8d01bc2c feat(analytic): exact Gamma, Digamma, Ln and Arcsin values (#92 group B) (#107)
widened.ts:226 (wrapOperator)	Ln	Ln(−2) and Ln(−1/2) evaluate stay unevaluated, while N gives Complex(0.693…, 3.14159…) (0.186 and 0.187).	For a negative rational q returns Ln(−q) + i·π.	Keep, ours by design (compute-engine's ruling: exactness-regressions P0-18).	6/228 / 6/228	d8d01bc2c feat(analytic): exact Gamma, Digamma, Ln and Arcsin values (#92 group B) (#107)
widened.ts:284 (wrapOperator)	Arcsin, Arccos, Arcosh, Artanh, Arcoth, +3	Outside the real domain evaluate leaves the call: Arcsin(2), Arccos(2), Arcosh(−2), Artanh(2), Arcoth(1/2), Arcsec(1/2), Arccsc(1/2), Arsech(−1/2) all stay unevaluated while N gives the principal value; Arcosh(1/2) → (π/3)·i already (0.186 and 0.187).	Returns the exact closed form of the principal value for a rational real argument outside the domain (e.g. Arcsin(x), |x|>1 → sign(x)(π/2 − i·arcosh|x|)).	Open decisions.	21/235 / 21/235	e7a41efbc fix: inverse family symmetric past the domain; GammaLn, LambertW, Round docs;…

arithmetic/adeles

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
declare.ts:176 (defineOverload)	Add	Leaves Add of profinite carriers unevaluated (probe ['Add',['Adele',1],['Adele',2]] -> unevaluated, 0.186 and 0.187); CE has no such value type.	Adds Profinite values componentwise (P.add) and writes a Profinite back.	Keep, ours by design.	0/1889 / 3/1888	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:182 (defineOverload)	Multiply	Leaves Multiply of profinite carriers unevaluated (same probe family as Add, 0.186/0.187).	Multiplies Profinite values with P.multiply.	Keep, ours by design.	2/1942 / 2/1941	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:188 (defineOverload)	Divide	Leaves Divide of profinite carriers unevaluated (not probed separately; ['Divide',['Foo',1],0] stays unevaluated, 0.186/0.187).	Divides Profinite values with P.divide.	Keep, ours by design.	0/782 / 0/781	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:195 (defineOverload)	Negate	['Negate',['Profinite',1]] -> unevaluated (0.186, 0.187).	Negates a Profinite value with P.negate.	Keep, ours by design.	0/789 / 1/788	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:205 (defineOverload)	Power	['Power',['Profinite',1],2] -> unevaluated (0.186, 0.187).	Raises a Profinite base to an integer power with P.power (gated on the base's head).	Keep, ours by design.	0/1493 / 3/1492	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:226 (defineOverload)	Add	['Add',['Adele',1],['Adele',2]] -> unevaluated (0.186, 0.187).	Adds adeles componentwise (real part via CE Add, finite part via P.add); a rational beside an adele is the diagonal adele.	Keep, ours by design.	1/1889 / 3/1888	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:232 (defineOverload)	Multiply	Leaves Multiply of adeles unevaluated (same probe family, 0.186/0.187).	Multiplies adeles componentwise.	Keep, ours by design.	1/1942 / 4/1941	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:238 (defineOverload)	Divide	Leaves Divide of adeles unevaluated (not probed separately).	Divides adeles componentwise (P.divide on the finite part).	Keep, ours by design.	0/782 / 0/781	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:245 (defineOverload)	Negate	Leaves Negate of an adele unevaluated (Negate of Profinite probed: unevaluated, 0.186/0.187).	Negates both components.	Keep, ours by design.	0/789 / 0/788	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:255 (defineOverload)	Power	Leaves Power of an adele unevaluated (Profinite analog probed, 0.186/0.187).	Integer power of an adele: real part via CE Power, finite part via P.power.	Keep, ours by design.	3/1493 / 2/1492	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:282 (defineOverload)	Multiply	Leaves Multiply of ideles unevaluated (same probe family, 0.186/0.187).	Multiplies ideles (group operation) componentwise.	Keep, ours by design.	1/1942 / 3/1941	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:288 (defineOverload)	Divide	Leaves Divide of ideles unevaluated (not probed separately).	Divides ideles by multiplying with the inverse (I.invert).	Keep, ours by design.	0/782 / 0/781	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:295 (defineOverload)	Power	Leaves Power of an idele unevaluated (Profinite analog probed, 0.186/0.187).	Integer power of an idele via I.power.	Keep, ours by design.	0/1493 / 2/1492	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:330 (defineOverload)	Equal, NotEqual	Equal of two different-looking Profinite carriers stays unevaluated (['Equal',['Profinite',1,2],['Profinite',3,4]] -> unevaluated); identical ones are True structurally (0.186/0.187).	Decides Hertogh equality (the represented sets meet) for profinite, adele and idele values, True/False.	Keep, ours by design.	8/471 / 8/471	ee2ea079b refactor(adeles, residues): extensions on their carriers become rows (#479)
declare.ts:385 (defineOverload)	Fibonacci, LucasL	Fibonacci of a Profinite argument is unevaluated (['Fibonacci',['Foo',5]] -> unevaluated, 0.186/0.187); native handles integers.	Fibonacci/LucasL of a Profinite value via P.fibonacci/P.lucas (the native handler keeps integer-like arguments via the native gate).	Keep, ours by design.	0/101 / 0/101	4dc9920c5 feat(engine): overloads as data, piloted on Fibonacci, LucasL and Inverse (#440)
declare.ts:404 (defineOverload)	Numerator	Numerator of a Profinite is returned as is (['Numerator',['Profinite',5]] -> ['Profinite',5], 0.186/0.187), which is not the profinite numerator.	Returns P.numerator of the profinite value; native keeps number arguments and the Over -> R Rule.	Keep, ours by design.	3/21 / 3/21	ee2ea079b refactor(adeles, residues): extensions on their carriers become rows (#479)
declare.ts:417 (defineOverload)	Denominator	Denominator of a Profinite is not meaningful natively (probe of the Rule operand gave 1; Profinite analog of Numerator returns the argument, 0.186/0.187).	Returns P.denominator as a plain integer level.	Keep, ours by design.	2/9 / 2/9	ee2ea079b refactor(adeles, residues): extensions on their carriers become rows (#479)

arithmetic/number-theory

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
declare-algebraic.ts:64 (wrapOperator)	IsPrime	IsPrime takes one argument: IsPrime(7, Rule(Over, GaussianIntegers)) → Error unexpected-argument (0.186 and 0.187).	With Over -> AlgebraicIntegers(θ) or AlgebraicOrder(θ) past degree 2, answers whether (x) is a prime ideal via the ce-patches number-field kernel; otherwise defers to the native handler.	Keep, ours by design.	4/92 / 4/92	d779c78e0 feat: algebraic numbers and the orders of number fields (#738)
declare-fast-factorial.ts:22 (wrapOperator)	Factorial	Factorial(25) → 15511210043330985984e+6 exact (0.186); a sequential bigint loop, so slower past large n (speed not measured here).	Answers an exact integer 0..200000 with a balanced product tree, same value, fewer bigint multiplications.	Open decisions.	0/80 / 0/80	8c65afc13 perf: fast Fibonacci/LucasL, sieved PrimePi/Prime, product-tree Factorial,…	https://github.com/enumeratio/notatio/issues/205
declare-fast-gcd.ts:36 (wrapOperator)	GCD	GCD({"num":"123456789012345678901234567890"}, {"num":"987654321098765432109876543210"}) → 9000000000900000000090 (exact, plain Euclid; 0.186).	Folds all-integer GCD with Stein binary gcd below 512 bits and Lehmer above, same value.	Open decisions.	0/59 / 0/59	8c65afc13 perf: fast Fibonacci/LucasL, sieved PrimePi/Prime, product-tree Factorial,…	https://github.com/enumeratio/notatio/issues/205
declare-fast-primes.ts:26 (wrapOperator)	PrimePi	PrimePi(1000) → 168; PrimePi(100000000) → THREW CancellationError exceeded 10000000 iterations (0.186 and 0.187).	Answers any literal non-negative integer with a sieve / Lucy_Hedgehog / Deléglise–Rivat count, declining past its limit.	Open decisions.	6/43 / 6/43	8c65afc13 perf: fast Fibonacci/LucasL, sieved PrimePi/Prime, product-tree Factorial,…	https://github.com/enumeratio/notatio/issues/205
declare-fast-primes.ts:45 (wrapOperator)	NthPrime	NthPrime(1000000) → 15485863 (correct, slow loop); NthPrime(100) → 541 (0.186).	Answers a positive integer index by inverse-π estimate, exact count and a short sieve.	Open decisions.	1/53 / 1/53	8c65afc13 perf: fast Fibonacci/LucasL, sieved PrimePi/Prime, product-tree Factorial,…	https://github.com/enumeratio/notatio/issues/205
declare-fast-recurrence.ts:31 (defineOverload)	Fibonacci, LucasL	Fibonacci(100) → 354224848179261915075 and LucasL(10) → 123, by an O(n) bigint loop (0.186).	Adds an overload row doing fast doubling for an integer index up to 10^7 in magnitude, declining to native past it.	Open decisions.	0/101 / 0/101	4dc9920c5 feat(engine): overloads as data, piloted on Fibonacci, LucasL and Inverse (#440)	https://github.com/enumeratio/notatio/issues/205
declare-gaussian.ts:129 (widenSignature)	Mod	Mod(7+2i, 2+i) → Error incompatible-type real vs complex (0.186 and 0.187).	Widens the signature to (number, number) -> number so a Gaussian integer or rational operand reaches our handler.	Keep, ours by design.	0/143 / 0/143	5d96d7b90 number-theory: PowerModList to Wolfram parity over bigints; Gaussian integers…
declare-gaussian.ts:131 (wrapOperator)	Mod	Mod(7+2i, 2+i) → Error (0.186); Mod(7/2, 2) → 3/2 natively.	Computes the Gaussian remainder in ℤ[i] when an operand is a Gaussian integer or rational.	Keep, ours by design.	33/143 / 32/143	5d96d7b90 number-theory: PowerModList to Wolfram parity over bigints; Gaussian integers…
declare-gaussian.ts:188 (wrapOperator)	GCD, LCM	GCD(3+i, 1+i) → left unevaluated (0.186 and 0.187).	Returns the Gaussian gcd/lcm (by Euclid in ℤ[i]) for Gaussian-integer operands.	Keep, ours by design.	48/108 / 48/108	5d96d7b90 number-theory: PowerModList to Wolfram parity over bigints; Gaussian integers…
declare-gaussian.ts:197 (widenSignature)	ExtendedGCD	ExtendedGCD(12, 18) → Tuple(6, -1, 1); a complex operand would be rejected as non-integer (not probed with complex).	Widens to (number, number) -> tuple<number,number,number> (guarded by mayBeInteger) so Gaussian operands reach our handler.	Keep, ours by design.	3/42 / 3/42	637084b84 style: print width 120, repo-wide (#213)
declare-gaussian.ts:199 (wrapOperator)	ExtendedGCD	ExtendedGCD(12, 18) → Tuple(6, -1, 1) (0.186); no Gaussian support.	Returns Tuple(g, x, y) over ℤ[i] for Gaussian operands.	Keep, ours by design.	25/42 / 25/42	5d96d7b90 number-theory: PowerModList to Wolfram parity over bigints; Gaussian integers…
declare-gaussian.ts:220 (widenSignature)	ModularInverse	ModularInverse(1+i, 5) → Error incompatible-type integer vs complex; ModularInverse(3, -7) → -2 natively (0.186 and 0.187).	Widens to (number, number) -> number so a Gaussian operand reaches our handler.	Keep, ours by design.	23/46 / 23/46	7026679dd Tighten the signatures our packages declare (#350)	cortex-js/compute-engine#339, cortex-js/compute-engine#347
declare-gaussian.ts:222 (wrapOperator)	ModularInverse	ModularInverse(1+i, 5) → Error (0.186).	Inverts modulo m in ℤ[i] when an operand is off the real line.	Keep, ours by design.	17/46 / 17/46	5d96d7b90 number-theory: PowerModList to Wolfram parity over bigints; Gaussian integers…
declare-gaussian.ts:248 (widenSignature)	IsPrime, FactorInteger, Divisors, PrimeNu, PrimeOmega, +3	FactorInteger(3+i), Divisors(3+i), PrimeNu(3+i), MoebiusMu(3+i), IsSquareFree(3+i) → Error incompatible-type integer vs complex; IsPrime(3+i) → False, IsComposite(3+i) → False (0.186 and 0.187).	Widens each to (number, any*) so a Gaussian argument or a trailing Over option reaches our evaluate.	Keep, ours by design.	3/328 / 3/328	62560d1cb fix(number-theory): widened integer heads no longer answer non-integers (#6)
declare-gaussian.ts:249 (widenSignature)	IsPrime, FactorInteger, Divisors, PrimeNu, PrimeOmega, +3	As the line above: complex and option arguments rejected or answered False (0.186).	A second widening to (quadratic_integer, any*) so our quadratic-integer carrier is accepted.	Keep, ours by design.	4/328 / 4/328	5e20ea551 Quadratic integers, lattice plots, explicit plot colors, complex bases (#715)
declare-gaussian.ts:251 (takeOptionsAsRules)	IsPrime, FactorInteger, Divisors, PrimeNu, PrimeOmega, +3	IsPrime(7, Rule(Over, GaussianIntegers)) → Error unexpected-argument (0.186 and 0.187); no options on these heads.	Canonicalizes a trailing option into a Rule that a broadcastable head does not thread over.	Keep, ours by design.	0/328 / 0/328	29e054112 engine: an option rule reaches its head as a Rule, not a Tuple (BL-208) (#1033)
declare-gaussian.ts:271 (extendHead)	IsPrime, FactorInteger, Divisors, PrimeNu, PrimeOmega, +3	FactorInteger of a 64-digit p^3 → THREW CancellationError Pollard rho exceeded 10000000 iterations; FactorInteger(-12) → -1,1],[2,2],[3,1 natively (0.186).	Reads Over, a Gaussian or quadratic-ring argument, and a list, answers there; for a rational integer uses our factorer for FactorInteger/Divisors and otherwise falls back to the native handler.	Keep, ours by design.	67/328 / 67/328	6b9a8b360 refactor: arithmetic and algebra libraries reach compute-engine through the…
declare-gaussian.ts:443 (widenSignature)	DivisorSigma	DivisorSigma(1, 3+i) → Error incompatible-type integer vs complex (0.186 and 0.187).	Widens to (number, number, any*) so a complex n or a trailing Over option reaches evaluate.	Keep, ours by design.	3/34 / 3/34	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-gaussian.ts:447 (takeOptionsAsRules)	DivisorSigma	No Over option on DivisorSigma natively (0.186).	Keeps a trailing Over option as a Rule so the broadcastable head does not thread over it.	Keep, ours by design.	0/34 / 0/34	29e054112 engine: an option rule reaches its head as a Rule, not a Tuple (BL-208) (#1033)
declare-gaussian.ts:449 (extendHead)	DivisorSigma	DivisorSigma(1, 3+i) → Error (0.186).	Answers DivisorSigma(k, z, Over -> GaussianIntegers) as the Gaussian divisor sum; otherwise native.	Keep, ours by design.	2/34 / 2/34	6b9a8b360 refactor: arithmetic and algebra libraries reach compute-engine through the…
declare-gaussian.ts:536 (wrapOperator)	GCD	GCD(1/2, 1/3) → left unevaluated (0.186 and 0.187).	For Gaussian rationals, gcd(p1/q1, ..) = gcd(p)/lcm(q) over ℤ[i]; its gate (any operand with denominator > 1) also catches plain real rationals.	Keep, ours by design.	1/59 / 1/59	e04309308 fix(web): prerender compiles plots in Node again (#802)
declare-gaussian.ts:551 (wrapOperator)	LCM	LCM(1/2, 1/3) → left unevaluated (0.186 and 0.187).	lcm(p/q, ..) = lcm(p)/gcd(q) over ℤ[i] for Gaussian rationals, also catching plain rationals.	Keep, ours by design.	1/51 / 1/51	e04309308 fix(web): prerender compiles plots in Node again (#802)
declare-gaussian.ts:572 (wrapOperator)	Numerator	Numerator(3/7 + i/11) → Complex(3/7, 1/11) unchanged (0.186 and 0.187).	Puts a complex with fractional part over its common denominator: numerator 33 + 7i.	Keep, ours by design.	1/21 / 1/21	67cc9692d triage (#552): floats stay floats in PDF/CDF, Gaussian-rational Numerator,…
declare-gaussian.ts:573 (wrapOperator)	Denominator	Denominator(3/7 + i/11) → 1 (0.186 and 0.187 for 0.186 probed).	Answers the common denominator 77.	Keep, ours by design.	0/9 / 0/9	67cc9692d triage (#552): floats stay floats in PDF/CDF, Gaussian-rational Numerator,…
declare-widened.ts:36 (widenSignature)	Totient	Totient(0) → 0 and Totient(-12) → 4 (0.186 and 0.187, nothing of ours loaded).	Widens the signature to (number) -> integer so zero and negative n reach the wrapper.	Unwind (done).Removed: Totient at zero and negative integers is compute-engine's.	0/45 / 0/45	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:38 (wrapOperator)	Totient	Totient(0) → 0, Totient(-12) → 4 (0.186).	Answers 0 for 0 and Totient(-n) = Totient(n) for n <= 0.	Unwind (done).Removed: Totient at zero and negative integers is compute-engine's.	0/45 / 0/45	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare-widened.ts:55 (wrapOperator)	DivisorSigma	DivisorSigma(-1, 12) → left unevaluated (0.186 and 0.187).	Answers σ_k(n) for k < 0 as σ_{-k}(n)/n^{-k}.	Keep, take upstream.	3/34 / 3/34	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare-widened.ts:74 (widenSignature)	NextPrime	NextPrime(7/2) and NextPrime(3.5) → Error incompatible-type integer (0.186 and 0.187).	Widens to (number, number?) -> integer so negative and non-integer arguments reach the wrappers.	Keep, take upstream.	2/24 / 2/24	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:76 (wrapOperator)	NextPrime	NextPrime(-10) → 2 (0.186 and 0.187).	For n < -2 returns -p, p the largest prime below -n: NextPrime(-10) = -7.	Keep, take upstream.	1/24 / 1/24	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:95 (wrapOperator)	NextPrime	NextPrime(7/2) → Error incompatible-type integer (0.186 and 0.187).	For a non-integer real or rational, the smallest prime greater than ceil(n).	Keep, take upstream.	2/24 / 2/24	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:121 (wrapOperator)	DivisorSigma	DivisorSigma(k, 6) → left unevaluated (0.186 and 0.187).	For symbolic k and concrete positive n, the sum of d^k over the divisors of n.	Keep, take upstream.	1/34 / 1/34	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:146 (wrapOperator)	DivisorSigma	DivisorSigma(1/2, 6) → Error incompatible-type integer vs rational (0.186 and 0.187).	For a non-integer rational k, the exact sum of d^k over the divisors of n (radicals left symbolic).	Keep, take upstream.	1/34 / 1/34	ef3e6d649 feat(arithmetic,number-theory,residues,collections,numerals): sweep #113's…
declare-widened.ts:175 (wrapOperator)	GCD, LCM	GCD(1/2, 1/3) and LCM(1/2, 1/3) → left unevaluated (0.186 and 0.187).	gcd(p/q, ..) = gcd(p, ..)/lcm(q, ..) and lcm(p/q, ..) = lcm(p, ..)/gcd(q, ..).	Keep, take upstream.	0/108 / 0/108	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare-widened.ts:198 (wrapOperator)	GCD, LCM	GCD(20!, 10^100+3) → 7 and LCM → exact 118-digit integer; GCD/LCM of two 30-digit integers exact (0.186 and 0.187). LCM(10^20, 7) prints as 7e+20.	Routes every plain-integer call through bigints.	Unwind (done).Removed: GCD and LCM of big integers are compute-engine's.	0/108 / 0/108	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:217 (wrapOperator)	IsSquareFree	IsSquareFree(6/35) → Error incompatible-type integer vs rational (0.186 and 0.187).	True when numerator and denominator are both squarefree.	Keep, take upstream.	1/35 / 1/35	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:241 (wrapOperator)	IsSquareFree	IsSquareFree of 2305843009213693951 * 618970019642690137449562111 → THREW CancellationError Pollard rho (0.186 and 0.187); the claimed wrong False was not reproduced.	Squarefree test through our factorInteger, declining when it cannot factor.	Keep, take upstream.	0/35 / 0/35	9d11d519b fix(number-theory,analytic,numerals): Wolfram-doc rows where our analysis and…
declare-widened.ts:262 (widenSignature)	IsSquareFree	IsSquareFree(x^2) → left unevaluated; IsSquareFree(x^2 y, y) → Error unexpected-argument (0.186 and 0.187).	Widens to (expression, expression?) -> boolean for a polynomial and an optional variable.	Keep, take upstream.	0/35 / 0/35	7026679dd Tighten the signatures our packages declare (#350)
declare-widened.ts:264 (wrapOperator)	IsSquareFree	IsSquareFree(x^2) → unevaluated (0.186 and 0.187).	Tests gcd(f, df/dx) for each variable using CE's own D and PolynomialGCD.	Keep, take upstream.	11/35 / 11/35	ef3e6d649 feat(arithmetic,number-theory,residues,collections,numerals): sweep #113's…
declare-widened.ts:291 (wrapOperator)	FactorInteger	FactorInteger(12/35) → Error incompatible-type integer vs rational (0.186 and 0.187).	Factors numerator and denominator, with the denominator's exponents negated.	Keep, take upstream.	2/55 / 2/55	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:324 (wrapOperator)	GCD, LCM	GCD(12, [3, 7, 40]) → 1 (0.186 and 0.187), not a list.	Threads over equal-length list arguments, scalars held fixed: GCD(12, {3,7,40}) = {3,1,4}; unequal lengths stay unevaluated.	Keep, take upstream.	4/108 / 4/108	7b40d64e8 feat(number-theory): #113 threading, wider domains and big-integer GCD (#142)
declare-widened.ts:349 (widenSignature)	Mod	Mod(7, 5, 3) → Error unexpected-argument '3' (0.186 and 0.187).	Widens to (number, number, number?) -> number so the offset form is accepted, keeping number operands so Gaussian Mod still reaches its handler.	Keep, take upstream.	2/143 / 2/143	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare-widened.ts:351 (wrapOperator)	Mod	Mod(7, 5, 3) → Error unexpected-argument (0.186 and 0.187).	For integers returns d + ((m - d) mod n) with the sign of n.	Keep, take upstream.	0/143 / 0/143	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare-widened.ts:368 (wrapOperator)	CarmichaelLambda	CarmichaelLambda(-12) and CarmichaelLambda(0) → left unevaluated (0.186 and 0.187).	Answers 0 for 0 and λ(-n) = λ(n) for negative n.	Keep, take upstream.	4/32 / 4/32	5c2299672 feat(collections): Riffle, Span, Gather, Split, SortBy, PadLeft and friends…
declare-widened.ts:383 (wrapOperator)	IsPerfect	IsPerfect(-6) → left unevaluated (0.186 and 0.187).	Answers False for a negative integer.	Keep, take upstream.	1/8 / 1/8	5c2299672 feat(collections): Riffle, Span, Gather, Split, SortBy, PadLeft and friends…
declare-widened.ts:401 (widenSignature)	ExtendedGCD	ExtendedGCD(12, 18, 27) → Error unexpected-argument '27'; ExtendedGCD(12) → Error missing (0.186 and 0.187).	Widens to (number, number*) -> tuple so one or more than two integers are accepted.	Keep, take upstream.	4/42 / 4/42	a28439f58 fix: review batch 4 — collections, statistics, graphs (#694)
declare-widened.ts:403 (wrapOperator)	ExtendedGCD	ExtendedGCD(0, 0) → Tuple(0, 1, 0); ExtendedGCD(12, 18, 27) → Error (0.186 and 0.187).	Folds the two-argument case pairwise for any number of integers, one argument is its own gcd, and all zeros take zero coefficients: ExtendedGCD(0, 0) = Tuple(0, 0, 0).	Keep, take upstream.	3/42 / 3/42	7dad04a12 feat(number-theory,numerals): n-argument ExtendedGCD, IsPrime of negatives,…
declare.ts:83 (threadOverLists)	Totient, NextPrime, NthPrime, PrimePi, FactorInteger, +20	Bare CE already threads lists for these heads: Totient([2,4,6]) → [1,2,2], Divisors([6,10]) → 1,2,3,6],[1,2,5,10, Fibonacci([3,4]) → [2,3], CarmichaelLambda([8,15]) → [2,4] (0.186 and 0.187). Exception: Multinomial([1,2], 3) → Error incompatible-type;…	Sets broadcastable: true on each head.	Unwind (done).Removed: thread only the heads compute-engine does not (Multinomial and KroneckerSymbol keep the flag).	1/855 / 1/855	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare.ts:129 (wrapOperator)	PowerModList	PowerModList(2, 2, 7) → [4] for integers; no complex support (0.186; Gaussian operand not probed).	Computes the list over ℤ[i] when the base or modulus is a Gaussian integer off the real line.	Keep, ours by design.	3/37 / 3/37	891789288 feat(boxed): arity parameter on wrapOperator (#141)
declare.ts:145 (wrapOperator)	PowerMod	PowerMod(1+i, 3, 5) → Error incompatible-type integer vs complex (0.186 and 0.187).	Computes the power modulo m in ℤ[i], also with a rational exponent through the root list.	Keep, ours by design.	22/78 / 22/78	891789288 feat(boxed): arity parameter on wrapOperator (#141)
declare.ts:165 (widenSignature)	RationalReconstruction	RationalReconstruction(3, 7, 2, 3) → Error unexpected-argument '2' (0.186 and 0.187).	Widens to (integer, integer, integer?, integer?) -> rational so explicit numerator and denominator bounds are accepted.	Keep, ours by design.	1/8 / 1/8	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:166 (threadOverLists)	RationalReconstruction	RationalReconstruction([3, 4], 7) → [RationalReconstruction(3,7), RationalReconstruction(4,7)] (threads natively; 0.186 and 0.187).	Marks the head broadcastable.	Unwind (done).Removed: thread only the heads compute-engine does not.	0/8 / 0/8	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:167 (wrapOperator)	RationalReconstruction	RationalReconstruction(3, 7) → left unevaluated (no reconstruction in bound); the 4-argument form → Error (0.186 and 0.187).	Passes two-argument calls to native and answers the explicit-bound four-argument form from rationalReconstruction().	Keep, ours by design.	1/8 / 1/8	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:269 (wrapOperator)	Binomial	Binomial(n, n-1) → Binomial(n, n-1) unevaluated (0.186 and 0.187).	Returns n for symbolic n when k evaluates to n-1.	Keep, take upstream.	2/91 / 2/91	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:280 (wrapOperator)	Binomial	Binomial(n, n) → Binomial(n, n) unevaluated (0.186 and 0.187).	Returns 1 for symbolic n when k equals n by value.	Keep, take upstream.	3/91 / 3/91	9d5ba30cf feat(collections,number-theory): symbolic products; Binomial(n, n),…
declare.ts:320 (widenSignature)	CatalanNumber	CatalanNumber(2.3) and CatalanNumber(1/2) → Error incompatible-type integer (0.186 and 0.187).	Widens to (any) -> any with native taking everything except inexact numbers.	Keep, take upstream.	0/34 / 0/34	3785db8cd feat(analytic): rigorous interval images, unions across poles, and the #113 §2…
declare.ts:321 (widenSignature)	Subfactorial	Subfactorial(4.5) → Error incompatible-type integer (0.186 and 0.187).	Widens to (any) -> any, native taking everything but inexact numbers.	Keep, take upstream.	3/27 / 3/27	3785db8cd feat(analytic): rigorous interval images, unions across poles, and the #113 §2…
declare.ts:322 (widenSignature)	Factorial2	Factorial2(2.5) → left unevaluated; N gives the same (0.186 and 0.187).	Widens to (any) -> any, native taking everything but inexact numbers.	Keep, take upstream.	0/19 / 0/19	3785db8cd feat(analytic): rigorous interval images, unions across poles, and the #113 §2…
declare.ts:325 (widenSignature)	Multinomial	Multinomial() → Error missing; Multinomial(2.5, 1.5) → Error incompatible-type integer (0.186 and 0.187).	Widens to (any*) -> any, native taking everything but inexact numbers, so zero arguments are allowed.	Keep, take upstream.	5/18 / 5/18	3785db8cd feat(analytic): rigorous interval images, unions across poles, and the #113 §2…
declare.ts:329 (wrapOperator)	Multinomial	Multinomial() → Error missing; Multinomial(x) → unevaluated (0.186 and 0.187).	Returns 1 for zero or one argument.	Keep, take upstream.	1/18 / 1/18	9d5ba30cf feat(collections,number-theory): symbolic products; Binomial(n, n),…
declare.ts:338 (wrapOperator)	Binomial	Binomial(1+i, 5) → unevaluated, N also unevaluated (0.186 and 0.187).	Exact falling factorial for an integer k (Binomial(1+i, 5) = -(1+i)/12), else the Gamma ratio in doubles.	Keep, take upstream.	2/91 / 2/91	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:357 (wrapOperator)	CatalanNumber	CatalanNumber(2.3) → Error incompatible-type integer (0.186 and 0.187).	Evaluates Γ(2n+1)/(Γ(n+1)Γ(n+2)) numerically for an inexact real or complex n.	Keep, take upstream.	3/34 / 3/34	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:372 (wrapOperator)	Pochhammer	Pochhammer(2+5i, 8i) → unevaluated, N also unevaluated (0.186 and 0.187).	Γ(a+n)/Γ(a) in doubles for a complex a or n, non-integer order only.	Keep, take upstream.	1/31 / 1/31	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:395 (wrapOperator)	Pochhammer	Pochhammer(3/2, 1/2) → unevaluated; N → 1.1283791670955125739 (0.186 and 0.187).	Evaluates Γ(a+n)/Γ(a) exactly for exact non-integer order, giving 2/sqrt(pi).	Keep, take upstream.	1/31 / 1/31	9d5ba30cf feat(collections,number-theory): symbolic products; Binomial(n, n),…
declare.ts:409 (wrapOperator)	Multinomial	Multinomial(2.5, 1.5) → Error incompatible-type integer (0.186 and 0.187).	Evaluates Γ(Σ+1)/ΠΓ(x_i+1) numerically when some operand is an inexact real or complex.	Keep, take upstream.	4/18 / 4/18	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:432 (wrapOperator)	Factorial2	Factorial2(2.5) → unevaluated, N the same (0.186 and 0.187).	The analytic continuation 2^((1+2x-cos πx)/4) π^((cos πx-1)/4) Γ(1+x/2) numerically.	Keep, take upstream.	1/19 / 1/19	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:448 (wrapOperator)	Subfactorial	Subfactorial(4.5) → Error incompatible-type integer (0.186 and 0.187).	Γ(n+1, -1)/e numerically, with a big-precision series for a real n past double digits.	Keep, take upstream.	3/27 / 3/27	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:469 (wrapOperator)	StirlingS1, Stirling	StirlingS1(3, 5) → 0, Stirling(3, 5) → 0, Stirling(0, 1) → 0 (0.186 and 0.187).	Returns 0 for k > n >= 0.	Unwind (done).Removed: Stirling numbers past the diagonal are compute-engine's.	0/74 / 0/74	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:489 (defineOverload)	Fibonacci, LucasL	Fibonacci(2.5) → Error incompatible-type integer; Fibonacci(10, x) → Error unexpected-argument 'x'; Fibonacci(-5) → 5 (0.186 and 0.187).	Adds rows to the overload tables: Binet formula at a real index, the polynomial families F_n(x) and L_n(x), with an exact path for exact operands.	Keep, take upstream.	24/101 / 24/101	4dc9920c5 feat(engine): overloads as data, piloted on Fibonacci, LucasL and Inverse (#440)
declare.ts:501 (widenSignature)	BellNumber	BellNumber(5, x) → Error unexpected-argument 'x' (0.186 and 0.187).	Widens to (integer, any?) -> any so the Bell polynomial form is accepted.	Keep, take upstream.	5/28 / 5/28	7026679dd Tighten the signatures our packages declare (#350)
declare.ts:610 (wrapOperator)	BellNumber	BellNumber(5, x) → Error unexpected-argument (0.186 and 0.187).	Sums Stirling(n, k) x^k for k = 0..n for a nonnegative integer n.	Keep, take upstream.	4/28 / 4/28	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…

arithmetic/numerals

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
adic-declare.ts:106 (defineOverload)	Add	Leaves Add of an unknown carrier head unevaluated (['Add',['Adele',1],['Adele',2]] shows the pattern; AdicNumeral itself not probed).	Adds p-adic numerals sharing a base via adic.add, written back as AdicNumeral.	Keep, ours by design.	1/1889 / 1/1888	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
adic-declare.ts:107 (defineOverload)	Multiply	Leaves Multiply of an unknown carrier unevaluated (same pattern, not probed with AdicNumeral).	Multiplies p-adic numerals via adic.multiply.	Keep, ours by design.	1/1942 / 3/1941	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
adic-declare.ts:109 (defineOverload)	Divide	['Divide',['AdicNumeral',5,1],0] -> unevaluated, and ['Divide',['Foo',1],0] -> unevaluated, while ['Divide',1,0] -> ComplexInfinity (0.186/0.187).	Divides p-adic numerals via adic.divide, and returns ComplexInfinity for a nonzero adic over 0.	Keep, ours by design.	1/782 / 0/781	90a4b8a63 chore: compute-engine 0.164 (#1074)
adic-declare.ts:122 (defineOverload)	Negate	Leaves Negate of an unknown carrier unevaluated (pattern probed on Profinite).	Negates an adic numeral via adic.negate.	Keep, ours by design.	0/789 / 0/788	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
adic-declare.ts:132 (defineOverload)	Power	Leaves Power of an unknown carrier unevaluated (pattern probed on Profinite).	Integer power of an adic base via adic.power.	Keep, ours by design.	1/1493 / 3/1492	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
declare.ts:275 (widenSignature)	IntegerDigits, FromDigits	['IntegerDigits',10,['FactorialNumerals']] -> unevaluated, ['FromDigits',['List',1,0],['FactorialNumerals']] -> unevaluated (0.186/0.187); native base slot is integer.	Widens the base slot to any so a numeral-system expression passes the type check.	Keep, ours by design.	16/131 / 16/131	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
declare.ts:278 (wrapOperator)	IntegerDigits, FromDigits	Native handles integer bases only; a system in the base slot stays unevaluated (probes above, 0.186/0.187).	When the base operand is one of our numeral systems, answers digits/value from the system (declining with a message when no numeral exists); otherwise native runs.	Keep, ours by design.	79/131 / 79/131	92319ba01 refactor: heads declared once; packages contribute signatures (#605)
declare.ts:334 (threadOverLists)	IntegerDigits, DigitCount, DigitSum	Already threads over lists: ['IntegerDigits',['List',6,7],2] -> 1,1,0],[1,1,1, ['DigitCount',['List',6,7]] -> list of count lists, ['DigitSum',['List',6,7]] -> [6,7] (0.186 and 0.187); the three native definitions carry broadcastable: true.	Sets broadcastable: true on the three heads.	Unwind (done).Removed: IntegerDigits, DigitCount and DigitSum thread natively.	0/154 / 0/154	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:339 (wrapOperator)	FromDigits	['FromDigits',{'str':'1923'}] -> Error incompatible-type (expected collection); ['FromDigits','ff',16] unevaluated (0.186/0.187).	Reads a string of digits 0-9a-z in the base (default 10), as Wolfram's FromDigits['ff', 16].	Keep, take upstream (ours until CE#582 settles the form).	2/40 / 2/40	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare.ts:356 (wrapOperator)	FromDigits	['FromDigits',['List',1,2,3],'x'] -> unevaluated (0.186/0.187).	Returns the Horner polynomial the digits spell in x (x^2 + 2x + 3).	Keep, take upstream.	1/40 / 1/40	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:378 (wrapOperator)	FromDigits	['FromDigits',['List',1,1,0],-2] -> unevaluated (0.186/0.187); native declines a negative base.	Horner reduction with a base <= -2: (1*-2+1)*-2+0 = 2.	Keep, take upstream.	3/40 / 3/40	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:401 (wrapOperator)	FromDigits	['FromDigits',['List',['List',1,4,1,5],1]] -> unevaluated (0.186/0.187).	Reads the RealDigits pair {digits, exponent} as base-10 value (1415 * 10^(1-4) = 283/200).	Keep, ours by design.	3/40 / 3/40	ef3e6d649 feat(arithmetic,number-theory,residues,collections,numerals): sweep #113's…
declare.ts:423 (wrapOperator)	FromDigits	['FromDigits',{'str':'XVII'},{'str':'Roman'}] not probed directly; a string in the base slot is a type error (['FromDigits',['List',1,0],'Roman'] -> Error incompatible-type, 0.186/0.187).	Reads a Roman numeral string, the reverse of RomanNumeral.	Keep, ours by design.	1/40 / 1/40	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:438 (widenSignature)	IntegerString	Native signature rejects a string base: ['IntegerString',1988,'Roman'] -> Error incompatible-type (0.186/0.187).	Widens to (integer, (integer | string)?, integer?) -> string, gated on a bigint-readable first operand.	Keep, ours by design.	4/14 / 4/14	7026679dd Tighten the signatures our packages declare (#350)
declare.ts:444 (wrapOperator)	IntegerString	Goes through a double and drifts: ['IntegerString',['Factorial',50],16] -> '49eebc961ed2780000...' (true value 49eebc961ed279b02b1e...), and a 30-digit integer in base 10 gives '1.2345678901234568e+29' (0.186 and 0.187).	Converts with bigint arithmetic (bigIntToBaseString), exact for any size, bases 2-36.	Keep, take upstream.	2/14 / 2/14	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…
declare.ts:456 (wrapOperator)	IntegerString	['IntegerString',5,2,8] -> Error unexpected-argument (0.186/0.187); no length argument.	IntegerString(n, b, len): left-pads with zeros or keeps the last len digits.	Keep, take upstream.	3/14 / 3/14	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:482 (wrapOperator)	IntegerString	['IntegerString',1988,'Roman'] -> Error incompatible-type (0.186/0.187).	Returns the Roman numeral 'MCMLXXXVIII'.	Keep, ours by design.	1/14 / 1/14	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
declare.ts:497 (widenSignature)	DigitSum	Native signature is (integer, integer?) -> integer; ['DigitSum',1234,10,2] -> Error unexpected-argument (0.186/0.187).	Widens to (integer, integer?, integer?) -> integer.	Keep, take upstream.	8/30 / 8/30	7dad04a12 feat(number-theory,numerals): n-argument ExtendedGCD, IsPrime of negatives,…
declare.ts:498 (wrapOperator)	DigitSum	['DigitSum',1234,10,2] -> Error unexpected-argument (0.186/0.187).	Sums the first k digits (last |k| for negative k), sign of n discarded.	Keep, take upstream.	5/30 / 5/30	7dad04a12 feat(number-theory,numerals): n-argument ExtendedGCD, IsPrime of negatives,…
declare.ts:518 (widenSignature)	DigitCount	Native signature takes up to three arguments; ['DigitCount',1000,10,0,6] -> Error unexpected-argument (0.186/0.187). A list as third argument already works natively (['DigitCount',1000,10,['List',0,1]] -> [3,1]).	Widens to four arguments and (integer | list) for the digit.	Keep, take upstream.	3/33 / 3/33	7026679dd Tighten the signatures our packages declare (#350)
declare.ts:523 (wrapOperator)	DigitCount	['DigitCount',1000,10,0,6] -> Error unexpected-argument (0.186/0.187).	Pads (or truncates) the digits to len places before counting, single digit or list of digits.	Keep, take upstream.	3/33 / 3/33	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…

arithmetic/residues

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
declare.ts:56 (direct)	PowerModList, PowerMod	CE's PowerMod and PowerModList are defined with lazy: true, evaluatesOperands: true and a custom canonical that canonicalizes the operands and type-checks them against ['integer','rational','integer'] (wrapping failures as incompatible-type errors); evaluate…	Sets lazy: false and removes the custom canonical, so the default canonicalization applies and the (widened) signature does the type check, with operands evaluated up front; evaluatesOperands is left as is.	Keep, take upstream.	44/113 / 44/113	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:58 (declareCompile)	MultiplicativeOrder, PrimitiveRootList	Not probed (the probe does not compile); native definitions seen in the dist carry no compile stance for these two heads.	Declares an undefined compile stance for each head passed to extend (the call runs for all four heads in the file, listed here for two).	Keep, ours by design.Closes heads compute-engine has no JavaScript lowering for, and our own carrier operands; a conservative stance, not a replacement.	0/46 / 0/46	e04309308 fix(web): prerender compiles plots in Node again (#802)
declare.ts:59 (wrapOperator)	PowerModList, PowerMod, MultiplicativeOrder, PrimitiveRootList	Native runs first and declines these: rational base (['PowerMod',['Rational',1,2],2,7] -> Error), PowerMod(3,0,0) and (3,0,-5) unevaluated, MultiplicativeOrder(ResidueClass(3,7)) -> Error incompatible-type, huge-modulus factoring (not probed). Rational…	Native first; when it declines (or the modulus is >= 2^64, or the exponent is 0), ours answers: rational base, a^0 = 1 mod m, order of a unit of Z/m, roots counted for huge moduli.	Keep, take upstream.	21/158 / 21/158	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:99 (widenSignature)	PowerModList	Native signature (integer, rational, integer) -> list; a rational base or list base errors (['PowerModList',['List',2,3],2,7] -> Error incompatible-type, 0.186/0.187).	Widens to (number, number, number) -> list, gated to operands that may be rational.	Keep, take upstream.	5/37 / 5/37	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:100 (threadOverLists)	PowerModList	['PowerModList',['List',2,3],2,7] -> Error incompatible-type; native has no broadcastable flag (0.186/0.187).	Sets broadcastable: true.	Keep, take upstream.	3/37 / 3/37	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:115 (widenSignature)	PowerMod	Native signature (integer, rational, integer) -> integer; ['PowerMod',['Rational',1,2],2,7] and a list base -> Error incompatible-type (0.186/0.187).	Widens to (number, number, number) -> number, gated to operands that may be rational.	Keep, take upstream.	30/78 / 30/78	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:116 (threadOverLists)	PowerMod	['PowerMod',['List',2,3],5,7] -> Error incompatible-type (0.186/0.187).	Sets broadcastable: true.	Keep, take upstream.	4/78 / 4/78	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:133 (widenSignature)	MultiplicativeOrder	Native (integer, integer?, list?); ['MultiplicativeOrder',['ResidueClass',3,7]] -> Error incompatible-type 'integer' vs 'residue' (0.186/0.187).	Widens the first slot to value and makes n optional, gated on may-be-integer for native.	Keep, ours by design.	0/29 / 0/29	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:174 (threadOverLists)	PrimitiveRootList	Already threads: ['PrimitiveRootList',['List',7,11]] -> 3,5],[2,6,7,8 (0.186/0.187).	Sets broadcastable: true.	Unwind (done).Removed: drop flags compute-engine already sets.	0/17 / 0/17	c5767dbe5 chore: compute-engine 0.146; native modular heads and StirlingS2 (#592)
declare.ts:180 (extendHead)	PrimitiveRootList	Past the listing cap the call stays unevaluated and is not a collection: ['Length',['PrimitiveRootList',{'num':'1000000000000000000000000000057'}]] -> unevaluated (0.186/0.187).	Declares a lazy collection (count from phi(phi(n)), ascending iterator, At by scan) so Length and At answer without the whole list.	Keep, ours by design.	2/17 / 2/17	6b9a8b360 refactor: arithmetic and algebra libraries reach compute-engine through the…
integer-mod.ts:138 (defineOverload)	Element, MultiplicativeOrder	MultiplicativeOrder of a residue-typed argument errors natively (['MultiplicativeOrder',['ResidueClass',3,7]] -> Error incompatible-type, 0.186/0.187); IntegerMod is not a CE head.	For IntegerMod operands, rewrites each to its strict class at its own modulus and re-evaluates the head.	Keep, ours by design.	0/118 / 0/118	cf9ef3806 feat(residues): IntegerMod combines mixed moduli like Sage, over strict…
integer-mod.ts:152 (defineOverload)	ChineseRemainder	Native takes two collections; ['ChineseRemainder',['ResidueClass',1,3],['ResidueClass',2,5]] -> Error incompatible-type 'collection' (0.186/0.187).	For IntegerMod operands, converts to strict classes, solves, and writes an IntegerMod class back.	Keep, ours by design.	0/17 / 0/17	cf9ef3806 feat(residues): IntegerMod combines mixed moduli like Sage, over strict…
mod-exact-constant.ts:5 (wrapOperator)	Mod	Already exact for most constants and moduli (['Mod','Pi',2] -> Pi-2, ['Mod','Pi',['Rational',1,2]] -> Pi-3, ['Mod',['Sqrt',2]] works); only a float modulus declines: ['Mod','Pi',1.5] stays unevaluated at evaluate() while N() gives 0.1415... (0.186/0.187).	For a bare constant symbol against a positive numeric modulus, not near a boundary, returns x - floor(x/m)*m exactly (or numerically under N), with compile stance 'builtin'.	Unwind (listed).compute-engine already answers Mod of an exact constant for every exact modulus probed; only a float modulus (Mod(Pi, 1.5)) differs. No reference example changes without it (0/143). Not removed: the float-modulus case and the compile stance were not swept.	0/143 / 0/143	ef3e6d649 feat(arithmetic,number-theory,residues,collections,numerals): sweep #113's…
numerator-declare.ts:278 (widenSignature)	Numerator, Denominator	Native (number) -> number | nothing; a second argument errors: ['Numerator',['Divide',6,4],['Rule','Over','Rationals']] -> Error unexpected-argument (0.186/0.187).	Widens to (number, any*) -> number so the option rule can ride as an extra operand.	Keep, ours by design.	0/30 / 0/30	1fda3d869 fix: Numerator over a ring, regularized Beta/Gamma continuation, Min/Max…
numerator-declare.ts:279 (takeOptionsAsRules)	Numerator, Denominator	Native canonical drops or errors on a trailing Rule (see above); a -> becomes a Tuple.	Canonical wrapper turns a trailing KeyValuePair into Rule.	Keep, ours by design.	2/30 / 2/30	29e054112 engine: an option rule reaches its head as a Rule, not a Tuple (BL-208) (#1033)
numerator-declare.ts:280 (extendHead)	Numerator, Denominator	Native definitions already declare broadcastExemptions: ['surplus-operands'] (read from dist chunk-OZKJQ53Z.js) and broadcastable: true; probe ['Numerator',['List',['Divide',2,4],['Divide',3,9]]] -> [1,1].	Declares broadcastExemptions: ['surplus-operands'].	Unwind (done).Removed: drop flags compute-engine already sets.	0/30 / 0/30	29e054112 engine: an option rule reaches its head as a Rule, not a Tuple (BL-208) (#1033)
numerator-declare.ts:281 (wrapOperator)	Numerator, Denominator	Numerator/Denominator over a ring is unsupported: ['Numerator',['Divide','x',['Multiply',2,'y']],['Rule','Over',['QuotientRing','Integers',7]]] -> Error unexpected-argument (0.186/0.187).	Reads Over -> ring, returns Together's numerator/denominator over Z/p (or the ordinary answer for Integers/Rationals), threading over lists.	Keep, ours by design.	2/30 / 2/30	1fda3d869 fix: Numerator over a ring, regularized Beta/Gamma continuation, Min/Max…
residue-class-declare.ts:81 (wrapOperator)	ResidueClass	['ResidueClass',['ResidueClass',3,12],4] -> unevaluated; ['ResidueClass',['Rational',1,3],4] -> ['ResidueClass',3,4]; native declines silently for a non-invertible rational (0.186/0.187).	Reduces a nested ResidueClass(a, m) mod n for n | m, and emits the ninv message when a rational has no inverse.	Keep, ours by design.	0/35 / 0/35	b378444b0 feat(residues): IntegerMod becomes compute-engine's ResidueClass (#684)
residue-class-declare.ts:112 (defineOverload)	Divide	['Divide',['ResidueClass',1,6],['ResidueClass',2,6]] -> unevaluated, silently (0.186/0.187).	Same decline, with the ninv message saying the divisor is not a unit mod m.	Keep, ours by design.	0/782 / 0/781	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
residue-class-declare.ts:122 (defineOverload)	Power	['Power',['ResidueClass',2,6],-1] -> unevaluated, silently (0.186/0.187).	Same decline, with the ninv message.	Keep, ours by design.	1/1493 / 4/1492	bf7356111 feat(arithmetic): the arithmetic heads' extensions become rows in their tables…
residue-class-declare.ts:137 (defineOverload)	ChineseRemainder	['ChineseRemainder',['ResidueClass',1,3],['ResidueClass',2,5]] -> Error incompatible-type 'collection' (0.186/0.187).	ChineseRemainder(ResidueClass(r1,m1), ...) gives the class mod lcm(m_i) reducing to each, with the nsol message when inconsistent.	Keep, ours by design.	4/17 / 4/17	ee2ea079b refactor(adeles, residues): extensions on their carriers become rows (#479)
residue-class-declare.ts:155 (wrapOperator)	ChineseRemainder	['ChineseRemainder',['List',1,2],['List',4,6]] -> unevaluated, silently, for the inconsistent system (0.186/0.187).	Calls native, and on decline emits the nsol message saying which pair clashes.	Keep, ours by design.	0/17 / 0/17	19caa5cc3 Evaluation messages, and \pmod notation for residues (#23)
residue-class-declare.ts:171 (wrapOperator)	ChineseRemainder	['ChineseRemainder',['List',1,2],['List',3,5],10] -> Error unexpected-argument (0.186/0.187); native takes two arguments.	Wolfram's ChineseRemainder[rs, ms, d]: the smallest solution x >= d, using the native two-argument answer shifted by multiples of lcm(ms).	Keep, take upstream.	2/17 / 2/17	9ad019526 Implement 42 "not yet implemented" reference examples; triage the rest in #92…

combinatorics/combinatorics/collections

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
arith-heads.ts:53 (wrapOperator)	Rationalize	Rationalize(0.1, 0) answers the short rational 1/10 (0.186 and 0.187), not the double's exact value.	For a float x and an exactly zero tolerance, answers the exact dyadic rational the double denotes (3602879701896397/36028797018963968).	Keep, take upstream.	1/24 / 1/24	ef3e6d649 feat(arithmetic,number-theory,residues,collections,numerals): sweep #113's…
arith-heads.ts:114 (wrapOperator)	Sign	Sign of an exact zero that is not structurally simplified stays unevaluated: Sign(Sqrt(2)+Sqrt(3)-Sqrt(5+2Sqrt(6))) -> Sign(Add(...)) (0.186 and 0.187); simple cases (Sign(Sqrt(2)-2) -> -1) are answered.	Certifies the sign by evaluating at two precisions (retrying up to 6 times) and returns -1, 0 or 1, declining when it cannot confirm.	Keep, take upstream.	0/52 / 0/52	ef3e6d649 feat(arithmetic,number-theory,residues,collections,numerals): sweep #113's…
expression-ops.ts:178 (wrapOperator)	Symbol	Symbol("x") -> x; Symbol(5) -> Error invalid-symbol (0.186 and 0.187).	Keeps Symbol(arg) unevaluated when arg is not a string.	Keep, ours by design.	2/2 / 2/2	e5657ffb9 fix(combinatorics): triage batch 20 (functional and list heads) (#785)
expression-ops.ts:189 (wrapOperator)	ReplaceAll	ReplaceAll(List(x, x^2), Rule(x^2, y)) comes back unchanged (0.186 and 0.187); it replaces only a symbol or the whole expression.	Applies the rules top-down at every part of the expression, first match wins, result not searched again.	Keep, take upstream.	1/19 / 1/19	6d63d2e74 fix(reference): triage batch 22 (statistics, algebras and core entries) (#793)
expression-ops.ts:213 (wrapOperator)	Same	Same(Reverse(List(1,2)), List(2,1)) -> False (0.186 and 0.187): the operands are compared as written, unevaluated.	Evaluates each operand (materialized) and then calls the native Same.	Keep, take upstream.	2/3 / 2/3	6d63d2e74 fix(reference): triage batch 22 (statistics, algebras and core entries) (#793)
expression-ops.ts:227 (extendHead)	Expand	Expand of a finite Product or Sum leaves it folded: Expand(Product(k+1, k=1..2)) -> Product(k+1, Limits(k,1,2)) (0.186 and 0.187).	Evaluates a Product or Sum operand first, then expands the polynomial it comes to.	Keep, take upstream.	2/25 / 3/25	6d63d2e74 fix(reference): triage batch 22 (statistics, algebras and core entries) (#793)
families/call-forms.ts:582 (extendHead)	Permutations	Permutations(3) -> Error incompatible-type (collection expected) (0.186; same 0.187 by design of the signature).	Adds a signature arm (integer<0..>) -> indexed_collection beside the native one.	Keep, ours by design.	2/4 / 2/4	1088eecf1 refactor: statistics reaches compute-engine through the engine facade (#647)
families/call-forms.ts:585 (wrapOperator)	Permutations	Permutations(3) -> Error incompatible-type (0.186 and 0.187).	Answers Permutations(n) as SymmetricGroup(n) for a nonnegative integer; native arms answer everything else.	Keep, ours by design.	2/4 / 2/4	1088eecf1 refactor: statistics reaches compute-engine through the engine facade (#647)
families/call-forms.ts:611 (wrapOperator)	Count	Count(Permutations(Range(1,30))) -> 265252859812191058636308480000000 exactly as a bignum decimal (0.186 and 0.187); Count(Subsets(Range(1,60))) stays unevaluated because Subsets is not a CE head.	Answers an exact integer for Count of Subsets (our head) or of Permutations of 19 to 10000 distinct items when the count passes 2^53.	Keep, ours by design.	1/250 / 1/250	a28439f58 fix: review batch 4 — collections, statistics, graphs (#694)
families/declare.ts:326 (wrapOperator)	Count	Count(SymmetricGroup(30)) stays unevaluated (SymmetricGroup is not a CE head) (0.186 and 0.187).	Answers an exact bigint count for our family heads whose count exceeds 2^53 and is not enumerative.	Keep, ours by design.	8/250 / 8/250	2a5777f9b fix(collections): SymmetricGroup(n) counts and pages past 2^53 (#372)
infinite-products.ts:274 (extendHead)	Product	Product((k+1)(k+2)/(k(k+3)), k=1..PositiveInfinity) stays unevaluated (0.186); CE does answer prod(1-1/k^2) -> 1/2 and prod((k+1)/(k+2)) -> 0.	After native leaves an infinite-bound Product unanswered, finds a Gamma-ratio closed form for a rational function of the index whose terms tend to 1.	Keep, take upstream.	3/41 / 3/41	1088eecf1 refactor: statistics reaches compute-engine through the engine facade (#647)
list-frontier.ts:221 (ensureRandom)	Random	Random(Range(0,5)) draws one element; Random(Range(0,5), 3) -> Error unexpected-argument; Random(NormalDistribution(0,1)) -> Error (0.186 and 0.187).	Rewrites Random's signature and evaluate to draw from the engine's seeded stream over any registered domain, with an optional count or shape.	Keep, ours by design.	3/5 / 5/5	fa56f442b One Random over what can be sampled (#351)
list-functional.ts:163 (wrapOperator)	FixedPoint	FixedPoint(x -> (x+2/x)/2, 1.0) at precision 21 -> 1.4142135623730950488015625 (0.186 and 0.187), wrong from about the 20th digit (sqrt 2 = 1.41421356237309504880168872...).	Runs the native iteration with 10 guard digits and rounds back to the engine's precision.	Keep, take upstream.	2/10 / 2/10	e50d65653 feat(collections): Nest, FixedPoint, LinearRecurrence, Outer, Association and…
list-functional.ts:303 (wrapOperator)	Length	Association is not a CE head, so there is nothing native for Length to read (not probed beyond that).	Length of an Association is its number of Rule pairs.	Keep, ours by design.	0/94 / 0/94	e50d65653 feat(collections): Nest, FixedPoint, LinearRecurrence, Outer, Association and…
list-functional.ts:319 (wrapOperator)	First	CE's First rejects an Association (indexed_collection typed) per the code comment; not probed because Association is ours.	First of an Association is its first value, with an optional default for an empty one.	Keep, ours by design.	3/39 / 3/39	fee87a481 fix(collections): guard wrapOperator rules by arity (#136)
list-functional.ts:331 (wrapOperator)	Last	CE's Last rejects an Association per the code comment; not probed because Association is ours.	Last of an Association is its last value, with an optional default for an empty one.	Keep, ours by design.	2/48 / 2/48	fee87a481 fix(collections): guard wrapOperator rules by arity (#136)
list-functional.ts:344 (wrapOperator)	Join	Not probed: Association is not a CE head, so CE has no Join arm for it.	Join of Associations merges them, later keys overriding, in first-appearance order.	Keep, ours by design.	2/27 / 2/27	e50d65653 feat(collections): Nest, FixedPoint, LinearRecurrence, Outer, Association and…
list-functional.ts:372 (wrapOperator)	Sort	Not probed: Association is not a CE head, so CE has no Sort arm for it.	Sort of an Association orders the rules ascending by value.	Keep, ours by design.	2/35 / 2/35	e50d65653 feat(collections): Nest, FixedPoint, LinearRecurrence, Outer, Association and…
list-heads.ts:228 (widenSignature)	First	First(List(), d) / Last(List(), d): CE 0.186 and 0.187 answer Error unexpected-argument for the second operand (First(List(),0), Last(List(),7)).	Accepts an optional second argument as the empty-collection default.	Keep, take upstream.	7/39 / 7/39	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:229 (wrapOperator)	First	First(List(), d) / Last(List(), d): CE 0.186 and 0.187 answer Error unexpected-argument for the second operand (First(List(),0), Last(List(),7)).	Returns ops[1] when the collection is empty, else the native First.	Keep, take upstream.	2/39 / 2/39	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:236 (widenSignature)	Last	Last(List(), d): CE 0.186 and 0.187 answer Error unexpected-argument (Last(List(),7)).	Accepts an optional second argument as the empty-collection default.	Keep, take upstream.	7/48 / 7/48	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:237 (wrapOperator)	Last	Last(List(), d): Error unexpected-argument (0.186 and 0.187).	Returns ops[1] when the collection is empty, else the native Last.	Keep, take upstream.	2/48 / 2/48	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:249 (wrapOperator)	First	First(f(a,b)): CE 0.186/0.187 answer Error incompatible-type (indexed_collection expected), e.g. First(f(a,b)).	Falls back to the first operand of any head, or the default when there are no operands.	Keep, ours by design.	3/39 / 3/39	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:262 (wrapOperator)	Last	Last(f(a,b)): CE 0.186/0.187 answer Error incompatible-type (indexed_collection expected).	Falls back to the last operand of any head, or the default when there are none.	Keep, ours by design.	2/48 / 2/48	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:284 (widenSignature)	Ordering	Ordering(List(c,a,b)) stays unevaluated in CE 0.186/0.187; Ordering(List(3,1,2),2) is Error incompatible-type (second operand must be a comparator).	Accepts up to three arguments (count, {m,n}, UpTo(n), All+Greater forms).	Keep, ours by design.	5/15 / 5/15	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:285 (wrapOperator)	Ordering	Ordering(List(c,a,b)) is returned unevaluated by CE 0.186/0.187 (it only orders numbers per the code comment; the number case was not probed).	Computes the full ordering with naturalCompare (symbols, strings, numbers) and slices it per OrderingSpec.	Keep, ours by design.	6/15 / 6/15	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:310 (widenSignature)	Mean, Median	Mean/Median(List(List(1,2),List(3,4))): CE 0.186/0.187 answer Error incompatible-type (matrix not collection).	Widens the data parameter to list<list> returning a list.	Keep, take upstream.	4/40 / 4/40	90a4b8a63 chore: compute-engine 0.164 (#1074)
list-heads.ts:311 (wrapOperator)	Mean, Median	Mean/Median of a matrix: Error incompatible-type in CE 0.186/0.187.	Threads the head over each column and returns a list of the results.	Keep, take upstream.	4/40 / 4/40	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:322 (widenSignature)	Clamp	Clamp(5): CE 0.186/0.187 answer Error missing (the bounds are required).	Makes the second and third arguments optional.	Keep, ours by design.	0/18 / 0/18	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:327 (wrapOperator)	Clamp	Clamp(5): Error missing in CE 0.186/0.187.	Calls the native Clamp with bounds -1 and 1; compile refuses the one-operand form.	Keep, ours by design.	3/18 / 3/18	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:339 (wrapOperator)	Sort	Sort(List('b',2,'a',1)): unevaluated in CE 0.186/0.187; Sort of pure strings works but lexicographically (List('b10','b9') stays that order).	Sorts string lists and mixed string/number lists with naturalCompare (numbers first).	Keep, ours by design.	5/35 / 5/35	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:359 (wrapOperator)	Sort	Sort(f(c,a)): unevaluated in CE 0.186/0.187.	Sorts any head's operands under naturalCompare and keeps the head.	Keep, ours by design.	1/35 / 1/35	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:386 (widenSignature)	Union	Union(List(3,1),List(2,1)): CE 0.186/0.187 answer Set(1,2,3) (a set, sorted for numbers).	Accepts one or more arguments of any type, returning a collection.	Keep, ours by design.	0/22 / 0/22	555fb8b66 feat(collections): standard Boolean/noncrossing permutations, bounded…
list-heads.ts:387 (wrapOperator)	Union	Union(List(3,1),List(2,1)) is Set(1,2,3) in CE 0.186/0.187; the 100-element eager cap in the code comment was not probed.	Lists in give a sorted de-duplicated List (canonicalCompare); sets in give a Set; a single unevaluated call is unioned over its own parts; no 100-element cap.	Open decisions.	13/22 / 13/22	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:438 (wrapOperator)	Length	Length(f(a,b)) and Length(x) stay unevaluated in CE 0.186/0.187; Length('abc') is 3.	Returns 0 for a string or atom and the operand count for any other head; declines on lazy collections that the native declines on.	Keep, ours by design.	22/94 / 22/94	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:457 (wrapOperator)	At	At(List(5,6),0): NaN in CE 0.186/0.187.	Returns the head of the collection (symbol List).	Keep, ours by design.	2/179 / 2/179	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:482 (direct)	At	At(Primes,3): CE 0.186/0.187 answer Error incompatible-type (set is not indexed).	Reroutes At(Primes, n>0) to PrimeNumbers when PrimeNumbers is declared.	Keep, ours by design.	0/179 / 0/179	a28439f58 fix: review batch 4 — collections, statistics, graphs (#694)
list-heads.ts:515 (direct)	At	At(Primes,3): CE 0.186/0.187 answer Error incompatible-type (set is not indexed).	Same reroute as 482, installed a second time over the first wrapper.	Unwind (done).Removed: reroute At(Primes, n) once.	0/179 / 0/179	a28439f58 fix: review batch 4 — collections, statistics, graphs (#694)
list-heads.ts:535 (wrapOperator)	At	At(List(5,6,7),Span(2,3)): unevaluated in CE 0.186/0.187 (CE has no Span).	Resolves Span(start,end,step) to an explicit index list, then calls the native list-of-indices form.	Keep, ours by design.	0/179 / 0/179	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:561 (wrapOperator)	At	At(matrix,All,1): Error incompatible-type on All in CE 0.186/0.187; At(m,List(1,2),List(2)) answers List(List(3,4)), reading the third operand as a row index rather than a column.	Returns each row's part for All, and the submatrix for two index lists.	Keep, ours by design.	2/179 / 2/179	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:580 (wrapOperator)	Partition	Partition(List(1,2,3,4,5),2): List(List(1,2),List(3,4),List(5)) in CE 0.186 and 0.187.	Drops the ragged remainder: List(List(1,2),List(3,4)).	Open decisions.	4/46 / 4/46	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:628 (wrapOperator)	Join	Join(List(1,2),List(3),1): List(1,2,3,1) in CE 0.186/0.187 (level read as an element); Join(Set(1,2),Set(3)), Join() and Join(f(a),f(b)) stay unevaluated.	Joins at a trailing integer level; Join of Sets, any shared head, and Join() as List().	Keep, ours by design.	4/27 / 4/27	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:667 (direct)	Join	Join(List(1,2),List(3),1) folds at canonicalization to List(1,2,3,1) in CE 0.186/0.187.	Replaces the canonical fold when the last argument is an integer level and the rest are lists.	Keep, ours by design.	5/27 / 5/27	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:704 (widenSignature)	Position	Position(List(1,2,1),1): Error incompatible-type (expects a predicate) in CE 0.186/0.187; the predicate form gives List(1,3).	Widens the second parameter to any value, with list<list> as a possible result.	Keep, ours by design.	4/6 / 4/6	7026679dd Tighten the signatures our packages declare (#350)
list-heads.ts:705 (wrapOperator)	Position	Position(List(1,2,1),1): Error in CE 0.186/0.187.	Returns every position of the value as its own list at every level, e.g. List(List(1),List(3)); a Function second operand is left to CE.	Keep, ours by design.	6/6 / 6/6	708b58a58 feat(collections): Wolfram semantics for the core list heads (#110)
list-heads.ts:732 (wrapOperator)	Rank	Rank(List(List(1,2),List(3))): 0 and Rank(List()): 1 in CE 0.186/0.187.	Computes Wolfram ArrayDepth: ragged gives 1, lazy Tabulate gives its dimension count.	Open decisions.	6/24 / 6/24	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:742 (wrapOperator)	MatrixRank	MatrixRank(Tabulate(f,2,2)): returned unevaluated by CE 0.186/0.187.	Materializes the m x n Tabulate and calls the native rank.	Keep, take upstream.	3/28 / 3/28	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:784 (direct)	Append	Append(f(a),b): unevaluated in CE 0.186/0.187; Append(List(1),2) gives List(1,2).	For a non-native head with operands, returns the same head with the value appended.	Keep, ours by design.	1/14 / 1/14	9f848890d fix(collections): #113 list bugs, list ops on any head, At/Ordering call forms…
list-heads.ts:827 (direct)	SetMinus	SetMinus(List(1,2,3),List(2)) and SetMinus(Range(1,5),List(2)): Error incompatible-type (set expected) in CE 0.186/0.187.	Reads List and finite Range operands as sets, then applies the native difference.	Keep, take upstream.	2/13 / 2/13	637084b84 style: print width 120, repo-wide (#213) (reformat; the override predates it)
list-levels.ts:267 (widenSignature)	Partition	Partition(List(1..5), 2, 1, List(1,1)) -> a trailing unexpected-argument Error; a list of block sizes as the 2nd argument -> incompatible-type Error (0.186 and 0.187).	Widens the signature to (any, any, any?, any?, any?) so the block and overhang forms box.	Keep, take upstream.	25/46 / 25/46	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:268 (wrapOperator)	Partition	Partition(matrix, List(1,1), 1) -> Error incompatible-type (0.186 and 0.187).	Cuts a rank-k array into rectangular blocks given a list of sizes and a shared or per-dimension offset.	Keep, take upstream.	2/46 / 2/46	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:300 (wrapOperator)	Partition	Partition(List(1..5), 2, 1, List(1,1)) -> trailing Error unexpected-argument (0.186 and 0.187).	Partition(list, n, d, {kL, kR}, pad?) answers wraparound or padded overhang windows; a scalar k means {k, k}.	Keep, take upstream.	22/46 / 22/46	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:321 (widenSignature)	Flatten	Flatten(list, PositiveInfinity) and Flatten(list, List(List(2),List(1))) -> Error incompatible-type (depth must be integer) (0.186 and 0.187).	Widens the second parameter to any so infinity and level-lists box.	Keep, take upstream.	2/26 / 2/26	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:322 (wrapOperator)	Flatten	Flatten(list, PositiveInfinity) -> Error incompatible-type (0.186 and 0.187).	Treats an infinite depth as the default full flatten by calling native with one operand.	Keep, take upstream.	1/26 / 1/26	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:331 (wrapOperator)	Flatten	Flatten(list, List(List(2),List(1))) -> Error incompatible-type (0.186 and 0.187).	Regroups an array's dimensions by a permutation-shaped list of levels, e.g. transposing a matrix.	Open decisions.	1/26 / 1/26	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:345 (wrapOperator)	Flatten	Flatten(Add(a, Add(b, c))) -> List(Add(a,b,c)): flattens only List, and gives a one-element list around the already-flat Add (0.186 and 0.187).	Flattens nested calls of any one head, Flatten(f(a, f(b, ...))), as Wolfram's Flatten does.	Keep, take upstream.	2/26 / 2/26	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:384 (direct)	Count	Count(List(1,2,1), 1, 1) -> Error unexpected-argument at box time (0.186 and 0.187).	Patches canonical so a third level-spec operand counts matches at those levels (bare integer: levels 1 through n; {n}: level n).	Keep, take upstream.	2/250 / 2/250	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:419 (direct)	All, Any	All(List(List(1,2),List(3,4)), IsInteger, 2) silently drops the third operand and answers All(list, IsInteger) (0.186 and 0.187).	Patches canonical so a third operand tests the elements at exactly that level.	Keep, take upstream.	2/37 / 2/37	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-levels.ts:456 (direct)	At	At(Add(a,b,c), 2) -> Error incompatible-type (first parameter typed dictionary | indexed_collection) at box time (0.186 and 0.187).	Patches canonical: recomputes the part of any expression when native's result is invalid, and reads the bare symbol All in a part spec as Span(1, -1).	Keep, take upstream.	4/179 / 4/179	ea047ee17 feat(collections): level-aware list ops, Partition blocks and overhangs,…
list-ops-wolfram.ts:196 (wrapOperator)	At	At(matrix, Span(1,2), 2) stays unevaluated (0.186 and 0.187); the code comment says native multi-operand At silently ignores every spec after a multi-value one.	A recursive part evaluator (partWithSpecs) answers At with one or more Span specs.	Keep, take upstream.	5/179 / 5/179	5c2299672 feat(collections): Riffle, Span, Gather, Split, SortBy, PadLeft and friends…
list-ops-wolfram.ts:220 (wrapOperator)	Partition	Partition(List(1..5), UpTo(2)) stays unevaluated (0.186 and 0.187); UpTo is not a CE head.	Chunks by n keeping a shorter final chunk for UpTo(n).	Keep, ours by design.	6/46 / 6/46	5c2299672 feat(collections): Riffle, Span, Gather, Split, SortBy, PadLeft and friends…
list-ops-wolfram.ts:240 (wrapOperator)	Ordering	Ordering(List(3,1,2), UpTo(2)) -> List(1,2,3): ignores the UpTo and returns the full ordering (0.186 and 0.187).	Returns at most n positions of the ordering for UpTo(n).	Keep, ours by design.	0/15 / 0/15	5c2299672 feat(collections): Riffle, Span, Gather, Split, SortBy, PadLeft and friends…
list-ops-wolfram.ts:393 (wrapOperator)	Sort	Sort(List(pairs), Function(Less(First(a),First(b)),a,b)) keeps tied elements in input order (0.186 and 0.187); a valid comparator otherwise sorts correctly (Sort(List(3,1,2), Greater) -> 3,2,1).	Orders by the predicate as Wolfram does: ties for a non-strict p keep input order, elements p holds neither way come out in reverse input order.	Keep, ours by design.	4/35 / 4/35	2aeaa85fc feat: BL-111, GridGraph order, Any/All/NoneTrue, SortBy/Sort ties (#722)
list-ops-wolfram.ts:471 (wrapOperator)	Any, All	Any(List(x,3), Function(Greater(t,2),t)) -> True; All(List(x,3), same) -> All(...) unevaluated with the predicate rewritten (0.186 and 0.187).	When native cannot decide, gives the disjunction (Any) or conjunction (All) of the still-undecided element predicates, as Wolfram's AnyTrue/AllTrue.	Keep, take upstream.	2/37 / 2/37	2aeaa85fc feat: BL-111, GridGraph order, Any/All/NoneTrue, SortBy/Sort ties (#722)
list-stats.ts:53 (wrapOperator)	Mean	Mean(List(Pi,1)) -> (1+Pi)/2 exactly; Mean(List(a,b)) stays unevaluated (0.186 and 0.187).	For a flat list with a non-literal element, answers the symbolic mean (sum over count).	Keep, take upstream.	5/24 / 5/24	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
list-stats.ts:68 (wrapOperator)	Median	Median(List(Pi,1,3)) -> 3 (0.186 and 0.187), but the median of 1, Pi, 3 is Pi.	For a flat list of non-literal numeric elements, sorts by value and answers the middle element, or the symbolic mean of the two middle ones.	Keep, take upstream.	0/16 / 0/16	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
list-stats.ts:110 (wrapOperator)	Mode	Mode(List(a,b,b)) stays unevaluated (0.186 and 0.187): native Mode takes numbers only, ties to the smallest.	For non-numeric data, answers the commonest value, ties to the first to appear (Commonest(c)'s first).	Keep, take upstream.	1/8 / 1/8	755ee47cc feat(analytic,collections): close 27 more aspirational reference examples (#179)
list-stats.ts:123 (wrapOperator)	Sort	Sort(List()) -> List() (0.186 and 0.187): CE already answers the empty list.	Answers the empty list for Sort of an empty list.	Unwind (done).Removed: Sort of the empty list is compute-engine's.	0/35 / 0/35	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
list-stats.ts:174 (direct)	Take	Take(List(1,2,3), UpTo(5)) stays unevaluated (0.186 and 0.187); UpTo is not a CE head.	Wraps Take's collection protocol functions to rewrite Take(xs, UpTo(n)) into Take(xs, Min(n, Length(xs))), and resolves a NaN count from a source of unknown size.	Keep, ours by design.	1/229 / 1/229	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
list-stats.ts:200 (direct)	Fold	Fold(Add, List(1,2,3)) -> Error missing (0.186 and 0.187): the unseeded two-argument form is not read.	Rewrites the two-argument form to Fold(f, First(xs), Rest(xs)) in canonical.	Keep, take upstream.	2/16 / 2/16	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
list-stats.ts:249 (direct)	Tabulate	Tabulate(Add, 2, 2, 2) drops the third dimension (-> Tabulate(Add,2,2)); a dimension of 0 stays unevaluated (0.186 and 0.187).	For three or more dimensions or a literal 0, materializes f at every 1-based index tuple.	Keep, take upstream.	2/18 / 2/18	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
list-stats.ts:268 (widenSignature)	Unique	Unique(list, Function(...)) -> Error unexpected-argument (0.186 and 0.187); Unique(List(1,1,2)) -> List(1,2).	Widens the signature to (collection, function?) -> list.	Keep, take upstream.	3/12 / 3/12	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
list-stats.ts:269 (wrapOperator)	Unique	Unique(list, test) -> Error unexpected-argument (0.186 and 0.187).	Keeps an element only if no kept one matches it under test, for a Function or symbol test.	Keep, take upstream.	3/12 / 3/12	701f4e450 feat(collections): #113 list stats, Commonest(c, n), Take/UpTo, unseeded Fold,…
misc-frontier.ts:162 (wrapOperator)	At	Association is not a CE head, so At(Association(...), Key(1)) stays unevaluated (0.186 and 0.187).	At(assoc, Key(k)) is the key lookup, Missing if absent.	Keep, ours by design.	2/179 / 2/179	33d533e73 feat(collections): DiagonalMatrix, HilbertMatrix, Extract, DeleteCases, Key,…
operator-forms.ts:22 (widenSignature)	Map, Fold, Filter	Apply(Map(Negate), List(1,2)) -> Error missing (0.186 and 0.187): Map(f) boxes with its collection missing.	Widens to (any) -> any so a one-operand Map, Fold or Filter is a valid callee.	Keep, take upstream.	21/116 / 21/116	302f55e6a chore: compute-engine 0.152 (#895)
operator-forms.ts:23 (wrapOperator)	Map, Fold, Filter	Apply(Map(Negate), List(1,2)) -> Error missing (0.186 and 0.187).	Holds a one-operand Map, Fold or Filter call (evaluate returns undefined) so it stays a value to be applied.	Keep, take upstream.	0/116 / 0/116	302f55e6a chore: compute-engine 0.152 (#895)
operator-forms.ts:35 (wrapOperator)	Apply	Apply(Add(f,1), 2) -> 3 (0.186 and 0.187): reads the sum as a function of its free symbols; Apply(Add(f,g), x) -> a Function wrapper.	Keeps Apply(callee, args) unevaluated when the callee is a sum, product or power without a slot.	Keep, take upstream.	1/95 / 1/95	6d63d2e74 fix(reference): triage batch 22 (statistics, algebras and core entries) (#793)	CE#426
operator-forms.ts:41 (wrapOperator)	Apply	Apply(Map(Negate), List(1,2)) -> Error missing (0.186 and 0.187).	Evaluates Apply of a one-operand Map/Fold/Filter by putting the argument in the held collection position and evaluating the full call.	Keep, take upstream.	3/95 / 3/95	e5657ffb9 fix(combinatorics): triage batch 20 (functional and list heads) (#785)
products.ts:158 (wrapOperator)	Product	Product(i+j, i=1..4, j=1..i) -> 4838400, and with a symbolic bound gives Product(Product(...,j=1..i), i=1..n) (0.186 and 0.187): CE already folds multiple Limits clauses right.	Rewrites Product(body, L1, ..., Lk) into nested Products, innermost first, and evaluates.	Unwind (listed).compute-engine evaluates a multi-clause Product with literal bounds the same way, but leaves a symbolic one flat where ours nests it; removing the wrapper changes two reference examples (Product/product-j-times-k-…), so it is listed, not removed.	2/41 / 2/41	9d5ba30cf feat(collections,number-theory): symbolic products; Binomial(n, n),…
products.ts:170 (wrapOperator)	Product	Product(i^2, i=1..n) and Product(2^i, i=1..n) stay unevaluated (0.186 and 0.187); literal bounds work (Product(2^i, i=1..4) -> 1024).	Answers i^m as Product(i)^m and c^f(i) as c to the Sum of f(i), in closed form.	Keep, take upstream.	7/41 / 7/41	9d5ba30cf feat(collections,number-theory): symbolic products; Binomial(n, n),…
rounding-heads.ts:12 (widenSignature)	Chop	Chop(0.005, 0.01) -> Error unexpected-argument (0.186 and 0.187); Chop(1e-5) stays 0.00001.	Widens the signature to (any, number?) -> any for a tolerance argument.	Keep, take upstream.	7/31 / 7/31	7026679dd Tighten the signatures our packages declare (#350)
rounding-heads.ts:14 (wrapOperator)	Chop	Chop(0.005, 0.01) -> Error unexpected-argument (0.186 and 0.187).	Zeroes the real and imaginary parts whose magnitude is below the given tolerance.	Keep, take upstream.	3/31 / 3/31	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
rounding-heads.ts:40 (widenSignature)	Clamp	Clamp(5, 0, 3, -1, 10) -> Error unexpected-argument on the fourth operand (0.186 and 0.187).	Widens the signature to (any, any?, any?, any?, any?) -> any.	Keep, take upstream.	0/18 / 0/18	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
rounding-heads.ts:42 (wrapOperator)	Clamp	Clamp(5, 0, 3, -1, 10) -> Error unexpected-argument (0.186 and 0.187).	Returns vLower below the range, vUpper above it, and x inside.	Keep, take upstream.	2/18 / 2/18	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
rounding-heads.ts:59 (widenSignature)	Min	Min() -> Error missing (0.186 and 0.187); Max() -> NaN.	Widens the signature to (any*) -> any so a bare Min() boxes.	Keep, take upstream.	0/36 / 0/36	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…
rounding-heads.ts:61 (wrapOperator)	Min	Min() -> Error missing (0.186 and 0.187).	Answers PositiveInfinity for an empty Min call.	Keep, take upstream.	2/36 / 2/36	c0043ec46 feat(numerals,collections,number-theory): #113 combinatorics, numeral bases,…

combinatorics/combinatorics/set-partitions

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
finset-heads.ts:20 (defineOverload)	Max, Min	Not probed: Finset is our own carrier type, which CE does not know.	Max and Min of a Finset answer the extremum of its member list.	Keep, ours by design.	0/78 / 0/78	95136a863 reference: BL-202 heads for the remaining stubs (#945)
finset-heads.ts:33 (defineOverload)	Length	Not probed: Finset is our own carrier type, which CE does not know.	Length of a Finset is its cardinality.	Keep, ours by design.	2/94 / 2/94	95136a863 reference: BL-202 heads for the remaining stubs (#945)

combinatorics/combinatorics

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
statistics/declare.ts:156 (direct)	Sign, Trace	Not probed: the carrier types (Permutation and others) are ours.	Adds a carrier type as one more accepted argument type to CE's own head signature, keeping the native arms.	Keep, ours by design.	0/58 / 0/58	3ce0c0b8b Statistics distributions as collection examples; more order-isomorphic…
statistics/declare.ts:160 (direct)	Sign, Trace	Not probed: the carrier types are ours; native handlers run for everything else.	Answers a call on a carrier value through the statistic's definition and passes everything else to the native evaluate.	Keep, ours by design.	0/58 / 0/58	28adb993d Stats and maps: compute-engine's generics, measured; Sign over permutations…

combinatorics/statistics

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
distributions-2.ts:971 (wrapOperator)	PDF	PDF(CauchyDistribution(0,1), 0) stays unevaluated (0.186 and 0.187); CE answers PDF only for its own distributions (Normal, Binomial, Poisson, Exponential, Uniform).	Answers PDF for the second-wave distributions (Geometric, Bernoulli, Cauchy, Student t, Weibull, ...) and falls back to native.	Keep, ours by design.	22/44 / 22/44	ad85526aa feat(statistics): 19 more distributions and moment/hazard/survival/InverseCDF…
distributions-2.ts:978 (wrapOperator)	CDF	CDF(CauchyDistribution(0,1), 0) stays unevaluated (0.186 and 0.187).	Answers CDF for the second-wave distributions and falls back to native.	Keep, ours by design.	18/32 / 18/32	ad85526aa feat(statistics): 19 more distributions and moment/hazard/survival/InverseCDF…
distributions-2.ts:985 (wrapOperator)	Mean	Mean(GeometricDistribution(1/3)) stays unevaluated (0.186 and 0.187); Mean(BinomialDistribution(10,1/3)) -> 10/3 natively.	Answers Mean for the second-wave distributions and falls back to native.	Keep, ours by design.	22/46 / 22/46	ad85526aa feat(statistics): 19 more distributions and moment/hazard/survival/InverseCDF…
distributions-2.ts:992 (wrapOperator)	Variance	Variance(CauchyDistribution(0,1)) stays unevaluated (0.186 and 0.187).	Answers Variance for the second-wave distributions and falls back to native.	Keep, ours by design.	18/33 / 18/33	ad85526aa feat(statistics): 19 more distributions and moment/hazard/survival/InverseCDF…
distributions-3.ts:345 (wrapOperator)	CDF	CDF of Cauchy, Student t and Hypergeometric distributions stays unevaluated (0.186 and 0.187).	Answers their CDFs (arctan form, regularized incomplete beta, exact finite sum).	Keep, ours by design.	3/32 / 3/32	2e82f7e29 feat(statistics): CharacteristicFunction, MomentGeneratingFunction, and the…
distributions-4.ts:612 (wrapOperator)	PDF	CE has no Mixture, Truncated, Product, Transformed or Dirichlet distribution heads; Mean(MixtureDistribution(...)) stays unevaluated (0.186 and 0.187).	Answers PDF for compound distributions.	Keep, ours by design.	5/44 / 5/44	214b53251 feat(statistics): compound distributions — Truncated, Mixture, Product,…
distributions-4.ts:635 (wrapOperator)	CDF	CE has no compound distribution heads (see PDF).	Answers CDF for Truncated, Mixture, Product and Transformed distributions.	Keep, ours by design.	2/32 / 2/32	214b53251 feat(statistics): compound distributions — Truncated, Mixture, Product,…
distributions-4.ts:656 (wrapOperator)	Mean	Mean(MixtureDistribution(...)) stays unevaluated (0.186 and 0.187).	Answers Mean for compound distributions.	Keep, ours by design.	8/46 / 8/46	214b53251 feat(statistics): compound distributions — Truncated, Mixture, Product,…
distributions-4.ts:679 (wrapOperator)	Variance	CE has no compound distribution heads, so Variance of one stays unevaluated.	Answers Variance for Mixture, Product, Transformed and Dirichlet distributions.	Keep, ours by design.	4/33 / 4/33	214b53251 feat(statistics): compound distributions — Truncated, Mixture, Product,…
distributions-6.ts:754 (wrapOperator)	PDF	CE has no multivariate, probability or histogram distribution heads; PDF of one stays unevaluated.	Answers PDF for Multinomial, Multinormal, MultivariatePoisson, Probability, ParameterMixture and Histogram distributions.	Keep, ours by design.	12/44 / 12/44	1aafd28b0 feat(statistics): multivariate, parameter-mixture, probability and histogram…
distributions-6.ts:779 (wrapOperator)	CDF	CE has no probability or histogram distribution heads.	Answers CDF for ProbabilityDistribution and HistogramDistribution.	Keep, ours by design.	2/32 / 2/32	1aafd28b0 feat(statistics): multivariate, parameter-mixture, probability and histogram…
distributions-6.ts:796 (wrapOperator)	Mean	CE has no multivariate or histogram distribution heads.	Answers Mean for the sixth-wave distributions.	Keep, ours by design.	9/46 / 9/46	1aafd28b0 feat(statistics): multivariate, parameter-mixture, probability and histogram…
distributions-6.ts:821 (wrapOperator)	Variance	CE has no multivariate or histogram distribution heads.	Answers Variance for the sixth-wave distributions.	Keep, ours by design.	6/33 / 6/33	1aafd28b0 feat(statistics): multivariate, parameter-mixture, probability and histogram…
distributions-6.ts:873 (widenSignature)	Covariance	Covariance(MultinormalDistribution(...)) -> Error incompatible-type (collection expected) (0.186 and 0.187); Covariance(List(1,2,3), List(1,2,4)) -> 3/2.	Widens the first parameter to collection | distribution so a vector distribution boxes.	Keep, ours by design.	3/3 / 3/3	1aafd28b0 feat(statistics): multivariate, parameter-mixture, probability and histogram…
distributions-6.ts:879 (wrapOperator)	Covariance	Covariance(MultinormalDistribution(...)) -> Error incompatible-type (0.186 and 0.187).	Answers the covariance matrix of Multinomial, Multinormal and MultivariatePoisson distributions.	Keep, ours by design.	3/3 / 3/3	1aafd28b0 feat(statistics): multivariate, parameter-mixture, probability and histogram…
distributions-6.ts:922 (wrapOperator)	PDF, CDF	PDF(NormalDistribution(0,1), 0.5) -> Divide(0.624019544..., Sqrt(Pi)), a half-float, half-exact form; PDF(NormalDistribution(0.0,1), 1/2) -> a fully exact expression (0.186 and 0.187).	When the distribution or point contains a float, numericizes the answer at the engine's precision.	Keep, take upstream.	0/76 / 0/76	67cc9692d triage (#552): floats stay floats in PDF/CDF, Gaussian-rational Numerator,…
distributions.ts:153 (widenSignature)	UniformDistribution	UniformDistribution(List(1,3)) stays unevaluated and Mean of it -> Error missing; zero arguments the same (0.186 and 0.187).	Widens the signature to accept (list | real)? and real?.	Keep, take upstream.	0/4 / 0/4	1088eecf1 refactor: statistics reaches compute-engine through the engine facade (#647)
distributions.ts:158 (extendHead)	UniformDistribution	Mean(UniformDistribution(List(1,3))) -> Error missing (0.186 and 0.187).	Rewrites the list and zero-argument forms to (min, max) in canonical, so native PDF/CDF/Mean/Variance work unchanged.	Keep, take upstream.	1/4 / 1/4	1088eecf1 refactor: statistics reaches compute-engine through the engine facade (#647)
distributions.ts:399 (extendHead)	PDF, CDF, Mean, Variance	CE answers PDF, CDF, Mean and Variance for its own distributions (PDF(Normal(0,1),0) -> sqrt(1/(2 pi))) and leaves the wave-one extra distributions unevaluated.	Answers a branch for each distribution kind this file adds (OWN_KINDS), ahead of native, and falls back to native otherwise.	Keep, ours by design.	17/155 / 17/155	1088eecf1 refactor: statistics reaches compute-engine through the engine facade (#647)
distributions.ts:412 (widenSignature)	PDF, CDF	PDF(NormalDistribution(0,1), List(0,1)) -> Error incompatible-type (second parameter real | signed_infinity) (0.186 and 0.187).	Widens the second parameter to also accept list.	Keep, ours by design.	8/76 / 8/76	1088eecf1 refactor: statistics reaches compute-engine through the engine facade (#647)
distributions.ts:763 (registerSampler)	Random	Random(NormalDistribution(0,1)) -> Error incompatible-type (collection expected) (0.186 and 0.187).	Registers a sampler so Random draws from a distribution on the seeded stream.	Keep, ours by design.	0/1 / 0/1	fa56f442b One Random over what can be sampled (#351)
distributions.ts:764 (addRandomArm)	Random	Random(NormalDistribution(0,1)) -> Error incompatible-type (0.186 and 0.187).	Adds the signature arm (distribution, (integer<0..> | list<integer<0..>>)?) random -> any to Random.	Keep, ours by design.	0/1 / 0/1	fa56f442b One Random over what can be sampled (#351)
median.ts:208 (widenSignature)	Median	Median(NormalDistribution(0,1)) -> Error incompatible-type (collection | number expected) (0.186 and 0.187).	Widens the signature with (distribution+) -> number, excluding the law arm from the collection one.	Keep, ours by design.	6/7 / 6/7	36de789e9 fix(statistics): statistics rows evaluate in statistics; Median of a…
median.ts:209 (wrapOperator)	Median	Median(NormalDistribution(0,1)) -> Error incompatible-type (0.186 and 0.187).	Answers the median of a distribution in closed form (exact parameters), falling back to native.	Keep, ours by design.	7/7 / 7/7	36de789e9 fix(statistics): statistics rows evaluate in statistics; Median of a…
processes.ts:85 (wrapOperator)	Apply	Apply(WienerProcess(), 1) stays unevaluated (0.186 and 0.187): CE holds a call on a callee it cannot type.	Evaluates proc(t) to the slice distribution for a WienerProcess or PoissonProcess.	Keep, ours by design.	4/5 / 4/5	6d63d2e74 fix(reference): triage batch 22 (statistics, algebras and core entries) (#793)	CE#426

evaluation/evaluation

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
about.ts:125 (direct)	About	About(Gamma) already returns a dictionary with name, kind, signature, description, examples, wikidata; About("Sin") describes the string (0.186).	Adds the manifest's keys (description, params and the like) and describes an undeclared name or a library's ns.Name field chain.	Keep, ours by design.	3/5 / 3/5	d87258a1a feat: About describes any name, declared or not, and the REPL answers ?Name
about.ts:133 (direct)	About	Native has no async step that imports a summary (About(Gamma) is synchronous, 0.186).	Awaits describe(name) so a not-yet-imported summary is imported before building the dictionary.	Keep, ours by design.	0/5 / 0/5	d87258a1a feat: About describes any name, declared or not, and the REPL answers ?Name

groups/modular

Site	Heads	compute-engine does	We do	Classification	Examples 0.186 / 0.187	Why it exists	Upstream
declare.ts:154 (widenSignature)	Dot	Dot of two integer matrices works: Dot({{1,2},{3,4}}, {{1,0},{0,1}}) -> {{1,2},{3,4}} (0.186, 0.187); a ModularMatrix(...) or an LR word is not a matrix type.	Widens Dot's signature to accept expression and string operands.	Keep, ours by design.	3/14 / 3/14	7026679dd Tighten the signatures our packages declare (#350)
declare.ts:161 (wrapOperator)	Dot	Dot multiplies plain matrices only (see above).	For a ModularMatrix or word operand multiplies the integer matrices and returns a ModularMatrix expression.	Keep, ours by design.	2/14 / 2/14	436b4c297 refactor(modular): the modular group goes through Dot, MatrixPower and Inverse…
declare.ts:172 (widenSignature)	MatrixPower	MatrixPower({{1,1},{1,0}}, 5) -> {{8,5},{5,3}} (0.186, 0.187); a ModularMatrix or word is not a matrix type.	Widens the signature to accept expression and string operands.	Keep, ours by design.	7/9 / 7/9	436b4c297 refactor(modular): the modular group goes through Dot, MatrixPower and Inverse…
declare.ts:179 (wrapOperator)	MatrixPower	MatrixPower works on plain matrices only (see above).	For a modular operand and an integer exponent computes the power (negative via the inverse) and returns a ModularMatrix expression.	Keep, ours by design.	7/9 / 7/9	436b4c297 refactor(modular): the modular group goes through Dot, MatrixPower and Inverse…
declare.ts:193 (defineOverload)	Inverse	Inverse of a 2x2 integer matrix -> {{-2,1},{3/2,-1/2}} (0.186, 0.187); a modular matrix is not a matrix type.	A row in Inverse's table for a ModularMatrix or word, returning the integer inverse as a ModularMatrix.	Keep, ours by design.	4/5 / 4/5	4dc9920c5 feat(engine): overloads as data, piloted on Fibonacci, LucasL and Inverse (#440)
declare.ts:602 (wrapOperator)	ContinuedFraction	ContinuedFraction(Sqrt(2)) -> a fixed 20 terms {1,2,2,...}; ContinuedFraction(e, 40) -> 19 terms ending 12, 2 (the true 19th term is 1), and ContinuedFraction(Sqrt(2)+Sqrt(3), 25) stays unevaluated; golden ratio exact form stays unevaluated (0.186; 0.187…	One argument on a quadratic irrational gives Wolfram's periodic form {a0, {period}}; two arguments on a non-rational value give n terms certified by agreement at two precisions, else decline.	Keep, take upstream.	16/28 / 16/28	ca478920d feat(modular): periodic and certified continued fractions (#143)
declare.ts:634 (wrapOperator)	FromContinuedFraction	FromContinuedFraction({1,2,3}) -> 10/7 but the periodic form stays unevaluated: FromContinuedFraction({1,{2}}) -> unchanged (0.186, 0.187).	Reads a trailing list as a repeating period and returns the exact quadratic irrational (e.g. Sqrt(2) for {1,{2}}).	Keep, take upstream.	5/14 / 5/14	ca478920d feat(modular): periodic and certified continued fractions (#143)