@cortex-js/compute-engine 0.32.1 → 0.34.0

package/dist/types/compute-engine/library/logic-analysis.d.ts

@@ -1,8 +1,37 @@
-/* 0.32.1 */
+/* 0.34.0 */
 /**
  * Quantifier domain helpers and boolean analysis functions.
  * Extracted from logic.ts for better code organization.
  */
+/**
+ * Result of extracting a finite domain from an Element expression.
+ * - `status: 'success'` - Domain was successfully extracted
+ * - `status: 'non-enumerable'` - Domain exists but cannot be enumerated (e.g., infinite set, unknown symbol)
+ * - `status: 'error'` - Invalid Element expression (missing variable, malformed domain)
+ */
+export type ExtractDomainResult = {
+    status: 'success';
+    variable: string;
+    values: BoxedExpression[];
+} | {
+    status: 'non-enumerable';
+    variable: string;
+    domain: BoxedExpression;
+    reason: string;
+} | {
+    status: 'error';
+    reason: string;
+};
+/**
+ * Extract the finite domain from a quantifier's condition.
+ * Supports:
+ * - ["Element", "x", ["Set", 1, 2, 3]] → [1, 2, 3]
+ * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
+ * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
+ * - ["Element", "x", ["Set", 1, 2, 3], condition] → filtered values (EL-3)
+ * Returns detailed result indicating success, non-enumerable domain, or error.
+ */
+export declare function extractFiniteDomainWithReason(condition: BoxedExpression, ce: ComputeEngine): ExtractDomainResult;
 /**
  * Extract the finite domain from a quantifier's condition.
  * Supports:
@@ -10,6 +39,7 @@
  * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
  * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
  * Returns null if the domain is not finite or not recognized.
+ * @deprecated Use extractFiniteDomainWithReason for better error handling
  */
 export declare function extractFiniteDomain(condition: BoxedExpression, ce: ComputeEngine): {
     variable: string;
@@ -49,16 +79,171 @@ export declare function evaluateExistsCartesian(domains: {
 }[], body: BoxedExpression, ce: ComputeEngine): BoxedExpression | undefined;
 /**
  * Check if a boolean expression is satisfiable.
- * Returns True if there exists an assignment that makes the expression true.
+ *
+ * Returns `True` if there exists an assignment of truth values to variables
+ * that makes the expression true, `False` if no such assignment exists.
+ *
+ * ## Algorithm
+ *
+ * Uses brute-force enumeration of all possible truth assignments.
+ * This has **O(2^n) time complexity** where n is the number of variables.
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Assignments | Approximate Time |
+ * |-----------|-------------|------------------|
+ * | 10        | 1,024       | < 1ms            |
+ * | 15        | 32,768      | ~10ms            |
+ * | 20        | 1,048,576   | ~100ms-1s        |
+ * | > 20      | (rejected)  | N/A              |
+ *
+ * ## Limits
+ *
+ * - **Maximum 20 variables**: Expressions with more than 20 distinct boolean
+ *   variables will return the unevaluated `IsSatisfiable` expression rather
+ *   than attempting evaluation (to prevent blocking the thread).
+ *
+ * ## Future Improvements
+ *
+ * For better performance on larger expressions, a DPLL-based SAT solver
+ * could be implemented. The current brute-force approach is suitable for
+ * small expressions typically encountered in educational and verification
+ * contexts.
+ *
+ * @param expr - A boolean expression to check for satisfiability
+ * @param ce - The ComputeEngine instance
+ * @returns `True` if satisfiable, `False` if unsatisfiable, or the
+ *          unevaluated expression if the variable limit is exceeded
  */
 export declare function isSatisfiable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
 /**
  * Check if a boolean expression is a tautology.
- * Returns True if the expression is true for all possible assignments.
+ *
+ * Returns `True` if the expression evaluates to true for all possible
+ * assignments of truth values to variables, `False` otherwise.
+ *
+ * ## Algorithm
+ *
+ * Uses brute-force enumeration of all possible truth assignments.
+ * This has **O(2^n) time complexity** where n is the number of variables.
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Assignments | Approximate Time |
+ * |-----------|-------------|------------------|
+ * | 10        | 1,024       | < 1ms            |
+ * | 15        | 32,768      | ~10ms            |
+ * | 20        | 1,048,576   | ~100ms-1s        |
+ * | > 20      | (rejected)  | N/A              |
+ *
+ * ## Limits
+ *
+ * - **Maximum 20 variables**: Expressions with more than 20 distinct boolean
+ *   variables will return the unevaluated `IsTautology` expression rather
+ *   than attempting evaluation (to prevent blocking the thread).
+ *
+ * ## Future Improvements
+ *
+ * For better performance on larger expressions, a DPLL-based approach
+ * (checking unsatisfiability of the negation) could be implemented.
+ *
+ * @param expr - A boolean expression to check
+ * @param ce - The ComputeEngine instance
+ * @returns `True` if a tautology, `False` if not, or the unevaluated
+ *          expression if the variable limit is exceeded
  */
 export declare function isTautology(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
 /**
  * Generate a truth table for a boolean expression.
- * Returns a List of Lists with headers and rows.
+ *
+ * Returns a `List` of `List`s where the first row contains column headers
+ * (variable names followed by "Result") and subsequent rows contain the
+ * truth values for each assignment.
+ *
+ * ## Algorithm
+ *
+ * Generates all 2^n possible truth assignments and evaluates the expression
+ * for each. This has **O(2^n) time and space complexity**.
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Rows Generated | Output Size |
+ * |-----------|----------------|-------------|
+ * | 5         | 32             | ~1 KB       |
+ * | 8         | 256            | ~8 KB       |
+ * | 10        | 1,024          | ~32 KB      |
+ * | > 10      | (rejected)     | N/A         |
+ *
+ * ## Limits
+ *
+ * - **Maximum 10 variables**: Expressions with more than 10 distinct boolean
+ *   variables will return the unevaluated `TruthTable` expression. This
+ *   stricter limit (compared to `IsSatisfiable`/`IsTautology`) accounts for
+ *   the memory required to store all rows.
+ *
+ * @param expr - A boolean expression to generate a truth table for
+ * @param ce - The ComputeEngine instance
+ * @returns A `List` of `List`s representing the truth table, or the
+ *          unevaluated expression if the variable limit is exceeded
  */
 export declare function generateTruthTable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+/**
+ * Find all prime implicants using the Quine-McCluskey algorithm.
+ *
+ * ## Algorithm
+ *
+ * 1. Generate minterms from the truth table (assignments where expression is true)
+ * 2. Group minterms by number of 1s
+ * 3. Combine terms differing in exactly one position, marking combined terms
+ * 4. Repeat until no more combinations possible
+ * 5. Return terms that were never combined (prime implicants)
+ *
+ * ## Performance Characteristics
+ *
+ * | Variables | Max Minterms | Approximate Time |
+ * |-----------|--------------|------------------|
+ * | 5         | 32           | < 1ms            |
+ * | 8         | 256          | ~10ms            |
+ * | 10        | 1,024        | ~100ms           |
+ * | > 12      | (rejected)   | N/A              |
+ *
+ * ## Limits
+ *
+ * - **Maximum 12 variables**: Larger expressions return unevaluated.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns A Set of expressions representing prime implicants
+ */
+export declare function findPrimeImplicants(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression[] | null;
+/**
+ * Find all prime implicates using the Quine-McCluskey algorithm.
+ *
+ * Prime implicates are the dual of prime implicants - they are the minimal
+ * clauses in CNF. We find them by finding prime implicants of the negation
+ * and then negating the result.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns A Set of expressions representing prime implicates (clauses)
+ */
+export declare function findPrimeImplicates(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression[] | null;
+/**
+ * Find a minimal DNF (sum of products) using prime implicants.
+ *
+ * This uses the Quine-McCluskey algorithm followed by a greedy covering
+ * algorithm to select a minimal set of prime implicants.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns The minimal DNF, or null if too many variables
+ */
+export declare function minimalDNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression | null;
+/**
+ * Find a minimal CNF (product of sums) using prime implicates.
+ *
+ * @param expr - A boolean expression
+ * @param ce - The ComputeEngine instance
+ * @returns The minimal CNF, or null if too many variables
+ */
+export declare function minimalCNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression | null;

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

@@ -1,8 +1,4 @@
-/* 0.32.1 */
-/**
- * Basic evaluation functions for logical operators.
- * Extracted from logic.ts for better code organization.
- */
+/* 0.34.0 */
 export declare function evaluateAnd(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
     engine: ComputeEngine;
 }): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const LOGIC_LIBRARY: SymbolDefinitions;
 export declare function simplifyLogicFunction(x: BoxedExpression): {
     value: BoxedExpression;

package/dist/types/compute-engine/library/number-theory.d.ts

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const NUMBER_THEORY_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const POLYNOMIALS_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/random-expression.d.ts

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare function randomExpression(level?: number): Expression;

package/dist/types/compute-engine/library/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const RELOP_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const SETS_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const STATISTICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const TRIGONOMETRY_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,20 @@
-/* 0.32.1 */
+/* 0.34.0 */
+/**
+ * EL-4: Convert known infinite integer sets to their equivalent Limits bounds.
+ * Returns undefined if the set cannot be converted to a Limits form.
+ *
+ * Mappings:
+ * - NonNegativeIntegers (ℕ₀) → [0, ∞)
+ * - PositiveIntegers (ℤ⁺) → [1, ∞)
+ * - NegativeIntegers (ℤ⁻) → Not supported (would need negative direction)
+ * - Integers (ℤ) → Not supported (bidirectional)
+ * - Other sets (Reals, Complexes, etc.) → Not supported (non-integer)
+ */
+export declare function convertInfiniteSetToLimits(domainSymbol: string): {
+    lower: number;
+    upper: number;
+    isFinite: false;
+} | undefined;
 export type IndexingSet = {
     index: string | undefined;
     lower: number;
@@ -58,20 +74,62 @@ export declare function canonicalLimits(ops: ReadonlyArray<BoxedExpression>, { e
  * - `lower` (a number), `Nothing` if none is present
  * - `upper` (a number), `Nothing` if none is present
  *
+ * Or, for Element expressions, preserve them in canonical form.
+ *
  * Assume we are in the context of a big operator
  * (i.e. `pushScope()` has been called)
  */
 export declare function canonicalIndexingSet(expr: BoxedExpression): BoxedExpression | undefined;
 export declare function canonicalBigop(bigOp: string, body: BoxedExpression, indexingSets: BoxedExpression[], scope: Scope | undefined): BoxedExpression | null;
+/**
+ * A special symbol used to signal that a BigOp could not be evaluated
+ * because the domain is non-enumerable (e.g., infinite set, unknown symbol).
+ * When this is returned, the Sum/Product should keep the expression symbolic
+ * rather than returning NaN.
+ */
+export declare const NON_ENUMERABLE_DOMAIN: unique symbol;
+/**
+ * Result type for reduceBigOp that includes reason for failure
+ */
+export type BigOpResult<T> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'non-enumerable';
+    reason: string;
+    domain?: BoxedExpression;
+} | {
+    status: 'error';
+    reason: string;
+};
 /**
  * Process an expression of the form
  * - ['Operator', body, ['Tuple', index1, lower, upper]]
  * - ['Operator', body, ['Tuple', index1, lower, upper], ['Tuple', index2, lower, upper], ...]
+ * - ['Operator', body, ['Element', index, collection]]
  * - ['Operator', body]
  * - ['Operator', collection]
  *
  * `fn()` is the processing done on each element
  * Apply the function `fn` to the body of a big operator, according to the
  * indexing sets.
+ *
+ * Returns either the reduced value, or `typeof NON_ENUMERABLE_DOMAIN` if the
+ * domain cannot be enumerated (in which case the expression should remain symbolic).
  */
-export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): Generator<T | undefined>;
+export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): Generator<T | typeof NON_ENUMERABLE_DOMAIN | undefined>;
+/**
+ * Result type for reduceElementIndexingSets to distinguish between
+ * successful evaluation, non-enumerable domains (keep symbolic), and errors.
+ */
+export type ReduceElementResult<T> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'non-enumerable';
+    reason: string;
+    domain?: BoxedExpression;
+} | {
+    status: 'error';
+    reason: string;
+};

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';
 import { Expression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import { Rational, SmallInteger } from '../numerics/types';
 import { BigNumFactory, ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { Expression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import type { Expression } from '../../math-json/types';
 import type { SmallInteger } from '../numerics/types';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
  *
  * ## THEORY OF OPERATIONS
  *

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare function bigint(a: Decimal | number | bigint | string): bigint | null;

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
     estimate: number;
     error: number;
 };

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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.32.1 */
+/* 0.34.0 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
 export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;

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

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,11 +1,11 @@
-/* 0.32.1 */
+/* 0.34.0 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;
 export declare const SMALL_INTEGER = 1000000;
 /** The largest number of digits of a bigint */
 export declare const MAX_BIGINT_DIGITS = 1024;
-export declare const MAX_ITERATION = 1000000;
+export declare const MAX_ITERATION = 10000;
 export declare const MAX_SYMBOLIC_TERMS = 200;
 /**
  * Returns the smallest floating-point number greater than x.

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.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,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.34.0 */
 import type { BigNum } from './types';
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;

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

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

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

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

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

@@ -0,0 +1,85 @@
+/* 0.34.0 */
+ * OEIS (Online Encyclopedia of Integer Sequences) Integration
+ *
+ * This module provides functions to look up sequences in the OEIS database
+ * and import them for use in the compute engine.
+ *
+ * @see https://oeis.org
+ */
+import type { ComputeEngine, BoxedExpression } from './global-types';
+/**
+ * Result from an OEIS lookup operation.
+ */
+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.
+ */
+export interface OEISOptions {
+    /** Request timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Maximum number of results to return for lookups (default: 5) */
+    maxResults?: number;
+}
+/**
+ * Look up sequences in OEIS by their terms.
+ *
+ * @param terms - Array of sequence terms to search for
+ * @param options - Optional configuration
+ * @returns Promise resolving to array of matching sequences
+ *
+ * @example
+ * ```typescript
+ * const results = await lookupOEISByTerms([0, 1, 1, 2, 3, 5, 8, 13]);
+ * // → [{ id: 'A000045', name: 'Fibonacci numbers', ... }]
+ * ```
+ */
+export declare function lookupOEISByTerms(terms: number[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+/**
+ * Look up a sequence in OEIS by its ID.
+ *
+ * @param id - OEIS sequence ID (e.g., 'A000045' or '45')
+ * @param options - Optional configuration
+ * @returns Promise resolving to sequence info, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const fib = await lookupOEISById('A000045');
+ * // → { id: 'A000045', name: 'Fibonacci numbers', terms: [0, 1, 1, 2, ...], ... }
+ * ```
+ */
+export declare function lookupOEISById(id: string, options?: OEISOptions): Promise<OEISSequenceInfo | undefined>;
+/**
+ * Look up a sequence in OEIS by its terms.
+ *
+ * @param ce - ComputeEngine instance
+ * @param terms - Array of sequence terms (numbers or BoxedExpressions)
+ * @param options - Optional configuration
+ * @returns Promise resolving to array of matching sequences
+ */
+export declare function lookupSequence(ce: ComputeEngine, terms: (number | BoxedExpression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+/**
+ * Check if a defined sequence matches an OEIS sequence.
+ *
+ * @param ce - ComputeEngine instance
+ * @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
+ */
+export declare function checkSequence(ce: ComputeEngine, name: string, count?: number, options?: OEISOptions): Promise<{
+    matches: OEISSequenceInfo[];
+    terms: number[];
+}>;