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) -> AssumptionPropositionCalling forms
Explicit context: Context.real_assumption
real_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is real.
rational_assumption#
Default context
rational_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.rational_assumption
rational_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is rational.
integer_assumption#
Default context
integer_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.integer_assumption
integer_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is an integer.
natural_assumption#
Default context
natural_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.natural_assumption
natural_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is a natural number.
positive_integer_assumption#
Default context
positive_integer_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.positive_integer_assumption
positive_integer_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is a positive integer.
positive_assumption#
Default context
positive_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.positive_assumption
positive_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is strictly positive.
negative_assumption#
Default context
negative_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.negative_assumption
negative_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is strictly negative.
nonzero_assumption#
Default context
nonzero_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.nonzero_assumption
nonzero_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is nonzero.
finite_assumption#
Default context
finite_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.finite_assumption
finite_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is finite.
complex_assumption#
Default context
complex_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.complex_assumption
complex_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is a finite complex number.
extended_real_assumption#
Default context
extended_real_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.extended_real_assumption
extended_real_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is an extended real, including signed infinity.
infinite_assumption#
Default context
infinite_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.infinite_assumption
infinite_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is one of the two signed infinities.
irrational_assumption#
Default context
irrational_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.irrational_assumption
irrational_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is real and not rational.
zero_assumption#
Default context
zero_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.zero_assumption
zero_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is exactly zero.
even_assumption#
Default context
even_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.even_assumption
even_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is an even integer.
odd_assumption#
Default context
odd_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.odd_assumption
odd_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is an odd integer.
prime_assumption#
Default context
prime_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.prime_assumption
prime_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is a proven ordinary prime integer.
composite_assumption#
Default context
composite_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.composite_assumption
composite_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is a proven ordinary composite integer.
algebraic_assumption#
Default context
algebraic_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.algebraic_assumption
algebraic_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is algebraic over the rationals.
transcendental_assumption#
Default context
transcendental_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.transcendental_assumption
transcendental_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild a proposition asserting that an expression is transcendental over the rationals.
defined_assumption#
Default context
defined_assumption(input_expression: ExpressionLike) -> AssumptionPropositionCalling forms
Explicit context: Context.defined_assumption
defined_assumption(subject: ExpressionLike) -> AssumptionPropositionBuild 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,
) -> AssumptionPropositionCalling forms
Explicit context: Context.equal_assumption
equal_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionBuild a defined scalar equality proposition.
not_equal_assumption#
Default context
not_equal_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionCalling forms
Explicit context: Context.not_equal_assumption
not_equal_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionBuild a defined scalar disequality proposition.
less_assumption#
Default context
less_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionCalling forms
Explicit context: Context.less_assumption
less_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionBuild a strict extended-real order proposition.
less_or_equal_assumption#
Default context
less_or_equal_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionCalling forms
Explicit context: Context.less_or_equal_assumption
less_or_equal_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionBuild a non-strict extended-real order proposition.
greater_assumption#
Default context
greater_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionCalling forms
Explicit context: Context.greater_assumption
greater_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionBuild 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,
) -> AssumptionPropositionCalling forms
Explicit context: Context.greater_or_equal_assumption
greater_or_equal_assumption(
left: ExpressionLike,
right: ExpressionLike,
) -> AssumptionPropositionBuild a non-strict extended-real order proposition by reversing its operands canonically.
member_assumption#
Default context
member_assumption(
element: ExpressionLike,
set_expression: ExpressionLike,
) -> AssumptionPropositionCalling forms
Explicit context: Context.member_assumption
member_assumption(
element: ExpressionLike,
set_expression: ExpressionLike,
) -> AssumptionPropositionBuild a scalar-membership proposition.
congruent_assumption#
Default context
congruent_assumption(
left: ExpressionLike,
right: ExpressionLike,
modulus: ExpressionLike,
) -> AssumptionPropositionCalling forms
Explicit context: Context.congruent_assumption
congruent_assumption(
left: ExpressionLike,
right: ExpressionLike,
modulus: ExpressionLike,
) -> AssumptionPropositionBuild 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) -> AssumptionPropositionCalling forms
Explicit context: Context.assumption_proposition_from_logical_expression
assumption_proposition_from_logical_expression(logical_expression: ExpressionLike) -> AssumptionPropositionConvert 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) -> strSerialize an assumption proposition in the versioned canonical grammar.
deserialize_assumption_proposition#
Default context
deserialize_assumption_proposition(text: str) -> AssumptionPropositionCalling forms
Explicit context: Context.deserialize_assumption_proposition
deserialize_assumption_proposition(text: str) -> AssumptionPropositionParse a versioned canonical assumption proposition in the receiving context.
Durable contexts and scopes#
add_assumptions#
Default context
add_assumptions(proposition: Any) -> NoneAtomically 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() -> NoneClear 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) -> AssumptionScopeCalling forms and variants
Explicit context: Context.assuming
assuming(proposition: Any) -> AssumptionScopeVariant using local assumptions — AssumptionScope method: AssumptionScope.assuming
assuming(proposition: Any) -> AssumptionScopeCreate 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,
) -> ExpressionCalling forms and variants
Explicit context: Context.refine
refine(
input_expression: ExpressionLike,
assumptions: Optional[Any] = None,
) -> ExpressionExpression method: Expression.refine
refine(assumptions: Optional[Any] = None) -> ExpressionVariant using local assumptions — AssumptionScope method: AssumptionScope.refine
refine(input_expression: ExpressionLike) -> ExpressionSimplify an expression using durable assumptions or one checked local proposition.
Additional API#
nonnegative_assumption#
Default context
nonnegative_assumption(input_expression: ExpressionLike) -> AssumptionPropositionBuild a universe-guarded nonnegative assumption proposition in the default context.
Calling forms
Explicit context: Context.nonnegative_assumption
nonnegative_assumption(subject: ExpressionLike) -> AssumptionPropositionnonpositive_assumption#
Default context
nonpositive_assumption(input_expression: ExpressionLike) -> AssumptionPropositionBuild a universe-guarded nonpositive assumption proposition in the default context.
Calling forms
Explicit context: Context.nonpositive_assumption
nonpositive_assumption(subject: ExpressionLike) -> AssumptionPropositionAssumptionProposition#
Type
class AssumptionPropositionA typed immutable assumption proposition owned by a Python context.
AssumptionProposition.str#
AssumptionProposition method
__str__() -> strReturn the canonical formula spelling.
AssumptionScope#
Type
class AssumptionScopeAn immutable local assumption scope owned by a Python context.