Skip to content
Symi Docs
WASM / JavaScript

Signatures in the WASM / JavaScript view are TypeScript. Where the JavaScript facade wraps an operation its form is listed first; the other calling forms are the raw wasm-bindgen exports.

On this page

Assumptions

Assumptions are typed, canonical propositions over scalar expressions. They are kept separately from the legacy per-symbol compatibility record, so compound Boolean formulas and immutable local scopes do not lose information.

Queries are three-valued: True means entailed, False means refuted, and None / undefined means that the bounded symbolic engine cannot decide. could_hold is a possibility query and may return true when ask is unknown.

A result keeps the facts it was derived under: the durable assumptions, local scope, or constraint its operation ran against, together with the facts its operands were derived under. Clearing or replacing an assumption later does not change what an earlier result means. Combining results whose facts contradict each other — x refined under x > 0 and -x refined under x < 0, for example — declines with an assumption conflict rather than producing a value no input could satisfy, and so does substituting a value that refutes one of those facts.

The retained facts describe when the returned object is valid, not how it was written: sqrt(x^2) refined under x > 0 returns x, and that x stays qualified by x > 0 even though a freshly built x is the same expression. The facts stay attached when their symbols disappear from the result — signum(x) refined under x > 0 is 1, still qualified by x > 0 — so a value of the result is valid only for inputs that satisfy them. They are conservative: a result may carry facts its derivation never consulted, but never omits one it did. A result whose facts were not recorded — from an operation that does not track them, from deserialization, or from a call during which the session's facts changed — is marked as having unknown provenance, which is never the same as having no conditions. Checking supplied values against retained facts never consults the declared assumptions: a fact still declared in the session is not evidence that a value supplied for its symbol satisfies it.

Proposition builders#

real_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.real_assumption in Python, UniffiSession.realAssumption in Kotlin, UniffiSession.realAssumption in Swift, api::Session::real_assumption in Rust.

Build a proposition asserting that an expression is real.

rational_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.rational_assumption in Python, UniffiSession.rationalAssumption in Kotlin, UniffiSession.rationalAssumption in Swift, api::Session::rational_assumption in Rust.

Build a proposition asserting that an expression is rational.

integer_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.integer_assumption in Python, UniffiSession.integerAssumption in Kotlin, UniffiSession.integerAssumption in Swift, api::Session::integer_assumption in Rust.

Build a proposition asserting that an expression is an integer.

natural_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.natural_assumption in Python, UniffiSession.naturalAssumption in Kotlin, UniffiSession.naturalAssumption in Swift, api::Session::natural_assumption in Rust.

Build a proposition asserting that an expression is a natural number.

positive_integer_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.positive_integer_assumption in Python, UniffiSession.positiveIntegerAssumption in Kotlin, UniffiSession.positiveIntegerAssumption in Swift, api::Session::positive_integer_assumption in Rust.

Build a proposition asserting that an expression is a positive integer.

positive_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.positive_assumption in Python, UniffiSession.positiveAssumption in Kotlin, UniffiSession.positiveAssumption in Swift, api::Session::positive_assumption in Rust.

Build a proposition asserting that an expression is strictly positive.

negative_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.negative_assumption in Python, UniffiSession.negativeAssumption in Kotlin, UniffiSession.negativeAssumption in Swift, api::Session::negative_assumption in Rust.

Build a proposition asserting that an expression is strictly negative.

nonzero_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.nonzero_assumption in Python, UniffiSession.nonzeroAssumption in Kotlin, UniffiSession.nonzeroAssumption in Swift, api::Session::nonzero_assumption in Rust.

Build a proposition asserting that an expression is nonzero.

finite_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.finite_assumption in Python, UniffiSession.finiteAssumption in Kotlin, UniffiSession.finiteAssumption in Swift, api::Session::finite_assumption in Rust.

Build a proposition asserting that an expression is finite.

complex_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.complex_assumption in Python, UniffiSession.complexAssumption in Kotlin, UniffiSession.complexAssumption in Swift, api::Session::complex_assumption in Rust.

Build a proposition asserting that an expression is a finite complex number.

extended_real_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.extended_real_assumption in Python, UniffiSession.extendedRealAssumption in Kotlin, UniffiSession.extendedRealAssumption in Swift, api::Session::extended_real_assumption in Rust.

Build a proposition asserting that an expression is an extended real, including signed infinity.

infinite_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.infinite_assumption in Python, UniffiSession.infiniteAssumption in Kotlin, UniffiSession.infiniteAssumption in Swift, api::Session::infinite_assumption in Rust.

Build a proposition asserting that an expression is one of the two signed infinities.

irrational_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.irrational_assumption in Python, UniffiSession.irrationalAssumption in Kotlin, UniffiSession.irrationalAssumption in Swift, api::Session::irrational_assumption in Rust.

Build a proposition asserting that an expression is real and not rational.

zero_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.zero_assumption in Python, UniffiSession.zeroAssumption in Kotlin, UniffiSession.zeroAssumption in Swift, api::Session::zero_assumption in Rust.

Build a proposition asserting that an expression is exactly zero.

even_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.even_assumption in Python, UniffiSession.evenAssumption in Kotlin, UniffiSession.evenAssumption in Swift, api::Session::even_assumption in Rust.

Build a proposition asserting that an expression is an even integer.

odd_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.odd_assumption in Python, UniffiSession.oddAssumption in Kotlin, UniffiSession.oddAssumption in Swift, api::Session::odd_assumption in Rust.

Build a proposition asserting that an expression is an odd integer.

prime_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.prime_assumption in Python, UniffiSession.primeAssumption in Kotlin, UniffiSession.primeAssumption in Swift, api::Session::prime_assumption in Rust.

Build a proposition asserting that an expression is a proven ordinary prime integer.

composite_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.composite_assumption in Python, UniffiSession.compositeAssumption in Kotlin, UniffiSession.compositeAssumption in Swift, api::Session::composite_assumption in Rust.

Build a proposition asserting that an expression is a proven ordinary composite integer.

algebraic_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.algebraic_assumption in Python, UniffiSession.algebraicAssumption in Kotlin, UniffiSession.algebraicAssumption in Swift, api::Session::algebraic_assumption in Rust.

Build a proposition asserting that an expression is algebraic over the rationals.

transcendental_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.transcendental_assumption in Python, UniffiSession.transcendentalAssumption in Kotlin, UniffiSession.transcendentalAssumption in Swift, api::Session::transcendental_assumption in Rust.

Build a proposition asserting that an expression is transcendental over the rationals.

defined_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.defined_assumption in Python, UniffiSession.definedAssumption in Kotlin, UniffiSession.definedAssumption in Swift, api::Session::defined_assumption in Rust.

Build a proposition asserting that an expression denotes one scalar value at the active point. Its negation asserts that the expression is undefined there; definedness alone authorizes no value, finiteness, realness, sign, continuity, or analyticity.

equal_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.equal_assumption in Python, UniffiSession.equalAssumption in Kotlin, UniffiSession.equalAssumption in Swift, api::defaults::Session::equal_assumption in Rust.

Build a defined scalar equality proposition.

not_equal_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.not_equal_assumption in Python, UniffiSession.notEqualAssumption in Kotlin, UniffiSession.notEqualAssumption in Swift, api::defaults::Session::not_equal_assumption in Rust.

Build a defined scalar disequality proposition.

less_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.less_assumption in Python, UniffiSession.lessAssumption in Kotlin, UniffiSession.lessAssumption in Swift, api::defaults::Session::less_assumption in Rust.

Build a strict extended-real order proposition.

less_or_equal_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.less_or_equal_assumption in Python, UniffiSession.lessOrEqualAssumption in Kotlin, UniffiSession.lessOrEqualAssumption in Swift, api::defaults::Session::less_or_equal_assumption in Rust.

Build a non-strict extended-real order proposition.

greater_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.greater_assumption in Python, UniffiSession.greaterAssumption in Kotlin, UniffiSession.greaterAssumption in Swift, api::defaults::Session::greater_assumption in Rust.

Build a strict extended-real order proposition by reversing its operands canonically.

greater_or_equal_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.greater_or_equal_assumption in Python, UniffiSession.greaterOrEqualAssumption in Kotlin, UniffiSession.greaterOrEqualAssumption in Swift, api::defaults::Session::greater_or_equal_assumption in Rust.

Build a non-strict extended-real order proposition by reversing its operands canonically.

member_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.member_assumption in Python, UniffiSession.memberAssumption in Kotlin, UniffiSession.memberAssumption in Swift, api::defaults::Session::member_assumption in Rust.

Build a scalar-membership proposition.

congruent_assumption#

Not exposed by the WASM / JavaScript bindings. Available as Context.congruent_assumption in Python, UniffiSession.congruentAssumption in Kotlin, UniffiSession.congruentAssumption in Swift, api::defaults::Session::congruent_assumption in Rust.

Build an integer-congruence proposition with a positive integer modulus.

assumption_equal#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_equal in Rust.

Construct an equality proposition over two scalar expressions.

assumption_not_equal#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_not_equal in Rust.

Construct a disequality proposition over two scalar expressions.

assumption_less#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_less in Rust.

Construct a strict scalar-order proposition.

assumption_less_or_equal#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_less_or_equal in Rust.

Construct a non-strict scalar-order proposition.

assumption_greater#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_greater in Rust.

Construct a strict scalar-order proposition with reversed operands.

assumption_greater_or_equal#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_greater_or_equal in Rust.

Construct a non-strict scalar-order proposition with reversed operands.

assumption_member#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_member in Rust.

Construct a scalar-membership proposition.

assumption_congruent#

Not exposed by the WASM / JavaScript bindings. Available as api::Session::assumption_congruent in Rust.

Construct an integer congruence proposition.

assumption_proposition_from_logical_expression#

Not exposed by the WASM / JavaScript bindings. Available as Context.assumption_proposition_from_logical_expression in Python, UniffiSession.assumptionPropositionFromLogicalExpression in Kotlin, UniffiSession.assumptionPropositionFromLogicalExpression in Swift, api::Session::assumption_proposition_from_logical_expression in Rust.

Convert a supported Boolean relation expression into a typed assumption proposition.

Matrix proposition builders#

Matrix propositions use an immutable, context-owned snapshot of the matrix. They return the same three-valued results as scalar assumptions and reject matrices from another context or an earlier context generation. matrix_shape additionally records the required dimensions in the canonical formula and serialization.

matrix_shape#

Build a proposition asserting that a matrix has the requested positive row and column counts.

square_matrix#

Build a proposition asserting that a matrix is square.

zero_matrix#

Build a proposition asserting that every matrix entry is zero.

identity_matrix#

Build a proposition asserting that a matrix is an identity matrix.

diagonal_matrix#

Build a proposition asserting that a matrix is diagonal.

upper_triangular_matrix#

Build a proposition asserting that a matrix is upper triangular.

lower_triangular_matrix#

Build a proposition asserting that a matrix is lower triangular.

symmetric_matrix#

Build a proposition asserting that a matrix equals its transpose.

hermitian_matrix#

Build a proposition asserting that a matrix equals its conjugate transpose.

orthogonal_matrix#

Build a proposition asserting that a real square matrix is orthogonal.

unitary_matrix#

Build a proposition asserting that a square matrix is unitary.

normal_matrix#

Build a proposition asserting that a square matrix commutes with its conjugate transpose.

full_rank_matrix#

Build a proposition asserting that a matrix has full rank.

invertible_matrix#

Build a proposition asserting that a matrix is square and invertible.

singular_matrix#

Build a proposition asserting that a matrix is square and singular.

integer_entries#

Build a proposition asserting that every matrix entry is an integer.

real_entries#

Build a proposition asserting that every matrix entry is real.

complex_entries#

Build a proposition asserting that every matrix entry is a finite complex value.

positive_definite_matrix#

Build a proposition asserting that a matrix is positive definite under the engine's exact Hermitian/real-domain convention.

positive_semidefinite_matrix#

Build a proposition asserting that a matrix is positive semidefinite under the engine's exact Hermitian/real-domain convention.

Scalar classification#

natural includes zero. positive and negative include the matching signed infinity; zero is finite zero, and nonzero includes non-real finite complex values and signed infinities. nonnegative and nonpositive are universe-guarded extended-real propositions; a bare negated sign does not establish either one. Prime and composite are not complements: negative integers, zero, and one are neither.

Primality is exact and proof-producing. A probable-prime screening result is deliberately unknown and is never exposed as a symbolic prime fact.

Proposition objects#

assumption_proposition#

An immutable, context-owned Boolean assumption formula.

and#

Conjoin two propositions and return a canonical proposition.

AssumptionProposition method

and(other: AssumptionProposition): AssumptionProposition

Conjoin two propositions.

Calling forms

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.and

and(other: AssumptionProposition): AssumptionProposition

or#

Disjoin two propositions and return a canonical proposition.

AssumptionProposition method

or(other: AssumptionProposition): AssumptionProposition

Disjoin two propositions.

Calling forms

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.or

or(other: AssumptionProposition): AssumptionProposition

not#

Negate a proposition and return a canonical proposition.

AssumptionProposition method

not(): AssumptionProposition

Negate a proposition in canonical negation-normal form.

Calling forms

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.not

not(): AssumptionProposition

relation_kind#

Not exposed by the WASM / JavaScript bindings. Available as AssumptionProposition.relation_kind in Python, UniffiAssumptionProposition.relationKind in Kotlin, UniffiAssumptionProposition.relationKind in Swift, api::AssumptionProposition::relation_kind in Rust.

Return the canonical relation kind for a relation atom.

left_operand#

Not exposed by the WASM / JavaScript bindings. Available as AssumptionProposition.left_operand in Python, UniffiAssumptionProposition.leftOperand in Kotlin, UniffiAssumptionProposition.leftOperand in Swift, api::AssumptionProposition::left_operand in Rust.

Return the left relation or congruence operand when present.

right_operand#

Not exposed by the WASM / JavaScript bindings. Available as AssumptionProposition.right_operand in Python, UniffiAssumptionProposition.rightOperand in Kotlin, UniffiAssumptionProposition.rightOperand in Swift, api::AssumptionProposition::right_operand in Rust.

Return the right relation or congruence operand when present.

membership_element#

Not exposed by the WASM / JavaScript bindings. Available as AssumptionProposition.membership_element in Python, UniffiAssumptionProposition.membershipElement in Kotlin, UniffiAssumptionProposition.membershipElement in Swift, api::AssumptionProposition::membership_element in Rust.

Return the membership element when present.

membership_set#

Not exposed by the WASM / JavaScript bindings. Available as AssumptionProposition.membership_set in Python, UniffiAssumptionProposition.membershipSet in Kotlin, UniffiAssumptionProposition.membershipSet in Swift, api::AssumptionProposition::membership_set in Rust.

Return the membership set expression when present.

congruence_modulus#

Not exposed by the WASM / JavaScript bindings. Available as AssumptionProposition.congruence_modulus in Python, UniffiAssumptionProposition.congruenceModulus in Kotlin, UniffiAssumptionProposition.congruenceModulus in Swift, api::AssumptionProposition::congruence_modulus in Rust.

Return the congruence modulus when present.

serialize#

Serialize a proposition in the versioned canonical formula grammar.

Raw WebAssembly: Default context

serialize(proposition: AssumptionProposition): string

Serialize an assumption proposition in the versioned canonical grammar.

Calling forms

AssumptionProposition method: AssumptionProposition.serialize

serialize(): string

SymiFacade method: SymiFacade.serialize

serialize(proposition: AssumptionProposition): string

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.serialize

serialize(): string

deserialize_assumption_proposition#

Not exposed by the WASM / JavaScript bindings. Available as Context.deserialize_assumption_proposition in Python, UniffiSession.deserializeAssumptionProposition in Kotlin, UniffiSession.deserializeAssumptionProposition in Swift, api::Session::deserialize_assumption_proposition in Rust.

Parse a versioned canonical assumption proposition in the receiving context.

Durable contexts and scopes#

add_assumptions#

Not exposed by the WASM / JavaScript bindings. Available as Context.add_assumptions in Python, UniffiSession.addAssumptions in Kotlin, UniffiSession.addAssumptions in Swift, api::Session::add_assumptions in Rust.

Atomically add a proposition to the durable assumption context. Contradictory updates are rejected without changing the prior state.

clear_all_assumptions#

Not exposed by the WASM / JavaScript bindings. Available as Context.clear_all_assumptions in Python, UniffiSession.clearAllAssumptions in Kotlin, UniffiSession.clearAllAssumptions in Swift, api::Session::clear_all_assumptions in Rust.

Clear both durable formulas and legacy symbol assumptions.

ask#

Raw WebAssembly: Default context

ask(proposition: AssumptionProposition): boolean | undefined
Calling forms and variants

Explicit context: Context.ask

ask(proposition: AssumptionProposition): boolean | null

Raw WebAssembly: Explicit context: Context.ask

ask(proposition: AssumptionProposition): boolean | undefined

SymiFacade method: SymiFacade.ask

ask(proposition: AssumptionProposition): boolean | null

Variant using local assumptions — AssumptionScope method: AssumptionScope.ask

ask(proposition: AssumptionProposition): boolean | null

Variant using local assumptions — Raw WebAssembly: AssumptionScope method: AssumptionScope.ask

ask(proposition: AssumptionProposition): boolean | undefined

Return whether a proposition is entailed by the current durable context.

could_hold#

Raw WebAssembly: Default context

couldHold(proposition: AssumptionProposition): boolean | undefined
Calling forms and variants

Explicit context: Context.couldHold

couldHold(proposition: AssumptionProposition): boolean | null

Raw WebAssembly: Explicit context: Context.couldHold

couldHold(proposition: AssumptionProposition): boolean | undefined

SymiFacade method: SymiFacade.couldHold

couldHold(proposition: AssumptionProposition): boolean | null

Variant using local assumptions — AssumptionScope method: AssumptionScope.couldHold

couldHold(proposition: AssumptionProposition): boolean | null

Variant using local assumptions — Raw WebAssembly: AssumptionScope method: AssumptionScope.couldHold

couldHold(proposition: AssumptionProposition): boolean | undefined

Return whether the current durable context is compatible with a proposition.

assuming#

Raw WebAssembly: Default context

assuming(proposition: AssumptionProposition): AssumptionScope
Calling forms and variants

Explicit context: Context.assuming

assuming(proposition: AssumptionProposition): AssumptionScope

Raw WebAssembly: Explicit context: Context.assuming

assuming(proposition: AssumptionProposition): AssumptionScope

SymiFacade method: SymiFacade.assuming

assuming(proposition: AssumptionProposition): AssumptionScope

Variant using local assumptions — AssumptionScope method: AssumptionScope.assuming

assuming(proposition: AssumptionProposition): AssumptionScope

Variant using local assumptions — Raw WebAssembly: AssumptionScope method: AssumptionScope.assuming

assuming(proposition: AssumptionProposition): AssumptionScope

Create an immutable local scope by overlaying a proposition. The overlay does not change the owning context.

assumption_scope#

An immutable local assumption scope. Its scope-aware operations—simplify, refine, integrate, integrate_definite, evaluate_limit, taylor_series, laplace_transform, fourier_transform, singularities, and continuous_domain—execute through the captured assumptions without mutating the owning context. Each one asks the same shared assumption session that the durable entry points use, so a compound or relational fact reaches them exactly as a per-symbol declaration does. If an assumption cannot be checked for the requested operation, the operation keeps its ordinary unevaluated or declined result rather than guessing a branch. Each of those operations is documented with its subject — integrate on Calculus, for instance — as an explicitly labelled variant that runs under local assumptions, not as an alias of the durable form.

refine#

Raw WebAssembly: Default context

refine(
    input_expression: Expression,
    assumptions?: AssumptionProposition | null,
): Expression
Calling forms and variants

Explicit context: Context.refine

refine(value: ExpressionLike, assumptions?: AssumptionProposition | null): Expression

Raw WebAssembly: Explicit context: Context.refine

refine(
    input_expression: Expression,
    assumptions?: AssumptionProposition | null,
): Expression

SymiFacade method: SymiFacade.refine

refine(value: ExpressionLike, assumptions?: AssumptionProposition | null): Expression

Expression method: Expression.refine

refine(assumptions?: AssumptionProposition | null): Expression

Raw WebAssembly: Expression method: Expression.refine

refine(assumptions?: AssumptionProposition | null): Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.refine

refine(value: ExpressionLike): Expression

Variant using local assumptions — Raw WebAssembly: AssumptionScope method: AssumptionScope.refine

refine(input_expression: Expression): Expression

Simplify an expression using durable assumptions or one checked local proposition.

Additional API#

addAssumptions#

Raw WebAssembly: Default context

addAssumptions(proposition: AssumptionProposition): void

Add a proposition to the default context's durable assumption store.

Calling forms

Explicit context: Context.addAssumptions

addAssumptions(proposition: AssumptionProposition): void

Raw WebAssembly: Explicit context: Context.addAssumptions

addAssumptions(proposition: AssumptionProposition): void

SymiFacade method: SymiFacade.addAssumptions

addAssumptions(proposition: AssumptionProposition): void

algebraicAssumption#

Raw WebAssembly: Default context

algebraicAssumption(subject: Expression): AssumptionProposition

Build an algebraicity assumption proposition in the default context.

Calling forms

Explicit context: Context.algebraicAssumption

algebraicAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.algebraicAssumption

algebraicAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.algebraicAssumption

algebraicAssumption(value: ExpressionLike): AssumptionProposition

assumptionPropositionFromLogicalExpression#

Raw WebAssembly: Default context

assumptionPropositionFromLogicalExpression(logical_expression: Expression): AssumptionProposition

Convert a supported logical expression to a typed assumption proposition in the default context.

Calling forms

Explicit context: Context.assumptionPropositionFromLogicalExpression

assumptionPropositionFromLogicalExpression(logicalExpression: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.assumptionPropositionFromLogicalExpression

assumptionPropositionFromLogicalExpression(logical_expression: Expression): AssumptionProposition

SymiFacade method: SymiFacade.assumptionPropositionFromLogicalExpression

assumptionPropositionFromLogicalExpression(logicalExpression: ExpressionLike): AssumptionProposition

clearAllAssumptions#

Raw WebAssembly: Default context

clearAllAssumptions(): void

Clear all assumptions in the default context.

Calling forms

Explicit context: Context.clearAllAssumptions

clearAllAssumptions(): void

Raw WebAssembly: Explicit context: Context.clearAllAssumptions

clearAllAssumptions(): void

SymiFacade method: SymiFacade.clearAllAssumptions

clearAllAssumptions(): void

complexAssumption#

Raw WebAssembly: Default context

complexAssumption(subject: Expression): AssumptionProposition

Build a finite-complex assumption proposition in the default context.

Calling forms

Explicit context: Context.complexAssumption

complexAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.complexAssumption

complexAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.complexAssumption

complexAssumption(value: ExpressionLike): AssumptionProposition

compositeAssumption#

Raw WebAssembly: Default context

compositeAssumption(subject: Expression): AssumptionProposition

Build a compositeness assumption proposition in the default context.

Calling forms

Explicit context: Context.compositeAssumption

compositeAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.compositeAssumption

compositeAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.compositeAssumption

compositeAssumption(value: ExpressionLike): AssumptionProposition

congruentAssumption#

Raw WebAssembly: Default context

congruentAssumption(
    left: Expression,
    right: Expression,
    modulus: Expression,
): AssumptionProposition

Build an integer-congruence assumption proposition in the default context.

Calling forms

Explicit context: Context.congruentAssumption

congruentAssumption(left: ExpressionLike, right: ExpressionLike, modulus: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.congruentAssumption

congruentAssumption(
    left: Expression,
    right: Expression,
    modulus: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.congruentAssumption

congruentAssumption(left: ExpressionLike, right: ExpressionLike, modulus: ExpressionLike): AssumptionProposition

definedAssumption#

Raw WebAssembly: Default context

definedAssumption(subject: Expression): AssumptionProposition

Build a pointwise definedness assumption proposition in the default context.

Calling forms

Explicit context: Context.definedAssumption

definedAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.definedAssumption

definedAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.definedAssumption

definedAssumption(value: ExpressionLike): AssumptionProposition

deserializeAssumptionProposition#

Raw WebAssembly: Default context

deserializeAssumptionProposition(text: string): AssumptionProposition

Parse a versioned canonical assumption proposition in the default context.

Calling forms

Explicit context: Context.deserializeAssumptionProposition

deserializeAssumptionProposition(text: string): AssumptionProposition

Raw WebAssembly: Explicit context: Context.deserializeAssumptionProposition

deserializeAssumptionProposition(text: string): AssumptionProposition

SymiFacade method: SymiFacade.deserializeAssumptionProposition

deserializeAssumptionProposition(text: string): AssumptionProposition

equalAssumption#

Raw WebAssembly: Default context

equalAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

Build an equality assumption proposition in the default context.

Calling forms

Explicit context: Context.equalAssumption

equalAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.equalAssumption

equalAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.equalAssumption

equalAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

evenAssumption#

Raw WebAssembly: Default context

evenAssumption(subject: Expression): AssumptionProposition

Build an evenness assumption proposition in the default context.

Calling forms

Explicit context: Context.evenAssumption

evenAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.evenAssumption

evenAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.evenAssumption

evenAssumption(value: ExpressionLike): AssumptionProposition

extendedRealAssumption#

Raw WebAssembly: Default context

extendedRealAssumption(subject: Expression): AssumptionProposition

Build an extended-real assumption proposition in the default context.

Calling forms

Explicit context: Context.extendedRealAssumption

extendedRealAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.extendedRealAssumption

extendedRealAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.extendedRealAssumption

extendedRealAssumption(value: ExpressionLike): AssumptionProposition

finiteAssumption#

Raw WebAssembly: Default context

finiteAssumption(subject: Expression): AssumptionProposition

Build a finiteness assumption proposition in the default context.

Calling forms

Explicit context: Context.finiteAssumption

finiteAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.finiteAssumption

finiteAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.finiteAssumption

finiteAssumption(value: ExpressionLike): AssumptionProposition

greaterAssumption#

Raw WebAssembly: Default context

greaterAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

Build a strict scalar-order assumption proposition with reversed operands in the default context.

Calling forms

Explicit context: Context.greaterAssumption

greaterAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.greaterAssumption

greaterAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.greaterAssumption

greaterAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

greaterOrEqualAssumption#

Raw WebAssembly: Default context

greaterOrEqualAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

Build a non-strict scalar-order assumption proposition with reversed operands in the default context.

Calling forms

Explicit context: Context.greaterOrEqualAssumption

greaterOrEqualAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.greaterOrEqualAssumption

greaterOrEqualAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.greaterOrEqualAssumption

greaterOrEqualAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

infiniteAssumption#

Raw WebAssembly: Default context

infiniteAssumption(subject: Expression): AssumptionProposition

Build an infinity assumption proposition in the default context.

Calling forms

Explicit context: Context.infiniteAssumption

infiniteAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.infiniteAssumption

infiniteAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.infiniteAssumption

infiniteAssumption(value: ExpressionLike): AssumptionProposition

integerAssumption#

Raw WebAssembly: Default context

integerAssumption(subject: Expression): AssumptionProposition

Build an integer assumption proposition in the default context.

Calling forms

Explicit context: Context.integerAssumption

integerAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.integerAssumption

integerAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.integerAssumption

integerAssumption(value: ExpressionLike): AssumptionProposition

irrationalAssumption#

Raw WebAssembly: Default context

irrationalAssumption(subject: Expression): AssumptionProposition

Build an irrationality assumption proposition in the default context.

Calling forms

Explicit context: Context.irrationalAssumption

irrationalAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.irrationalAssumption

irrationalAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.irrationalAssumption

irrationalAssumption(value: ExpressionLike): AssumptionProposition

lessAssumption#

Raw WebAssembly: Default context

lessAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

Build a strict scalar-order assumption proposition in the default context.

Calling forms

Explicit context: Context.lessAssumption

lessAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.lessAssumption

lessAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.lessAssumption

lessAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

lessOrEqualAssumption#

Raw WebAssembly: Default context

lessOrEqualAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

Build a non-strict scalar-order assumption proposition in the default context.

Calling forms

Explicit context: Context.lessOrEqualAssumption

lessOrEqualAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.lessOrEqualAssumption

lessOrEqualAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.lessOrEqualAssumption

lessOrEqualAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

memberAssumption#

Raw WebAssembly: Default context

memberAssumption(
    element: Expression,
    set_expression: Expression,
): AssumptionProposition

Build a scalar-membership assumption proposition in the default context.

Calling forms

Explicit context: Context.memberAssumption

memberAssumption(element: ExpressionLike, setExpression: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.memberAssumption

memberAssumption(
    element: Expression,
    set_expression: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.memberAssumption

memberAssumption(element: ExpressionLike, setExpression: ExpressionLike): AssumptionProposition

naturalAssumption#

Raw WebAssembly: Default context

naturalAssumption(subject: Expression): AssumptionProposition

Build a natural-number assumption proposition in the default context.

Calling forms

Explicit context: Context.naturalAssumption

naturalAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.naturalAssumption

naturalAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.naturalAssumption

naturalAssumption(value: ExpressionLike): AssumptionProposition

negativeAssumption#

Raw WebAssembly: Default context

negativeAssumption(subject: Expression): AssumptionProposition

Build a strict-negativity assumption proposition in the default context.

Calling forms

Explicit context: Context.negativeAssumption

negativeAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.negativeAssumption

negativeAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.negativeAssumption

negativeAssumption(value: ExpressionLike): AssumptionProposition

nonnegativeAssumption#

Raw WebAssembly: Default context

nonnegativeAssumption(subject: Expression): AssumptionProposition

Build a universe-guarded nonnegative assumption proposition in the default context.

Calling forms

Explicit context: Context.nonnegativeAssumption

nonnegativeAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.nonnegativeAssumption

nonnegativeAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.nonnegativeAssumption

nonnegativeAssumption(value: ExpressionLike): AssumptionProposition

nonpositiveAssumption#

Raw WebAssembly: Default context

nonpositiveAssumption(subject: Expression): AssumptionProposition

Build a universe-guarded nonpositive assumption proposition in the default context.

Calling forms

Explicit context: Context.nonpositiveAssumption

nonpositiveAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.nonpositiveAssumption

nonpositiveAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.nonpositiveAssumption

nonpositiveAssumption(value: ExpressionLike): AssumptionProposition

nonzeroAssumption#

Raw WebAssembly: Default context

nonzeroAssumption(subject: Expression): AssumptionProposition

Build a nonzero assumption proposition in the default context.

Calling forms

Explicit context: Context.nonzeroAssumption

nonzeroAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.nonzeroAssumption

nonzeroAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.nonzeroAssumption

nonzeroAssumption(value: ExpressionLike): AssumptionProposition

notEqualAssumption#

Raw WebAssembly: Default context

notEqualAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

Build a disequality assumption proposition in the default context.

Calling forms

Explicit context: Context.notEqualAssumption

notEqualAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.notEqualAssumption

notEqualAssumption(
    left: Expression,
    right: Expression,
): AssumptionProposition

SymiFacade method: SymiFacade.notEqualAssumption

notEqualAssumption(left: ExpressionLike, right: ExpressionLike): AssumptionProposition

oddAssumption#

Raw WebAssembly: Default context

oddAssumption(subject: Expression): AssumptionProposition

Build an oddness assumption proposition in the default context.

Calling forms

Explicit context: Context.oddAssumption

oddAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.oddAssumption

oddAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.oddAssumption

oddAssumption(value: ExpressionLike): AssumptionProposition

positiveAssumption#

Raw WebAssembly: Default context

positiveAssumption(subject: Expression): AssumptionProposition

Build a strict-positivity assumption proposition in the default context.

Calling forms

Explicit context: Context.positiveAssumption

positiveAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.positiveAssumption

positiveAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.positiveAssumption

positiveAssumption(value: ExpressionLike): AssumptionProposition

positiveIntegerAssumption#

Raw WebAssembly: Default context

positiveIntegerAssumption(subject: Expression): AssumptionProposition

Build a positive-integer assumption proposition in the default context.

Calling forms

Explicit context: Context.positiveIntegerAssumption

positiveIntegerAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.positiveIntegerAssumption

positiveIntegerAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.positiveIntegerAssumption

positiveIntegerAssumption(value: ExpressionLike): AssumptionProposition

primeAssumption#

Raw WebAssembly: Default context

primeAssumption(subject: Expression): AssumptionProposition

Build a primality assumption proposition in the default context.

Calling forms

Explicit context: Context.primeAssumption

primeAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.primeAssumption

primeAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.primeAssumption

primeAssumption(value: ExpressionLike): AssumptionProposition

rationalAssumption#

Raw WebAssembly: Default context

rationalAssumption(subject: Expression): AssumptionProposition

Build a rationality assumption proposition in the default context.

Calling forms

Explicit context: Context.rationalAssumption

rationalAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.rationalAssumption

rationalAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.rationalAssumption

rationalAssumption(value: ExpressionLike): AssumptionProposition

realAssumption#

Raw WebAssembly: Default context

realAssumption(subject: Expression): AssumptionProposition

Build a realness assumption proposition in the default context.

Calling forms

Explicit context: Context.realAssumption

realAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.realAssumption

realAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.realAssumption

realAssumption(value: ExpressionLike): AssumptionProposition

transcendentalAssumption#

Raw WebAssembly: Default context

transcendentalAssumption(subject: Expression): AssumptionProposition

Build a transcendence assumption proposition in the default context.

Calling forms

Explicit context: Context.transcendentalAssumption

transcendentalAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.transcendentalAssumption

transcendentalAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.transcendentalAssumption

transcendentalAssumption(value: ExpressionLike): AssumptionProposition

zeroAssumption#

Raw WebAssembly: Default context

zeroAssumption(subject: Expression): AssumptionProposition

Build a zero assumption proposition in the default context.

Calling forms

Explicit context: Context.zeroAssumption

zeroAssumption(value: ExpressionLike): AssumptionProposition

Raw WebAssembly: Explicit context: Context.zeroAssumption

zeroAssumption(subject: Expression): AssumptionProposition

SymiFacade method: SymiFacade.zeroAssumption

zeroAssumption(value: ExpressionLike): AssumptionProposition

AssumptionProposition#

Type

class AssumptionProposition

Public type placement for AssumptionProposition.

AssumptionProposition.congruenceModulus#

Raw WebAssembly: Default context

congruenceModulus(proposition: AssumptionProposition): Expression | undefined

Return the congruence modulus when present.

Calling forms

AssumptionProposition method: AssumptionProposition.congruenceModulus

congruenceModulus(): Expression | null

SymiFacade method: SymiFacade.congruenceModulus

congruenceModulus(proposition: AssumptionProposition): Expression | null

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.congruenceModulus

congruenceModulus(): Expression | undefined

AssumptionProposition.free#

AssumptionProposition method

free(): void

Public method placement for free.

AssumptionProposition.leftOperand#

Raw WebAssembly: Default context

leftOperand(proposition: AssumptionProposition): Expression | undefined

Return the left relation or congruence operand when present.

Calling forms

AssumptionProposition method: AssumptionProposition.leftOperand

leftOperand(): Expression | null

SymiFacade method: SymiFacade.leftOperand

leftOperand(proposition: AssumptionProposition): Expression | null

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.leftOperand

leftOperand(): Expression | undefined

AssumptionProposition.membershipElement#

Raw WebAssembly: Default context

membershipElement(proposition: AssumptionProposition): Expression | undefined

Return the membership element when present.

Calling forms

AssumptionProposition method: AssumptionProposition.membershipElement

membershipElement(): Expression | null

SymiFacade method: SymiFacade.membershipElement

membershipElement(proposition: AssumptionProposition): Expression | null

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.membershipElement

membershipElement(): Expression | undefined

AssumptionProposition.membershipSet#

Raw WebAssembly: Default context

membershipSet(proposition: AssumptionProposition): Expression | undefined

Return the membership set expression when present.

Calling forms

AssumptionProposition method: AssumptionProposition.membershipSet

membershipSet(): Expression | null

SymiFacade method: SymiFacade.membershipSet

membershipSet(proposition: AssumptionProposition): Expression | null

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.membershipSet

membershipSet(): Expression | undefined

AssumptionProposition.relationKind#

Raw WebAssembly: Default context

relationKind(proposition: AssumptionProposition): string | undefined

Return the canonical relation kind for an assumption proposition.

Calling forms

AssumptionProposition method: AssumptionProposition.relationKind

relationKind(): "equal" | "not_equal" | "less" | "less_or_equal" | null

SymiFacade method: SymiFacade.relationKind

relationKind(proposition: AssumptionProposition): "equal" | "not_equal" | "less" | "less_or_equal" | null

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.relationKind

relationKind(): string | undefined

AssumptionProposition.rightOperand#

Raw WebAssembly: Default context

rightOperand(proposition: AssumptionProposition): Expression | undefined

Return the right relation or congruence operand when present.

Calling forms

AssumptionProposition method: AssumptionProposition.rightOperand

rightOperand(): Expression | null

SymiFacade method: SymiFacade.rightOperand

rightOperand(proposition: AssumptionProposition): Expression | null

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.rightOperand

rightOperand(): Expression | undefined

AssumptionProposition.toString#

AssumptionProposition method

toString(): string

Return the canonical formula spelling.

Calling forms

Raw WebAssembly: AssumptionProposition method: AssumptionProposition.toString

toString(): string

AssumptionScope#

Type

class AssumptionScope

Public type placement for AssumptionScope.

AssumptionScope.free#

AssumptionScope method

free(): void

Public method placement for free.

Symi documentation · WASM / JavaScript