Skip to content
Symi Docs
Python
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#

Default context

real_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.real_assumption

real_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is real.

rational_assumption#

Default context

rational_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.rational_assumption

rational_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is rational.

integer_assumption#

Default context

integer_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.integer_assumption

integer_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is an integer.

natural_assumption#

Default context

natural_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.natural_assumption

natural_assumption(subject: ExpressionLike) -> AssumptionProposition

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

positive_integer_assumption#

Default context

positive_integer_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.positive_integer_assumption

positive_integer_assumption(subject: ExpressionLike) -> AssumptionProposition

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

positive_assumption#

Default context

positive_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.positive_assumption

positive_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is strictly positive.

negative_assumption#

Default context

negative_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.negative_assumption

negative_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is strictly negative.

nonzero_assumption#

Default context

nonzero_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.nonzero_assumption

nonzero_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is nonzero.

finite_assumption#

Default context

finite_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.finite_assumption

finite_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is finite.

complex_assumption#

Default context

complex_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.complex_assumption

complex_assumption(subject: ExpressionLike) -> AssumptionProposition

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

extended_real_assumption#

Default context

extended_real_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.extended_real_assumption

extended_real_assumption(subject: ExpressionLike) -> AssumptionProposition

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

infinite_assumption#

Default context

infinite_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.infinite_assumption

infinite_assumption(subject: ExpressionLike) -> AssumptionProposition

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

irrational_assumption#

Default context

irrational_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.irrational_assumption

irrational_assumption(subject: ExpressionLike) -> AssumptionProposition

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

zero_assumption#

Default context

zero_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.zero_assumption

zero_assumption(subject: ExpressionLike) -> AssumptionProposition

Build a proposition asserting that an expression is exactly zero.

even_assumption#

Default context

even_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.even_assumption

even_assumption(subject: ExpressionLike) -> AssumptionProposition

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

odd_assumption#

Default context

odd_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.odd_assumption

odd_assumption(subject: ExpressionLike) -> AssumptionProposition

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

prime_assumption#

Default context

prime_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.prime_assumption

prime_assumption(subject: ExpressionLike) -> AssumptionProposition

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

composite_assumption#

Default context

composite_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.composite_assumption

composite_assumption(subject: ExpressionLike) -> AssumptionProposition

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

algebraic_assumption#

Default context

algebraic_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.algebraic_assumption

algebraic_assumption(subject: ExpressionLike) -> AssumptionProposition

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

transcendental_assumption#

Default context

transcendental_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.transcendental_assumption

transcendental_assumption(subject: ExpressionLike) -> AssumptionProposition

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

defined_assumption#

Default context

defined_assumption(input_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.defined_assumption

defined_assumption(subject: ExpressionLike) -> AssumptionProposition

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#

Default context

equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.equal_assumption

equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition

Build a defined scalar equality proposition.

not_equal_assumption#

Default context

not_equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.not_equal_assumption

not_equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition

Build a defined scalar disequality proposition.

less_assumption#

Default context

less_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.less_assumption

less_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition

Build a strict extended-real order proposition.

less_or_equal_assumption#

Default context

less_or_equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.less_or_equal_assumption

less_or_equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition

Build a non-strict extended-real order proposition.

greater_assumption#

Default context

greater_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.greater_assumption

greater_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition

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

greater_or_equal_assumption#

Default context

greater_or_equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.greater_or_equal_assumption

greater_or_equal_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
) -> AssumptionProposition

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

member_assumption#

Default context

member_assumption(
    element: ExpressionLike,
    set_expression: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.member_assumption

member_assumption(
    element: ExpressionLike,
    set_expression: ExpressionLike,
) -> AssumptionProposition

Build a scalar-membership proposition.

congruent_assumption#

Default context

congruent_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
    modulus: ExpressionLike,
) -> AssumptionProposition
Calling forms

Explicit context: Context.congruent_assumption

congruent_assumption(
    left: ExpressionLike,
    right: ExpressionLike,
    modulus: ExpressionLike,
) -> AssumptionProposition

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

assumption_equal#

Not exposed by the Python bindings. Available as api::Session::assumption_equal in Rust.

Construct an equality proposition over two scalar expressions.

assumption_not_equal#

Not exposed by the Python bindings. Available as api::Session::assumption_not_equal in Rust.

Construct a disequality proposition over two scalar expressions.

assumption_less#

Not exposed by the Python bindings. Available as api::Session::assumption_less in Rust.

Construct a strict scalar-order proposition.

assumption_less_or_equal#

Not exposed by the Python bindings. Available as api::Session::assumption_less_or_equal in Rust.

Construct a non-strict scalar-order proposition.

assumption_greater#

Not exposed by the Python 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 Python 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 Python bindings. Available as api::Session::assumption_member in Rust.

Construct a scalar-membership proposition.

assumption_congruent#

Not exposed by the Python bindings. Available as api::Session::assumption_congruent in Rust.

Construct an integer congruence proposition.

assumption_proposition_from_logical_expression#

Default context

assumption_proposition_from_logical_expression(logical_expression: ExpressionLike) -> AssumptionProposition
Calling forms

Explicit context: Context.assumption_proposition_from_logical_expression

assumption_proposition_from_logical_expression(logical_expression: ExpressionLike) -> AssumptionProposition

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)

Conjoin two propositions.

or#

Disjoin two propositions and return a canonical proposition.

AssumptionProposition method

or(other)

Disjoin two propositions.

not#

Negate a proposition and return a canonical proposition.

AssumptionProposition method

not()

Negate a proposition.

relation_kind#

Return the canonical relation kind for a relation atom.

Default context

relation_kind(proposition: Any) -> Optional[str]

Return the canonical relation kind for an assumption proposition.

Calling forms

AssumptionProposition method: AssumptionProposition.relation_kind

relation_kind() -> Optional[str]

left_operand#

Return the left relation or congruence operand when present.

Default context

left_operand(proposition: Any) -> Optional[Expression]

Return the left relation or congruence operand when present.

Calling forms

AssumptionProposition method: AssumptionProposition.left_operand

left_operand() -> Optional[Expression]

right_operand#

Return the right relation or congruence operand when present.

Default context

right_operand(proposition: Any) -> Optional[Expression]

Return the right relation or congruence operand when present.

Calling forms

AssumptionProposition method: AssumptionProposition.right_operand

right_operand() -> Optional[Expression]

membership_element#

Return the membership element when present.

Default context

membership_element(proposition: Any) -> Optional[Expression]

Return the membership element when present.

Calling forms

AssumptionProposition method: AssumptionProposition.membership_element

membership_element() -> Optional[Expression]

membership_set#

Return the membership set expression when present.

Default context

membership_set(proposition: Any) -> Optional[Expression]

Return the membership set expression when present.

Calling forms

AssumptionProposition method: AssumptionProposition.membership_set

membership_set() -> Optional[Expression]

congruence_modulus#

Return the congruence modulus when present.

Default context

congruence_modulus(proposition: Any) -> Optional[Expression]

Return the congruence modulus when present.

Calling forms

AssumptionProposition method: AssumptionProposition.congruence_modulus

congruence_modulus() -> Optional[Expression]

serialize#

Serialize a proposition in the versioned canonical formula grammar.

Default context

serialize(proposition: Any) -> str

Serialize an assumption proposition in the versioned canonical grammar.

Calling forms

AssumptionProposition method: AssumptionProposition.serialize

serialize() -> str

deserialize_assumption_proposition#

Default context

deserialize_assumption_proposition(text: str) -> AssumptionProposition
Calling forms

Explicit context: Context.deserialize_assumption_proposition

deserialize_assumption_proposition(text: str) -> AssumptionProposition

Parse a versioned canonical assumption proposition in the receiving context.

Durable contexts and scopes#

add_assumptions#

Default context

add_assumptions(proposition: Any) -> None
Calling forms

Explicit context: Context.add_assumptions

add_assumptions(proposition: Any) -> None

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

clear_all_assumptions#

Default context

clear_all_assumptions() -> None
Calling forms

Explicit context: Context.clear_all_assumptions

clear_all_assumptions() -> None

Clear both durable formulas and legacy symbol assumptions.

ask#

Default context

ask(proposition: Any) -> Optional[bool]
Calling forms and variants

Explicit context: Context.ask

ask(proposition: Any) -> Optional[bool]

Variant using local assumptions — AssumptionScope method: AssumptionScope.ask

ask(proposition: Any) -> Optional[bool]

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

could_hold#

Default context

could_hold(proposition: Any) -> Optional[bool]
Calling forms and variants

Explicit context: Context.could_hold

could_hold(proposition: Any) -> Optional[bool]

Variant using local assumptions — AssumptionScope method: AssumptionScope.could_hold

could_hold(proposition: Any) -> Optional[bool]

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

assuming#

Default context

assuming(proposition: Any) -> AssumptionScope
Calling forms and variants

Explicit context: Context.assuming

assuming(proposition: Any) -> AssumptionScope

Variant using local assumptions — AssumptionScope method: AssumptionScope.assuming

assuming(proposition: Any) -> 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#

Default context

refine(
    input_expression: ExpressionLike,
    assumptions: Optional[Any] = None,
) -> Expression
Calling forms and variants

Explicit context: Context.refine

refine(
    input_expression: ExpressionLike,
    assumptions: Optional[Any] = None,
) -> Expression

Expression method: Expression.refine

refine(assumptions: Optional[Any] = None) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.refine

refine(input_expression: ExpressionLike) -> Expression

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

Additional API#

nonnegative_assumption#

Default context

nonnegative_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.nonnegative_assumption

nonnegative_assumption(subject: ExpressionLike) -> AssumptionProposition

nonpositive_assumption#

Default context

nonpositive_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.nonpositive_assumption

nonpositive_assumption(subject: ExpressionLike) -> AssumptionProposition

AssumptionProposition#

Type

class AssumptionProposition

A typed immutable assumption proposition owned by a Python context.

AssumptionProposition.str#

AssumptionProposition method

__str__() -> str

Return the canonical formula spelling.

AssumptionScope#

Type

class AssumptionScope

An immutable local assumption scope owned by a Python context.

Symi documentation · Python