@cortex-js/compute-engine 0.33.0 → 0.35.0

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

@@ -1,4 +1,4 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import type { OneOf } from '../common/one-of';
 import type { Expression, MathJsonNumberObject, MathJsonStringObject, MathJsonFunctionObject, MathJsonSymbolObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
 import type { Type, TypeReference, TypeResolver, TypeString } from '../common/type/types';
@@ -506,7 +506,7 @@ export interface BoxedExpression {
      * Compute Engine or it may return a different value each time it is
      * evaluated, even if the state of the Compute Engine is the same.
      *
-     * As an example, the ["Add", 2, 3]` function expression is pure, but
+     * As an example, the `["Add", 2, 3]` function expression is pure, but
      * the `["Random"]` function expression is not pure.
      *
      * For a function expression to be pure, the function itself (its operator)
@@ -1344,9 +1344,25 @@ export interface BoxedExpression {
      * `options.fallback` is set to `false`. If it is set to `false`, the
      * function will throw an error if it cannot be compiled.
      *
+     * **Custom operators**: You can override operators to use function calls
+     * instead of native operators, useful for vector/matrix operations:
+     *
+     * ```javascript
+     * const expr = ce.parse("v + w");
+     * const f = expr.compile({
+     *   operators: {
+     *     Add: ['add', 11],      // Convert + to add()
+     *     Multiply: ['mul', 12]   // Convert * to mul()
+     *   }
+     * });
+     * // Result: add(v, w) instead of v + w
+     * ```
+     *
      */
     compile(options?: {
-        to?: 'javascript' | 'wgsl' | 'python' | 'webassembly';
+        to?: string;
+        target?: any;
+        operators?: Partial<Record<MathJsonSymbol, [op: string, prec: number]>> | ((op: MathJsonSymbol) => [op: string, prec: number] | undefined);
         functions?: Record<MathJsonSymbol, JSSource | ((...any: any[]) => any)>;
         vars?: Record<MathJsonSymbol, JSSource>;
         imports?: ((...any: any[]) => any)[];
@@ -1359,15 +1375,27 @@ export interface BoxedExpression {
      * If this is an equation, solve the equation for the variables in vars.
      * Otherwise, solve the equation `this = 0` for the variables in vars.
      *
+     * For univariate equations, returns an array of solutions (roots).
+     * For systems of linear equations (List of Equal expressions), returns
+     * an object mapping variable names to their values.
+     * For non-linear polynomial systems (like xy=6, x+y=5), returns an array
+     * of solution objects (multiple solutions possible).
      *
      * ```javascript
+     * // Univariate equation
      * const expr = ce.parse("x^2 + 2*x + 1 = 0");
-     * console.log(expr.solve("x"));
-     * ```
+     * console.log(expr.solve("x")); // Returns array of roots
      *
+     * // System of linear equations
+     * const system = ce.parse("\\begin{cases}x+y=70\\\\2x-4y=80\\end{cases}");
+     * console.log(system.solve(["x", "y"])); // Returns { x: 60, y: 10 }
      *
+     * // Non-linear polynomial system (product + sum)
+     * const nonlinear = ce.parse("\\begin{cases}xy=6\\\\x+y=5\\end{cases}");
+     * console.log(nonlinear.solve(["x", "y"])); // Returns [{ x: 2, y: 3 }, { x: 3, y: 2 }]
+     * ```
      */
-    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression> | Record<string, BoxedExpression> | Array<Record<string, BoxedExpression>>;
     /**
      * If this expression is a number literal, a string literal or a function
      *  literal, return the expression.
@@ -1833,7 +1861,194 @@ export type ValueDefinition = BaseDefinition & {
     neq: (a: BoxedExpression) => boolean | undefined;
     cmp: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
     collection: CollectionHandlers;
+    /**
+     * Custom evaluation handler for subscripted expressions of this symbol.
+     * Called when evaluating `Subscript(symbol, index)`.
+     *
+     * @param subscript - The subscript expression (already evaluated)
+     * @param options - Contains the compute engine and evaluation options
+     * @returns The evaluated result, or `undefined` to fall back to symbolic form
+     */
+    subscriptEvaluate?: (subscript: BoxedExpression, options: {
+        engine: ComputeEngine;
+        numericApproximation?: boolean;
+    }) => BoxedExpression | undefined;
 };
+/**
+ * Definition for a sequence declared with `ce.declareSequence()`.
+ *
+ * A sequence is defined by base cases and a recurrence relation.
+ *
+ * @example
+ * ```typescript
+ * // Fibonacci sequence
+ * ce.declareSequence('F', {
+ *   base: { 0: 0, 1: 1 },
+ *   recurrence: 'F_{n-1} + F_{n-2}',
+ * });
+ * ce.parse('F_{10}').evaluate();  // → 55
+ * ```
+ *
+ * @category Definitions
+ */
+export interface SequenceDefinition {
+    /**
+     * Index variable name for single-index sequences, default 'n'.
+     * For multi-index sequences, use `variables` instead.
+     */
+    variable?: string;
+    /**
+     * Index variable names for multi-index sequences.
+     * Example: `['n', 'k']` for Pascal's triangle `P\_{n,k}`
+     *
+     * If provided, this takes precedence over `variable`.
+     */
+    variables?: string[];
+    /**
+     * Base cases as index → value mapping.
+     *
+     * For single-index sequences, use numeric keys:
+     * ```typescript
+     * base: { 0: 0, 1: 1 }  // F_0 = 0, F_1 = 1
+     * ```
+     *
+     * For multi-index sequences, use comma-separated string keys:
+     * ```typescript
+     * base: {
+     *   '0,0': 1,    // Exact: P_{0,0} = 1
+     *   'n,0': 1,    // Pattern: P_{n,0} = 1 for all n
+     *   'n,n': 1,    // Pattern: P_{n,n} = 1 (diagonal)
+     * }
+     * ```
+     *
+     * Pattern keys use variable names to match any value. When the same
+     * variable appears multiple times (e.g., 'n,n'), the indices must be equal.
+     */
+    base: Record<number | string, number | BoxedExpression>;
+    /** Recurrence relation as LaTeX string or BoxedExpression */
+    recurrence: string | BoxedExpression;
+    /** Whether to memoize computed values (default: true) */
+    memoize?: boolean;
+    /**
+     * Valid index domain constraints.
+     *
+     * For single-index sequences:
+     * ```typescript
+     * domain: { min: 0, max: 100 }
+     * ```
+     *
+     * For multi-index sequences, use per-variable constraints:
+     * ```typescript
+     * domain: { n: { min: 0 }, k: { min: 0 } }
+     * ```
+     */
+    domain?: {
+        min?: number;
+        max?: number;
+    } | Record<string, {
+        min?: number;
+        max?: number;
+    }>;
+    /**
+     * Constraint expression for multi-index sequences.
+     * The expression should evaluate to a boolean/numeric value.
+     * If it evaluates to false or 0, the subscript is considered out of domain.
+     *
+     * Example: `'k <= n'` for Pascal's triangle (only valid when k ≤ n)
+     */
+    constraints?: string | BoxedExpression;
+}
+/**
+ * Status of a sequence definition.
+ * @category Definitions
+ */
+export interface SequenceStatus {
+    /**
+     * Status of the sequence:
+     * - 'complete': Both base case(s) and recurrence defined
+     * - 'pending': Waiting for base case(s) or recurrence
+     * - 'not-a-sequence': Symbol is not a sequence
+     */
+    status: 'complete' | 'pending' | 'not-a-sequence';
+    /** Whether at least one base case is defined */
+    hasBase: boolean;
+    /** Whether a recurrence relation is defined */
+    hasRecurrence: boolean;
+    /**
+     * Keys of defined base cases.
+     * For single-index: numeric indices (e.g., [0, 1])
+     * For multi-index: string keys including patterns (e.g., ['0,0', 'n,0', 'n,n'])
+     */
+    baseIndices: (number | string)[];
+    /** Index variable name if recurrence is defined (single-index) */
+    variable?: string;
+    /** Index variable names if recurrence is defined (multi-index) */
+    variables?: string[];
+}
+/**
+ * Information about a defined sequence for introspection.
+ * @category Definitions
+ */
+export interface SequenceInfo {
+    /** The sequence name */
+    name: string;
+    /** Index variable name for single-index sequences (e.g., `"n"`) */
+    variable?: string;
+    /** Index variable names for multi-index sequences (e.g., `["n", "k"]`) */
+    variables?: string[];
+    /**
+     * Base case keys.
+     * For single-index: numeric indices
+     * For multi-index: string keys including patterns
+     */
+    baseIndices: (number | string)[];
+    /** Whether memoization is enabled */
+    memoize: boolean;
+    /**
+     * Domain constraints.
+     * For single-index: `{ min?, max? }`
+     * For multi-index: per-variable constraints
+     */
+    domain: {
+        min?: number;
+        max?: number;
+    } | Record<string, {
+        min?: number;
+        max?: number;
+    }>;
+    /** Number of cached values */
+    cacheSize: number;
+    /** Whether this is a multi-index sequence */
+    isMultiIndex: boolean;
+}
+/**
+ * Result from an OEIS lookup operation.
+ * @category OEIS
+ */
+export interface OEISSequenceInfo {
+    /** OEIS sequence ID (e.g., 'A000045') */
+    id: string;
+    /** Sequence name/description */
+    name: string;
+    /** First several terms of the sequence */
+    terms: number[];
+    /** Formula or recurrence (if available) */
+    formula?: string;
+    /** Comments about the sequence */
+    comments?: string[];
+    /** URL to the OEIS page */
+    url: string;
+}
+/**
+ * Options for OEIS operations.
+ * @category OEIS
+ */
+export interface OEISOptions {
+    /** Request timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Maximum number of results to return for lookups (default: 5) */
+    maxResults?: number;
+}
 /**
  * Definition record for a function.
  * @category Definitions
@@ -2316,6 +2531,14 @@ export interface BoxedValueDefinition extends BoxedBaseDefinition {
      */
     inferredType: boolean;
     type: BoxedType;
+    /**
+     * Custom evaluation handler for subscripted expressions of this symbol.
+     * Called when evaluating `Subscript(symbol, index)`.
+     */
+    subscriptEvaluate?: (subscript: BoxedExpression, options: {
+        engine: ComputeEngine;
+        numericApproximation?: boolean;
+    }) => BoxedExpression | undefined;
 }
 /**
  * An operator definition can have some flags to indicate specific
@@ -2616,7 +2839,7 @@ export type RuleSteps = RuleStep[];
  * into a new expression `replace`.
  *
  * - `x-1` \( \to \) `1-x`
- * - `(x+1)(x-1)` \( \to \) `x^2-1
+ * - `(x+1)(x-1)` \( \to \) `x^2-1`
  *
  * The patterns can be expressed as LaTeX strings or `SemiBoxedExpression`'s.
  * Alternatively, match/replace logic may be specified by a `RuleFunction`, allowing both custom
@@ -2796,6 +3019,8 @@ export interface ComputeEngine extends IBigNum {
     readonly context: EvalContext;
     contextStack: ReadonlyArray<EvalContext>;
     /** @internal */
+    readonly isVerifying: boolean;
+    /** @internal */
     readonly _typeResolver: TypeResolver;
     /** Absolute time beyond which evaluation should not proceed
      * @internal
@@ -2929,6 +3154,11 @@ export interface ComputeEngine extends IBigNum {
      * Use `ce.assign(id, value)` instead.
      * @internal */
     _setSymbolValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
+    /**
+     * Set a value directly in the current context's values map.
+     * Used for assumptions so values are properly scoped.
+     * @internal */
+    _setCurrentContextValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
     /** A list of the function calls to the current evaluation context */
     trace: ReadonlyArray<string>;
     lookupContext(id: MathJsonSymbol): undefined | EvalContext;
@@ -2953,9 +3183,111 @@ export interface ComputeEngine extends IBigNum {
         [id: MathJsonSymbol]: Type | TypeString | Partial<SymbolDefinition>;
     }, arg2?: Type | TypeString | Partial<SymbolDefinition>, arg3?: Scope): ComputeEngine;
     assume(predicate: BoxedExpression): AssumeResult;
+    /**
+     * Declare a sequence with a recurrence relation.
+     *
+     * @example
+     * ```typescript
+     * // Fibonacci sequence
+     * ce.declareSequence('F', {
+     *   base: { 0: 0, 1: 1 },
+     *   recurrence: 'F_{n-1} + F_{n-2}',
+     * });
+     * ce.parse('F_{10}').evaluate();  // → 55
+     * ```
+     */
+    declareSequence(name: string, def: SequenceDefinition): ComputeEngine;
+    /**
+     * Get the status of a sequence definition.
+     *
+     * @example
+     * ```typescript
+     * ce.parse('F_0 := 0').evaluate();
+     * ce.getSequenceStatus('F');
+     * // → { status: 'pending', hasBase: true, hasRecurrence: false, baseIndices: [0] }
+     * ```
+     */
+    getSequenceStatus(name: string): SequenceStatus;
+    /**
+     * Get information about a defined sequence.
+     * Returns `undefined` if the symbol is not a sequence.
+     */
+    getSequence(name: string): SequenceInfo | undefined;
+    /**
+     * List all defined sequences.
+     * Returns an array of sequence names.
+     */
+    listSequences(): string[];
+    /**
+     * Check if a symbol is a defined sequence.
+     */
+    isSequence(name: string): boolean;
+    /**
+     * Clear the memoization cache for a sequence.
+     * If no name is provided, clears caches for all sequences.
+     */
+    clearSequenceCache(name?: string): void;
+    /**
+     * Get the memoization cache for a sequence.
+     * Returns a Map of index → value, or `undefined` if not a sequence or memoization is disabled.
+     *
+     * For single-index sequences, keys are numbers.
+     * For multi-index sequences, keys are comma-separated strings (e.g., '5,2').
+     */
+    getSequenceCache(name: string): Map<number | string, BoxedExpression> | undefined;
+    /**
+     * Generate a list of sequence terms from start to end (inclusive).
+     *
+     * @param name - The sequence name
+     * @param start - Starting index (inclusive)
+     * @param end - Ending index (inclusive)
+     * @param step - Step size (default: 1)
+     * @returns Array of BoxedExpressions, or undefined if not a sequence
+     *
+     * @example
+     * ```typescript
+     * ce.declareSequence('F', { base: { 0: 0, 1: 1 }, recurrence: 'F_{n-1} + F_{n-2}' });
+     * ce.getSequenceTerms('F', 0, 10);
+     * // → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+     * ```
+     */
+    getSequenceTerms(name: string, start: number, end: number, step?: number): BoxedExpression[] | undefined;
+    /**
+     * Look up sequences in OEIS by their terms.
+     *
+     * @param terms - Array of sequence terms to search for
+     * @param options - Optional configuration (timeout, maxResults)
+     * @returns Promise resolving to array of matching sequences
+     *
+     * @example
+     * ```typescript
+     * const results = await ce.lookupOEIS([0, 1, 1, 2, 3, 5, 8, 13]);
+     * // → [{ id: 'A000045', name: 'Fibonacci numbers', ... }]
+     * ```
+     */
+    lookupOEIS(terms: (number | BoxedExpression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+    /**
+     * Check if a defined sequence matches an OEIS sequence.
+     *
+     * @param name - Name of the defined sequence
+     * @param count - Number of terms to check (default: 10)
+     * @param options - Optional configuration
+     * @returns Promise with match results including OEIS matches and generated terms
+     *
+     * @example
+     * ```typescript
+     * ce.declareSequence('F', { base: { 0: 0, 1: 1 }, recurrence: 'F_{n-1} + F_{n-2}' });
+     * const result = await ce.checkSequenceOEIS('F', 10);
+     * // → { matches: [{ id: 'A000045', name: 'Fibonacci numbers', ... }], terms: [0, 1, 1, ...] }
+     * ```
+     */
+    checkSequenceOEIS(name: string, count?: number, options?: OEISOptions): Promise<{
+        matches: OEISSequenceInfo[];
+        terms: number[];
+    }>;
     forget(symbol?: MathJsonSymbol | MathJsonSymbol[]): void;
     ask(pattern: BoxedExpression): BoxedSubstitution[];
-    verify(query: BoxedExpression): boolean;
+    verify(query: BoxedExpression): boolean | undefined;
     /** @internal */
     _shouldContinueExecution(): boolean;
     /** @internal */

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

@@ -1,19 +1,28 @@
-/* 0.33.0 */
+/* 0.35.0 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
 import type { OneOf } from '../common/one-of';
 import { ConfigurationChangeListener } from '../common/configuration-change';
 import type { Expression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
-import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, BoxedExpression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, SymbolDefinitions, Metadata, Rule, Scope, EvalContext, SemiBoxedExpression, ComputeEngine as IComputeEngine, BoxedDefinition, SymbolDefinition } from './global-types';
+import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, BoxedExpression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, SymbolDefinitions, Metadata, Rule, Scope, EvalContext, SemiBoxedExpression, ComputeEngine as IComputeEngine, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions } from './global-types';
 import type { LatexDictionaryEntry, LatexString, LibraryCategory, ParseLatexOptions } from './latex-syntax/types';
 import { type IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
 import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
 import { validatePattern } from './boxed-expression/boxed-patterns';
+import { factor, factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial } from './boxed-expression/factor';
 import './boxed-expression/serialize';
 export * from './global-types';
 export { validatePattern };
+export { factor, factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompiledExecutable, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';
+export { JavaScriptTarget } from './compilation/javascript-target';
+export { GLSLTarget } from './compilation/glsl-target';
+export { IntervalJavaScriptTarget } from './compilation/interval-javascript-target';
+export { IntervalGLSLTarget } from './compilation/interval-glsl-target';
+export { BaseCompiler } from './compilation/base-compiler';
+import type { LanguageTarget } from './compilation/types';
 /**
  *
  * To use the Compute Engine, create a `ComputeEngine` instance:
@@ -101,6 +110,8 @@ export declare class ComputeEngine implements IComputeEngine {
     private _configurationChangeTracker;
     /** @internal */
     private _cost?;
+    /** @internal Registry of compilation targets */
+    private _compilationTargets;
     /** @internal */
     private _commonSymbols;
     /** @internal */
@@ -240,6 +251,43 @@ export declare class ComputeEngine implements IComputeEngine {
     _reset(): void;
     /** @internal */
     listenToConfigurationChange(tracker: ConfigurationChangeListener): () => void;
+    /**
+     * Register a custom compilation target.
+     *
+     * This allows you to compile mathematical expressions to different target
+     * languages beyond the built-in JavaScript and GLSL targets.
+     *
+     * @param name - The name of the target (e.g., 'python', 'wgsl', 'matlab')
+     * @param target - The LanguageTarget implementation
+     *
+     * @example
+     * ```typescript
+     * import { ComputeEngine, GLSLTarget } from '@cortex-js/compute-engine';
+     *
+     * const ce = new ComputeEngine();
+     *
+     * // Register a custom target
+     * class PythonTarget implements LanguageTarget {
+     *   // Implementation...
+     * }
+     *
+     * ce.registerCompilationTarget('python', new PythonTarget());
+     *
+     * // Use the custom target
+     * const expr = ce.parse('x^2 + y^2');
+     * const code = expr.compile({ to: 'python' });
+     * ```
+     */
+    registerCompilationTarget(name: string, target: LanguageTarget): void;
+    /**
+     * Get a registered compilation target by name.
+     *
+     * @param name - The name of the target (e.g., 'javascript', 'glsl')
+     * @returns The LanguageTarget implementation, or undefined if not found
+     *
+     * @internal
+     */
+    _getCompilationTarget(name: string): LanguageTarget | undefined;
     get precision(): number;
     /** The precision, or number of significant digits, of numeric
      * calculations.
@@ -298,6 +346,35 @@ export declare class ComputeEngine implements IComputeEngine {
     get recursionLimit(): number;
     set recursionLimit(t: number);
     private _recursionLimit;
+    /**
+     * Flag to prevent infinite recursion in the verify/ask/equality checking cycle.
+     *
+     * **The Problem:**
+     * When verifying equality predicates, a recursion loop can occur:
+     * 1. `verify(Equal(x, 0))` evaluates the expression
+     * 2. `Equal.evaluate()` calls `eq(x, 0)` to check equality
+     * 3. `eq()` calls `ask(['NotEqual', x, 0])` to check assumptions
+     * 4. `ask()` calls `verify(NotEqual(x, 0))` as a fallback
+     * 5. `verify()` evaluates, calling `eq()` again → infinite loop
+     *
+     * **The Solution:**
+     * - Set `_isVerifying = true` when entering `verify()`
+     * - `ask()` skips the `verify()` fallback when `_isVerifying` is true
+     * - `Equal/NotEqual` evaluate handlers check this flag to preserve 3-valued
+     *   logic in verification mode while still returning False/True in normal mode
+     *
+     * @see verify() in index.ts
+     * @see ask() in index.ts
+     * @see eq() in compare.ts
+     * @see Equal/NotEqual operators in relational-operator.ts
+     */
+    private _isVerifying;
+    /**
+     * @internal
+     * Indicates whether we're currently inside a verify() call.
+     * Used to prevent recursion and to enable 3-valued logic in verification mode.
+     */
+    get isVerifying(): boolean;
     get tolerance(): number;
     /**
      * Values smaller than the tolerance are considered to be zero for the
@@ -473,6 +550,13 @@ export declare class ComputeEngine implements IComputeEngine {
      * @internal
      */
     _setSymbolValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
+    /**
+     * Set a value directly in the current context's values map.
+     * This is used for assumptions so that the value is scoped to the current
+     * evaluation context and is automatically removed when the scope is popped.
+     * @internal
+     */
+    _setCurrentContextValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
     /**
      * Declare a symbol in the current lexical scope: specify their type and
      * other attributes, including optionally a value.
@@ -491,6 +575,107 @@ export declare class ComputeEngine implements IComputeEngine {
     declare(symbols: {
         [id: string]: Type | TypeString | Partial<SymbolDefinition>;
     }): IComputeEngine;
+    /**
+     * Declare a sequence with a recurrence relation.
+     *
+     * @example
+     * ```typescript
+     * // Fibonacci sequence
+     * ce.declareSequence('F', {
+     *   base: { 0: 0, 1: 1 },
+     *   recurrence: 'F_{n-1} + F_{n-2}',
+     * });
+     * ce.parse('F_{10}').evaluate();  // → 55
+     * ```
+     */
+    declareSequence(name: string, def: SequenceDefinition): IComputeEngine;
+    /**
+     * Get the status of a sequence definition.
+     *
+     * @example
+     * ```typescript
+     * ce.parse('F_0 := 0').evaluate();
+     * ce.getSequenceStatus('F');
+     * // → { status: 'pending', hasBase: true, hasRecurrence: false, baseIndices: [0] }
+     * ```
+     */
+    getSequenceStatus(name: string): SequenceStatus;
+    /**
+     * Get information about a defined sequence.
+     * Returns `undefined` if the symbol is not a sequence.
+     */
+    getSequence(name: string): SequenceInfo | undefined;
+    /**
+     * List all defined sequences.
+     */
+    listSequences(): string[];
+    /**
+     * Check if a symbol is a defined sequence.
+     */
+    isSequence(name: string): boolean;
+    /**
+     * Clear the memoization cache for a sequence.
+     * If no name is provided, clears caches for all sequences.
+     */
+    clearSequenceCache(name?: string): void;
+    /**
+     * Get the memoization cache for a sequence.
+     * Returns a Map of index → value, or `undefined` if not a sequence or memoization is disabled.
+     *
+     * For single-index sequences, keys are numbers.
+     * For multi-index sequences, keys are comma-separated strings (e.g., '5,2').
+     */
+    getSequenceCache(name: string): Map<number | string, BoxedExpression> | undefined;
+    /**
+     * Generate a list of sequence terms from start to end (inclusive).
+     *
+     * @param name - The sequence name
+     * @param start - Starting index (inclusive)
+     * @param end - Ending index (inclusive)
+     * @param step - Step size (default: 1)
+     * @returns Array of BoxedExpressions, or undefined if not a sequence
+     *
+     * @example
+     * ```typescript
+     * ce.declareSequence('F', { base: { 0: 0, 1: 1 }, recurrence: 'F_{n-1} + F_{n-2}' });
+     * ce.getSequenceTerms('F', 0, 10);
+     * // → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+     * ```
+     */
+    getSequenceTerms(name: string, start: number, end: number, step?: number): BoxedExpression[] | undefined;
+    /**
+     * Look up sequences in OEIS by their terms.
+     *
+     * @param terms - Array of sequence terms to search for
+     * @param options - Optional configuration (timeout, maxResults)
+     * @returns Promise resolving to array of matching sequences
+     *
+     * @example
+     * ```typescript
+     * const results = await ce.lookupOEIS([0, 1, 1, 2, 3, 5, 8, 13]);
+     * // → [{ id: 'A000045', name: 'Fibonacci numbers', ... }]
+     * ```
+     */
+    lookupOEIS(terms: (number | BoxedExpression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+    /**
+     * Check if a defined sequence matches an OEIS sequence.
+     *
+     * @param name - Name of the defined sequence
+     * @param count - Number of terms to check (default: 10)
+     * @param options - Optional configuration
+     * @returns Promise with match results including OEIS matches and generated terms
+     *
+     * @example
+     * ```typescript
+     * ce.declareSequence('F', { base: { 0: 0, 1: 1 }, recurrence: 'F_{n-1} + F_{n-2}' });
+     * const result = await ce.checkSequenceOEIS('F', 10);
+     * // → { matches: [{ id: 'A000045', name: 'Fibonacci numbers', ... }], terms: [0, 1, 1, ...] }
+     * ```
+     */
+    checkSequenceOEIS(name: string, count?: number, options?: OEISOptions): Promise<{
+        matches: OEISSequenceInfo[];
+        terms: number[];
+    }>;
     /**
      * Return an evaluation context in which the symbol is defined.
      */
@@ -632,7 +817,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * Answer a query based on the current assumptions.
      *
      */
-    verify(_query: BoxedExpression): boolean;
+    verify(query: BoxedExpression): boolean | undefined;
     /**
      * Add an assumption.
      *