@cortex-js/compute-engine 0.57.0 → 0.59.0

package/dist/types/compute-engine/numeric-value/exact-numeric-value.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { Rational, SmallInteger } from '../numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { MathJsonExpression } from '../../math-json/types';
@@ -62,6 +62,12 @@ export declare class ExactNumericValue extends NumericValue {
     abs(): NumericValue;
     ln(base?: number): NumericValue;
     exp(): NumericValue;
+    /**
+     * Floor/ceil/round of a pure rational (`radical === 1`) computed exactly with
+     * bigints. Routing through `this.re` (a float) would lose digits for
+     * integers/rationals larger than 2^53.
+     */
+    private _integerPart;
     floor(): NumericValue;
     ceil(): NumericValue;
     round(): NumericValue;

package/dist/types/compute-engine/numeric-value/machine-numeric-value.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { SmallInteger } from '../numerics/types';
 import { NumericValue, NumericValueData } from './types';
 import type { MathJsonExpression } from '../../math-json/types';

package/dist/types/compute-engine/numeric-value/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  *
  * ## THEORY OF OPERATIONS
  *

package/dist/types/compute-engine/numerics/bernoulli.d.ts

@@ -0,0 +1,39 @@
+/* 0.59.0 */
+ * Exact Bernoulli numbers and exact values of the Riemann zeta function at
+ * integers, computed with bigint rationals.
+ *
+ * Used by the exact (non-numericApproximation) evaluation path of `Zeta`
+ * in `library/arithmetic.ts`:
+ *
+ * - ζ(2k)  = (−1)^{k+1} · B₂ₖ · (2π)^{2k} / (2·(2k)!)  →  rational · π^{2k}
+ * - ζ(−n)  = −Bₙ₊₁/(n+1)                               →  exact rational
+ *
+ * (The numeric approximation path uses the BigDecimal Bernoulli rationals in
+ * `numerics/special-functions.ts`; this module is self-contained so that the
+ * exact path has no dependency on the BigDecimal machinery.)
+ */
+/**
+ * Bernoulli number Bₙ (B₁ = −1/2 convention) as a reduced bigint rational
+ * `[numerator, denominator]`.
+ *
+ * Uses the defining recurrence Bₘ = −1/(m+1) · Σ_{k=0}^{m−1} C(m+1, k)·Bₖ
+ * with exact bigint rational arithmetic. Suitable for moderate n (the Zeta
+ * exact path caps |argument| at 100, i.e. at most B₁₀₁).
+ */
+export declare function bernoulliRational(n: number): [bigint, bigint];
+/**
+ * The exact rational c such that ζ(2k) = c·π^{2k}, for integer k ≥ 1.
+ *
+ * From ζ(2k) = (−1)^{k+1}·B₂ₖ·(2π)^{2k} / (2·(2k)!) and the sign alternation
+ * of B₂ₖ, the coefficient is |B₂ₖ|·2^{2k−1}/(2k)! (always positive).
+ *
+ * ζ(2) = π²/6, ζ(4) = π⁴/90, ζ(6) = π⁶/945, ζ(8) = π⁸/9450, …
+ */
+export declare function zetaEvenCoefficient(k: number): [bigint, bigint];
+/**
+ * ζ(−n) for integer n ≥ 1 as an exact reduced rational: ζ(−n) = −Bₙ₊₁/(n+1).
+ *
+ * ζ(−1) = −1/12, ζ(−3) = 1/120, and ζ(−2k) = 0 (the trivial zeros, since
+ * the odd Bernoulli numbers B₃, B₅, … vanish).
+ */
+export declare function zetaNegativeInteger(n: number): [bigint, bigint];

package/dist/types/compute-engine/numerics/bigint.d.ts

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function bigint(a: BigDecimal | number | bigint | string): bigint | null;

package/dist/types/compute-engine/numerics/expression.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function bigintValue(expr: MathJsonExpression | null | undefined): bigint | null;
 /** Output a shorthand if possible */
 export declare function numberToExpression(num: number | bigint, fractionalDigits?: string | number): MathJsonExpression;

package/dist/types/compute-engine/numerics/interval.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** An interval is a continuous set of real numbers */
 export type Interval = {
     start: number;

package/dist/types/compute-engine/numerics/linear-algebra.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  *  Test: determinant([[1,3,7],[2,-1,4],[5,0,2]]) === 81
  */
 export declare function determinant(matrix: number[][]): number;

package/dist/types/compute-engine/numerics/monte-carlo.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
     estimate: number;
     error: number;
 };

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function lcm(a: bigint, b: bigint): bigint;
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
 export declare function factorial2(n: BigNum): Generator<BigNum, BigNum>;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,14 @@
-/* 0.57.0 */
+/* 0.59.0 */
+/**
+ * Gamma function for a complex argument, via the Lanczos approximation.
+ *
+ * Uses the reflection formula Γ(z)·Γ(1−z) = π / sin(πz) for Re(z) < 0.5 so the
+ * series converges on the whole complex plane (except at the non-positive
+ * integer poles, where the result is a (signed) infinity / NaN).
+ */
 export declare function gamma(c: Complex): Complex;
+/**
+ * Natural logarithm of the Gamma function for a complex argument (principal
+ * branch), via the Lanczos approximation.
+ */
 export declare function gammaln(c: Complex): Complex;

package/dist/types/compute-engine/numerics/numeric.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;

package/dist/types/compute-engine/numerics/primes.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function primeFactors(n: number): {
     [factor: number]: number;
 };

package/dist/types/compute-engine/numerics/random.d.ts

@@ -0,0 +1,23 @@
+/* 0.59.0 */
+ * Shared deterministic-PRNG helpers for Random/Shuffle/Sample.
+ *
+ * The hash matches the GLSL/WGSL formula used by the GPU compile target:
+ *   fract(sin(seed * 12.9898) * 43758.5453)
+ *
+ * JS↔GLSL parity is approximate (fp64 vs fp32; Math.sin is not bit-portable).
+ * Within a single host, the same seed always yields the same value.
+ */
+/**
+ * Return a deterministic pseudorandom value in [0, 1) for the given seed.
+ * Matches the GLSL `_gpu_random(seed)` hash to within fp32 precision.
+ */
+export declare function deterministicRandom(seed: number): number;
+/**
+ * Advance the seed by a fixed amount so subsequent calls produce decorrelated
+ * draws. Used by Shuffle/Sample to walk through the elements deterministically.
+ * Uses a Weyl-sequence-style increment (golden-ratio fractional part).
+ *
+ * @param seed The current seed value.
+ * @returns The next seed in the sequence.
+ */
+export declare function nextSeed(seed: number): number;

package/dist/types/compute-engine/numerics/rationals.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function isRational(x: unknown | null): x is Rational;
 export declare function isMachineRational(x: unknown | null): x is [SmallInteger, SmallInteger];
 export declare function isBigRational(x: unknown | null): x is [bigint, bigint];

package/dist/types/compute-engine/numerics/richardson.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -1,27 +1,47 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;
 /**
- * Inverse Error Function.
+ * Inverse Error Function, accurate to full machine (double) precision.
  *
+ * Winitzki's approximation (~3 correct digits) refined with Newton's
+ * method on the full-precision `erf()`:
+ *    y ← y − (erf(y) − x)·(√π/2)·e^{y²}
+ * Each iteration doubles the number of correct digits, so 4 iterations
+ * reach machine precision.
+ *
+ * (Previously used a 6-term truncated Maclaurin series, which was only
+ * ~4-digit accurate at x = 0.5 and diverged badly for |x| → 1.)
  */
 export declare function erfInv(x: number): number;
 /**
- * Trivial function, used when compiling.
+ * Complementary error function, erfc(x) = 1 - erf(x), accurate to full
+ * machine (double) precision.
+ *
+ * For |x| < 2 the value is computed as `1 - erf(x)` (no significant
+ * cancellation). For larger |x|, `1 - erf(x)` would lose all precision
+ * (erf(x) ≈ 1), so erfc is computed directly from a continued fraction
+ * (DLMF 7.9.3) evaluated with the modified Lentz algorithm.
+ *
+ * References:
+ * - NIST DLMF: https://dlmf.nist.gov/7.9
  */
 export declare function erfc(x: number): number;
 /**
- * An approximation of the gaussian error function, Erf(), using
- * Abramowitz and Stegun approximation.
+ * The Gauss error function, erf(x), accurate to full machine (double)
+ * precision.
+ *
+ * Computed from the well-conditioned Maclaurin series (DLMF 7.6.2):
+ *   erf(x) = (2/√π) e^{-x²} Σ_{n≥0} 2^n x^{2n+1} / (1·3·5···(2n+1))
+ * All terms are positive, so there is no subtractive cancellation. For
+ * |x| ≥ 6 the result rounds to ±1 (erfc(6) ≈ 2.15e-17, below machine eps).
  *
- * Thoughts for future improvements:
- * - https://math.stackexchange.com/questions/321569/approximating-the-error-function-erf-by-analytical-functions
- * - https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions
-
+ * (Previously used the 5-term Abramowitz & Stegun rational approximation,
+ * which was only ~7-digit accurate.)
  *
  * References:
- * - NIST: https://dlmf.nist.gov/7.24#i
+ * - NIST DLMF: https://dlmf.nist.gov/7.6
  */
 export declare function erf(x: number): number;
 /**
@@ -185,3 +205,51 @@ export declare function fresnelS(x: number): number;
 export declare function fresnelC(x: number): number;
 /** Unnormalized cardinal sine: sinc(x) = sin(x)/x, sinc(0) = 1. */
 export declare function sinc(x: number): number;
+/**
+ * Bignum error function. Precision scales with `BigDecimal.precision`.
+ *
+ * - |x| ≤ √((p+10)·ln 10): Maclaurin series (DLMF 7.6.2), no cancellation.
+ * - beyond: erf(x) rounds to ±1 at the working precision
+ *   (erfc(x) < e^{−x²} ≤ 10^{−(p+10)}).
+ */
+export declare function bigErf(ce: ComputeEngine, x: BigNum): BigNum;
+/**
+ * Bignum complementary error function.
+ * Precision scales with `BigDecimal.precision`.
+ *
+ * - x² log10(e) ≤ p+10: computed as 1 − erf(x) with the working precision
+ *   raised by the x²·log10(e) digits lost to cancellation.
+ * - beyond: the asymptotic series (DLMF 7.12.1), which by construction of
+ *   the switchover delivers ≥ p+10 digits there.
+ */
+export declare function bigErfc(ce: ComputeEngine, x: BigNum): BigNum;
+/**
+ * Bignum inverse error function: y such that erf(y) = x, for x ∈ [−1, 1].
+ * Precision scales with `BigDecimal.precision`.
+ *
+ * Newton iteration on `bigErf`:
+ *    y ← y − (erf(y) − x)·(√π/2)·e^{y²}
+ * seeded from the machine-precision Winitzki estimate (~3 digits; each
+ * iteration doubles the digits). Note that erfInv is intrinsically
+ * ill-conditioned as |x| → 1 (|dy/dx| = (√π/2)e^{y²}): the result is the
+ * best possible for the given input, but tiny perturbations of x near ±1
+ * produce large changes in y.
+ */
+export declare function bigErfInv(ce: ComputeEngine, x: BigNum): BigNum;
+/**
+ * Bignum unnormalized cardinal sine: sinc(x) = sin(x)/x, sinc(0) = 1.
+ * Precision scales with `BigDecimal.precision` (sin uses the engine's
+ * 1100-digit π for argument reduction).
+ */
+export declare function bigSinc(x: BigNum): BigNum;
+/**
+ * Bignum Fresnel sine integral S(x). Precision scales with
+ * `BigDecimal.precision`: Taylor series for πx²/2·log10(e) ≤ p+20 (with
+ * raised working precision to absorb the alternating-series cancellation),
+ * asymptotic expansion beyond (where it delivers ≥ p+10 digits).
+ */
+export declare function bigFresnelS(x: BigNum): BigNum;
+/**
+ * Bignum Fresnel cosine integral C(x). Same switchover as `bigFresnelS`.
+ */
+export declare function bigFresnelC(x: BigNum): BigNum;

package/dist/types/compute-engine/numerics/statistics.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(values: Iterable<BigDecimal>): BigDecimal;
 export declare function median(values: Iterable<number>): number;

package/dist/types/compute-engine/numerics/strings.d.ts

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

package/dist/types/compute-engine/numerics/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6

package/dist/types/compute-engine/numerics/unit-data.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Unit registry: dimension vectors, SI base units, prefixes, and conversion.
  *
  * A DimensionVector encodes the exponents for each of the 7 SI base

package/dist/types/compute-engine/oeis.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * OEIS (Online Encyclopedia of Integer Sequences) Integration
  *
  * This module provides functions to look up sequences in the OEIS database

package/dist/types/compute-engine/sequence.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Utilities for declarative sequence definitions.
  *
  * This module provides functions to create subscriptEvaluate handlers

package/dist/types/compute-engine/symbolic/antiderivative.d.ts

@@ -1,3 +1,3 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** Calculate the antiderivative of fn, as an expression (not a function) */
 export declare function antiderivative(fn: Expression, index: string): Expression;

package/dist/types/compute-engine/symbolic/derivative.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  *
  * @param fn The function to differentiate, a function literal.

package/dist/types/compute-engine/symbolic/distribute.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  *
  */

package/dist/types/compute-engine/symbolic/fu-cost.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Cost functions for the Fu trigonometric simplification algorithm.
  *
  * The primary objective is to minimize the number of trigonometric functions,

package/dist/types/compute-engine/symbolic/fu-transforms.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Fu Algorithm Transformation Rules
  *
  * Programmatic implementations of TR1-TR22 from the Fu trigonometric

package/dist/types/compute-engine/symbolic/fu.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Fu Algorithm for Trigonometric Simplification
  *
  * Implementation of the algorithm by Fu, Zhong, and Zeng:

package/dist/types/compute-engine/symbolic/logic-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function evaluateAnd(args: ReadonlyArray<Expression>, { engine: ce }: {
     engine: ComputeEngine;
 }): Expression | undefined;

package/dist/types/compute-engine/symbolic/simplify-abs.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function simplifyAbs(x: Expression): RuleStep | undefined;
 /**
  * Simplify expressions where Abs appears as the base of a power.

package/dist/types/compute-engine/symbolic/simplify-divide.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Division simplification rules consolidated from simplify-rules.ts.
  *

package/dist/types/compute-engine/symbolic/simplify-factorial.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Extracts base + integer offset from an expression.
  * - Symbol `n` → { base: n, offset: 0 }

package/dist/types/compute-engine/symbolic/simplify-hyperbolic.d.ts

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function simplifyHyperbolic(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-infinity.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Infinity simplification rules consolidated from simplify-rules.ts.
  * Handles ~20 patterns for simplifying expressions involving infinity.

package/dist/types/compute-engine/symbolic/simplify-log.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Logarithm simplification rules consolidated from simplify-rules.ts.
  * Handles ~30 patterns for simplifying Ln and Log expressions.

package/dist/types/compute-engine/symbolic/simplify-logic.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function simplifyLogicFunction(x: Expression): {
     value: Expression;
     because: string;

package/dist/types/compute-engine/symbolic/simplify-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Power simplification rules consolidated from simplify-rules.ts.
  * Handles ~25 patterns for simplifying Power expressions.

package/dist/types/compute-engine/symbolic/simplify-product.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Product simplification rules extracted from simplify-rules.ts.
  * Handles 13 patterns for simplifying Product expressions.

package/dist/types/compute-engine/symbolic/simplify-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * # Performance Optimization Notes for Simplification Rules
  *

package/dist/types/compute-engine/symbolic/simplify-sum.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Sum simplification rules extracted from simplify-rules.ts.
  * Handles 16 patterns for simplifying Sum expressions.

package/dist/types/compute-engine/symbolic/simplify-trig.d.ts

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function simplifyTrig(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/tensor/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { Expression, IComputeEngine as ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
 /** @category Tensors */
 export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;

package/dist/types/compute-engine/tensor/tensors.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;
@@ -6,8 +6,8 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
      * Return a tuple of tensors that have the same dtype.
      * If necessary, one of the two input tensors is upcast.
      *
-     * The shape of the tensors is reshaped to a compatible
-     * shape. If the shape is not compatible, `undefined` is returned.
+     * This harmonizes only the *dtype*; it does not reshape. Element-wise
+     * callers (see `broadcast`) must ensure the shapes are compatible.
      *
      * @param lhs
      * @param rhs

package/dist/types/compute-engine/types-definitions.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString } from './latex-syntax/types';

package/dist/types/compute-engine/types-engine.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonSymbol, MathJsonNumberObject } from '../math-json';
 import type { Type, TypeString, TypeResolver } from '../common/type/types';
@@ -10,8 +10,9 @@ import type { BigNum, Rational } from './numerics/types';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Metadata, CanonicalOptions, FormOption, BoxedSubstitution } from './types-serialization';
 import type { AngularUnit, SymbolDefinition, OperatorDefinition, ValueDefinition, BoxedDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions } from './types-definitions';
-import type { AssumeResult, Rule as KernelRule, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, RuleStep as KernelRuleStep, AssignValue as KernelAssignValue, Scope as KernelScope, EvalContext as KernelEvalContext } from './types-kernel-evaluation';
+import type { AssumeResult, Rule as KernelRule, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, RulePurpose, RuleStep as KernelRuleStep, AssignValue as KernelAssignValue, Scope as KernelScope, EvalContext as KernelEvalContext } from './types-kernel-evaluation';
 import type { LanguageTarget, CompilationResult } from './compilation/types';
+export type { RulePurpose } from './types-kernel-evaluation';
 type Rule = KernelRule<Expression, ExpressionInput, IComputeEngine>;
 type BoxedRule = KernelBoxedRule<Expression, IComputeEngine>;
 type BoxedRuleSet = KernelBoxedRuleSet<Expression, IComputeEngine>;
@@ -29,6 +30,10 @@ export type OperatorInfo = {
     kind: 'function' | 'opaque';
     signature?: BoxedType;
 };
+export type SymbolInfo = {
+    kind: 'constant' | 'variable';
+    type: BoxedType;
+};
 /** @internal */
 export interface IComputeEngine {
     /** The LatexSyntax instance used for LaTeX parsing/serialization.
@@ -79,6 +84,7 @@ export interface IComputeEngine {
     timeLimit: number;
     iterationLimit: number;
     recursionLimit: number;
+    maxCollectionSize: number;
     chop(n: number): number;
     chop(n: BigNum): BigNum | 0;
     chop(n: number | BigNum): number | BigNum;
@@ -95,6 +101,19 @@ export interface IComputeEngine {
      *  Initialized to the built-in simplification rules.
      *  Users can `push()` additional rules or replace the entire array. */
     simplificationRules: Rule[];
+    /** The rules used by `solve()` to find roots of univariate expressions.
+     *  Each rule matches a normalized equation `f(_x) = 0` — the unknown is
+     *  the wildcard `_x` — and `replace` produces a root expression.
+     *  Conditions should reject matches where other wildcards capture `_x`.
+     *  Candidate roots are validated against the original equation, so an
+     *  over-eager template degrades to a no-op rather than a wrong answer.
+     *  Initialized to the built-in root-finding rules; `push()` to extend,
+     *  assign to replace. */
+    solveRules: Rule[];
+    /** The rules used by `solve()` to transform an equation into equivalent,
+     *  easier-to-solve forms before root-finding (e.g. `ln f(x) → f(x) - 1`).
+     *  Same conventions and extension pattern as `solveRules`. */
+    harmonizationRules: Rule[];
     strict: boolean;
     expr(expr: NumericValue | ExpressionInput, options?: {
         form?: FormOption;
@@ -169,6 +188,9 @@ export interface IComputeEngine {
     type(type: Type | TypeString | BoxedType): BoxedType;
     rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
         canonical?: boolean;
+        /** Default purpose applied to any rule in the set that doesn't carry
+         *  its own `purpose` tag (a per-rule tag takes precedence). */
+        purpose?: RulePurpose;
     }): BoxedRuleSet;
     getRuleSet(id?: 'harmonization' | 'solve-univariate' | 'standard-simplification'): BoxedRuleSet | undefined;
     pushScope(scope?: Scope, name?: string): void;
@@ -377,6 +399,34 @@ export interface IComputeEngine {
      * maintaining a parallel list of "known" operators.
      */
     operatorInfo(head: string): OperatorInfo | undefined;
+    /**
+     * Convert a LaTeX identifier string to its canonical MathJSON name without
+     * declaring the symbol in the engine scope.
+     *
+     * Examples:
+     * - `'R_{3}'` → `'R_3'`
+     * - `'\\theta_x'` → `'theta_x'`
+     * - `'\\alpha'` → `'alpha'`
+     * - `'1 + 2'` → `''` (not an identifier)
+     *
+     * Use this instead of `ce.parse(latex).symbol` when you need the canonical
+     * name without the side-effect of auto-declaring the symbol.
+     */
+    normalizeIdentifier(latex: string): string;
+    /**
+     * Return introspection metadata for a symbol (value definition) in the
+     * current scope chain.
+     *
+     * - `kind: 'constant'` when the symbol is a CE-registered constant
+     *   (e.g. `Pi`, `True`, `ExponentialE`).
+     * - `kind: 'variable'` for declared but non-constant value symbols
+     *   (e.g. after `ce.declare('a', 'real')`).
+     *
+     * Returns `undefined` for unknown names and for names that resolve to
+     * operator/function definitions (use `operatorInfo()` for those — the
+     * two methods are non-overlapping).
+     */
+    symbolInfo(name: string): SymbolInfo | undefined;
 }
 declare module './types-expression' {
     interface ExpressionComputeEngine extends IComputeEngine {
@@ -386,4 +436,3 @@ declare module './types-definitions' {
     interface ComputeEngine extends IComputeEngine {
     }
 }
-export {};

package/dist/types/compute-engine/types-evaluation.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { IComputeEngine as ComputeEngine } from './types-engine';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Assumption as KernelAssumption, AssumeResult, AssignValue as KernelAssignValue, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, EvaluateOptions as KernelEvaluateOptions, EvalContext as KernelEvalContext, ExpressionMapInterface as KernelExpressionMapInterface, Rule as KernelRule, RuleConditionFunction as KernelRuleConditionFunction, RuleFunction as KernelRuleFunction, RuleReplaceFunction as KernelRuleReplaceFunction, RuleStep as KernelRuleStep, RuleSteps as KernelRuleSteps, Scope as KernelScope } from './types-kernel-evaluation';