@cortex-js/compute-engine 0.15.0 → 0.16.0

package/dist/math-json.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.15.0 */
+/** CortexJS Compute Engine 0.16.0 */
 
 // src/math-json/utils.ts
 function isSymbolObject(expr) {
@@ -239,7 +239,7 @@ function mapArgs(expr, fn) {
 }
 
 // src/math-json.ts
-var version = "0.15.0";
+var version = "0.16.0";
 export {
   applyRecursively,
   dictionary as getDictionary,

package/dist/math-json.js

@@ -1,4 +1,4 @@
-/** CortexJS MathJSON 0.15.0 */
+/** CortexJS MathJSON 0.16.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MathJson = {}));})(this, (function (exports) { 'use strict';
 var MathJson = (() => {
   var __defProp = Object.defineProperty;
@@ -277,7 +277,7 @@ var MathJson = (() => {
   }
 
   // src/math-json.ts
-  var version = "0.15.0";
+  var version = "0.16.0";
   return __toCommonJS(math_json_exports);
 })();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/math-json.min.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.15.0 */
+/** CortexJS Compute Engine 0.16.0 */
 
 // src/math-json/utils.ts
 function isSymbolObject(expr) {
@@ -239,7 +239,7 @@ function mapArgs(expr, fn) {
 }
 
 // src/math-json.ts
-var version = "0.15.0";
+var version = "0.16.0";
 export {
   applyRecursively,
   dictionary as getDictionary,

package/dist/math-json.min.js

@@ -1,4 +1,4 @@
-/** CortexJS MathJSON 0.15.0 */
+/** CortexJS MathJSON 0.16.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MathJson = {}));})(this, (function (exports) { 'use strict';
 var MathJson = (() => {
   var __defProp = Object.defineProperty;
@@ -277,7 +277,7 @@ var MathJson = (() => {
   }
 
   // src/math-json.ts
-  var version = "0.15.0";
+  var version = "0.16.0";
   return __toCommonJS(math_json_exports);
 })();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/types/common/ansi-codes.d.ts

@@ -0,0 +1,15 @@
+/* 0.16.0 */
+export declare const BLACK = "\u001B[30;1m${s}";
+export declare const GREY = "\u001B[30;1m${s}";
+export declare const GREEN = "\u001B[32;1m";
+export declare const RED = "\u001B[31;1m";
+export declare const YELLOW = "\u001B[33m";
+export declare const BLUE = "\u001B[34;1m";
+export declare const MAGENTA = "\u001B[35;1m";
+export declare const CYAN = "\u001B[36;1m";
+export declare const INVERSE_RED = "\u001B[101;97m";
+export declare const INVERSE_GREEN = "\u001B[102;97m";
+export declare const INVERSE_YELLOW = "\u001B[103;97m";
+export declare const INVERSE_BLUE = "\u001B[104;97m";
+export declare const BOLD = "\u001B[1m";
+export declare const GREY_BG = "\u001B[40;1m";

package/dist/types/common/grapheme-splitter.d.ts

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 /**
  * Return a string or an array of graphemes.
  *

package/dist/types/common/signals.d.ts

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 export type SignalCode = RuntimeSignalCode | ('invalid-name' | 'expected-predicate' | 'expected-symbol' | 'operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'prefix-operator-requires-one-operand' | 'unbalanced-symbols' | 'expected-argument' | 'unexpected-command' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry' | 'syntax-error');
 export type SignalMessage = SignalCode | [SignalCode, ...any[]];
 export type SignalOrigin = {

package/dist/types/common/utils.d.ts

@@ -1 +1 @@
-/* 0.15.0 */
+/* 0.16.0 */

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -9,7 +9,7 @@
  *
  * Some assumptions are handled separately, specifically, those that can
  * be represented as a symbol definition (equality to an expression,
- * membership to Integer, RealNumber, etc..., >0, <=0, etc...). The result
+ * membership to Integers, RealNumbers, etc..., >0, <=0, etc...). The result
  * of these are stored directly in the current scope's symbols dictionary
  * (and an entry for the symbol is created if necessary).
  *

package/dist/types/compute-engine/boxed-expression/abstract-boxed-expression.d.ts

@@ -1,11 +1,11 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSymbolDefinition, BoxedDomain, EvaluateOptions, IComputeEngine, LatexString, Metadata, NOptions, PatternMatchOptions, SemiBoxedExpression, SimplifyOptions, Substitution, RuntimeScope, DomainCompatibility, DomainLiteral, BoxedBaseDefinition, Rational, BoxedSubstitution } from '../public';
 /**
- * AbstractBoxedExpression
+ * _BoxedExpression
  */
-export declare abstract class AbstractBoxedExpression implements BoxedExpression {
+export declare abstract class _BoxedExpression implements BoxedExpression {
     abstract readonly hash: number;
     abstract readonly json: Expression;
     abstract readonly head: BoxedExpression | string;
@@ -15,11 +15,10 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     abstract isEqual(rhs: BoxedExpression): boolean;
     abstract match(rhs: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     readonly engine: IComputeEngine;
-    /** Verbatim LaTeX, obtained from a source, i.e. from parsing, not generated
-     * synthetically
+    /** Verbatim LaTeX, obtained from a source, i.e. from parsing,
+     *  not generated synthetically
      */
     protected _latex?: string;
-    protected _wikidata: string | undefined;
     constructor(ce: IComputeEngine, metadata?: Metadata);
     /** `Object.valueOf()`: return a primitive value for the object
      *
@@ -43,7 +42,8 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     getSubexpressions(head: string): BoxedExpression[];
     get subexpressions(): BoxedExpression[];
     get symbols(): string[];
-    get freeVars(): string[];
+    get unknowns(): string[];
+    get freeVariables(): string[];
     get errors(): BoxedExpression[];
     get ops(): null | BoxedExpression[];
     get nops(): number;
@@ -53,8 +53,6 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     get isValid(): boolean;
     get isPure(): boolean;
     get isExact(): boolean;
-    /** For a symbol, true if the symbol is a free variable (no value) */
-    get isFree(): boolean;
     /** For a symbol, true if the symbol is a constant (unchangeable value) */
     get isConstant(): boolean;
     get canonical(): BoxedExpression;
@@ -90,11 +88,11 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     get description(): string[] | undefined;
     get url(): string | undefined;
     get wikidata(): string | undefined;
-    set wikidata(val: string | undefined);
     get complexity(): number | undefined;
-    get basedDefinition(): BoxedBaseDefinition | undefined;
+    get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
+    infer(_domain: BoxedDomain): boolean;
     bind(_scope: RuntimeScope | null): void;
     unbind(): void;
     get keys(): IterableIterator<string> | null;
@@ -105,7 +103,6 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     set value(_value: BoxedExpression | number | undefined);
     get domain(): BoxedDomain;
     set domain(_domain: BoxedDomain);
-    get explicitDomain(): BoxedDomain | undefined;
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;

package/dist/types/compute-engine/boxed-expression/box.d.ts

@@ -1,9 +1,9 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { Decimal } from 'decimal.js';
 import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, Rational } from '../public';
 import { MathJsonNumber } from '../../math-json/math-json-format';
 /**
- * **Theory of Operations**
+ * ## THEORY OF OPERATIONS
  *
  * 1/ Boxing does not depend on the numeric mode. The numeric mode could be
  * changed later, but the previously boxed numbers could not be retroactively
@@ -20,7 +20,12 @@ import { MathJsonNumber } from '../../math-json/math-json-format';
  * which is canonical from the start avoid going through an intermediary step
  * with a non-canonical expression.
  *
- * 3/ When implementing an `evaluate()`:
+ * 3/ When boxing (and canonicalizing), if the function is "scoped", a new
+ *    scope is created before the canonicalization, so that any declaration
+ *    are done within that scope. Example of scoped functions include `Block`
+ *    and `Sum`.
+ *
+ * 4/ When implementing an `evaluate()`:
  * - if `bignumPreferred()` all operations should be done in bignum and complex,
  *    otherwise, they should all be done in machine numbers and complex.
  * - if not `complexAllowed()`, return `NaN` if a complex value is encountered

package/dist/types/compute-engine/boxed-expression/boxed-dictionary.d.ts

@@ -1,10 +1,10 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, BoxedSubstitution } from '../public';
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { _BoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedDictionary
  */
-export declare class BoxedDictionary extends AbstractBoxedExpression {
+export declare class BoxedDictionary extends _BoxedExpression {
     private _value;
     private _isCanonical;
     constructor(ce: IComputeEngine, dict: {

package/dist/types/compute-engine/boxed-expression/boxed-domain.d.ts

@@ -1,19 +1,19 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { BoxedDomain, BoxedExpression, BoxedSubstitution, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOptions } from '../public';
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { _BoxedExpression } from './abstract-boxed-expression';
 /**
  * A `_BoxedDomain` is a wrapper around a boxed, canonical, domain expression.
  *
  * If could also be an error, in which case, `isValid` is `false`.
  *
  */
-export declare class _BoxedDomain extends AbstractBoxedExpression implements BoxedDomain {
+export declare class _BoxedDomain extends _BoxedExpression implements BoxedDomain {
     /** The value of a boxed domain is either a string if a domain literal, or a
      * domain constructor function.
      * Since the domains are alway canonicalized when boxed, their value can
      * be represented by a simple array, without the need for extra boxing.
      */
-    _value: DomainExpression<BoxedExpression>;
+    _value: DomainLiteral | DomainExpression<BoxedExpression>;
     private _hash;
     constructor(ce: IComputeEngine, dom: DomainExpression, metadata?: Metadata);
     get isCanonical(): boolean;
@@ -24,7 +24,6 @@ export declare class _BoxedDomain extends AbstractBoxedExpression implements Box
     get literal(): string | null;
     get ctor(): DomainConstructor | null;
     get domainArgs(): (string | BoxedExpression | DomainExpression<BoxedExpression>)[] | null;
-    get domainArg1(): string | BoxedExpression | DomainExpression<BoxedExpression> | null;
     get codomain(): BoxedDomain | null;
     get hash(): number;
     isEqual(rhs: BoxedExpression): boolean;
@@ -48,4 +47,5 @@ export declare function boxDomain(ce: IComputeEngine, dom: BoxedExpression | Dom
 export declare function isDomain(expr: Expression | BoxedExpression | BoxedDomain | DomainExpression): expr is BoxedDomain | DomainExpression;
 export declare function isValidDomain(expr: any): expr is BoxedDomain | DomainExpression;
 /** Return the ancestor domain that is shared by both `a` and `b` */
-export declare function sharedAncestorDomain(a: BoxedDomain, b: BoxedDomain): BoxedDomain;
+export declare function widen(a: BoxedDomain | undefined | null, b: BoxedDomain | undefined | null): BoxedDomain;
+export declare function narrow(a: BoxedDomain | undefined, b: BoxedDomain | undefined): BoxedDomain;

package/dist/types/compute-engine/boxed-expression/boxed-function-definition.d.ts

@@ -1,2 +1,28 @@
-/* 0.15.0 */
+/* 0.16.0 */
+export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
+    engine: IComputeEngine;
+    scope: RuntimeScope;
+    name: string;
+    description?: string | string[];
+    wikidata?: string;
+    threadable: boolean;
+    associative: boolean;
+    commutative: boolean;
+    idempotent: boolean;
+    involution: boolean;
+    pure: boolean;
+    inert: boolean;
+    numeric: boolean;
+    complexity: number;
+    hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    dynamic: boolean;
+    signature: BoxedFunctionSignature;
+    iterator?: (expr: BoxedExpression, start?: number, count?: number) => Iterator<BoxedExpression>;
+    at?: (expr: BoxedExpression, index: number | string) => undefined | BoxedExpression;
+    size?: (expr: BoxedExpression) => number;
+    keys?: (expr: BoxedExpression) => undefined | Iterator<string>;
+    indexOf?: (expr: BoxedExpression, target: BoxedExpression, from?: number) => number | string | undefined;
+    constructor(ce: IComputeEngine, name: string, def: FunctionDefinition);
+    reset(): void;
+}
 export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: FunctionDefinition | BoxedFunctionDefinition): BoxedFunctionDefinition;

package/dist/types/compute-engine/boxed-expression/boxed-function.d.ts

@@ -1,28 +1,23 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition } from '../public';
 /**
  * BoxedFunction
  */
-export declare class BoxedFunction extends AbstractBoxedExpression {
-    private _scope;
+export declare class BoxedFunction extends _BoxedExpression {
     private readonly _head;
     private readonly _ops;
     private _canonical;
+    private _scope;
     private _def;
     private _isPure;
-    /** The domain of the value of the function applied to its arguments */
     private _codomain;
-    /** The cached values of applying the tail to the head.
-     * If the function is not pure, it is never cached.
-     */
     private _value;
     private _numericValue;
     private _hash;
     constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], options?: {
         metadata?: Metadata;
         canonical?: boolean;
-        def?: BoxedFunctionDefinition;
     });
     get hash(): number;
     get isCanonical(): boolean;
@@ -48,13 +43,11 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     /** `isSame` is structural/symbolic equality */
     isSame(rhs: BoxedExpression): boolean;
     match(rhs: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    unbind(): void;
-    get wikidata(): string | undefined;
-    get description(): string[] | undefined;
-    get url(): string | undefined;
     get complexity(): number | undefined;
+    get baseDefinition(): BoxedBaseDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    bind(_scope: RuntimeScope | null): void;
+    bind(_scope?: RuntimeScope | null): void;
+    unbind(): void;
     get value(): BoxedExpression | undefined;
     /** `isEqual` is mathematical equality */
     isEqual(rhs: BoxedExpression): boolean;
@@ -86,11 +79,6 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     solve(vars: string[]): null | BoxedExpression[];
 }
 export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
-/** Apply arguments to an expression. If the expression is a lambda expression
- * its wildcard arguments are substituted before being evaluated. Otherwise
- * the expression is just evaluated.
- */
-export declare function apply(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;
 /** Apply the function `f` to elements of `xs`, except to the elements
  * described by `skip`:
  * - `all`: don't apply f to any elements

package/dist/types/compute-engine/boxed-expression/boxed-number.d.ts

@@ -1,12 +1,12 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, Rational, SimplifyOptions, BoxedSubstitution } from '../public';
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { _BoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedNumber
  */
-export declare class BoxedNumber extends AbstractBoxedExpression {
+export declare class BoxedNumber extends _BoxedExpression {
     protected readonly _value: number | Decimal | Complex | Rational;
     private _domain;
     private _hash;

package/dist/types/compute-engine/boxed-expression/boxed-patterns.d.ts

@@ -1,7 +1,7 @@
-/* 0.15.0 */
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/* 0.16.0 */
+import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedSubstitution, BoxedDomain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOptions, SemiBoxedExpression, Substitution } from '../public';
-export declare class BoxedPattern extends AbstractBoxedExpression implements Pattern {
+export declare class BoxedPattern extends _BoxedExpression implements Pattern {
     _pattern: BoxedExpression;
     constructor(ce: IComputeEngine, pattern: LatexString | SemiBoxedExpression, metadata?: Metadata);
     get hash(): number;

package/dist/types/compute-engine/boxed-expression/boxed-string.d.ts

@@ -1,10 +1,10 @@
-/* 0.15.0 */
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/* 0.16.0 */
+import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution } from '../public';
 /**
  * BoxedString
  */
-export declare class BoxedString extends AbstractBoxedExpression {
+export declare class BoxedString extends _BoxedExpression {
     private readonly _string;
     constructor(ce: IComputeEngine, expr: string, metadata?: Metadata);
     get hash(): number;

package/dist/types/compute-engine/boxed-expression/boxed-symbol-definition.d.ts

@@ -1,6 +1,6 @@
-/* 0.15.0 */
+/* 0.16.0 */
 /**
- * THEORY OF OPERATIONS
+ * ## THEORY OF OPERATIONS
  *
  * - The value or domain of a constant cannot be changed.
  * - If set explicitly, the value is the source of truth: it overrides any
@@ -18,24 +18,25 @@
  * Otherwise, the stored flags are (the stored flags are also set when the domain is changed)
  *
  */
-export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition {
+export declare class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
     readonly name: string;
-    readonly wikidata?: string;
-    readonly description?: string | string[];
-    readonly url?: string;
+    wikidata?: string;
+    description?: string | string[];
+    url?: string;
     private _engine;
     readonly scope: RuntimeScope | undefined;
     private _defValue?;
     private _value;
     private _domain;
+    inferredDomain: boolean;
     private _flags;
-    readonly constant: boolean;
-    readonly holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
-    private _at;
-    at?: (index: string | number) => undefined | BoxedExpression;
+    constant: boolean;
+    holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
     prototype?: BoxedFunctionDefinition;
     self?: unknown;
     constructor(ce: IComputeEngine, name: string, def: SymbolDefinition);
+    /** The symbol was previously inferred, but now it has a declaration. Update the def accordingly (we can't replace defs, as other expressions may be referencing them) */
+    update(def: SymbolDefinition): void;
     reset(): void;
     get value(): BoxedExpression | undefined;
     set value(val: SemiBoxedExpression | number | undefined);

package/dist/types/compute-engine/boxed-expression/boxed-symbol.d.ts

@@ -1,6 +1,8 @@
-/* 0.15.0 */
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/* 0.16.0 */
+import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution } from '../public';
+import Complex from 'complex.js';
+import Decimal from 'decimal.js';
 /**
  * BoxedSymbol
  *
@@ -14,7 +16,7 @@ import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, E
  * not a function expression, i.e. `Sin`, not `["Sin", "Pi"]`. This is used
  * for example in `["InverseFunction", "Sin"]`
  */
-export declare class BoxedSymbol extends AbstractBoxedExpression {
+export declare class BoxedSymbol extends _BoxedExpression {
     private _scope;
     protected _name: string;
     private _hash;
@@ -29,15 +31,10 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     get isPure(): boolean;
     get json(): Expression;
     get scope(): RuntimeScope | null;
-    /** A free variable either has no definition, or it has a definition, but no value */
-    get isFree(): boolean;
     get isConstant(): boolean;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get canonical(): BoxedExpression;
-    get wikidata(): string | undefined;
-    get description(): string[] | undefined;
-    get url(): string | undefined;
     get complexity(): number;
     get head(): string;
     get symbol(): string;
@@ -45,12 +42,21 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    bind(scope: RuntimeScope | null): void;
+    /**
+     * Subsequence inferences will narrow the domain of the symbol.
+     * f(:integer), g(:real)
+     * g(x) => x:real
+     * f(x) => x:integer narrowed from integer to real
+     */
+    infer(domain: BoxedDomain): boolean;
+    /**
+     * Associate a definition with this symbol, if one is not already available
+     */
+    bind(scope?: RuntimeScope | null): void;
     get value(): BoxedExpression | undefined;
-    set value(value: BoxedExpression | number | undefined);
+    set value(value: boolean | string | Decimal | Complex | [num: number, denom: number] | BoxedExpression | number | undefined);
     get domain(): BoxedDomain;
     set domain(inDomain: BoxedExpression | DomainExpression | BoxedDomain);
-    get explicitDomain(): BoxedDomain | undefined;
     get sgn(): -1 | 0 | 1 | undefined | null;
     has(x: string | string[]): boolean;
     isSame(rhs: BoxedExpression): boolean;

package/dist/types/compute-engine/boxed-expression/expression-map.d.ts

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

package/dist/types/compute-engine/boxed-expression/order.d.ts

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

package/dist/types/compute-engine/boxed-expression/serialize.d.ts

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata, Rational } from '../public';

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine } from '../public';
 export declare function isLatexString(s: unknown): s is string;
@@ -12,15 +12,36 @@ export declare function latexString(s: unknown): string | null;
  * - ['Multiply', 'ImaginaryUnit', 5]
  */
 export declare function getImaginaryCoef(expr: BoxedExpression): number | null;
+export declare function getSymbols(expr: BoxedExpression, result: Set<string>): void;
 /**
- * Return the free symbols in the expression, recursively.
- * A variable, or free symbol, is a symbol that is not bound to a value.
- * Note: do not use `isFree`: it has a side effect of creating a definition
- * if one does not exist, and we want to avoid that. For example, `assume()`
- * relies on `expr.freeVars` *not* creating a definition.
- */
-export declare function getFreeVars(expr: BoxedExpression, set: Set<string>): void;
-export declare function getSymbols(expr: BoxedExpression, set: Set<string>): void;
+ * Return the unknowns in the expression, recursively.
+ *
+ * An unknown is an identifier (symbol or function) that is not bound
+ * to a value.
+ *
+ */
+export declare function getUnknowns(expr: BoxedExpression, result: Set<string>): void;
+/**
+ * Return the free variables (non local variable) in the expression,
+ * recursively.
+ *
+ * A free variable is an identifier that is not an argument to a function,
+ * or a local variable.
+ *
+ */
+export declare function getFreeVariables(expr: BoxedExpression, result: Set<string>): void;
+/** Return the local variables in the expression.
+ *
+ * A local variable is an identifier that is declared with a `Declare`
+ * expression in a `Block` expression.
+ *
+ * Note that the canonical form of a `Block` expression will hoist all
+ * `Declare` expressions to the top of the block. `Assign` expressions
+ * of undeclared variables will also have a matching `Declare` expressions
+ * hoisted.
+ *
+ */
+export declare function getLocalVariables(expr: BoxedExpression, result: Set<string>): void;
 export declare function getSubexpressions(expr: BoxedExpression, head: string): BoxedExpression[];
 /**
  * For any numeric result, if `bignumPreferred()` is true, calculate using

package/dist/types/compute-engine/boxed-expression/validate.d.ts

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 export declare function validateArgumentCount(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
 /**
  * Validation of arguments is normally done by checking the signature of the

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.16.0 */
 export type CompiledType = boolean | number | string | object;
 /** This is an extension of the Function class that allows us to pass
  * a custom scope for "global" functions. */