Skip to content
Symi Docs
Python
On this page

Complete placement index

CylindricalAlgebraicDecomposition#

CylindricalAlgebraicDecomposition constructor

CylindricalAlgebraicDecomposition(
    expressions: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    equational_constraints: list[int] = [],
)

Decompose real space into sign-invariant cells for the given polynomials, in the given variable order.

CylindricalAlgebraicDecomposition.cell_count#

CylindricalAlgebraicDecomposition method

cell_count() -> int

The number of full-dimensional cells partitioning Rn\mathbb{R}^n.

CylindricalAlgebraicDecomposition.cell_dimension#

CylindricalAlgebraicDecomposition method

cell_dimension(index: int) -> int

The geometric dimension of the full cell as a subset of Rn\mathbb{R}^n (the number of sector coordinates along its cylindrical stack).

CylindricalAlgebraicDecomposition.cell_kind#

CylindricalAlgebraicDecomposition method

cell_kind(index: int) -> str

"section" or "sector" — whether the cell is a root section or an open interval in its top variable.

CylindricalAlgebraicDecomposition.cell_sample_point#

CylindricalAlgebraicDecomposition method

cell_sample_point(index: int) -> list[float]

The coordinates of the full cell's sample point as floats — a numeric view via the multi-precision evaluator, not a decision.

CylindricalAlgebraicDecomposition.cell_sign_vector#

CylindricalAlgebraicDecomposition method

cell_sign_vector(index: int) -> list[int]

The exact sign (−1-1, 00, or +1+1) of each input polynomial on the full cell, in input order.

CylindricalAlgebraicDecomposition.projection_operator_used#

CylindricalAlgebraicDecomposition method

projection_operator_used() -> str

The projection operator the decomposition was built with: "brown" for the well-oriented fast path, "lazard" when the well-orientedness guard forced the complete fallback, "equational_constraint" for an equational-constraint CAD.

Matrix#

Matrix constructor

Matrix(rows: Any)

Build a matrix from ordered rows. Direct Python construction and the facade module function use the shared default context. The raw wasm-bindgen compatibility layer retains (rows, columns, flat_entries); new JavaScript code should use the nested facade form.

Matrix.add#

Matrix method

__add__(other: Matrix) -> Matrix

Entrywise sum self + other of two matrices of the same shape.

Matrix.getattribute#

Matrix method

__getattribute__(name: str) -> Any

Reject attribute access on a stale object before delegating to the default lookup.

Matrix.getitem#

Matrix method

__getitem__(index: tuple[int, int]) -> Expression

The entry at the (row, column) index pair.

Matrix.mul#

Matrix method

__mul__(other: Any) -> Matrix

Matrix product self * other when other is a matrix, and scaling of every entry when other is an expression-like scalar.

Matrix.repr#

Matrix method

__repr__() -> str

The repr() text: the entries row by row, as Matrix([[a, b], [c, d]]), eliding beyond eight rows or columns. It reports staleness instead of failing.

Matrix.rmul#

Matrix method

__rmul__(scalar: Any) -> Matrix

Scaling scalar * self of every entry by an expression-like scalar, the same product as self * scalar.

Matrix.sub#

Matrix method

__sub__(other: Matrix) -> Matrix

Entrywise difference self - other of two matrices of the same shape.

Matrix.add#

Matrix method

add(other: Matrix) -> Matrix

Entrywise sum of two matrices of the same shape.

Matrix.adjugate#

Matrix method

adjugate() -> Matrix

The classical adjoint (transpose of the cofactor matrix); satisfies Madj⁡(M)=det⁡(M)IM\operatorname{adj}(M) = \det(M) I.

Matrix.characteristic_polynomial#

Matrix method

characteristic_polynomial(variable: Any) -> Expression

det⁡(λI−M)\det(\lambda I - M) as a polynomial in the named variable.

Matrix.cofactor_matrix#

Matrix method

cofactor_matrix() -> Matrix

The matrix of cofactors, whose transpose is the adjugate.

Matrix.column_hermite_normal_form#

Matrix method

column_hermite_normal_form() -> tuple[Matrix, Matrix, int, list[int]]

The transpose-dual column form, returning H, a unimodular V satisfying MV=HM V = H, the rank, and pivot metadata. Notes: WASM returns a hermite_normal_form_decomposition object.

Matrix.columns#

Matrix property

columns: int

Number of columns.

Matrix.cosine#

Matrix method

cosine() -> Matrix

The primary matrix cosine cos(M), evaluated exactly through the certified Jordan decomposition and the trigonometric identity certificate.

Matrix.determinant#

Matrix method

determinant() -> Expression

Fraction-free (Berkowitz/Bareiss) determinant of a square matrix.

Matrix.eigenvalues#

Matrix method

eigenvalues() -> list[Expression]

Eigenvalues with multiplicity, via the characteristic polynomial and the root finder; eigenvalues the root finder cannot close remain as exact first-class polynomial_root values.

Matrix.eigenvectors#

Matrix method

eigenvectors() -> list[tuple[Expression, list[Matrix]]]

For each eigenvalue, a basis of its eigenspace as column matrices. Notes: WASM returns eigenpair objects with eigenvalue/vectors getters.

Matrix.execute#

Matrix method

execute() -> Matrix

Re-dispatch every unevaluated node (integral, derivative, summation, transform, ODE/recurrence placeholder) in the expression; useful after substitution has changed the inputs.

Matrix.exponential#

Matrix method

exponential() -> Matrix

The matrix exponential exp(M), evaluated through the certified Jordan decomposition. Declines on inputs whose eigenvalues cannot be certified exactly.

Matrix.has_complex_entries#

Matrix method

has_complex_entries() -> Optional[bool]

Query whether every entry is finite complex.

Matrix.has_integer_entries#

Matrix method

has_integer_entries() -> Optional[bool]

Query whether every entry is an integer.

Matrix.has_real_entries#

Matrix method

has_real_entries() -> Optional[bool]

Query whether every entry is real.

Matrix.hermite_normal_form#

Matrix method

hermite_normal_form() -> tuple[Matrix, Matrix, int, list[int]]

Returns the canonical row-oriented Hermite normal form H, a unimodular transformation U satisfying UM=HU M = H, the rank, and the strictly increasing pivot-column indices. Entries must be exact integers. Every result is verified for Hermite shape, the certificate identity, and unimodularity before return. Notes: WASM returns a hermite_normal_form_decomposition object carrying the same four results as getters.

Matrix.hyperbolic_cosine#

Matrix method

hyperbolic_cosine() -> Matrix

The primary hyperbolic matrix cosine cosh(M), evaluated exactly through the certified Jordan decomposition and the hyperbolic identity certificate.

Matrix.hyperbolic_sine#

Matrix method

hyperbolic_sine() -> Matrix

The primary hyperbolic matrix sine sinh(M), evaluated exactly through the certified Jordan decomposition. The result is certified together with the hyperbolic matrix cosine by cosh(M)^2 - sinh(M)^2 = I.

Matrix.integer_cokernel_structure#

Matrix method

integer_cokernel_structure() -> tuple[int, list[Expression]]

Returns the free rank and nontrivial torsion invariant factors of Z^m / M Z^n.

Matrix.integer_image_lattice_basis#

Matrix method

integer_image_lattice_basis() -> list[Matrix]

The nonzero columns of the column Hermite form, returned as column matrices; these form the canonical basis of M Z^n.

Matrix.integer_kernel_basis#

Matrix method

integer_kernel_basis() -> list[Matrix]

A canonical basis of the integer kernel {x∈Zn:Mx=0}\{x \in \mathbb{Z}^n : M x = 0\}, returned as column matrices.

Matrix.integer_row_lattice_basis#

Matrix method

integer_row_lattice_basis() -> list[Matrix]

The nonzero rows of the row Hermite form, returned as row matrices; these form the canonical basis of the integer row lattice.

Matrix.inverse#

Matrix method

inverse() -> Matrix

Inverse via the adjugate; raises on singular input.

Matrix.is_diagonal_matrix#

Matrix method

is_diagonal_matrix() -> Optional[bool]

Query whether this matrix is diagonal.

Matrix.is_equality#

Matrix method

is_equality() -> bool

Always false: a matrix is never an equal relation node.

Matrix.is_finite_set#

Matrix method

is_finite_set() -> bool

Always false: a matrix is never a finite set.

Matrix.is_full_rank_matrix#

Matrix method

is_full_rank_matrix() -> Optional[bool]

Query whether this matrix has full rank.

Matrix.is_hermitian_matrix#

Matrix method

is_hermitian_matrix() -> Optional[bool]

Query whether this matrix is Hermitian.

Matrix.is_identity_matrix#

Matrix method

is_identity_matrix() -> Optional[bool]

Query whether this matrix is the identity matrix.

Matrix.is_image_set#

Matrix method

is_image_set() -> bool

Always false: a matrix is never an image set.

Matrix.is_integral#

Matrix method

is_integral() -> bool

Always false: a matrix is never an unevaluated integral node.

Matrix.is_invertible_matrix#

Matrix method

is_invertible_matrix() -> Optional[bool]

Query whether this matrix is invertible.

Matrix.is_matrix#

Matrix property

is_matrix: bool

Always False on expressions and True on matrix objects, so mixed result streams can be discriminated.

Matrix.is_normal_matrix#

Matrix method

is_normal_matrix() -> Optional[bool]

Query whether this matrix is normal.

Matrix.is_orthogonal_matrix#

Matrix method

is_orthogonal_matrix() -> Optional[bool]

Query whether this matrix is orthogonal.

Matrix.is_positive#

Matrix method

is_positive() -> Optional[bool]

Always None: positivity is a property of the entries, not of the matrix.

Matrix.is_positive_definite_matrix#

Matrix method

is_positive_definite_matrix() -> Optional[bool]

Query whether this matrix is positive definite.

Matrix.is_positive_semidefinite_matrix#

Matrix method

is_positive_semidefinite_matrix() -> Optional[bool]

Query whether this matrix is positive semidefinite.

Matrix.is_real#

Matrix method

is_real() -> Optional[bool]

Always None: realness is a property of the entries, not of the matrix.

Matrix.is_singular_matrix#

Matrix method

is_singular_matrix() -> Optional[bool]

Query whether this matrix is singular.

Matrix.is_square#

Matrix method

is_square() -> Optional[bool]

Query whether this matrix is square.

Matrix.is_stale#

Matrix property

is_stale: bool

Reports whether resetting the owning context invalidated the expression. All other operations reject a stale receiver with an actionable error.

Matrix.is_symmetric_matrix#

Matrix method

is_symmetric_matrix() -> Optional[bool]

Query whether this matrix is symmetric.

Matrix.is_union#

Matrix method

is_union() -> bool

Always false: a matrix is never a union of sets.

Matrix.is_unitary_matrix#

Matrix method

is_unitary_matrix() -> Optional[bool]

Query whether this matrix is unitary.

Matrix.is_zero_matrix#

Matrix method

is_zero_matrix() -> Optional[bool]

Query whether this matrix is the zero matrix.

Matrix.jordan_decomposition#

Matrix method

jordan_decomposition() -> tuple[Matrix, Matrix, list[tuple[Expression, int]]]

The Jordan decomposition returned as (similarity, jordan_form, blocks) with similarity⁡jordan_form⁡similarity⁡−1=M\operatorname{similarity} \operatorname{jordan\_form} \operatorname{similarity}^{-1} = M, where blocks lists each Jordan block as an (eigenvalue, size) pair. Every root is certified over an exact algebraic field. Notes: WASM returns a jordan_decomposition result class with similarity/jordan_form/blocks getters, each block a jordan_block with eigenvalue/size getters.

Matrix.logarithm#

Matrix method

logarithm() -> Matrix

The principal matrix logarithm log(M).

Matrix.lower_upper_decomposition#

Matrix method

lower_upper_decomposition() -> tuple[Matrix, Matrix, Matrix]

Partial-pivoting LU decomposition returned as (permutation, lower, upper) with permutation⁡M=lower⁡ upper⁡\operatorname{permutation} M = \operatorname{lower}\,\operatorname{upper}.

Matrix.minimal_polynomial#

Matrix method

minimal_polynomial(variable: Any) -> Expression

The monic minimal polynomial over the rationals. The matrix must have rational entries.

Matrix.multiply#

Matrix method

multiply(other: Matrix) -> Matrix

Matrix product; inner dimensions must agree.

Matrix.nullspace_basis#

Matrix method

nullspace_basis() -> list[Matrix]

A basis of the kernel, as column matrices; empty list for full column rank.

Matrix.rank#

Matrix method

rank() -> int

Rank via Bareiss fraction-free elimination.

Matrix.rational_canonical_form#

Matrix method

rational_canonical_form(variable: VariableLike) -> RationalCanonicalForm

Returns the certified Frobenius canonical form over the rationals. Its invariant factors are monic and ordered by divisibility, and similarity satisfies matrix⁡ similarity⁡=similarity⁡ canonical_form⁡\operatorname{matrix}\,\operatorname{similarity} = \operatorname{similarity}\,\operatorname{canonical\_form} exactly.

Matrix.row_reduce#

Matrix method

row_reduce() -> Matrix

Bareiss row-reduced form (fraction-free; pivots remain on the diagonal).

Matrix.rows#

Matrix property

rows: int

Number of rows.

Matrix.scalar_multiply#

Matrix method

scalar_multiply(scalar: Any) -> Matrix

Scale every entry by scalar.

Matrix.sine#

Matrix method

sine() -> Matrix

The primary matrix sine sin(M), evaluated exactly through the certified Jordan decomposition. The result is certified together with the matrix cosine by sin(M)^2 + cos(M)^2 = I.

Matrix.smith_normal_form#

Matrix method

smith_normal_form() -> tuple[Matrix, Matrix, Matrix, int, list[Expression]]

Returns the canonical integer Smith normal form D, unimodular transformations U and V satisfying UMV=DU M V = D, the rank, and the invariant factors including trailing zeros. The nonnegative positive prefix is divisibility-ordered. Every result is verified for diagonal shape, divisibility, the exact certificate, and unimodularity of both transformations before return. Notes: WASM returns a smith_normal_form_decomposition object carrying the same results as getters.

Matrix.square_root#

Matrix method

square_root() -> Matrix

The principal matrix square root sqrt(M); the result is verified to square back to M.

Matrix.subtract#

Matrix method

subtract(other: Matrix) -> Matrix

Entrywise difference of two matrices of the same shape.

Matrix.summary#

Matrix method

summary() -> str

A one-line summary listing the entries row by row, Matrix([[a, b], [c, d]]). A matrix with more than eight rows or columns lists its leading eight of each, marks every elided run with ..., and states its full shape first.

Matrix.trace#

Matrix method

trace() -> Expression

Sum of the diagonal entries of a square matrix.

Matrix.transpose#

Matrix method

transpose() -> Matrix

The transpose, with rows and columns exchanged.

RationalCanonicalForm#

Type

class RationalCanonicalForm

Returns the certified Frobenius canonical form over the rationals. Its invariant factors are monic and ordered by divisibility, and similarity satisfies matrix⁡ similarity⁡=similarity⁡ canonical_form⁡\operatorname{matrix}\,\operatorname{similarity} = \operatorname{similarity}\,\operatorname{canonical\_form} exactly.

RationalCanonicalForm.canonical_form#

RationalCanonicalForm property

canonical_form: Matrix

The Frobenius canonical form of the decomposed matrix.

RationalCanonicalForm.characteristic_polynomial#

RationalCanonicalForm property

characteristic_polynomial: Expression

det⁡(λI−M)\det(\lambda I - M) as a polynomial in the named variable.

RationalCanonicalForm.invariant_factors#

RationalCanonicalForm property

invariant_factors: list[Expression]

The certified invariant factors, monic and ordered by divisibility.

RationalCanonicalForm.minimal_polynomial#

RationalCanonicalForm property

minimal_polynomial: Expression

The monic minimal polynomial over the rationals. The matrix must have rational entries.

RationalCanonicalForm.similarity#

RationalCanonicalForm property

similarity: Matrix

The certified change of basis S, satisfying matrix * S == S * canonical_form.

change_monomial_order#

Default context

change_monomial_order(
    basis: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    source_order: str,
    target_order: str,
) -> Optional[list[Expression]]

Convert a Gröbner basis of a zero-dimensional ideal from source_order to target_order by FGLM (Faugère–Gianni–Lazard–Mora) — linear algebra in the finite-dimensional quotient ring Q[variables]/I\mathbb{Q}[\text{variables}]/I, far cheaper than computing the target basis directly (the msolve route to a lexicographic basis is a cheap degrevlex basis followed by this conversion).

Calling forms

Explicit context: Context.change_monomial_order

change_monomial_order(
    basis: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    source_order: str,
    target_order: str,
) -> Optional[list[Expression]]

coefficient#

Default context

coefficient(
    input_expression: ExpressionLike,
    variable: VariableLike,
    power: int,
) -> Expression

Coefficient of variable^power; integer 0 when the term is absent. Errors on non-polynomial input.

Calling forms

Explicit context: Context.coefficient

coefficient(
    input_expression: ExpressionLike,
    variable: VariableLike,
    power: int,
) -> Expression

complex_entries#

Default context

complex_entries(subject: Matrix) -> AssumptionProposition

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

Calling forms

Explicit context: Context.complex_entries

complex_entries(subject: Matrix) -> AssumptionProposition

degree#

Default context

degree(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Optional[int]

Degree in variable.

Calling forms

Explicit context: Context.degree

degree(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Optional[int]

diagonal_matrix#

Default context

diagonal_matrix(subject: Matrix) -> AssumptionProposition

Build a diagonal-matrix proposition in the default context.

Calling forms

Explicit context: Context.diagonal_matrix

diagonal_matrix(subject: Matrix) -> AssumptionProposition

elimination_ideal#

Default context

elimination_ideal(
    generators: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    eliminate: Iterable[VariableLike],
) -> Optional[list[Expression]]

A Gröbner basis of the elimination ideal ⟨generators⁡⟩∩Q[surviving variables]\langle\operatorname{generators}\rangle \cap \mathbb{Q}[\text{surviving variables}], projecting away the variables named in eliminate via the Elimination Theorem (a block order ranks the eliminated variables high and the generators free of them are kept).

Calling forms

Explicit context: Context.elimination_ideal

elimination_ideal(
    generators: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    eliminate: Iterable[VariableLike],
) -> Optional[list[Expression]]

full_rank_matrix#

Default context

full_rank_matrix(subject: Matrix) -> AssumptionProposition

Build a full-rank-matrix proposition in the default context.

Calling forms

Explicit context: Context.full_rank_matrix

full_rank_matrix(subject: Matrix) -> AssumptionProposition

groebner_basis#

Default context

groebner_basis(
    generators: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

The canonical reduced Gröbner basis of the ideal <generators> under the named monomial order — monic, autoreduced, and sorted, so it is unique for the (ideal, order) pair. None when any generator is outside Q[variables]\mathbb{Q}[\text{variables}].

Calling forms

Explicit context: Context.groebner_basis

groebner_basis(
    generators: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

hermitian_matrix#

Default context

hermitian_matrix(subject: Matrix) -> AssumptionProposition

Build a Hermitian-matrix proposition in the default context.

Calling forms

Explicit context: Context.hermitian_matrix

hermitian_matrix(subject: Matrix) -> AssumptionProposition

ideal_intersection#

Default context

ideal_intersection(
    generators_left: Iterable[ExpressionLike],
    generators_right: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

A generating set of the ideal intersection I∩JI \cap J, computed by the standard tag-variable elimination construction tI+(1−t)Jt I + (1-t) J.

Calling forms

Explicit context: Context.ideal_intersection

ideal_intersection(
    generators_left: Iterable[ExpressionLike],
    generators_right: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

ideal_membership#

Default context

ideal_membership(
    element: ExpressionLike,
    generators: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[bool]

Whether element lies in the ideal <generators>, decided by reducing it to its normal form modulo the Gröbner basis (zero exactly when it is a member).

Calling forms

Explicit context: Context.ideal_membership

ideal_membership(
    element: ExpressionLike,
    generators: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[bool]

ideal_product#

Default context

ideal_product(
    generators_left: Iterable[ExpressionLike],
    generators_right: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

A Gröbner basis of the ideal product IJI J, generated by all pairwise products of the two generator lists. None on a non-Q[variables]\mathbb{Q}[\text{variables}] generator.

Calling forms

Explicit context: Context.ideal_product

ideal_product(
    generators_left: Iterable[ExpressionLike],
    generators_right: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

ideal_sum#

Default context

ideal_sum(
    generators_left: Iterable[ExpressionLike],
    generators_right: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

A Gröbner basis of the ideal sum I + J, the ideal generated by the two generator lists together. None on a non-Q[variables]\mathbb{Q}[\text{variables}] generator.

Calling forms

Explicit context: Context.ideal_sum

ideal_sum(
    generators_left: Iterable[ExpressionLike],
    generators_right: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    order: Optional[str] = None,
) -> Optional[list[Expression]]

identity_matrix#

Default context

identity_matrix(subject: Matrix) -> AssumptionProposition

Build an identity-matrix proposition in the default context.

Calling forms

Explicit context: Context.identity_matrix

identity_matrix(subject: Matrix) -> AssumptionProposition

implicitize#

Default context

implicitize(
    coordinates: Iterable[VariableLike],
    parameters: Iterable[VariableLike],
    parametric_expressions: Iterable[ExpressionLike],
) -> Optional[list[Expression]]

The implicit ideal of a parametric curve or surface xi=fi(parameters⁡)x_i = f_i(\operatorname{parameters}) (the i-th coordinate paired with the i-th parametric expression), returned as a generator list over Q[coordinates]\mathbb{Q}[\text{coordinates}] — the elimination of the parameters (Cox–Little–O'Shea ch. 3).

Calling forms

Explicit context: Context.implicitize

implicitize(
    coordinates: Iterable[VariableLike],
    parameters: Iterable[VariableLike],
    parametric_expressions: Iterable[ExpressionLike],
) -> Optional[list[Expression]]

integer_entries#

Default context

integer_entries(subject: Matrix) -> AssumptionProposition

Build an integer-entry proposition in the default context.

Calling forms

Explicit context: Context.integer_entries

integer_entries(subject: Matrix) -> AssumptionProposition

invertible_matrix#

Default context

invertible_matrix(subject: Matrix) -> AssumptionProposition

Build an invertible-matrix proposition in the default context.

Calling forms

Explicit context: Context.invertible_matrix

invertible_matrix(subject: Matrix) -> AssumptionProposition

isolate_real_roots#

Default context

isolate_real_roots(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> list[tuple[Expression, Expression]]

One (lower, upper) rational isolating interval per distinct real root, sorted ascending; a collapsed pair (r, r) marks an exact rational root. Requires a non-zero univariate polynomial with rational coefficients. Notes: WASM returns isolating_interval objects with lower/upper getters.

Calling forms

Explicit context: Context.isolate_real_roots

isolate_real_roots(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> list[tuple[Expression, Expression]]

leading_coefficient#

Default context

leading_coefficient(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

Coefficient of the highest power of variable; may contain the other free variables. Errors on non-polynomial or zero input.

Calling forms

Explicit context: Context.leading_coefficient

leading_coefficient(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

lower_triangular_matrix#

Default context

lower_triangular_matrix(subject: Matrix) -> AssumptionProposition

Build a lower-triangular-matrix proposition in the default context.

Calling forms

Explicit context: Context.lower_triangular_matrix

lower_triangular_matrix(subject: Matrix) -> AssumptionProposition

matrix#

Explicit context

matrix(rows: Any) -> Matrix

Build a matrix from ordered rows. Direct Python construction and the facade module function use the shared default context. The raw wasm-bindgen compatibility layer retains (rows, columns, flat_entries); new JavaScript code should use the nested facade form.

matrix_diagonal#

Default context

matrix_diagonal(entries: Iterable[ExpressionLike]) -> Matrix

Square matrix with the given main diagonal and zeros elsewhere; the empty list raises.

Calling forms

Explicit context: Context.matrix_diagonal

matrix_diagonal(entries: Iterable[ExpressionLike]) -> Matrix

matrix_identity#

Default context

matrix_identity(size: int) -> Matrix

The size×size\mathit{size}\times\mathit{size} identity; size 0 raises.

Calling forms

Explicit context: Context.matrix_identity

matrix_identity(size: int) -> Matrix

matrix_shape#

Default context

matrix_shape(
    subject: Matrix,
    rows: int,
    columns: int,
) -> AssumptionProposition

Build a matrix shape proposition in the default context.

Calling forms

Explicit context: Context.matrix_shape

matrix_shape(
    subject: Matrix,
    rows: int,
    columns: int,
) -> AssumptionProposition

matrix_zero#

Default context

matrix_zero(rows: int, columns: int) -> Matrix

The rows×columns\mathit{rows}\times\mathit{columns} zero matrix.

Calling forms

Explicit context: Context.matrix_zero

matrix_zero(rows: int, columns: int) -> Matrix

normal_matrix#

Default context

normal_matrix(subject: Matrix) -> AssumptionProposition

Build a normal-matrix proposition in the default context.

Calling forms

Explicit context: Context.normal_matrix

normal_matrix(subject: Matrix) -> AssumptionProposition

orthogonal_matrix#

Default context

orthogonal_matrix(subject: Matrix) -> AssumptionProposition

Build an orthogonal-matrix proposition in the default context.

Calling forms

Explicit context: Context.orthogonal_matrix

orthogonal_matrix(subject: Matrix) -> AssumptionProposition

polynomial_gcd#

Default context

polynomial_gcd(
    a: ExpressionLike,
    b: ExpressionLike,
    variable: VariableLike,
) -> Expression

Greatest common divisor of the two expressions as polynomials in variable (primitive, with the core's sign normalisation).

Calling forms

Explicit context: Context.polynomial_gcd

polynomial_gcd(
    a: ExpressionLike,
    b: ExpressionLike,
    variable: VariableLike,
) -> Expression

positive_definite_matrix#

Default context

positive_definite_matrix(subject: Matrix) -> AssumptionProposition

Build a positive-definite-matrix proposition in the default context.

Calling forms

Explicit context: Context.positive_definite_matrix

positive_definite_matrix(subject: Matrix) -> AssumptionProposition

positive_semidefinite_matrix#

Default context

positive_semidefinite_matrix(subject: Matrix) -> AssumptionProposition

Build a positive-semidefinite-matrix proposition in the default context.

Calling forms

Explicit context: Context.positive_semidefinite_matrix

positive_semidefinite_matrix(subject: Matrix) -> AssumptionProposition

real_entries#

Default context

real_entries(subject: Matrix) -> AssumptionProposition

Build a real-entry proposition in the default context.

Calling forms

Explicit context: Context.real_entries

real_entries(subject: Matrix) -> AssumptionProposition

resultant#

Default context

resultant(
    a: ExpressionLike,
    b: ExpressionLike,
    variable: VariableLike,
) -> Expression

Resultant with respect to variable; zero exactly when the two polynomials share a root (over the algebraic closure).

Calling forms

Explicit context: Context.resultant

resultant(
    a: ExpressionLike,
    b: ExpressionLike,
    variable: VariableLike,
) -> Expression

singular_matrix#

Default context

singular_matrix(subject: Matrix) -> AssumptionProposition

Build a singular-matrix proposition in the default context.

Calling forms

Explicit context: Context.singular_matrix

singular_matrix(subject: Matrix) -> AssumptionProposition

square_matrix#

Default context

square_matrix(subject: Matrix) -> AssumptionProposition

Build a square-matrix proposition in the default context.

Calling forms

Explicit context: Context.square_matrix

square_matrix(subject: Matrix) -> AssumptionProposition

symmetric_matrix#

Default context

symmetric_matrix(subject: Matrix) -> AssumptionProposition

Build a symmetric-matrix proposition in the default context.

Calling forms

Explicit context: Context.symmetric_matrix

symmetric_matrix(subject: Matrix) -> AssumptionProposition

unitary_matrix#

Default context

unitary_matrix(subject: Matrix) -> AssumptionProposition

Build a unitary-matrix proposition in the default context.

Calling forms

Explicit context: Context.unitary_matrix

unitary_matrix(subject: Matrix) -> AssumptionProposition

upper_triangular_matrix#

Default context

upper_triangular_matrix(subject: Matrix) -> AssumptionProposition

Build a upper-triangular-matrix proposition in the default context.

Calling forms

Explicit context: Context.upper_triangular_matrix

upper_triangular_matrix(subject: Matrix) -> AssumptionProposition

zero_matrix#

Default context

zero_matrix(subject: Matrix) -> AssumptionProposition

Build a zero-matrix proposition in the default context.

Calling forms

Explicit context: Context.zero_matrix

zero_matrix(subject: Matrix) -> AssumptionProposition

DefiniteIntegrationResult#

Type

class DefiniteIntegrationResult

A definite-integration outcome that keeps its verdict distinct from its value.

DefiniteIntegrationResult.decline_reason#

DefiniteIntegrationResult property

decline_reason: Optional[str]

The reason, present exactly when the verdict is declined.

DefiniteIntegrationResult.divergence_direction#

DefiniteIntegrationResult property

divergence_direction: Optional[str]

The signed infinity of a divergent request, when a single direction was established.

DefiniteIntegrationResult.interpretation#

DefiniteIntegrationResult property

interpretation: str

The interpretation under which the request was answered.

DefiniteIntegrationResult.value#

DefiniteIntegrationResult property

value: Optional[Expression]

The exact value, present exactly when the verdict is evaluated.

DefiniteIntegrationResult.verdict#

DefiniteIntegrationResult property

verdict: str

Whether the request was evaluated, proved divergent, or declined.

LimitResult#

Type

class LimitResult

A limit classification that keeps its status distinct from its value.

LimitResult.decline_reason#

LimitResult property

decline_reason: Optional[str]

The reason, present exactly when the status is unknown.

LimitResult.status#

LimitResult property

status: str

Whether the limit is finite, a signed infinity, proved nonexistent, or undecided.

LimitResult.value#

LimitResult property

value: Optional[Expression]

The exact limit, present exactly when the status is finite.

complex_limit#

Default context

complex_limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
) -> Expression

complex_limit(expression, variable, point) constructs the deferred limit of an expression as the variable tends to a finite point through a punctured complex disk.

Calling forms

Explicit context: Context.complex_limit

complex_limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
) -> Expression

complex_sector_limit#

Default context

complex_sector_limit(
    input_expression: ExpressionLike,
    variable: Any,
    lower_angle: ExpressionLike,
    upper_angle: ExpressionLike,
) -> Expression

complex_sector_limit(expression, variable, lower_angle, upper_angle) constructs the deferred limit of an expression as the variable tends to infinity inside a closed sector.

Calling forms

Explicit context: Context.complex_sector_limit

complex_sector_limit(
    input_expression: ExpressionLike,
    variable: Any,
    lower_angle: ExpressionLike,
    upper_angle: ExpressionLike,
) -> Expression

continuous_domain#

Default context

continuous_domain(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

The subset of the real line on which the expression is continuous in variable, as a set expression. Compound rational square-root radicands are lowered to an exact univariate semialgebraic condition when supported, so, for example, sqrt(x + 1/x - 2) has continuous real domain (0, infinity).

Calling forms and variants

Explicit context: Context.continuous_domain

continuous_domain(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

Expression method: Expression.continuous_domain

continuous_domain(variable: VariableLike) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.continuous_domain

continuous_domain(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

diff#

Expression method

diff(variable: Any) -> Expression

The eager derivative with respect to variable, the conventional short spelling of differentiate: y(t).diff(t) differentiates at once and never builds a deferred node.

differentiate#

Default context

differentiate(
    input_expression: ExpressionLike,
    variable: Any,
) -> Expression

Symbolic derivative with respect to variable.

Calling forms

Explicit context: Context.differentiate

differentiate(
    input_expression: ExpressionLike,
    variable: Any,
) -> Expression

Expression method: Expression.differentiate

differentiate(variable: Any) -> Expression

evaluate_complex_limit#

Default context

evaluate_complex_limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
) -> Expression

evaluate_complex_limit(expression, variable, point) evaluates a limit through a punctured complex disk. It returns the deferred complex_limit when the limit is not decided.

Calling forms

Explicit context: Context.evaluate_complex_limit

evaluate_complex_limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
) -> Expression

evaluate_complex_limit_detailed#

Default context

evaluate_complex_limit_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    point: ExpressionLike,
) -> LimitResult

Classify a limit through a punctured complex disk as finite, proved nonexistent, or undecided, keeping the status apart from the value.

Calling forms

Explicit context: Context.evaluate_complex_limit_detailed

evaluate_complex_limit_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    point: ExpressionLike,
) -> LimitResult

evaluate_complex_sector_limit#

Default context

evaluate_complex_sector_limit(
    input_expression: ExpressionLike,
    variable: Any,
    lower_angle: ExpressionLike,
    upper_angle: ExpressionLike,
) -> Expression

evaluate_complex_sector_limit(expression, variable, lower_angle, upper_angle) evaluates a limit at infinity inside a closed sector, or returns the deferred complex_sector_limit.

Calling forms

Explicit context: Context.evaluate_complex_sector_limit

evaluate_complex_sector_limit(
    input_expression: ExpressionLike,
    variable: Any,
    lower_angle: ExpressionLike,
    upper_angle: ExpressionLike,
) -> Expression

evaluate_complex_sector_limit_detailed#

Default context

evaluate_complex_sector_limit_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower_angle: ExpressionLike,
    upper_angle: ExpressionLike,
) -> LimitResult

Classify a limit at infinity inside a closed sector as finite, proved nonexistent, or undecided, keeping the status apart from the value.

Calling forms

Explicit context: Context.evaluate_complex_sector_limit_detailed

evaluate_complex_sector_limit_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower_angle: ExpressionLike,
    upper_angle: ExpressionLike,
) -> LimitResult

evaluate_joint_limit#

Default context

evaluate_joint_limit(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    point: Iterable[ExpressionLike],
    relative_domain: Optional[ExpressionLike] = None,
) -> Expression

evaluate_joint_limit(expression, variables, point, relative_domain=None) evaluates a joint limit of two or more real variables. It returns the deferred joint_limit when the limit is not decided.

Calling forms

Explicit context: Context.evaluate_joint_limit

evaluate_joint_limit(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    point: Iterable[ExpressionLike],
    relative_domain: Optional[ExpressionLike] = None,
) -> Expression

evaluate_joint_limit_detailed#

Default context

evaluate_joint_limit_detailed(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    point: Iterable[ExpressionLike],
    relative_domain: Optional[ExpressionLike] = None,
) -> LimitResult

Classify a joint limit of two or more real variables as finite, nonexistent or undecided, keeping the status apart from the value.

Calling forms

Explicit context: Context.evaluate_joint_limit_detailed

evaluate_joint_limit_detailed(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    point: Iterable[ExpressionLike],
    relative_domain: Optional[ExpressionLike] = None,
) -> LimitResult

evaluate_limit#

Default context

evaluate_limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> Expression

evaluate_limit(expression, variable, point, direction="two_sided") runs the eager limit engine. It returns an unevaluated limit when the engine cannot close the result.

Calling forms and variants

Explicit context: Context.evaluate_limit

evaluate_limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> Expression

Expression method: Expression.evaluate_limit

evaluate_limit(
    variable: Any,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.evaluate_limit

evaluate_limit(
    input_expression: ExpressionLike,
    variable: VariableLike,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> Expression

evaluate_limit_detailed#

Default context

evaluate_limit_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> LimitResult

Classify a limit as finite, a signed infinity, proved nonexistent, or undecided, keeping the status apart from the value.

Calling forms

Explicit context: Context.evaluate_limit_detailed

evaluate_limit_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> LimitResult

evaluate_on_grid#

Default context

evaluate_on_grid(
    input_expression: ExpressionLike,
    variable: VariableLike,
    x_values: list[float],
) -> list[float]

Evaluate at each grid point, substituting variable.

Calling forms

Explicit context: Context.evaluate_on_grid

evaluate_on_grid(
    input_expression: ExpressionLike,
    variable: VariableLike,
    x_values: list[float],
) -> list[float]

evaluate_on_grid_points#

Default context

evaluate_on_grid_points(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    points: list[float],
) -> list[float]

Multi-variable companion to evaluate_on_grid: evaluate at each point of a flat row-major coordinate array (one coordinate per variable, so the points length must be a multiple of the variable count), returning one float per point. Positions where evaluation fails hold NaN. Raises when variables is empty or the lengths disagree. Intended for sampling surfaces and implicit curves.

Calling forms

Explicit context: Context.evaluate_on_grid_points

evaluate_on_grid_points(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    points: list[float],
) -> list[float]

evaluate_sequence_limit#

Default context

evaluate_sequence_limit(
    input_expression: ExpressionLike,
    index: Any,
) -> Expression

evaluate_sequence_limit(expression, index) evaluates the limit of a sequence as its positive-integer index tends to infinity. It returns the deferred sequence_limit when the engine cannot decide the limit.

Calling forms and variants

Explicit context: Context.evaluate_sequence_limit

evaluate_sequence_limit(
    input_expression: ExpressionLike,
    index: Any,
) -> Expression

Expression method: Expression.evaluate_sequence_limit

evaluate_sequence_limit(index: Any) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.evaluate_sequence_limit

evaluate_sequence_limit(
    input_expression: ExpressionLike,
    index: VariableLike,
) -> Expression

evaluate_sequence_limit_detailed#

Default context

evaluate_sequence_limit_detailed(
    input_expression: ExpressionLike,
    index: VariableLike,
) -> LimitResult

Classify a sequence limit as finite, a signed infinity, proved nonexistent, or undecided, keeping the status apart from the value.

Calling forms

Explicit context: Context.evaluate_sequence_limit_detailed

evaluate_sequence_limit_detailed(
    input_expression: ExpressionLike,
    index: VariableLike,
) -> LimitResult

execute#

Default context

execute(input_expression: ExpressionLike) -> Expression

Re-dispatch every unevaluated node (integral, derivative, summation, transform, ODE/recurrence placeholder) in the expression; useful after substitution has changed the inputs.

Calling forms

Explicit context: Context.execute

execute(input_expression: ExpressionLike) -> Expression

Expression method: Expression.execute

execute() -> Expression

fourier_transform#

Default context

fourier_transform(
    input_expression: ExpressionLike,
    time_variable: VariableLike,
    frequency_variable: VariableLike,
) -> Expression

Forward Fourier transform in the angular-frequency convention F(ω)=∫f(t)e−iωt dtF(\omega) = \int f(t)e^{-i\omega t}\,dt.

Calling forms and variants

Explicit context: Context.fourier_transform

fourier_transform(
    input_expression: ExpressionLike,
    time_variable: VariableLike,
    frequency_variable: VariableLike,
) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.fourier_transform

fourier_transform(
    input_expression: ExpressionLike,
    time_variable: VariableLike,
    frequency_variable: VariableLike,
) -> Expression

integrate#

Default context

integrate(input_expression: ExpressionLike, variable: Any) -> Expression

Indefinite integration (no constant of integration).

Calling forms and variants

Explicit context: Context.integrate

integrate(input_expression: ExpressionLike, variable: Any) -> Expression

Expression method: Expression.integrate

integrate(variable: Any) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.integrate

integrate(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

integrate_definite#

Default context

integrate_definite(
    input_expression: ExpressionLike,
    variable: Any,
    lower: ExpressionLike,
    upper: ExpressionLike,
) -> Expression

Definite integration over [lower, upper] (bounds may be infinite).

Calling forms and variants

Explicit context: Context.integrate_definite

integrate_definite(
    input_expression: ExpressionLike,
    variable: Any,
    lower: ExpressionLike,
    upper: ExpressionLike,
) -> Expression

Expression method: Expression.integrate_definite

integrate_definite(
    variable: Any,
    lower: ExpressionLike,
    upper: ExpressionLike,
) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.integrate_definite

integrate_definite(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower_bound: ExpressionLike,
    upper_bound: ExpressionLike,
) -> Expression

integrate_definite_detailed#

Default context

integrate_definite_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    interpretation: str = "ordinary",
    constraint: Optional[ExpressionLike] = None,
) -> DefiniteIntegrationResult

Evaluate a definite integral under an interpretation and an optional declared region, retaining whether it was evaluated, proved divergent, or declined.

Calling forms

Explicit context: Context.integrate_definite_detailed

integrate_definite_detailed(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    interpretation: str = "ordinary",
    constraint: Optional[ExpressionLike] = None,
) -> DefiniteIntegrationResult

integrate_definite_under_constraint#

Default context

integrate_definite_under_constraint(
    input_expression: ExpressionLike,
    variable: Any,
    lower: ExpressionLike,
    upper: ExpressionLike,
    constraint: ExpressionLike,
) -> Expression

Definite integration under a local bounded logical constraint.

Calling forms

Explicit context: Context.integrate_definite_under_constraint

integrate_definite_under_constraint(
    input_expression: ExpressionLike,
    variable: Any,
    lower: ExpressionLike,
    upper: ExpressionLike,
    constraint: ExpressionLike,
) -> Expression

Expression method: Expression.integrate_definite_under_constraint

integrate_definite_under_constraint(
    variable: Any,
    lower: ExpressionLike,
    upper: ExpressionLike,
    constraint: ExpressionLike,
) -> Expression

integrate_iterated#

Default context

integrate_iterated(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Expression

Iterated indefinite integration, applying the single-variable pipeline once per entry of variables in left-to-right order (innermost binder first).

Calling forms

Explicit context: Context.integrate_iterated

integrate_iterated(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Expression

Expression method: Expression.integrate_iterated

integrate_iterated(variables: Iterable[VariableLike]) -> Expression

inverse_fourier_transform#

Default context

inverse_fourier_transform(
    input_expression: ExpressionLike,
    frequency_variable: VariableLike,
    time_variable: VariableLike,
) -> Expression

Inverse Fourier transform of the same convention.

Calling forms

Explicit context: Context.inverse_fourier_transform

inverse_fourier_transform(
    input_expression: ExpressionLike,
    frequency_variable: VariableLike,
    time_variable: VariableLike,
) -> Expression

inverse_laplace_transform#

Default context

inverse_laplace_transform(
    input_expression: ExpressionLike,
    frequency_variable: VariableLike,
    time_variable: VariableLike,
) -> Expression

Inverse Laplace transform; rational inputs route through a partial-fraction reverse lookup.

Calling forms

Explicit context: Context.inverse_laplace_transform

inverse_laplace_transform(
    input_expression: ExpressionLike,
    frequency_variable: VariableLike,
    time_variable: VariableLike,
) -> Expression

joint_limit#

Default context

joint_limit(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    point: Iterable[ExpressionLike],
    relative_domain: Optional[ExpressionLike] = None,
) -> Expression

joint_limit(expression, variables, point, relative_domain=None) constructs the deferred joint limit of an expression as the ordered variables tend together to the center, optionally relative to a domain given as a logical expression.

Calling forms

Explicit context: Context.joint_limit

joint_limit(
    input_expression: ExpressionLike,
    variables: Iterable[VariableLike],
    point: Iterable[ExpressionLike],
    relative_domain: Optional[ExpressionLike] = None,
) -> Expression

laplace_transform#

Default context

laplace_transform(
    input_expression: ExpressionLike,
    time_variable: VariableLike,
    frequency_variable: VariableLike,
) -> Expression

Forward Laplace transform F(s)=∫0∞f(t)e−st dtF(s) = \int_0^\infty f(t)e^{-st}\,dt.

Calling forms and variants

Explicit context: Context.laplace_transform

laplace_transform(
    input_expression: ExpressionLike,
    time_variable: VariableLike,
    frequency_variable: VariableLike,
) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.laplace_transform

laplace_transform(
    input_expression: ExpressionLike,
    time_variable: VariableLike,
    frequency_variable: VariableLike,
) -> Expression

laurent_series#

Default context

laurent_series(
    input_expression: ExpressionLike,
    variable: VariableLike,
    center: ExpressionLike,
    order: int,
) -> Expression

Truncated Laurent expansion at center: every (variable⁡−center⁡)k(\operatorname{variable} - \operatorname{center})^k term with −m≤k<order⁡-m \le k < \operatorname{order}, where m is the pole order. Analytic points degrade to the Taylor expansion. At an essential singularity (where pole_order declines) the result is an unevaluated series_unevaluated(...) placeholder, because no finite truncation of the principal part is correct.

Calling forms

Explicit context: Context.laurent_series

laurent_series(
    input_expression: ExpressionLike,
    variable: VariableLike,
    center: ExpressionLike,
    order: int,
) -> Expression

Expression method: Expression.laurent_series

laurent_series(
    variable: VariableLike,
    center: ExpressionLike,
    order: int,
) -> Expression

limit#

Default context

limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> Expression

limit(expression, variable, point, direction="two_sided") constructs a deferred limit.

Calling forms

Explicit context: Context.limit

limit(
    input_expression: ExpressionLike,
    variable: Any,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> Expression

Expression method: Expression.limit

limit(
    variable: Any,
    point: ExpressionLike,
    direction: str = "two_sided",
) -> Expression

maclaurin_series#

Default context

maclaurin_series(
    input_expression: ExpressionLike,
    variable: VariableLike,
    order: int,
) -> Expression

taylor_series specialised to expansion point 0.

Calling forms

Explicit context: Context.maclaurin_series

maclaurin_series(
    input_expression: ExpressionLike,
    variable: VariableLike,
    order: int,
) -> Expression

Expression method: Expression.maclaurin_series

maclaurin_series(variable: VariableLike, order: int) -> Expression

pole_order#

Default context

pole_order(
    input_expression: ExpressionLike,
    variable: VariableLike,
    center: ExpressionLike,
) -> Optional[int]

Order of the singularity at center: 0 for analytic/removable points, m≥1m \ge 1 for a pole of order mm.

Calling forms

Explicit context: Context.pole_order

pole_order(
    input_expression: ExpressionLike,
    variable: VariableLike,
    center: ExpressionLike,
) -> Optional[int]

Expression method: Expression.pole_order

pole_order(
    variable: VariableLike,
    center: ExpressionLike,
) -> Optional[int]

residue#

Default context

residue(
    input_expression: ExpressionLike,
    variable: Any,
    center: Any,
) -> Expression

Coefficient of (variable⁡−center⁡)−1(\operatorname{variable} - \operatorname{center})^{-1} in the Laurent expansion at center.

Calling forms

Explicit context: Context.residue

residue(
    input_expression: ExpressionLike,
    variable: Any,
    center: Any,
) -> Expression

Expression method: Expression.residue

residue(variable: Any, center: Any) -> Expression

sequence_limit#

Default context

sequence_limit(
    input_expression: ExpressionLike,
    index: Any,
) -> Expression

sequence_limit(expression, index) constructs the deferred limit of a sequence as its positive-integer index tends to infinity.

Calling forms

Explicit context: Context.sequence_limit

sequence_limit(
    input_expression: ExpressionLike,
    index: Any,
) -> Expression

Expression method: Expression.sequence_limit

sequence_limit(index: Any) -> Expression

singularities#

Default context

singularities(
    input_expression: ExpressionLike,
    variable: Any,
) -> Expression

The singular points of the expression in the complex plane, as a set expression (finite set, union, image set for periodic families, …).

Calling forms and variants

Explicit context: Context.singularities

singularities(
    input_expression: ExpressionLike,
    variable: Any,
) -> Expression

Expression method: Expression.singularities

singularities(variable: Any) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.singularities

singularities(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

taylor_series#

Default context

taylor_series(
    input_expression: ExpressionLike,
    variable: VariableLike,
    expansion_point: ExpressionLike,
    order: int,
) -> Expression

Truncated Taylor expansion about expansion_point, keeping terms of degree strictly less than order (the remainder is O((x−a)order⁡)O((x-a)^{\operatorname{order}}).

Calling forms and variants

Explicit context: Context.taylor_series

taylor_series(
    input_expression: ExpressionLike,
    variable: VariableLike,
    expansion_point: ExpressionLike,
    order: int,
) -> Expression

Expression method: Expression.taylor_series

taylor_series(
    variable: VariableLike,
    expansion_point: ExpressionLike,
    order: int,
) -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.taylor_series

taylor_series(
    input_expression: ExpressionLike,
    variable: VariableLike,
    expansion_point: ExpressionLike,
    truncation_order: int,
) -> Expression

e#

Default context

e: Expression

Euler's number ee, the base of the natural logarithm. exp(1) and this constant are the same expression.

Calling forms

Explicit context: Context.e

e: Expression

euler_gamma#

Default context

euler_gamma: Expression

The Euler–Mascheroni constant γ\gamma.

Calling forms

Explicit context: Context.euler_gamma

euler_gamma: Expression

imaginary_unit#

Default context

imaginary_unit: Expression

The imaginary unit ii with i2=−1i^2 = -1.

Calling forms

Explicit context: Context.imaginary_unit

imaginary_unit: Expression

infinity#

Default context

infinity: Expression

Unsigned positive infinity ∞\infty.

Calling forms

Explicit context: Context.infinity

infinity: Expression

pi#

Default context

pi: Expression

The circle constant π\pi.

Calling forms

Explicit context: Context.pi

pi: Expression

derivative#

Default context

derivative(
    input_expression: ExpressionLike,
    variable: Any,
    order: int = 1,
) -> Expression

Constructs a deferred derivative. The variable may be a name or a same-context symbol expression. Use execute to evaluate it.

Calling forms

Explicit context: Context.derivative

derivative(
    input_expression: ExpressionLike,
    variable: Any,
    order: int = 1,
) -> Expression

Expression method: Expression.derivative

derivative(variable: Any, order: int = 1) -> Expression

derivative_unevaluated#

Default context

derivative_unevaluated(
    input_expression: ExpressionLike,
    variable: Any,
    order: int = 1,
) -> Expression

Constructs the deferred derivative of the given order without differentiating; execute evaluates it. The variable may be a name or a same-context symbol expression. Use differentiate for the eager derivative.

Calling forms

Explicit context: Context.derivative_unevaluated

derivative_unevaluated(
    input_expression: ExpressionLike,
    variable: Any,
    order: int = 1,
) -> Expression

Expression method: Expression.derivative_unevaluated

derivative_unevaluated(variable: Any, order: int = 1) -> Expression

integer#

Default context

integer(value: Any) -> Expression

Build an arbitrary-precision exact integer. Python bool values are rejected. JavaScript's recommended facade accepts bigint and safe integral number values.

Calling forms

Explicit context: Context.integer

integer(value: Any) -> Expression

integer_from_string#

Default context

integer_from_string(text: str) -> Expression

Build an arbitrary-precision integer literal from its decimal string.

Calling forms

Explicit context: Context.integer_from_string

integer_from_string(text: str) -> Expression

integral#

Default context

integral(
    integrand: ExpressionLike,
    variable: Any,
    lower: Optional[ExpressionLike] = None,
    upper: Optional[ExpressionLike] = None,
) -> Expression

Build an unevaluated integral node (indefinite when bounds are omitted).

Calling forms

Explicit context: Context.integral

integral(
    integrand: ExpressionLike,
    variable: Any,
    lower: Optional[ExpressionLike] = None,
    upper: Optional[ExpressionLike] = None,
) -> Expression

parse#

Default context

parse(text: str) -> Expression

Parse Symi textual syntax into an expression. Accepts ^ and ** for powers; knows the builtin function names (sin, log, sqrt, …) and the constants pi, e.

Calling forms

Explicit context: Context.parse

parse(text: str) -> Expression

parse_latex#

Default context

parse_latex(latex: str) -> Any

Parse a LaTeX string in Symi's canonical input dialect — the inverse of to_latex and the parser the Symi frontend uses. Returns whichever top-level object the input denotes: an ordinary expression, a \begin{matrix}…\end{matrix}, or a geometry figure ((x, y) point, segment, polygon, or circle), wrapped in the matching exported class exactly as parse_serialized_object does. Coverage spans arithmetic, powers, fractions, roots, the elementary and many special functions, comparisons, integrals (including the bare-d differential), Leibniz derivatives (\frac{d}{dx} — differentiated eagerly), limits, summations, products, determinants, and actuarial annuities. The resolution is context-aware in a way parse is not: a bare i is the imaginary unit and a bare e is Euler's number unless the letter is a bound index (a summation / product / limit index shadows the constant), and \mathrm{d} — or a bare d that closes an integral — is the differential operator while a bare d elsewhere is an ordinary variable. Raises on syntax errors.

Calling forms

Explicit context: Context.parse_latex

parse_latex(latex: str) -> Any

parse_latex_with_environment#

Default context

parse_latex_with_environment(
    latex: str,
    serialized_definitions: list[str],
) -> Any

Parse LaTeX after building an ordered definition environment. Each serialized definition is a string with four fields separated by ASCII Unit Separator (U+001F): kind, name, parameters, and body_latex.

Calling forms

Explicit context: Context.parse_latex_with_environment

parse_latex_with_environment(
    latex: str,
    serialized_definitions: list[str],
) -> Any

parse_serialized_object#

Default context

parse_serialized_object(text: str) -> Any

Inverse of serialize_object; returns the matching surface class.

Calling forms

Explicit context: Context.parse_serialized_object

parse_serialized_object(text: str) -> Any

piecewise#

Default context

piecewise(
    branches: Iterable[tuple[ExpressionLike, ExpressionLike]],
    otherwise: Optional[ExpressionLike] = None,
) -> Expression

Build a piecewise expression from (value, condition) pairs with first-match semantics; otherwise appends an always-true final branch. Branches whose condition is provably false are dropped at construction; if every condition fails the result is the undefined sentinel.

Calling forms

Explicit context: Context.piecewise

piecewise(
    branches: Iterable[tuple[ExpressionLike, ExpressionLike]],
    otherwise: Optional[ExpressionLike] = None,
) -> Expression

product#

Default context

product(
    multiplicand: ExpressionLike,
    index: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
) -> Expression

Definite indexed product ∏index=loweruppermultiplicand\prod_{\mathit{index}=\mathit{lower}}^{\mathit{upper}} \mathit{multiplicand}, a first-class indexed_product binder (rendered \prod in LaTeX).

Calling forms

Explicit context: Context.product

product(
    multiplicand: ExpressionLike,
    index: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
) -> Expression

product_indefinite#

Default context

product_indefinite(
    multiplicand: ExpressionLike,
    index: VariableLike,
) -> Expression

Indefinite (anti-quotient) product: the P(k) satisfying P(k+1)/P(k) = multiplicand(k), the multiplicative analogue of summation_indefinite.

Calling forms

Explicit context: Context.product_indefinite

product_indefinite(
    multiplicand: ExpressionLike,
    index: VariableLike,
) -> Expression

rational#

Default context

rational(numerator: Any, denominator: Any) -> Expression

Constructs an exact reduced rational from arbitrary-size integers. A zero denominator is an argument error. Python also accepts fractions.Fraction wherever an expression-like input is accepted.

Calling forms

Explicit context: Context.rational

rational(numerator: Any, denominator: Any) -> Expression

reset_context#

Explicit context

reset_context() -> None

Replace the context's entire symbol table and expression store with fresh empty ones. Warning: existing expression/matrix/geometry objects from this context become stale and must not be used afterwards — their symbol identifiers no longer resolve. Deliberately not available at module level: resetting the shared default context would strand every live object, and the weak expression store already keeps memory bounded by live objects (see the default context).

serialize_object#

Default context

serialize_object(object: Any) -> str

Serialize an expression, matrix, or geometry object to the stable Symi serialization format, round-trippable via parse_serialized_object.

Calling forms

Explicit context: Context.serialize_object

serialize_object(object: Any) -> str

summation#

Default context

summation(
    summand: ExpressionLike,
    index: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
) -> Expression

Build a summation node ∑\sum.

Calling forms

Explicit context: Context.summation

summation(
    summand: ExpressionLike,
    index: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
) -> Expression

summation_indefinite#

Default context

summation_indefinite(
    summand: ExpressionLike,
    index: VariableLike,
) -> Expression

Anti-difference: a closed form FF with F(index⁡+1)−F(index⁡)=summand⁡F(\operatorname{index}+1) - F(\operatorname{index}) = \operatorname{summand}.

Calling forms

Explicit context: Context.summation_indefinite

summation_indefinite(
    summand: ExpressionLike,
    index: VariableLike,
) -> Expression

Expression method: Expression.summation_indefinite

summation_indefinite(index: VariableLike) -> Expression

symbol#

Default context

symbol(
    name: str,
    real: bool = False,
    positive: bool = False,
    negative: bool = False,
    integer: bool = False,
    finite: bool = False,
    rational: bool = False,
    natural: bool = False,
    nonzero: bool = False,
) -> Expression

Intern a symbol and (optionally) attach assumptions used by the assumption engine and the simplifier. Domain flags refine in the order natural →\to integer →\to rational →\to real; positive/negative also set nonzero, and nonzero may be requested independently.

Calling forms

Explicit context: Context.symbol

symbol(
    name: str,
    real: bool = False,
    positive: bool = False,
    negative: bool = False,
    integer: bool = False,
    finite: bool = False,
    rational: bool = False,
    natural: bool = False,
    nonzero: bool = False,
) -> Expression

to_latex#

Default context

to_latex(input_expression: ExpressionLike) -> str

Render an expression as LaTeX. Matrices and geometry objects have their own to_latex methods.

Calling forms and variants

Explicit context: Context.to_latex

to_latex(input_expression: ExpressionLike) -> str

Expression method: Expression.to_latex

to_latex() -> str

Variant for this object — Circle2d method: Circle2d.to_latex

to_latex() -> str

Variant for this object — Matrix method: Matrix.to_latex

to_latex() -> str

Variant for this object — Point2d method: Point2d.to_latex

to_latex() -> str

Variant for this object — Polygon2d method: Polygon2d.to_latex

to_latex() -> str

Variant for this object — Segment2d method: Segment2d.to_latex

to_latex() -> str

Variant for this object — Triangle2d method: Triangle2d.to_latex

to_latex() -> str

to_latex_with_options#

Default context

to_latex_with_options(
    input_expression: ExpressionLike,
    exponential_style: str,
    natural_logarithm_style: str,
    multiletter_symbol_style: str,
) -> str

Render an expression as LaTeX with presentation flags. Each argument is a string naming the choice for one flag; an unrecognized name falls back to that flag's canonical default (so to_latex_with_options(e, "", "", "") equals to_latex(e)):

Calling forms

Explicit context: Context.to_latex_with_options

to_latex_with_options(
    input_expression: ExpressionLike,
    exponential_style: str,
    natural_logarithm_style: str,
    multiletter_symbol_style: str,
) -> str

Expression method: Expression.to_latex_with_options

to_latex_with_options(
    exponential_style: str,
    natural_logarithm_style: str,
    multiletter_symbol_style: str,
) -> str

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.

AssumptionProposition.and#

AssumptionProposition method

and(other)

Conjoin two propositions.

AssumptionProposition.congruence_modulus#

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]

AssumptionProposition.left_operand#

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]

AssumptionProposition.membership_element#

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]

AssumptionProposition.membership_set#

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]

AssumptionProposition.not#

AssumptionProposition method

not()

Negate a proposition.

AssumptionProposition.or#

AssumptionProposition method

or(other)

Disjoin two propositions.

AssumptionProposition.relation_kind#

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]

AssumptionProposition.right_operand#

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]

AssumptionProposition.serialize#

Default context

serialize(proposition: Any) -> str

Serialize an assumption proposition in the versioned canonical grammar.

Calling forms

AssumptionProposition method: AssumptionProposition.serialize

serialize() -> str

AssumptionScope#

Type

class AssumptionScope

An immutable local assumption scope owned by a Python context.

Context#

Context constructor

Context()

Create an isolated context with its own symbol table, interner, and assumptions.

add_assumptions#

Default context

add_assumptions(proposition: Any) -> None

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

Calling forms

Explicit context: Context.add_assumptions

add_assumptions(proposition: Any) -> None

algebraic_assumption#

Default context

algebraic_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build an algebraicity assumption proposition in the default context.

Calling forms

Explicit context: Context.algebraic_assumption

algebraic_assumption(subject: ExpressionLike) -> AssumptionProposition

ask#

Default context

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

Ask whether a proposition is entailed by the default context's assumptions.

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]

assuming#

Default context

assuming(proposition: Any) -> AssumptionScope

Create an immutable local assumption scope in the default context.

Calling forms and variants

Explicit context: Context.assuming

assuming(proposition: Any) -> AssumptionScope

Variant using local assumptions — AssumptionScope method: AssumptionScope.assuming

assuming(proposition: Any) -> AssumptionScope

assumption_proposition_from_logical_expression#

Default context

assumption_proposition_from_logical_expression(logical_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.assumption_proposition_from_logical_expression

assumption_proposition_from_logical_expression(logical_expression: ExpressionLike) -> AssumptionProposition

assumptions_of#

Default context

assumptions_of(variable: Any) -> list[str]

Return every assumption declared about one symbol, as a list of proposition texts such as "real(x)" or "prime(n)". The variable may be a name or same-context symbol. The list is what was declared, not what can be proved; use ask for a three-valued verdict.

Calling forms

Explicit context: Context.assumptions_of

assumptions_of(variable: Any) -> list[str]

clear_all_assumptions#

Default context

clear_all_assumptions() -> None

Clear all assumptions in the default context.

Calling forms

Explicit context: Context.clear_all_assumptions

clear_all_assumptions() -> None

clear_assumptions#

Default context

clear_assumptions(variable: VariableLike) -> None

Reset one symbol's assumptions to the default (complex domain, every property unknown).

Calling forms

Explicit context: Context.clear_assumptions

clear_assumptions(variable: VariableLike) -> None

complex_assumption#

Default context

complex_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.complex_assumption

complex_assumption(subject: ExpressionLike) -> AssumptionProposition

composite_assumption#

Default context

composite_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a compositeness assumption proposition in the default context.

Calling forms

Explicit context: Context.composite_assumption

composite_assumption(subject: ExpressionLike) -> AssumptionProposition

congruent_assumption#

Default context

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

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

Calling forms

Explicit context: Context.congruent_assumption

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

could_hold#

Default context

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

Ask whether a proposition is compatible with the default context's assumptions.

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]

default_context#

Default context

default_context() -> Context

Return a handle to the thread's default context — the same context every module-level function and direct structural-class constructor uses. Pass it to code written against the explicit-context API. Each call returns a new handle to the same underlying context.

defined_assumption#

Default context

defined_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a pointwise definedness assumption proposition in the default context.

Calling forms

Explicit context: Context.defined_assumption

defined_assumption(subject: ExpressionLike) -> AssumptionProposition

deserialize_assumption_proposition#

Default context

deserialize_assumption_proposition(text: str) -> AssumptionProposition

Parse a versioned canonical assumption proposition in the default context.

Calling forms

Explicit context: Context.deserialize_assumption_proposition

deserialize_assumption_proposition(text: str) -> AssumptionProposition

differentiate_bulk#

Default context

differentiate_bulk(
    targets: Iterable[ExpressionLike],
    variable: ExpressionLike,
) -> Any

Differentiate an ordered collection in the thread's default context.

Calling forms

Explicit context: Context.differentiate_bulk

differentiate_bulk(
    targets: Iterable[ExpressionLike],
    variable: ExpressionLike,
) -> Any

equal_assumption#

Default context

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

Build an equality assumption proposition in the default context.

Calling forms

Explicit context: Context.equal_assumption

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

evaluate_numeric_bulk#

Default context

evaluate_numeric_bulk(
    targets: Iterable[ExpressionLike],
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> Any

Evaluate an ordered collection numerically in the thread's default context.

Calling forms

Explicit context: Context.evaluate_numeric_bulk

evaluate_numeric_bulk(
    targets: Iterable[ExpressionLike],
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> Any

even_assumption#

Default context

even_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build an evenness assumption proposition in the default context.

Calling forms

Explicit context: Context.even_assumption

even_assumption(subject: ExpressionLike) -> AssumptionProposition

execution_mode#

Default context

execution_mode() -> str

Return the execution mode selected by the thread's default context.

Calling forms

Explicit context: Context.execution_mode

execution_mode() -> str

expand_bulk#

Default context

expand_bulk(targets: Iterable[ExpressionLike]) -> Any

Expand an ordered collection in the thread's default context.

Calling forms

Explicit context: Context.expand_bulk

expand_bulk(targets: Iterable[ExpressionLike]) -> Any

extended_real_assumption#

Default context

extended_real_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.extended_real_assumption

extended_real_assumption(subject: ExpressionLike) -> AssumptionProposition

finite_assumption#

Default context

finite_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a finiteness assumption proposition in the default context.

Calling forms

Explicit context: Context.finite_assumption

finite_assumption(subject: ExpressionLike) -> AssumptionProposition

greater_assumption#

Default context

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

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

Calling forms

Explicit context: Context.greater_assumption

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

greater_or_equal_assumption#

Default context

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

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

Calling forms

Explicit context: Context.greater_or_equal_assumption

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

infinite_assumption#

Default context

infinite_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build an infinity assumption proposition in the default context.

Calling forms

Explicit context: Context.infinite_assumption

infinite_assumption(subject: ExpressionLike) -> AssumptionProposition

initialize_parallelism#

Default context

initialize_parallelism(worker_count: int) -> str

Initialize the process-wide parallel backend from the thread's default context.

Calling forms

Explicit context: Context.initialize_parallelism

initialize_parallelism(worker_count: int) -> str

integer_assumption#

Default context

integer_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build an integer assumption proposition in the default context.

Calling forms

Explicit context: Context.integer_assumption

integer_assumption(subject: ExpressionLike) -> AssumptionProposition

interner_length#

Default context

interner_length() -> int

Number of live expressions currently interned in the context. Dead entries awaiting the amortized sweep are not counted. Useful for observing memory in long-running sessions and in tests that assert the store stays bounded.

Calling forms

Explicit context: Context.interner_length

interner_length() -> int

irrational_assumption#

Default context

irrational_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build an irrationality assumption proposition in the default context.

Calling forms

Explicit context: Context.irrational_assumption

irrational_assumption(subject: ExpressionLike) -> AssumptionProposition

less_assumption#

Default context

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

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

Calling forms

Explicit context: Context.less_assumption

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

less_or_equal_assumption#

Default context

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

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

Calling forms

Explicit context: Context.less_or_equal_assumption

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

member_assumption#

Default context

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

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

Calling forms

Explicit context: Context.member_assumption

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

natural_assumption#

Default context

natural_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.natural_assumption

natural_assumption(subject: ExpressionLike) -> AssumptionProposition

negative_assumption#

Default context

negative_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.negative_assumption

negative_assumption(subject: ExpressionLike) -> AssumptionProposition

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

nonzero_assumption#

Default context

nonzero_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a nonzero assumption proposition in the default context.

Calling forms

Explicit context: Context.nonzero_assumption

nonzero_assumption(subject: ExpressionLike) -> AssumptionProposition

not_equal_assumption#

Default context

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

Build a disequality assumption proposition in the default context.

Calling forms

Explicit context: Context.not_equal_assumption

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

odd_assumption#

Default context

odd_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build an oddness assumption proposition in the default context.

Calling forms

Explicit context: Context.odd_assumption

odd_assumption(subject: ExpressionLike) -> AssumptionProposition

parallelism_capability#

Default context

parallelism_capability() -> Any

Return capability facts for the thread's default context.

Calling forms

Explicit context: Context.parallelism_capability

parallelism_capability() -> Any

positive_assumption#

Default context

positive_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.positive_assumption

positive_assumption(subject: ExpressionLike) -> AssumptionProposition

positive_integer_assumption#

Default context

positive_integer_assumption(input_expression: ExpressionLike) -> AssumptionProposition

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

Calling forms

Explicit context: Context.positive_integer_assumption

positive_integer_assumption(subject: ExpressionLike) -> AssumptionProposition

prime_assumption#

Default context

prime_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a primality assumption proposition in the default context.

Calling forms

Explicit context: Context.prime_assumption

prime_assumption(subject: ExpressionLike) -> AssumptionProposition

rational_assumption#

Default context

rational_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a rationality assumption proposition in the default context.

Calling forms

Explicit context: Context.rational_assumption

rational_assumption(subject: ExpressionLike) -> AssumptionProposition

real_assumption#

Default context

real_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a realness assumption proposition in the default context.

Calling forms

Explicit context: Context.real_assumption

real_assumption(subject: ExpressionLike) -> AssumptionProposition

refine#

Default context

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

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

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

serialize_bulk#

Default context

serialize_bulk(targets: Iterable[ExpressionLike]) -> Any

Serialize an ordered collection in the thread's default context.

Calling forms

Explicit context: Context.serialize_bulk

serialize_bulk(targets: Iterable[ExpressionLike]) -> Any

set_execution_mode#

Default context

set_execution_mode(name: str) -> None

Select the execution mode used by the thread's default context.

Calling forms

Explicit context: Context.set_execution_mode

set_execution_mode(name: str) -> None

simplify_bulk#

Default context

simplify_bulk(targets: Iterable[ExpressionLike]) -> Any

Simplify an ordered collection in the thread's default context.

Calling forms

Explicit context: Context.simplify_bulk

simplify_bulk(targets: Iterable[ExpressionLike]) -> Any

substitute_bulk#

Default context

substitute_bulk(
    targets: Iterable[ExpressionLike],
    variable: ExpressionLike,
    value: ExpressionLike,
) -> Any

Substitute one symbol and value throughout an ordered collection in the thread's default context.

Calling forms

Explicit context: Context.substitute_bulk

substitute_bulk(
    targets: Iterable[ExpressionLike],
    variable: ExpressionLike,
    value: ExpressionLike,
) -> Any

transcendental_assumption#

Default context

transcendental_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a transcendence assumption proposition in the default context.

Calling forms

Explicit context: Context.transcendental_assumption

transcendental_assumption(subject: ExpressionLike) -> AssumptionProposition

zero_assumption#

Default context

zero_assumption(input_expression: ExpressionLike) -> AssumptionProposition

Build a zero assumption proposition in the default context.

Calling forms

Explicit context: Context.zero_assumption

zero_assumption(subject: ExpressionLike) -> AssumptionProposition

zero_equivalent#

Default context

zero_equivalent(
    input_expression: ExpressionLike,
    constraint: Optional[ExpressionLike] = None,
) -> str

Prove whether an expression is zero wherever it is defined, returning "true", "false", or "unknown".

Calling forms

Explicit context: Context.zero_equivalent

zero_equivalent(
    input_expression: ExpressionLike,
    constraint: Optional[ExpressionLike] = None,
) -> str

Expression method: Expression.zero_equivalent

zero_equivalent(constraint: Optional[ExpressionLike] = None) -> str

iter#

Expression method

__iter__() -> Any

Iterate the elements of a finite_set expression.

len#

Expression method

__len__() -> int

Number of elements of a finite_set expression.

bell_number#

Default context

bell_number(n: ExpressionLike) -> Expression

The n-th Bell number.

Calling forms

Explicit context: Context.bell_number

bell_number(n: ExpressionLike) -> Expression

catalan_number#

Default context

catalan_number(n: ExpressionLike) -> Expression

The n-th Catalan number.

Calling forms

Explicit context: Context.catalan_number

catalan_number(n: ExpressionLike) -> Expression

chinese_remainder#

Default context

chinese_remainder(residues_and_moduli: Iterable[tuple[ExpressionLike, ExpressionLike]]) -> Expression

The smallest non-negative solution of the simultaneous congruences x≡ri(modmi)x \equiv r_i \pmod{m_i}.

Calling forms

Explicit context: Context.chinese_remainder

chinese_remainder(residues_and_moduli: Iterable[tuple[ExpressionLike, ExpressionLike]]) -> Expression

complex_plane#

Default context

complex_plane: Expression

The set C\mathbb{C} — the ambient universe, and the domain a variable ranges over when it carries no realness assumption.

Calling forms

Explicit context: Context.complex_plane

complex_plane: Expression

condition_set#

Default context

condition_set(
    variable: VariableLike,
    condition: ExpressionLike,
    domain: ExpressionLike,
) -> Expression

The set {variable⁡∈domain⁡:condition⁡}\{\operatorname{variable} \in \operatorname{domain} : \operatorname{condition}\}.

Calling forms

Explicit context: Context.condition_set

condition_set(
    variable: VariableLike,
    condition: ExpressionLike,
    domain: ExpressionLike,
) -> Expression

conjunctive_normal_form#

Default context

conjunctive_normal_form(input_expression: ExpressionLike) -> Expression

The dual of disjunctive_normal_form: a reduced conjunctive normal form (an AND of OR-clauses over literals).

Calling forms

Explicit context: Context.conjunctive_normal_form

conjunctive_normal_form(input_expression: ExpressionLike) -> Expression

Expression method: Expression.conjunctive_normal_form

conjunctive_normal_form() -> Expression

continued_fraction_quadratic_irrational#

Default context

continued_fraction_quadratic_irrational(value: ExpressionLike) -> tuple[list[Expression], list[Expression]]

Eventually-periodic expansion of d\sqrt{d} for a non-negative integer d, returned as (initial_terms, periodic_part).

Calling forms

Explicit context: Context.continued_fraction_quadratic_irrational

continued_fraction_quadratic_irrational(value: ExpressionLike) -> tuple[list[Expression], list[Expression]]

continued_fraction_rational#

Default context

continued_fraction_rational(value: ExpressionLike) -> list[Expression]

Terminating continued-fraction expansion [a0; a1, a2, ...] of an integer or rational expression leaf.

Calling forms

Explicit context: Context.continued_fraction_rational

continued_fraction_rational(value: ExpressionLike) -> list[Expression]

disjunctive_normal_form#

Default context

disjunctive_normal_form(input_expression: ExpressionLike) -> Expression

Rewrite a propositional formula into a reduced disjunctive normal form (an OR of AND-terms over literals): derived connectives are eliminated, negations are pushed to the atoms, the formula is distributed, and contradictory, duplicate, and subsumed terms are dropped.

Calling forms

Explicit context: Context.disjunctive_normal_form

disjunctive_normal_form(input_expression: ExpressionLike) -> Expression

Expression method: Expression.disjunctive_normal_form

disjunctive_normal_form() -> Expression

divisor_count#

Default context

divisor_count(n: ExpressionLike) -> Expression

Number of positive divisors τ(n)\tau(n).

Calling forms

Explicit context: Context.divisor_count

divisor_count(n: ExpressionLike) -> Expression

divisor_sigma#

Default context

divisor_sigma(n: ExpressionLike, power: int) -> Expression

Sum of the power-th powers of the positive divisors σpower(n)\sigma_{\mathit{power}}(n); power = 0 gives divisor_count, power = 1 the divisor sum.

Calling forms

Explicit context: Context.divisor_sigma

divisor_sigma(n: ExpressionLike, power: int) -> Expression

eliminate_derived_logical_connectives#

Default context

eliminate_derived_logical_connectives(input_expression: ExpressionLike) -> Expression

Rewrite every implies, equivalent, and exclusive_or occurrence into the logical_and / logical_or / logical_not basis. This is a directed presentation request, not a cost decision, so the result may be larger than the input; a formula already in the basis, and a conversion that would cross the fixed size ceiling, both return the input unchanged.

Calling forms

Explicit context: Context.eliminate_derived_logical_connectives

eliminate_derived_logical_connectives(input_expression: ExpressionLike) -> Expression

Expression method: Expression.eliminate_derived_logical_connectives

eliminate_derived_logical_connectives() -> Expression

empty_set#

Default context

empty_set: Expression

The empty set ∅\varnothing.

Calling forms

Explicit context: Context.empty_set

empty_set: Expression

enumerate_set_in_interval#

Default context

enumerate_set_in_interval(
    set: ExpressionLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    lower_inclusive: bool = True,
    upper_inclusive: bool = True,
    limit: Optional[int] = None,
) -> Any

Exact elements of a set inside [lower⁡,upper⁡][\operatorname{lower}, \operatorname{upper}], in increasing order, as {"outcome": str, "elements": list[expression]}. outcome is "complete" when those are exactly the elements in the interval, "truncated" when limit cut the list short (the family is still solved), and "declined" when the set's shape is not enumerable — never a licence to approximate.

Calling forms

Explicit context: Context.enumerate_set_in_interval

enumerate_set_in_interval(
    set: ExpressionLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    lower_inclusive: bool = True,
    upper_inclusive: bool = True,
    limit: Optional[int] = None,
) -> Any

euler_totient#

Default context

euler_totient(n: ExpressionLike) -> Expression

Euler's φ(n)\varphi(n); requires a positive integer.

Calling forms

Explicit context: Context.euler_totient

euler_totient(n: ExpressionLike) -> Expression

evaluate_truth#

Default context

evaluate_truth(input_expression: ExpressionLike) -> Optional[bool]

evaluate_truth(predicate) uses exact three-valued logic. Python returns True, False, or None; JavaScript returns true, false, or null; Rust returns truth_value. The third value means undecided, never false: a host-language if reads it as falsy, so compare against True / False explicitly. Order, equality and sign relations between closed-form real constants — rationals, pi, radicals and real algebraic numbers — are decided exactly by rational arithmetic; transcendental, symbolic and provably non-real operands decline rather than guess.

Calling forms

Explicit context: Context.evaluate_truth

evaluate_truth(input_expression: ExpressionLike) -> Optional[bool]

Expression method: Expression.evaluate_truth

evaluate_truth() -> Optional[bool]

extended_euclidean#

Default context

extended_euclidean(
    a: ExpressionLike,
    b: ExpressionLike,
) -> tuple[Expression, Expression, Expression]

(gcd, x, y) with ax+by=gcd⁡a x + b y = \operatorname{gcd}.

Calling forms

Explicit context: Context.extended_euclidean

extended_euclidean(
    a: ExpressionLike,
    b: ExpressionLike,
) -> tuple[Expression, Expression, Expression]

factor_integer#

Default context

factor_integer(n: ExpressionLike) -> list[tuple[Expression, int]]

Prime factorization as (prime, multiplicity) pairs, ascending. Errors on zero. Notes: WASM returns prime_factor objects with prime/multiplicity getters; the sign −1-1 of a negative input is carried as a leading (-1, 1) factor exactly as the core reports it.

Calling forms

Explicit context: Context.factor_integer

factor_integer(n: ExpressionLike) -> list[tuple[Expression, int]]

falling_factorial#

Default context

falling_factorial(
    base: ExpressionLike,
    length: ExpressionLike,
) -> Expression

base⁡(base⁡−1)⋯(base⁡−length⁡+1)\operatorname{base}(\operatorname{base}-1)\cdots(\operatorname{base}-\operatorname{length}+1); length must be a non-negative integer, base may be any integer.

Calling forms

Explicit context: Context.falling_factorial

falling_factorial(
    base: ExpressionLike,
    length: ExpressionLike,
) -> Expression

fibonacci_number#

Default context

fibonacci_number(n: ExpressionLike) -> Expression

The n-th Fibonacci number (F(0) = 0, F(1) = 1).

Calling forms

Explicit context: Context.fibonacci_number

fibonacci_number(n: ExpressionLike) -> Expression

finite_set#

Default context

finite_set(elements: Any) -> Expression

Finite set; elements are deduplicated and canonically ordered. An empty list gives the empty set.

Calling forms

Explicit context: Context.finite_set

finite_set(elements: Any) -> Expression

image_set#

Default context

image_set(
    lambda_expression: ExpressionLike,
    variable: VariableLike,
    domain: ExpressionLike,
) -> Expression

The set {lambda_expression⁡:variable⁡∈domain⁡}\{\operatorname{lambda\_expression} : \operatorname{variable} \in \operatorname{domain}\}; variable is a binder over lambda_expression.

Calling forms

Explicit context: Context.image_set

image_set(
    lambda_expression: ExpressionLike,
    variable: VariableLike,
    domain: ExpressionLike,
) -> Expression

integer_gcd#

Default context

integer_gcd(a: ExpressionLike, b: ExpressionLike) -> Expression

Greatest common divisor (non-negative).

Calling forms

Explicit context: Context.integer_gcd

integer_gcd(a: ExpressionLike, b: ExpressionLike) -> Expression

integer_lcm#

Default context

integer_lcm(a: ExpressionLike, b: ExpressionLike) -> Expression

Least common multiple.

Calling forms

Explicit context: Context.integer_lcm

integer_lcm(a: ExpressionLike, b: ExpressionLike) -> Expression

integer_nth_root#

Default context

integer_nth_root(n: ExpressionLike, root_index: int) -> Expression

⌊n1/root_index⌋\lfloor n^{1/\mathit{root\_index}}\rfloor; odd indices accept negative n. Errors when no real root exists (even index, negative n).

Calling forms

Explicit context: Context.integer_nth_root

integer_nth_root(n: ExpressionLike, root_index: int) -> Expression

integer_set#

Default context

integer_set: Expression

The set Z\mathbb{Z}.

Calling forms

Explicit context: Context.integer_set

integer_set: Expression

integer_square_root#

Default context

integer_square_root(n: ExpressionLike) -> Expression

⌊n⌋\lfloor\sqrt{n}\rfloor for non-negative n.

Calling forms

Explicit context: Context.integer_square_root

integer_square_root(n: ExpressionLike) -> Expression

interval#

Default context

interval(
    lower: ExpressionLike,
    upper: ExpressionLike,
    lower_open: bool = False,
    upper_open: bool = False,
) -> Expression

Real-line interval. Closed by default; endpoints at infinity are forced open. Degenerate shapes collapse (empty interval →\to empty set, single point →\to finite set, (−∞,∞)→(-\infty, \infty)\to real line).

Calling forms

Explicit context: Context.interval

interval(
    lower: ExpressionLike,
    upper: ExpressionLike,
    lower_open: bool = False,
    upper_open: bool = False,
) -> Expression

introduce_derived_logical_connectives#

Default context

introduce_derived_logical_connectives(input_expression: ExpressionLike) -> Expression

Recognise the exact canonical definitions of implication, equivalence, and exclusive-or inside an and/or/not formula and replace each match with the derived connective, but only where the replacement is strictly smaller. It is a local structural compressor: a formula merely equivalent to a definition, without matching it, is left unchanged.

Calling forms

Explicit context: Context.introduce_derived_logical_connectives

introduce_derived_logical_connectives(input_expression: ExpressionLike) -> Expression

Expression method: Expression.introduce_derived_logical_connectives

introduce_derived_logical_connectives() -> Expression

is_member#

Default context

is_member(
    element: ExpressionLike,
    set: ExpressionLike,
) -> Optional[bool]

Three-valued membership: True only on structural proof, False only on a structural counterexample, None otherwise. Covers ∅\varnothing, R\mathbb{R}, finite sets, intervals, unions, intersections, complements.

Calling forms

Explicit context: Context.is_member

is_member(
    element: ExpressionLike,
    set: ExpressionLike,
) -> Optional[bool]

is_prime#

Default context

is_prime(n: ExpressionLike) -> Optional[bool]

Deterministic primality verdict; None when the input is outside the classifier's domain (e.g. not a natural number ≥0\geq 0 representation it handles).

Calling forms

Explicit context: Context.is_prime

is_prime(n: ExpressionLike) -> Optional[bool]

Expression method: Expression.is_prime

is_prime() -> Optional[bool]

is_subset#

Default context

is_subset(
    set_a: ExpressionLike,
    set_b: ExpressionLike,
) -> Optional[bool]

Three-valued subset query: ∅⊆\varnothing \subseteq anything, structural equality, finite-set element checks, interval-in-interval endpoint tests; None otherwise.

Calling forms

Explicit context: Context.is_subset

is_subset(
    set_a: ExpressionLike,
    set_b: ExpressionLike,
) -> Optional[bool]

jacobi_symbol#

Default context

jacobi_symbol(
    numerator: ExpressionLike,
    denominator: ExpressionLike,
) -> int

The Jacobi symbol (n/d)∈{−1,0,1}(n/d) \in \{-1, 0, 1\}; the denominator must be a positive odd integer.

Calling forms

Explicit context: Context.jacobi_symbol

jacobi_symbol(
    numerator: ExpressionLike,
    denominator: ExpressionLike,
) -> int

kronecker_symbol#

Default context

kronecker_symbol(
    numerator: ExpressionLike,
    denominator: ExpressionLike,
) -> int

The Kronecker extension of the Jacobi symbol to all integer denominators.

Calling forms

Explicit context: Context.kronecker_symbol

kronecker_symbol(
    numerator: ExpressionLike,
    denominator: ExpressionLike,
) -> int

legendre_symbol#

Default context

legendre_symbol(numerator: ExpressionLike, prime: ExpressionLike) -> int

The Legendre symbol; the second argument must be an odd prime.

Calling forms

Explicit context: Context.legendre_symbol

legendre_symbol(numerator: ExpressionLike, prime: ExpressionLike) -> int

logical_false#

Default context

logical_false: Expression

The Boolean constant false (⊥\bot).

Calling forms

Explicit context: Context.logical_false

logical_false: Expression

logical_true#

Default context

logical_true: Expression

The Boolean constant true (⊤\top).

Calling forms

Explicit context: Context.logical_true

logical_true: Expression

minimize_logical#

Default context

minimize_logical(input_expression: ExpressionLike) -> Expression

The smaller of the minimum sum-of-products and product-of-sums two-level forms. Within a practical atom bound this is the exact Quine–McCluskey minimum (prime implicants, essential extraction, and Petrick's method on the residual chart); above it, an Espresso-style heuristic returns a good — not provably minimal — cover.

Calling forms

Explicit context: Context.minimize_logical

minimize_logical(input_expression: ExpressionLike) -> Expression

Expression method: Expression.minimize_logical

minimize_logical() -> Expression

mobius#

Default context

mobius(n: ExpressionLike) -> Expression

Möbius μ(n)∈{−1,0,1}\mu(n) \in \{-1, 0, 1\}; requires a positive integer.

Calling forms

Explicit context: Context.mobius

mobius(n: ExpressionLike) -> Expression

modular_inverse#

Default context

modular_inverse(
    value: ExpressionLike,
    modulus: ExpressionLike,
) -> Expression

Multiplicative inverse of value modulo modulus; errors when gcd⁡(value⁡,modulus⁡)≠1\operatorname{gcd}(\operatorname{value}, \operatorname{modulus}) \ne 1.

Calling forms

Explicit context: Context.modular_inverse

modular_inverse(
    value: ExpressionLike,
    modulus: ExpressionLike,
) -> Expression

modular_power#

Default context

modular_power(
    base: ExpressionLike,
    exponent: ExpressionLike,
    modulus: ExpressionLike,
) -> Expression

base^exponent mod modulus by square-and-multiply; requires positive modulus and non-negative exponent.

Calling forms

Explicit context: Context.modular_power

modular_power(
    base: ExpressionLike,
    exponent: ExpressionLike,
    modulus: ExpressionLike,
) -> Expression

multinomial#

Default context

multinomial(parts: Iterable[ExpressionLike]) -> Expression

Multinomial coefficient (∑parts⁡)!/∏(part⁡i!)(\sum \operatorname{parts})! / \prod (\operatorname{part}_i!); parts must be non-negative integers.

Calling forms

Explicit context: Context.multinomial

multinomial(parts: Iterable[ExpressionLike]) -> Expression

partition_count#

Default context

partition_count(n: ExpressionLike) -> Expression

Number of integer partitions p(n).

Calling forms

Explicit context: Context.partition_count

partition_count(n: ExpressionLike) -> Expression

pell_solutions#

Default context

pell_solutions(radicand: ExpressionLike, count: int) -> list[Expression]

The first count positive solutions of x2−Dy2=1x^2 - D y^2 = 1, materialised from the fundamental solution by the Pell recurrence and returned as a flat list [x1,y1,x2,y2,…][x_1, y_1, x_2, y_2, \ldots].

Calling forms

Explicit context: Context.pell_solutions

pell_solutions(radicand: ExpressionLike, count: int) -> list[Expression]

real_line#

Default context

real_line: Expression

The set R\mathbb{R}.

Calling forms

Explicit context: Context.real_line

real_line: Expression

rising_factorial#

Default context

rising_factorial(
    base: ExpressionLike,
    length: ExpressionLike,
) -> Expression

base⁡(base⁡+1)⋯(base⁡+length⁡−1)\operatorname{base}(\operatorname{base}+1)\cdots(\operatorname{base}+\operatorname{length}-1) (the Pochhammer symbol on integers).

Calling forms

Explicit context: Context.rising_factorial

rising_factorial(
    base: ExpressionLike,
    length: ExpressionLike,
) -> Expression

set_complement#

Default context

set_complement(
    set_a: ExpressionLike,
    set_b: ExpressionLike,
) -> Expression

The relative complement a∖ba \setminus b.

Calling forms

Explicit context: Context.set_complement

set_complement(
    set_a: ExpressionLike,
    set_b: ExpressionLike,
) -> Expression

set_intersection#

Default context

set_intersection(
    set_a: ExpressionLike,
    set_b: ExpressionLike,
) -> Expression

Intersection, computed eagerly where the structural rules allow (interval pairs, finite-set membership filtering; R\mathbb{R} drops, ∅\varnothing absorbs); otherwise the structural set_intersection node.

Calling forms

Explicit context: Context.set_intersection

set_intersection(
    set_a: ExpressionLike,
    set_b: ExpressionLike,
) -> Expression

set_union#

Default context

set_union(set_a: ExpressionLike, set_b: ExpressionLike) -> Expression

Union, computed eagerly where the structural rules allow (overlapping or touching interval pairs merge; nested unions splice, ∅\varnothing drops, R\mathbb{R} absorbs); otherwise the structural set_union node.

Calling forms

Explicit context: Context.set_union

set_union(set_a: ExpressionLike, set_b: ExpressionLike) -> Expression

simplify_logical#

Default context

simplify_logical(input_expression: ExpressionLike) -> Expression

Return whichever of the original form, the disjunctive and conjunctive normal forms, and the two minimal two-level forms has the smallest weighted size.

Calling forms

Explicit context: Context.simplify_logical

simplify_logical(input_expression: ExpressionLike) -> Expression

Expression method: Expression.simplify_logical

simplify_logical() -> Expression

solve_integers#

Default context

solve_integers(
    equations: Iterable[ExpressionLike],
    unknowns: Iterable[VariableLike],
    congruences: Optional[Iterable[ExpressionLike]] = ...,
    moduli: Optional[Iterable[ExpressionLike]] = ...,
    maximum_seed_candidates: int = ...,
    maximum_integer_bits: int = ...,
) -> Any

Solve equations and linear congruences over the integers, returning the complete exact solution set as tuples in integer parameters, or a typed decline.

Calling forms

Explicit context: Context.solve_integers

solve_integers(
    equations: Iterable[ExpressionLike],
    unknowns: Iterable[VariableLike],
    congruences: Optional[Iterable[ExpressionLike]] = ...,
    moduli: Optional[Iterable[ExpressionLike]] = ...,
    maximum_seed_candidates: int = ...,
    maximum_integer_bits: int = ...,
) -> Any

solve_linear_diophantine#

Default context

solve_linear_diophantine(
    coefficients: Iterable[ExpressionLike],
    constant: ExpressionLike,
) -> list[Expression]

General integer solution of a1x1+…+anxn=ca_1 x_1 + \ldots + a_n x_n = c, returned as the parametric coordinates — one expression per unknown, affine in fresh integer parameter symbols (diophantine_parameter_k) shared across the coordinates so that choosing any integers for the parameters yields a solution tuple. The list is empty when the equation has no integer solution (gcd⁡(ai)∤c\gcd(a_i) \nmid c).

Calling forms

Explicit context: Context.solve_linear_diophantine

solve_linear_diophantine(
    coefficients: Iterable[ExpressionLike],
    constant: ExpressionLike,
) -> list[Expression]

solve_linear_diophantine_system#

Default context

solve_linear_diophantine_system(
    coefficient_matrix: Matrix,
    constants: Iterable[ExpressionLike],
) -> list[Expression]

General integer solution of the rectangular system Ax=bA x = b, returned as one parametric coordinate expression per column of A.

Calling forms

Explicit context: Context.solve_linear_diophantine_system

solve_linear_diophantine_system(
    coefficient_matrix: Matrix,
    constants: Iterable[ExpressionLike],
) -> list[Expression]

solve_negative_pell#

Default context

solve_negative_pell(radicand: ExpressionLike) -> list[Expression]

Fundamental solution [x, y] of the negative-Pell equation x2−Dy2=−1x^2 - D y^2 = -1 when it is solvable (exactly when the continued fraction of D\sqrt{D} has odd period), and an empty list otherwise.

Calling forms

Explicit context: Context.solve_negative_pell

solve_negative_pell(radicand: ExpressionLike) -> list[Expression]

solve_pell#

Default context

solve_pell(radicand: ExpressionLike) -> list[Expression]

Fundamental solution [x, y] of x2−Dy2=1x^2 - D y^2 = 1 for a positive non-square integer D, the smallest positive solution from which all others are generated by the recurrence xk+1=x1xk+Dy1ykx_{k+1} = x_1 x_k + D y_1 y_k, yk+1=x1yk+y1xky_{k+1} = x_1 y_k + y_1 x_k.

Calling forms

Explicit context: Context.solve_pell

solve_pell(radicand: ExpressionLike) -> list[Expression]

stirling_first_signed#

Default context

stirling_first_signed(
    n: ExpressionLike,
    k: ExpressionLike,
) -> Expression

Signed Stirling number of the first kind s(n, k).

Calling forms

Explicit context: Context.stirling_first_signed

stirling_first_signed(
    n: ExpressionLike,
    k: ExpressionLike,
) -> Expression

stirling_second#

Default context

stirling_second(n: ExpressionLike, k: ExpressionLike) -> Expression

Stirling number of the second kind S(n, k).

Calling forms

Explicit context: Context.stirling_second

stirling_second(n: ExpressionLike, k: ExpressionLike) -> Expression

EquationTransformation#

Type

class EquationTransformation

An equation produced by side-wise arithmetic, with how it relates to its input.

EquationTransformation.condition#

EquationTransformation property

condition: Expression

The Boolean condition on the free symbols under which the relation is claimed.

EquationTransformation.equation#

EquationTransformation property

equation: Expression

The transformed equation.

EquationTransformation.relation#

EquationTransformation property

relation: str

Whether the transformed equation is equivalent to its input or only implied by it.

abs#

Default context

abs(x: Any) -> Expression

Absolute value of x.

Calling forms

Explicit context: Context.abs

abs(x: Any) -> Expression

arccos#

Default context

arccos(x: Any) -> Expression

Inverse cosine of x.

Calling forms

Explicit context: Context.arccos

arccos(x: Any) -> Expression

arccosh#

Default context

arccosh(x: Any) -> Expression

Inverse hyperbolic cosine of x.

Calling forms

Explicit context: Context.arccosh

arccosh(x: Any) -> Expression

arccot#

Default context

arccot(x: Any) -> Expression

Inverse cotangent of x.

Calling forms

Explicit context: Context.arccot

arccot(x: Any) -> Expression

arccoth#

Default context

arccoth(x: Any) -> Expression

Inverse hyperbolic cotangent of x.

Calling forms

Explicit context: Context.arccoth

arccoth(x: Any) -> Expression

arccsc#

Default context

arccsc(x: Any) -> Expression

Inverse cosecant of x.

Calling forms

Explicit context: Context.arccsc

arccsc(x: Any) -> Expression

arccsch#

Default context

arccsch(x: Any) -> Expression

Inverse hyperbolic cosecant of x.

Calling forms

Explicit context: Context.arccsch

arccsch(x: Any) -> Expression

arcsec#

Default context

arcsec(x: Any) -> Expression

Inverse secant of x.

Calling forms

Explicit context: Context.arcsec

arcsec(x: Any) -> Expression

arcsech#

Default context

arcsech(x: Any) -> Expression

Inverse hyperbolic secant of x.

Calling forms

Explicit context: Context.arcsech

arcsech(x: Any) -> Expression

arcsin#

Default context

arcsin(x: Any) -> Expression

Inverse sine of x.

Calling forms

Explicit context: Context.arcsin

arcsin(x: Any) -> Expression

arcsinh#

Default context

arcsinh(x: Any) -> Expression

Inverse hyperbolic sine of x.

Calling forms

Explicit context: Context.arcsinh

arcsinh(x: Any) -> Expression

arctan#

Default context

arctan(x: Any) -> Expression

Inverse tangent of x.

Calling forms

Explicit context: Context.arctan

arctan(x: Any) -> Expression

arctanh#

Default context

arctanh(x: Any) -> Expression

Inverse hyperbolic tangent of x.

Calling forms

Explicit context: Context.arctanh

arctanh(x: Any) -> Expression

binomial#

Default context

binomial(n: Any, k: Any) -> Expression

Binomial coefficient C(n, k).

Calling forms

Explicit context: Context.binomial

binomial(n: Any, k: Any) -> Expression

ceiling#

Default context

ceiling(x: Any) -> Expression

Least integer greater than or equal to x.

Calling forms

Explicit context: Context.ceiling

ceiling(x: Any) -> Expression

conjugate#

Default context

conjugate(x: Any) -> Expression

Complex conjugate.

Calling forms

Explicit context: Context.conjugate

conjugate(x: Any) -> Expression

cos#

Default context

cos(x: Any) -> Expression

Cosine of x.

Calling forms

Explicit context: Context.cos

cos(x: Any) -> Expression

cosh#

Default context

cosh(x: Any) -> Expression

Hyperbolic cosine of x.

Calling forms

Explicit context: Context.cosh

cosh(x: Any) -> Expression

cot#

Default context

cot(x: Any) -> Expression

Cotangent of x, the reciprocal of the tangent.

Calling forms

Explicit context: Context.cot

cot(x: Any) -> Expression

coth#

Default context

coth(x: Any) -> Expression

Hyperbolic cotangent of x, the reciprocal of the hyperbolic tangent.

Calling forms

Explicit context: Context.coth

coth(x: Any) -> Expression

csc#

Default context

csc(x: Any) -> Expression

Cosecant of x, the reciprocal of the sine.

Calling forms

Explicit context: Context.csc

csc(x: Any) -> Expression

csch#

Default context

csch(x: Any) -> Expression

Hyperbolic cosecant of x, the reciprocal of the hyperbolic sine.

Calling forms

Explicit context: Context.csch

csch(x: Any) -> Expression

equal#

Default context

equal(left: Any, right: Any) -> Expression

Build the relation left = right without deciding its truth.

Calling forms

Explicit context: Context.equal

equal(left: Any, right: Any) -> Expression

Expression method: Expression.equal

equal(other: ExpressionLike) -> Expression

equation#

Default context

equation(left: Any, right: Any) -> Expression

Build an immutable equation value without deciding its truth.

Calling forms

Explicit context: Context.equation

equation(left: Any, right: Any) -> Expression

Expression method: Expression.equation

equation(other: ExpressionLike) -> Expression

exp#

Default context

exp(x: Any) -> Expression

The natural exponential.

Calling forms

Explicit context: Context.exp

exp(x: Any) -> Expression

factorial#

Default context

factorial(x: Any) -> Expression

Factorial of x, evaluated exactly on nonnegative integers.

Calling forms

Explicit context: Context.factorial

factorial(x: Any) -> Expression

floor#

Default context

floor(x: Any) -> Expression

Greatest integer less than or equal to x.

Calling forms

Explicit context: Context.floor

floor(x: Any) -> Expression

greater_than#

Default context

greater_than(left: Any, right: Any) -> Expression

Build the relation left > right without deciding its truth.

Calling forms

Explicit context: Context.greater_than

greater_than(left: Any, right: Any) -> Expression

Expression method: Expression.__gt__

__gt__(other: ExpressionLike) -> Expression

Expression method: Expression.greater_than

greater_than(other: ExpressionLike) -> Expression

greater_than_or_equal#

Default context

greater_than_or_equal(left: Any, right: Any) -> Expression

Build the relation left >= right without deciding its truth.

Calling forms

Explicit context: Context.greater_than_or_equal

greater_than_or_equal(left: Any, right: Any) -> Expression

Expression method: Expression.__ge__

__ge__(other: ExpressionLike) -> Expression

Expression method: Expression.greater_than_or_equal

greater_than_or_equal(other: ExpressionLike) -> Expression

less_than#

Default context

less_than(left: Any, right: Any) -> Expression

Build the relation left < right without deciding its truth.

Calling forms

Explicit context: Context.less_than

less_than(left: Any, right: Any) -> Expression

Expression method: Expression.__lt__

__lt__(other: ExpressionLike) -> Expression

Expression method: Expression.less_than

less_than(other: ExpressionLike) -> Expression

less_than_or_equal#

Default context

less_than_or_equal(left: Any, right: Any) -> Expression

Build the relation left <= right without deciding its truth.

Calling forms

Explicit context: Context.less_than_or_equal

less_than_or_equal(left: Any, right: Any) -> Expression

Expression method: Expression.__le__

__le__(other: ExpressionLike) -> Expression

Expression method: Expression.less_than_or_equal

less_than_or_equal(other: ExpressionLike) -> Expression

log#

Default context

log(x: Any, base: Optional[Any] = None) -> Expression

Natural logarithm; with base given, log(x)/log(base).

Calling forms

Explicit context: Context.log

log(x: Any, base: Optional[Any] = None) -> Expression

max#

Default context

max(*arguments: Any) -> Expression

Maximum of the arguments (variadic in Python; a JS array in WASM).

Calling forms

Explicit context: Context.max

max(*arguments: Any) -> Expression

min#

Default context

min(*arguments: Any) -> Expression

Minimum of the arguments (variadic in Python; a JS array in WASM).

Calling forms

Explicit context: Context.min

min(*arguments: Any) -> Expression

not_equal#

Default context

not_equal(left: Any, right: Any) -> Expression

Build the relation left != right without deciding its truth.

Calling forms

Explicit context: Context.not_equal

not_equal(left: Any, right: Any) -> Expression

Expression method: Expression.not_equal

not_equal(other: ExpressionLike) -> Expression

root#

Default context

root(x: Any, n: Any) -> Expression

Principal n-th root, stored as x^(1/n).

Calling forms

Explicit context: Context.root

root(x: Any, n: Any) -> Expression

sec#

Default context

sec(x: Any) -> Expression

Secant of x, the reciprocal of the cosine.

Calling forms

Explicit context: Context.sec

sec(x: Any) -> Expression

sech#

Default context

sech(x: Any) -> Expression

Hyperbolic secant of x, the reciprocal of the hyperbolic cosine.

Calling forms

Explicit context: Context.sech

sech(x: Any) -> Expression

sin#

Default context

sin(x: Any) -> Expression

Sine of x.

Calling forms

Explicit context: Context.sin

sin(x: Any) -> Expression

sinh#

Default context

sinh(x: Any) -> Expression

Hyperbolic sine of x.

Calling forms

Explicit context: Context.sinh

sinh(x: Any) -> Expression

sqrt#

Default context

sqrt(x: Any) -> Expression

Principal square root, stored as x^(1/2).

Calling forms

Explicit context: Context.sqrt

sqrt(x: Any) -> Expression

tan#

Default context

tan(x: Any) -> Expression

Tangent of x.

Calling forms

Explicit context: Context.tan

tan(x: Any) -> Expression

tanh#

Default context

tanh(x: Any) -> Expression

Hyperbolic tangent of x.

Calling forms

Explicit context: Context.tanh

tanh(x: Any) -> Expression

transform_equation#

Default context

transform_equation(
    left: ExpressionLike,
    right: ExpressionLike,
    operation: str,
) -> EquationTransformation

Apply one arithmetic operation to an equation, reporting how the result relates to it.

Calling forms

Explicit context: Context.transform_equation

transform_equation(
    left: ExpressionLike,
    right: ExpressionLike,
    operation: str,
) -> EquationTransformation

FirstOrderNonlinearParametricSolution#

Type

class FirstOrderNonlinearParametricSolution

One separately certified parameterized nonlinear first-order solution branch.

FirstOrderNonlinearParametricSolution.coordinate#

FirstOrderNonlinearParametricSolution property

coordinate: Expression

The independent coordinate as a function of the parameter.

FirstOrderNonlinearParametricSolution.generated_constants#

FirstOrderNonlinearParametricSolution property

generated_constants: list[Expression]

The integration constants of this parameterized branch.

FirstOrderNonlinearParametricSolution.parameter#

FirstOrderNonlinearParametricSolution property

parameter: Expression

The exact parameter symbol for this parameterized branch.

FirstOrderNonlinearParametricSolution.value#

FirstOrderNonlinearParametricSolution property

value: Expression

The dependent value as a function of the parameter.

FirstOrderNonlinearSolutionAnalysis#

Type

class FirstOrderNonlinearSolutionAnalysis

The complete certified branch analysis of one nonlinear first-order equation.

FirstOrderNonlinearSolutionAnalysis.parametric_solutions#

FirstOrderNonlinearSolutionAnalysis property

parametric_solutions: list[FirstOrderNonlinearParametricSolution]

Every certified parameterized branch.

FirstOrderNonlinearSolutionAnalysis.regular_family#

FirstOrderNonlinearSolutionAnalysis property

regular_family: Optional[FirstOrderNonlinearSolutionBranch]

The certified regular one-parameter family, when one was proved.

FirstOrderNonlinearSolutionAnalysis.singular_solutions#

FirstOrderNonlinearSolutionAnalysis property

singular_solutions: list[FirstOrderNonlinearSolutionBranch]

Every certified singular or equilibrium branch outside the regular family.

FirstOrderNonlinearSolutionBranch#

Type

class FirstOrderNonlinearSolutionBranch

One separately certified regular or singular nonlinear first-order solution branch.

FirstOrderNonlinearSolutionBranch.expression#

FirstOrderNonlinearSolutionBranch property

expression: Expression

The branch value or its implicit residual relation.

FirstOrderNonlinearSolutionBranch.form#

FirstOrderNonlinearSolutionBranch property

form: str

Whether this branch gives a value or an implicit relation read as zero.

FirstOrderNonlinearSolutionBranch.generated_constants#

FirstOrderNonlinearSolutionBranch property

generated_constants: list[Expression]

The free constants generated for this branch.

LinearDifferentialOperator#

Type

class LinearDifferentialOperator

A normalized rational-coefficient scalar linear differential operator.

LinearDifferentialOperator.coefficients#

LinearDifferentialOperator property

coefficients: list[Expression]

Coefficients in ascending derivative order.

LinearDifferentialOperator.forcing#

LinearDifferentialOperator property

forcing: Expression

The forcing in L[y] = forcing.

LinearDifferentialOperator.order#

LinearDifferentialOperator property

order: int

The order of this differential operator.

LinearDifferentialOperator.restrictions#

LinearDifferentialOperator property

restrictions: list[Expression]

Denominators required to remain nonzero on the operator chart.

OrdinaryDifferentialEquationPointSymmetry#

Type

class OrdinaryDifferentialEquationPointSymmetry

One independently verified first-order ordinary differential equation point symmetry.

OrdinaryDifferentialEquationPointSymmetry.horizontal_component#

OrdinaryDifferentialEquationPointSymmetry property

horizontal_component: Expression

The horizontal component of the verified infinitesimal generator.

OrdinaryDifferentialEquationPointSymmetry.vertical_component#

OrdinaryDifferentialEquationPointSymmetry property

vertical_component: Expression

The vertical component of the verified infinitesimal generator.

OrdinaryDifferentialEquationPointSymmetrySearch#

Type

class OrdinaryDifferentialEquationPointSymmetrySearch

The bounded first-order point-symmetry search outcome and its typed decline, if any.

OrdinaryDifferentialEquationPointSymmetrySearch.decline#

OrdinaryDifferentialEquationPointSymmetrySearch property

decline: Optional[str]

The typed reason no symmetry was proved, when the bounded search declined.

OrdinaryDifferentialEquationPointSymmetrySearch.symmetries#

OrdinaryDifferentialEquationPointSymmetrySearch property

symmetries: list[OrdinaryDifferentialEquationPointSymmetry]

Every independently verified generator found within the fixed search budget.

OrdinaryDifferentialEquationSeries#

Type

class OrdinaryDifferentialEquationSeries

An exact formal local Taylor solution with its recurrence and initial data.

OrdinaryDifferentialEquationSeries.expansion_point#

OrdinaryDifferentialEquationSeries property

expansion_point: Expression

The expansion point.

OrdinaryDifferentialEquationSeries.initial_coefficients#

OrdinaryDifferentialEquationSeries property

initial_coefficients: list[Expression]

Normalized Taylor coefficients from the supplied initial derivative jet.

OrdinaryDifferentialEquationSeries.operator#

OrdinaryDifferentialEquationSeries property

operator: LinearDifferentialOperator

The normalized operator defining this local problem.

OrdinaryDifferentialEquationSeries.proof_status#

OrdinaryDifferentialEquationSeries property

proof_status: str

The exact proof status of this series.

OrdinaryDifferentialEquationSeries.recurrence#

OrdinaryDifferentialEquationSeries property

recurrence: OrdinaryDifferentialEquationSeriesRecurrence

The all-index recurrence proved by formal coefficient comparison.

OrdinaryDifferentialEquationSeriesRecurrence#

Type

class OrdinaryDifferentialEquationSeriesRecurrence

An all-index Taylor coefficient recurrence for a local ordinary differential equation series.

OrdinaryDifferentialEquationSeriesRecurrence.forcing_coefficients#

OrdinaryDifferentialEquationSeriesRecurrence property

forcing_coefficients: list[Expression]

Shifted forcing coefficients.

OrdinaryDifferentialEquationSeriesRecurrence.index_start#

OrdinaryDifferentialEquationSeriesRecurrence property

index_start: int

The first nonnegative recurrence index.

OrdinaryDifferentialEquationSeriesRecurrence.operator_coefficient_series#

OrdinaryDifferentialEquationSeriesRecurrence property

operator_coefficient_series: list[Expression]

Concatenated shifted coefficient series in derivative-order sequence.

OrdinaryDifferentialEquationSeriesRecurrence.operator_coefficient_series_lengths#

OrdinaryDifferentialEquationSeriesRecurrence property

operator_coefficient_series_lengths: list[int]

The length of each derivative-order coefficient series in the concatenation.

OrdinaryDifferentialEquationSeriesRecurrence.order#

OrdinaryDifferentialEquationSeriesRecurrence property

order: int

The order of the operator defining this recurrence.

OrdinaryDifferentialEquationSolveResult#

Type

class OrdinaryDifferentialEquationSolveResult

A scalar ordinary differential equation outcome that keeps the evidence behind its answer.

OrdinaryDifferentialEquationSolveResult.decline#

OrdinaryDifferentialEquationSolveResult property

decline: Optional[str]

The typed reason no certified candidate was produced.

OrdinaryDifferentialEquationSolveResult.form#

OrdinaryDifferentialEquationSolveResult property

form: Optional[str]

Whether the solution is the value of the unknown or a relation read as zero.

OrdinaryDifferentialEquationSolveResult.frequency_domain_equation#

OrdinaryDifferentialEquationSolveResult property

frequency_domain_equation: Optional[Expression]

The frequency-domain equation of a Laplace transform solution, read as zero.

OrdinaryDifferentialEquationSolveResult.generality#

OrdinaryDifferentialEquationSolveResult property

generality: Optional[str]

The rank decision behind a complete-family claim, when the request required one.

OrdinaryDifferentialEquationSolveResult.generated_constants#

OrdinaryDifferentialEquationSolveResult property

generated_constants: list[Expression]

Exactly the constants the solution treats as free.

OrdinaryDifferentialEquationSolveResult.image#

OrdinaryDifferentialEquationSolveResult property

image: Optional[Expression]

The image of the unknown a Laplace transform solution solved for.

OrdinaryDifferentialEquationSolveResult.method#

OrdinaryDifferentialEquationSolveResult property

method: str

The method the request actually ran.

OrdinaryDifferentialEquationSolveResult.solution#

OrdinaryDifferentialEquationSolveResult property

solution: Optional[Expression]

The certified solution, which no declined request carries.

OrdinaryDifferentialEquationSolveResult.verdict#

OrdinaryDifferentialEquationSolveResult property

verdict: str

Whether the request was solved or declined.

OrdinaryDifferentialEquationSolveResult.verification#

OrdinaryDifferentialEquationSolveResult property

verification: Optional[str]

The independent verifier's decision on the candidate, when verification ran.

OrdinaryDifferentialEquationSystemSolveResult#

Type

class OrdinaryDifferentialEquationSystemSolveResult

A system of ordinary differential equations outcome that keeps the evidence behind its answer.

OrdinaryDifferentialEquationSystemSolveResult.components#

OrdinaryDifferentialEquationSystemSolveResult property

components: list[Expression]

One explicit value per declared unknown, in declaration order, when solved.

OrdinaryDifferentialEquationSystemSolveResult.decline#

OrdinaryDifferentialEquationSystemSolveResult property

decline: Optional[str]

The typed reason no certified assignment was produced.

OrdinaryDifferentialEquationSystemSolveResult.generality#

OrdinaryDifferentialEquationSystemSolveResult property

generality: Optional[str]

The rank decision on the constants-to-initial-jet map, when verification ran.

OrdinaryDifferentialEquationSystemSolveResult.generated_constants#

OrdinaryDifferentialEquationSystemSolveResult property

generated_constants: list[Expression]

Exactly the constants the assignment treats as free.

OrdinaryDifferentialEquationSystemSolveResult.method#

OrdinaryDifferentialEquationSystemSolveResult property

method: str

The method the system request actually ran.

OrdinaryDifferentialEquationSystemSolveResult.route#

OrdinaryDifferentialEquationSystemSolveResult property

route: Optional[str]

The route the certified assignment came from.

OrdinaryDifferentialEquationSystemSolveResult.verdict#

OrdinaryDifferentialEquationSystemSolveResult property

verdict: str

Whether the system was solved or declined.

OrdinaryDifferentialEquationSystemSolveResult.verification#

OrdinaryDifferentialEquationSystemSolveResult property

verification: Optional[str]

The independent verifier's decision on the assignment, when verification ran.

OrdinaryDifferentialEquationSystemVerificationReport#

Type

class OrdinaryDifferentialEquationSystemVerificationReport

Independent exact evidence about a supplied assignment for a system of ordinary differential equations.

OrdinaryDifferentialEquationSystemVerificationReport.generality#

OrdinaryDifferentialEquationSystemVerificationReport property

generality: str

The rank decision on the map from the supplied constants to the initial jet.

OrdinaryDifferentialEquationSystemVerificationReport.required_rank#

OrdinaryDifferentialEquationSystemVerificationReport property

required_rank: int

The dimension a complete family of the system must span.

OrdinaryDifferentialEquationSystemVerificationReport.verdict#

OrdinaryDifferentialEquationSystemVerificationReport property

verdict: str

The decision on every equation residual and every datum of the supplied assignment.

PartialDifferentialEquationArbitraryFunction#

Type

class PartialDifferentialEquationArbitraryFunction

A collision-free arbitrary function allocated for a PDE candidate.

PartialDifferentialEquationArbitraryFunction.repr#

PartialDifferentialEquationArbitraryFunction method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationArbitraryFunction.arity#

PartialDifferentialEquationArbitraryFunction property

arity: int

The recorded and validated function arity.

PartialDifferentialEquationArbitraryFunction.name#

PartialDifferentialEquationArbitraryFunction property

name: str

The collision-free allocated function name.

PartialDifferentialEquationArbitraryFunction.summary#

PartialDifferentialEquationArbitraryFunction method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationCanonicalizationResult#

Type

class PartialDifferentialEquationCanonicalizationResult

The verified canonical coordinates or typed decline from automatic canonicalization.

PartialDifferentialEquationCanonicalizationResult.repr#

PartialDifferentialEquationCanonicalizationResult method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationCanonicalizationResult.canonicalized#

PartialDifferentialEquationCanonicalizationResult property

canonicalized: bool

Whether verified canonical coordinates were constructed.

PartialDifferentialEquationCanonicalizationResult.decline#

PartialDifferentialEquationCanonicalizationResult property

decline: Optional[str]

The exact reason automatic canonicalization declined.

PartialDifferentialEquationCanonicalizationResult.principal_form#

PartialDifferentialEquationCanonicalizationResult property

principal_form: Optional[str]

The exact canonical principal form that was reached.

PartialDifferentialEquationCanonicalizationResult.summary#

PartialDifferentialEquationCanonicalizationResult method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationCanonicalizationResult.transformation#

PartialDifferentialEquationCanonicalizationResult property

transformation: Optional[PartialDifferentialEquationTransformationResult]

The verified coordinate transformation of a successful canonicalization.

PartialDifferentialEquationCanonicalizationResult.transformation_decline#

PartialDifferentialEquationCanonicalizationResult property

transformation_decline: Optional[str]

The underlying coordinate-transformation decline, when one caused the decline.

PartialDifferentialEquationClassification#

Type

class PartialDifferentialEquationClassification

Exact structural analysis data for one scalar partial differential equation.

PartialDifferentialEquationClassification.repr#

PartialDifferentialEquationClassification method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationClassification.coefficient_data#

PartialDifferentialEquationClassification property

coefficient_data: PartialDifferentialEquationCoefficientData

The exact affine coefficient data extracted from the governing residual.

PartialDifferentialEquationClassification.linearity#

PartialDifferentialEquationClassification property

linearity: str

The most-specific exact linearity class.

PartialDifferentialEquationClassification.method_candidates#

PartialDifferentialEquationClassification property

method_candidates: Any

The advisory methods in deterministic preference order.

PartialDifferentialEquationClassification.order#

PartialDifferentialEquationClassification property

order: int

The exact highest derivative order.

PartialDifferentialEquationClassification.second_order_principal_part#

PartialDifferentialEquationClassification property

second_order_principal_part: Optional[PartialDifferentialEquationPrincipalPart]

The exact second-order principal metadata, when the equation has one.

PartialDifferentialEquationClassification.summary#

PartialDifferentialEquationClassification method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationCoefficientData.repr#

PartialDifferentialEquationCoefficientData method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationCoefficientData.full_coefficients#

PartialDifferentialEquationCoefficientData property

full_coefficients: Optional[list[PartialDifferentialEquationJetCoefficient]]

Every jet coefficient, when the equation is exactly linear.

PartialDifferentialEquationCoefficientData.highest_order_coefficients#

PartialDifferentialEquationCoefficientData property

highest_order_coefficients: Optional[list[PartialDifferentialEquationJetCoefficient]]

The highest-order jet coefficients, when the equation is affine in them.

PartialDifferentialEquationCoefficientData.homogeneous#

PartialDifferentialEquationCoefficientData property

homogeneous: Optional[bool]

Whether the equation was proved homogeneous, when that statement is meaningful.

PartialDifferentialEquationCoefficientData.remainder#

PartialDifferentialEquationCoefficientData property

remainder: Optional[Expression]

The exact jet-free remainder term, when one was extracted.

PartialDifferentialEquationCoefficientData.summary#

PartialDifferentialEquationCoefficientData method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationCoordinateChange#

Type

class PartialDifferentialEquationCoordinateChange

A validated exact two-variable change of independent variables.

PartialDifferentialEquationCoordinateChange.repr#

PartialDifferentialEquationCoordinateChange method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationCoordinateChange.forward_coordinates#

PartialDifferentialEquationCoordinateChange property

forward_coordinates: list[Expression]

The ordered source-to-target coordinate expressions.

PartialDifferentialEquationCoordinateChange.inverse_coordinates#

PartialDifferentialEquationCoordinateChange property

inverse_coordinates: list[Expression]

The ordered target-to-source coordinate expressions.

PartialDifferentialEquationCoordinateChange.jacobian#

PartialDifferentialEquationCoordinateChange property

jacobian: Expression

The exact forward-map Jacobian determinant.

PartialDifferentialEquationCoordinateChange.serialize_object#

PartialDifferentialEquationCoordinateChange method

serialize_object() -> str

Serialize this coordinate change in the versioned canonical object grammar.

PartialDifferentialEquationCoordinateChange.source_variables#

PartialDifferentialEquationCoordinateChange property

source_variables: list[str]

The ordered source coordinate names.

PartialDifferentialEquationCoordinateChange.summary#

PartialDifferentialEquationCoordinateChange method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationCoordinateChange.target_dependent_function#

PartialDifferentialEquationCoordinateChange property

target_dependent_function: str

The target unknown-function name.

PartialDifferentialEquationCoordinateChange.target_variables#

PartialDifferentialEquationCoordinateChange property

target_variables: list[str]

The ordered target coordinate names.

PartialDifferentialEquationJetCoefficient.repr#

PartialDifferentialEquationJetCoefficient method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationJetCoefficient.coefficient#

PartialDifferentialEquationJetCoefficient property

coefficient: Expression

The exact coefficient expression.

PartialDifferentialEquationJetCoefficient.derivative_orders#

PartialDifferentialEquationJetCoefficient property

derivative_orders: list[int]

The derivative multi-index of the jet this coefficient multiplies.

PartialDifferentialEquationJetCoefficient.summary#

PartialDifferentialEquationJetCoefficient method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationMethodCandidate.repr#

PartialDifferentialEquationMethodCandidate method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationMethodCandidate.method#

PartialDifferentialEquationMethodCandidate property

method: str

The stable advisory method name.

PartialDifferentialEquationMethodCandidate.proof_obligations#

PartialDifferentialEquationMethodCandidate property

proof_obligations: list[str]

The exact obligations this method must discharge before it may solve.

PartialDifferentialEquationMethodCandidate.summary#

PartialDifferentialEquationMethodCandidate method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationPointSymmetryAction#

Type

class PartialDifferentialEquationPointSymmetryAction

The connected local point-symmetry action of a PDE, or its typed decline.

PartialDifferentialEquationPointSymmetryAction.repr#

PartialDifferentialEquationPointSymmetryAction method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationPointSymmetryAction.admits_additive_solution_symmetry#

PartialDifferentialEquationPointSymmetryAction property

admits_additive_solution_symmetry: bool

Whether the action adds an arbitrary solution by linear superposition.

PartialDifferentialEquationPointSymmetryAction.amplitude#

PartialDifferentialEquationPointSymmetryAction property

amplitude: Optional[Expression]

The amplitude multiplying the transformed seed.

PartialDifferentialEquationPointSymmetryAction.applied_to_seed#

PartialDifferentialEquationPointSymmetryAction method

applied_to_seed(seed: UndefinedFunction) -> Expression

The transformed seed solution under the action.

PartialDifferentialEquationPointSymmetryAction.applied_to_seed_with_additive_solution#

PartialDifferentialEquationPointSymmetryAction method

applied_to_seed_with_additive_solution(
    seed: UndefinedFunction,
    additive_solution: UndefinedFunction,
) -> Expression

The transformed seed solution plus an added solution under the action.

PartialDifferentialEquationPointSymmetryAction.decline#

PartialDifferentialEquationPointSymmetryAction property

decline: Optional[str]

The typed reason the action was not constructed.

PartialDifferentialEquationPointSymmetryAction.intertwining#

PartialDifferentialEquationPointSymmetryAction property

intertwining: Optional[str]

The exact decision on the intertwining identity.

PartialDifferentialEquationPointSymmetryAction.invertibility#

PartialDifferentialEquationPointSymmetryAction property

invertibility: Optional[str]

The exact decision that the coordinate map is invertible on its chart.

PartialDifferentialEquationPointSymmetryAction.multiplier#

PartialDifferentialEquationPointSymmetryAction property

multiplier: Optional[Expression]

The multiplier of the intertwining identity.

PartialDifferentialEquationPointSymmetryAction.outstanding_obligations#

PartialDifferentialEquationPointSymmetryAction property

outstanding_obligations: list[str]

The claims the action explicitly does not make.

PartialDifferentialEquationPointSymmetryAction.parameters#

PartialDifferentialEquationPointSymmetryAction property

parameters: list[Expression]

The group parameters the closed forms depend on.

PartialDifferentialEquationPointSymmetryAction.point_symmetry_decline#

PartialDifferentialEquationPointSymmetryAction property

point_symmetry_decline: Optional[str]

The reason the underlying point-symmetry algebra was not derived, when it was not.

PartialDifferentialEquationPointSymmetryAction.summary#

PartialDifferentialEquationPointSymmetryAction method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationPointSymmetryAction.transformed_coordinates#

PartialDifferentialEquationPointSymmetryAction property

transformed_coordinates: list[Expression]

The coordinates at which a seed solution is evaluated.

PartialDifferentialEquationPointSymmetryAlgebra#

Type

class PartialDifferentialEquationPointSymmetryAlgebra

The derived point-symmetry algebra of a PDE, or its typed decline.

PartialDifferentialEquationPointSymmetryAlgebra.repr#

PartialDifferentialEquationPointSymmetryAlgebra method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationPointSymmetryAlgebra.admits_additive_solution_symmetry#

PartialDifferentialEquationPointSymmetryAlgebra property

admits_additive_solution_symmetry: bool

Whether adding any solution of the linear homogeneous equation is also a symmetry.

PartialDifferentialEquationPointSymmetryAlgebra.basis#

PartialDifferentialEquationPointSymmetryAlgebra property

basis: list[PartialDifferentialEquationPointSymmetryGenerator]

The independently verified basis generators, one per parameter.

PartialDifferentialEquationPointSymmetryAlgebra.decline#

PartialDifferentialEquationPointSymmetryAlgebra property

decline: Optional[str]

The typed reason the algebra was not derived.

PartialDifferentialEquationPointSymmetryAlgebra.determining_equations#

PartialDifferentialEquationPointSymmetryAlgebra property

determining_equations: list[Expression]

The determining equations exactly as derived, before any reduction.

PartialDifferentialEquationPointSymmetryAlgebra.general_generator#

PartialDifferentialEquationPointSymmetryAlgebra property

general_generator: Optional[PartialDifferentialEquationPointSymmetryGenerator]

The general generator, a combination of the basis through the parameters.

PartialDifferentialEquationPointSymmetryAlgebra.outstanding_obligations#

PartialDifferentialEquationPointSymmetryAlgebra property

outstanding_obligations: list[str]

The claims the algebra explicitly does not make.

PartialDifferentialEquationPointSymmetryAlgebra.parameters#

PartialDifferentialEquationPointSymmetryAlgebra property

parameters: list[Expression]

The constants of the general generator, one per basis generator.

PartialDifferentialEquationPointSymmetryAlgebra.summary#

PartialDifferentialEquationPointSymmetryAlgebra method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationPointSymmetryGenerator#

Type

class PartialDifferentialEquationPointSymmetryGenerator

One point-symmetry generator of a PDE, given by its infinitesimals.

PartialDifferentialEquationPointSymmetryGenerator.repr#

PartialDifferentialEquationPointSymmetryGenerator method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationPointSymmetryGenerator.coordinate_infinitesimals#

PartialDifferentialEquationPointSymmetryGenerator property

coordinate_infinitesimals: list[Expression]

The coordinate infinitesimals in the problem's independent-variable order.

PartialDifferentialEquationPointSymmetryGenerator.dependent_infinitesimal#

PartialDifferentialEquationPointSymmetryGenerator property

dependent_infinitesimal: Expression

The dependent infinitesimal of the generator.

PartialDifferentialEquationPointSymmetryGenerator.summary#

PartialDifferentialEquationPointSymmetryGenerator method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationPrincipalCoefficient.repr#

PartialDifferentialEquationPrincipalCoefficient method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationPrincipalCoefficient.coefficient#

PartialDifferentialEquationPrincipalCoefficient property

coefficient: Expression

The raw coefficient expression, before mixed terms are halved.

PartialDifferentialEquationPrincipalCoefficient.derivative_orders#

PartialDifferentialEquationPrincipalCoefficient property

derivative_orders: list[int]

The derivative multi-index of the second-order jet this coefficient multiplies.

PartialDifferentialEquationPrincipalCoefficient.summary#

PartialDifferentialEquationPrincipalCoefficient method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationPrincipalPart.repr#

PartialDifferentialEquationPrincipalPart method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationPrincipalPart.derivative_coefficients#

PartialDifferentialEquationPrincipalPart property

derivative_coefficients: list[PartialDifferentialEquationPrincipalCoefficient]

The raw mixed-derivative coefficients, before symmetrization halves them.

PartialDifferentialEquationPrincipalPart.matrix#

PartialDifferentialEquationPrincipalPart property

matrix: Matrix

The symmetric principal matrix whose quadratic form is the exact principal symbol.

PartialDifferentialEquationPrincipalPart.summary#

PartialDifferentialEquationPrincipalPart method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationProblem#

Type

class PartialDifferentialEquationProblem

A validated scalar partial differential equation owned by one Python context.

PartialDifferentialEquationProblem.repr#

PartialDifferentialEquationProblem method

__repr__() -> str

The repr() text of this problem, which is its deterministic plain-text form.

PartialDifferentialEquationProblem.str#

PartialDifferentialEquationProblem method

__str__() -> str

The deterministic plain-text form of this problem.

PartialDifferentialEquationProblem.boundary_conditions#

PartialDifferentialEquationProblem property

boundary_conditions: list[Expression]

The boundary-condition residuals in insertion order.

PartialDifferentialEquationProblem.dependent_function#

PartialDifferentialEquationProblem property

dependent_function: str

The declared dependent-function name.

PartialDifferentialEquationProblem.equation#

PartialDifferentialEquationProblem property

equation: Expression

The governing residual, interpreted as equal to zero.

PartialDifferentialEquationProblem.independent_variables#

PartialDifferentialEquationProblem property

independent_variables: list[str]

The independent variables in their semantic declared order.

PartialDifferentialEquationProblem.initial_conditions#

PartialDifferentialEquationProblem property

initial_conditions: list[Expression]

The initial-condition residuals in insertion order.

PartialDifferentialEquationProblem.serialize_object#

PartialDifferentialEquationProblem method

serialize_object() -> str

Serialize this problem in the versioned canonical object grammar.

PartialDifferentialEquationProblem.to_latex#

PartialDifferentialEquationProblem method

to_latex() -> str

Render this problem as LaTeX, as a system when it carries conditions.

PartialDifferentialEquationSecondOrderClassification#

Type

class PartialDifferentialEquationSecondOrderClassification

Exact real elliptic, parabolic, or hyperbolic analysis of a second-order equation.

PartialDifferentialEquationSecondOrderClassification.repr#

PartialDifferentialEquationSecondOrderClassification method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSecondOrderClassification.cases#

PartialDifferentialEquationSecondOrderClassification property

cases: list[PartialDifferentialEquationSecondOrderTypeCase]

The complete exact case table, when the verdict is conditional.

PartialDifferentialEquationSecondOrderClassification.decline#

PartialDifferentialEquationSecondOrderClassification property

decline: Optional[str]

The exact reason an unknown analysis could not be completed.

PartialDifferentialEquationSecondOrderClassification.discriminant#

PartialDifferentialEquationSecondOrderClassification property

discriminant: Expression

The exact discriminant b^2 - a*c of the symmetric principal matrix.

PartialDifferentialEquationSecondOrderClassification.equation_type#

PartialDifferentialEquationSecondOrderClassification property

equation_type: Optional[str]

The single proved classical type, when the verdict is definite.

PartialDifferentialEquationSecondOrderClassification.principal_matrix#

PartialDifferentialEquationSecondOrderClassification property

principal_matrix: Matrix

The frozen symmetric principal matrix this analysis classified.

PartialDifferentialEquationSecondOrderClassification.proof_obligations#

PartialDifferentialEquationSecondOrderClassification property

proof_obligations: list[str]

The obligations a downstream canonical-coordinate route must discharge.

PartialDifferentialEquationSecondOrderClassification.summary#

PartialDifferentialEquationSecondOrderClassification method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSecondOrderClassification.verdict#

PartialDifferentialEquationSecondOrderClassification property

verdict: str

Whether one type, a complete case table, or neither was proved.

PartialDifferentialEquationSecondOrderTypeCase#

Type

class PartialDifferentialEquationSecondOrderTypeCase

One exact condition and the classical second-order type proved under it.

PartialDifferentialEquationSecondOrderTypeCase.repr#

PartialDifferentialEquationSecondOrderTypeCase method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSecondOrderTypeCase.condition#

PartialDifferentialEquationSecondOrderTypeCase property

condition: AssumptionProposition

The exact condition under which this case's classical type holds.

PartialDifferentialEquationSecondOrderTypeCase.equation_type#

PartialDifferentialEquationSecondOrderTypeCase property

equation_type: str

The classical type proved under this case's condition.

PartialDifferentialEquationSecondOrderTypeCase.summary#

PartialDifferentialEquationSecondOrderTypeCase method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSeparatedEquation#

Type

class PartialDifferentialEquationSeparatedEquation

One exact separated ordinary differential equation exposed by a PDE transformation.

PartialDifferentialEquationSeparatedEquation.repr#

PartialDifferentialEquationSeparatedEquation method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSeparatedEquation.independent_variable_name#

PartialDifferentialEquationSeparatedEquation property

independent_variable_name: str

The name of this ODE's independent variable.

PartialDifferentialEquationSeparatedEquation.residual#

PartialDifferentialEquationSeparatedEquation property

residual: Expression

The exact ODE residual, interpreted as equal to zero.

PartialDifferentialEquationSeparatedEquation.summary#

PartialDifferentialEquationSeparatedEquation method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSeparationResult#

Type

class PartialDifferentialEquationSeparationResult

A verified directed separation transformation with its two exact ODE factors.

PartialDifferentialEquationSeparationResult.repr#

PartialDifferentialEquationSeparationResult method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSeparationResult.first_equation#

PartialDifferentialEquationSeparationResult property

first_equation: PartialDifferentialEquationSeparatedEquation

The first exact separated ODE.

PartialDifferentialEquationSeparationResult.reconstruction#

PartialDifferentialEquationSeparationResult property

reconstruction: Expression

The product or sum reconstruction of the working unknown.

PartialDifferentialEquationSeparationResult.second_equation#

PartialDifferentialEquationSeparationResult property

second_equation: PartialDifferentialEquationSeparatedEquation

The second exact separated ODE.

PartialDifferentialEquationSeparationResult.separation_constant#

PartialDifferentialEquationSeparationResult property

separation_constant: Expression

The fresh exact separation constant.

PartialDifferentialEquationSeparationResult.strategy#

PartialDifferentialEquationSeparationResult property

strategy: str

The directed separation strategy selected by exact analysis.

PartialDifferentialEquationSeparationResult.summary#

PartialDifferentialEquationSeparationResult method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSeparationResult.verification#

PartialDifferentialEquationSeparationResult property

verification: str

The independent recombination-verification verdict.

PartialDifferentialEquationSimilaritySolution#

Type

class PartialDifferentialEquationSimilaritySolution

The invariant solutions of a PDE under one point symmetry, or a typed decline.

PartialDifferentialEquationSimilaritySolution.repr#

PartialDifferentialEquationSimilaritySolution method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSimilaritySolution.decline#

PartialDifferentialEquationSimilaritySolution property

decline: Optional[str]

The typed reason no similarity family was produced.

PartialDifferentialEquationSimilaritySolution.invariant#

PartialDifferentialEquationSimilaritySolution property

invariant: Optional[Expression]

The invariant of the generator's base field.

PartialDifferentialEquationSimilaritySolution.lifted_constants#

PartialDifferentialEquationSimilaritySolution property

lifted_constants: list[Expression]

The constants the lifted family is parameterized by.

PartialDifferentialEquationSimilaritySolution.lifted_family#

PartialDifferentialEquationSimilaritySolution property

lifted_family: Optional[PartialDifferentialEquationSolutionFamily]

The invariant solutions of the original equation.

PartialDifferentialEquationSimilaritySolution.lifted_family_verification#

PartialDifferentialEquationSimilaritySolution property

lifted_family_verification: Optional[str]

The exact decision that the lifted family solves the original equation.

PartialDifferentialEquationSimilaritySolution.multiplier#

PartialDifferentialEquationSimilaritySolution property

multiplier: Optional[Expression]

The multiplier of the reduction identity.

PartialDifferentialEquationSimilaritySolution.outstanding_obligations#

PartialDifferentialEquationSimilaritySolution property

outstanding_obligations: list[str]

The claims the family explicitly does not make.

PartialDifferentialEquationSimilaritySolution.reduced_equation#

PartialDifferentialEquationSimilaritySolution property

reduced_equation: Optional[Expression]

The reduced ordinary differential equation for the profile, read as zero.

PartialDifferentialEquationSimilaritySolution.similarity_variable#

PartialDifferentialEquationSimilaritySolution property

similarity_variable: Optional[Expression]

The coordinate of the reduced equation, standing for the invariant.

PartialDifferentialEquationSimilaritySolution.summary#

PartialDifferentialEquationSimilaritySolution method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSimilaritySolution.weight#

PartialDifferentialEquationSimilaritySolution property

weight: Optional[Expression]

The weight of invariant solutions.

PartialDifferentialEquationSolutionFamily#

Type

class PartialDifferentialEquationSolutionFamily

An explicit or implicit PDE candidate solution family.

PartialDifferentialEquationSolutionFamily.repr#

PartialDifferentialEquationSolutionFamily method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSolutionFamily.arbitrary_functions#

PartialDifferentialEquationSolutionFamily property

arbitrary_functions: list[PartialDifferentialEquationArbitraryFunction]

The functions that stay arbitrary and opaque throughout verification.

PartialDifferentialEquationSolutionFamily.establishes_completeness#

PartialDifferentialEquationSolutionFamily property

establishes_completeness: bool

Whether the family carries a completeness theorem whose every identity was proved.

PartialDifferentialEquationSolutionFamily.expression#

PartialDifferentialEquationSolutionFamily property

expression: Expression

The exact candidate expression carried by this family.

PartialDifferentialEquationSolutionFamily.form#

PartialDifferentialEquationSolutionFamily property

form: Any

Whether this candidate is an explicit value or an implicit residual.

PartialDifferentialEquationSolutionFamily.proof_obligations#

PartialDifferentialEquationSolutionFamily property

proof_obligations: list[str]

The obligations recorded against this candidate family.

PartialDifferentialEquationSolutionFamily.summary#

PartialDifferentialEquationSolutionFamily method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSolutionProvenance.repr#

PartialDifferentialEquationSolutionProvenance method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSolutionProvenance.discharged_obligations#

PartialDifferentialEquationSolutionProvenance property

discharged_obligations: list[str]

The obligations discharged by exact query before the solution was returned.

PartialDifferentialEquationSolutionProvenance.linearity#

PartialDifferentialEquationSolutionProvenance property

linearity: str

The exact linearity class recorded at the time the candidate was produced.

PartialDifferentialEquationSolutionProvenance.method#

PartialDifferentialEquationSolutionProvenance property

method: str

The method identity this solution was produced by.

PartialDifferentialEquationSolutionProvenance.order#

PartialDifferentialEquationSolutionProvenance property

order: int

The exact order recorded at the time the candidate was produced.

PartialDifferentialEquationSolutionProvenance.summary#

PartialDifferentialEquationSolutionProvenance method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSolveResult#

Type

class PartialDifferentialEquationSolveResult

The sound result or typed decline from PDE dispatch.

PartialDifferentialEquationSolveResult.repr#

PartialDifferentialEquationSolveResult method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationSolveResult.classification#

PartialDifferentialEquationSolveResult property

classification: Optional[PartialDifferentialEquationClassification]

The exact classification the dispatcher established, when it reached one.

PartialDifferentialEquationSolveResult.decline#

PartialDifferentialEquationSolveResult property

decline: Optional[str]

The stable decline reason, when no solution was produced.

PartialDifferentialEquationSolveResult.method#

PartialDifferentialEquationSolveResult property

method: Optional[str]

The method that produced a solution, when one did.

PartialDifferentialEquationSolveResult.provenance#

PartialDifferentialEquationSolveResult property

provenance: Optional[PartialDifferentialEquationSolutionProvenance]

The mathematical provenance a verified solution carries.

PartialDifferentialEquationSolveResult.solution#

PartialDifferentialEquationSolveResult property

solution: Optional[PartialDifferentialEquationSolutionFamily]

The verified solution family, which no declined route may carry.

PartialDifferentialEquationSolveResult.summary#

PartialDifferentialEquationSolveResult method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationSolveResult.verdict#

PartialDifferentialEquationSolveResult property

verdict: str

Whether the dispatcher solved or honestly declined.

PartialDifferentialEquationSolveResult.verification#

PartialDifferentialEquationSolveResult property

verification: Optional[PartialDifferentialEquationVerificationReport]

The independent verification report a solved result must carry.

PartialDifferentialEquationTransformationResult#

Type

class PartialDifferentialEquationTransformationResult

The transformed problem or typed decline from an exact change of variables.

PartialDifferentialEquationTransformationResult.repr#

PartialDifferentialEquationTransformationResult method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationTransformationResult.coordinate_change#

PartialDifferentialEquationTransformationResult property

coordinate_change: Optional[PartialDifferentialEquationCoordinateChange]

The validated coordinate change of a successful transformation.

PartialDifferentialEquationTransformationResult.decline#

PartialDifferentialEquationTransformationResult property

decline: Optional[str]

The exact reason no transformation was produced.

PartialDifferentialEquationTransformationResult.normalization_multiplier#

PartialDifferentialEquationTransformationResult property

normalization_multiplier: Optional[Expression]

The proved-nonzero residual-normalization multiplier.

PartialDifferentialEquationTransformationResult.summary#

PartialDifferentialEquationTransformationResult method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationTransformationResult.target_problem#

PartialDifferentialEquationTransformationResult property

target_problem: Optional[PartialDifferentialEquationProblem]

The transformed PDE problem stated in the target coordinates.

PartialDifferentialEquationTransformationResult.transformed#

PartialDifferentialEquationTransformationResult property

transformed: bool

Whether a verified transformation was produced.

PartialDifferentialEquationTransformationVerificationReport#

Type

class PartialDifferentialEquationTransformationVerificationReport

Independent exact evidence that a coordinate transformation is correct.

PartialDifferentialEquationTransformationVerificationReport.repr#

PartialDifferentialEquationTransformationVerificationReport method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationTransformationVerificationReport.claimed_governing_residual#

PartialDifferentialEquationTransformationVerificationReport property

claimed_governing_residual: Expression

The governing residual the transformation claimed.

PartialDifferentialEquationTransformationVerificationReport.composition_residuals#

PartialDifferentialEquationTransformationVerificationReport property

composition_residuals: list[Expression]

Every forward and inverse map-composition residual.

PartialDifferentialEquationTransformationVerificationReport.jacobian#

PartialDifferentialEquationTransformationVerificationReport property

jacobian: Expression

The independently recomputed forward-map Jacobian.

PartialDifferentialEquationTransformationVerificationReport.principal_congruence_residuals#

PartialDifferentialEquationTransformationVerificationReport property

principal_congruence_residuals: list[Expression]

The exact principal-matrix congruence residuals.

PartialDifferentialEquationTransformationVerificationReport.summary#

PartialDifferentialEquationTransformationVerificationReport method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationTransformationVerificationReport.transformed_governing_residual#

PartialDifferentialEquationTransformationVerificationReport property

transformed_governing_residual: Expression

The independently transformed source governing residual.

PartialDifferentialEquationTransformationVerificationReport.verdict#

PartialDifferentialEquationTransformationVerificationReport property

verdict: str

The aggregate exact verification verdict.

PartialDifferentialEquationVerificationReport#

Type

class PartialDifferentialEquationVerificationReport

Independent exact verification evidence for a PDE candidate solution.

PartialDifferentialEquationVerificationReport.repr#

PartialDifferentialEquationVerificationReport method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationVerificationReport.boundary_condition_residuals#

PartialDifferentialEquationVerificationReport property

boundary_condition_residuals: list[PartialDifferentialEquationVerificationResidual]

One reduced residual per boundary condition, in insertion order.

PartialDifferentialEquationVerificationReport.explicit_branch#

PartialDifferentialEquationVerificationReport property

explicit_branch: Optional[Expression]

The isolated explicit branch checked for an implicit candidate.

PartialDifferentialEquationVerificationReport.governing_residual#

PartialDifferentialEquationVerificationReport property

governing_residual: Any

Independently reduced governing-equation evidence.

PartialDifferentialEquationVerificationReport.inconclusive_reason#

PartialDifferentialEquationVerificationReport property

inconclusive_reason: Optional[str]

The deterministic reason verification could not reach a proof.

PartialDifferentialEquationVerificationReport.initial_condition_residuals#

PartialDifferentialEquationVerificationReport property

initial_condition_residuals: list[PartialDifferentialEquationVerificationResidual]

One reduced residual per initial condition, in insertion order.

PartialDifferentialEquationVerificationReport.proof_obligations#

PartialDifferentialEquationVerificationReport property

proof_obligations: list[str]

The obligations consulted or left unresolved by this verification.

PartialDifferentialEquationVerificationReport.summary#

PartialDifferentialEquationVerificationReport method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationVerificationReport.verdict#

PartialDifferentialEquationVerificationReport property

verdict: str

The aggregate exact verification verdict.

PartialDifferentialEquationVerificationResidual.repr#

PartialDifferentialEquationVerificationResidual method

__repr__() -> str

The repr() text: the record's one-line summary. It reports staleness instead of failing.

PartialDifferentialEquationVerificationResidual.residual#

PartialDifferentialEquationVerificationResidual property

residual: Expression

The independently reduced residual expression.

PartialDifferentialEquationVerificationResidual.summary#

PartialDifferentialEquationVerificationResidual method

summary() -> str

A one-line summary naming this record's decisive fields; supporting evidence is reported by verdict or by a bounded prefix, and every accessor keeps the full data.

PartialDifferentialEquationVerificationResidual.verdict#

PartialDifferentialEquationVerificationResidual property

verdict: str

The exact verdict proved about this one residual.

UndefinedFunction#

Type

class UndefinedFunction

A callable proxy for user-defined named functions. context.undefined_function("f") returns one of these; calling it with expression arguments builds a function_call node in the context's interner.

UndefinedFunction.call#

UndefinedFunction method

__call__(*arguments: Any) -> Expression

Apply the named function to arguments, building an unevaluated function_call.

UndefinedFunction.repr#

UndefinedFunction method

__repr__() -> str

The repr() text naming the undefined function.

UndefinedFunction.derivative#

UndefinedFunction method

derivative(
    orders: list[int],
    arguments: Iterable[ExpressionLike],
) -> Expression

Constructs the structural derivative of this named function, one order per argument: y.derivative([1], [x]) is y'(x). This is the shape the differential-equation classifiers recognise, not a deferred derivative of an arbitrary expression.

analyze_first_order_nonlinear_equation#

Default context

analyze_first_order_nonlinear_equation(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> Optional[FirstOrderNonlinearSolutionAnalysis]

Classify a nonlinear first-order equation into every separately certified branch.

Calling forms

Explicit context: Context.analyze_first_order_nonlinear_equation

analyze_first_order_nonlinear_equation(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> Optional[FirstOrderNonlinearSolutionAnalysis]

canonicalize_partial_differential_equation#

Default context

canonicalize_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationCanonicalizationResult

Construct and independently verify exact canonical coordinates for a supported PDE.

Calling forms

Explicit context: Context.canonicalize_partial_differential_equation

canonicalize_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationCanonicalizationResult

change_partial_differential_equation_variables#

Default context

change_partial_differential_equation_variables(
    problem: PartialDifferentialEquationProblem,
    target_variables: Iterable[VariableLike],
    forward_coordinates: Optional[Iterable[ExpressionLike]] = None,
    inverse_coordinates: Optional[Iterable[ExpressionLike]] = None,
    target_dependent_function: Optional[Any] = None,
) -> PartialDifferentialEquationTransformationResult

Transform a two-variable PDE through an exact user-supplied change of variables.

Calling forms

Explicit context: Context.change_partial_differential_equation_variables

change_partial_differential_equation_variables(
    problem: PartialDifferentialEquationProblem,
    target_variables: Iterable[VariableLike],
    forward_coordinates: Optional[Iterable[ExpressionLike]] = None,
    inverse_coordinates: Optional[Iterable[ExpressionLike]] = None,
    target_dependent_function: Optional[Any] = None,
) -> PartialDifferentialEquationTransformationResult

classify_partial_differential_equation#

Default context

classify_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationClassification

Classify a validated scalar partial differential equation with exact structural analysis.

Calling forms

Explicit context: Context.classify_partial_differential_equation

classify_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationClassification

classify_second_order_partial_differential_equation#

Default context

classify_second_order_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationSecondOrderClassification

Classify a two-variable linear second-order PDE over real coordinates.

Calling forms

Explicit context: Context.classify_second_order_partial_differential_equation

classify_second_order_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationSecondOrderClassification

classify_unconstrained#

Default context

classify_unconstrained(
    objective: ExpressionLike,
    variables: Iterable[VariableLike],
    point_variables: Iterable[VariableLike],
    point_values: Iterable[ExpressionLike],
) -> str

Classify one given interior point — supplied as the parallel point_variables / point_values lists — by Hessian definiteness, returning the verdict string.

Calling forms

Explicit context: Context.classify_unconstrained

classify_unconstrained(
    objective: ExpressionLike,
    variables: Iterable[VariableLike],
    point_variables: Iterable[VariableLike],
    point_values: Iterable[ExpressionLike],
) -> str

clear_function_declarations#

Default context

clear_function_declarations(function: Any) -> None

Withdraw everything declared about an undefined function.

Calling forms

Explicit context: Context.clear_function_declarations

clear_function_declarations(function: Any) -> None

compare_real_roots#

Default context

compare_real_roots(
    first_expression: ExpressionLike,
    first_variable: VariableLike,
    first_index: int,
    second_expression: ExpressionLike,
    second_variable: VariableLike,
    second_index: int,
) -> Optional[int]

Compare two real algebraic numbers exactly, each given as the index-th smallest real root of a univariate polynomial over the rationals. Returns -1, 0, or 1 according to whether the first is less than, equal to, or greater than the second — a total order decided exactly (for example compare_real_roots of 2\sqrt{2} and 33\sqrt[3]{3} returns -1).

Calling forms

Explicit context: Context.compare_real_roots

compare_real_roots(
    first_expression: ExpressionLike,
    first_variable: VariableLike,
    first_index: int,
    second_expression: ExpressionLike,
    second_variable: VariableLike,
    second_index: int,
) -> Optional[int]

construct_partial_differential_equation_point_symmetry_action#

Default context

construct_partial_differential_equation_point_symmetry_action(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationPointSymmetryAction

Integrate and compose the point-symmetry algebra of a PDE into its connected local action.

Calling forms

Explicit context: Context.construct_partial_differential_equation_point_symmetry_action

construct_partial_differential_equation_point_symmetry_action(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationPointSymmetryAction

count_distinct_real_roots#

Default context

count_distinct_real_roots(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Optional[int]

Number of distinct real roots over all of R\mathbb{R}.

Calling forms

Explicit context: Context.count_distinct_real_roots

count_distinct_real_roots(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Optional[int]

declare_bijection#

Default context

declare_bijection(
    function: Any,
    source: ExpressionLike,
    target: ExpressionLike,
) -> None

Declare an undefined function a bijection from a source set onto a target set.

Calling forms

Explicit context: Context.declare_bijection

declare_bijection(
    function: Any,
    source: ExpressionLike,
    target: ExpressionLike,
) -> None

declare_bijection_with_inverse#

Default context

declare_bijection_with_inverse(
    function: Any,
    source: ExpressionLike,
    target: ExpressionLike,
    inverse: Any,
) -> None

Declare an undefined function a bijection from a source set onto a target set, with a named inverse.

Calling forms

Explicit context: Context.declare_bijection_with_inverse

declare_bijection_with_inverse(
    function: Any,
    source: ExpressionLike,
    target: ExpressionLike,
    inverse: Any,
) -> None

derive_partial_differential_equation_point_symmetries#

Default context

derive_partial_differential_equation_point_symmetries(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationPointSymmetryAlgebra

Derive the point-symmetry algebra of a scalar PDE, each basis generator independently verified.

Calling forms

Explicit context: Context.derive_partial_differential_equation_point_symmetries

derive_partial_differential_equation_point_symmetries(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationPointSymmetryAlgebra

discover_partial_differential_equation#

Default context

discover_partial_differential_equation(
    equation: ExpressionLike,
    initial_conditions: Optional[Iterable[ExpressionLike]] = None,
    boundary_conditions: Optional[Iterable[ExpressionLike]] = None,
) -> PartialDifferentialEquationProblem

Discover the unique scalar partial differential equation signature from one governing residual, in the default context.

Calling forms

Explicit context: Context.discover_partial_differential_equation

discover_partial_differential_equation(
    equation: ExpressionLike,
    initial_conditions: Iterable[ExpressionLike] = None,
    boundary_conditions: Iterable[ExpressionLike] = None,
) -> PartialDifferentialEquationProblem

eliminate_quantifiers#

Default context

eliminate_quantifiers(
    matrix: ExpressionLike,
    quantifiers: list[str],
    variables: Iterable[VariableLike],
) -> Expression

context.eliminate_quantifiers(matrix, quantifiers: list[str], variables: list[VariableLike])

Calling forms

Explicit context: Context.eliminate_quantifiers

eliminate_quantifiers(
    matrix: ExpressionLike,
    quantifiers: list[str],
    variables: Iterable[VariableLike],
) -> Expression

explicit_partial_differential_equation_solution#

Default context

explicit_partial_differential_equation_solution(
    solution: ExpressionLike,
    arbitrary_functions: Optional[list[PartialDifferentialEquationArbitraryFunction]] = None,
    proof_obligations: Optional[list[str]] = None,
) -> PartialDifferentialEquationSolutionFamily

Create an explicit partial differential equation solution family in the default context.

Calling forms

Explicit context: Context.explicit_partial_differential_equation_solution

explicit_partial_differential_equation_solution(
    solution: ExpressionLike,
    arbitrary_functions: Any = ...,
    proof_obligations: Any = ...,
) -> PartialDifferentialEquationSolutionFamily

find_ordinary_differential_equation_symmetries#

Default context

find_ordinary_differential_equation_symmetries(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> OrdinaryDifferentialEquationPointSymmetrySearch

Find every first-order point symmetry proved within the fixed deterministic search budget.

Calling forms

Explicit context: Context.find_ordinary_differential_equation_symmetries

find_ordinary_differential_equation_symmetries(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> OrdinaryDifferentialEquationPointSymmetrySearch

global_optimum_on_semialgebraic#

Default context

global_optimum_on_semialgebraic(
    objective: ExpressionLike,
    constraints: ExpressionLike,
    variables: Iterable[VariableLike],
    direction: str,
) -> Any

context.global_optimum_on_semialgebraic(objective, constraints, variables: list[VariableLike], direction: str)

Calling forms

Explicit context: Context.global_optimum_on_semialgebraic

global_optimum_on_semialgebraic(
    objective: ExpressionLike,
    constraints: ExpressionLike,
    variables: Iterable[VariableLike],
    direction: str,
) -> Any

implicit_partial_differential_equation_solution#

Default context

implicit_partial_differential_equation_solution(
    residual: ExpressionLike,
    arbitrary_functions: Optional[list[PartialDifferentialEquationArbitraryFunction]] = None,
    proof_obligations: Optional[list[str]] = None,
) -> PartialDifferentialEquationSolutionFamily

Create an implicit partial differential equation solution family in the default context.

Calling forms

Explicit context: Context.implicit_partial_differential_equation_solution

implicit_partial_differential_equation_solution(
    residual: ExpressionLike,
    arbitrary_functions: Any = ...,
    proof_obligations: Any = ...,
) -> PartialDifferentialEquationSolutionFamily

karush_kuhn_tucker_points#

Default context

karush_kuhn_tucker_points(
    objective: ExpressionLike,
    inequality_constraints: Iterable[ExpressionLike],
    equality_constraints: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Any

The Karush–Kuhn–Tucker points found by active-set enumeration. Each inequality is read as inequality⁡≤0\operatorname{inequality} \le 0 and each equality as equality = 0.

Calling forms

Explicit context: Context.karush_kuhn_tucker_points

karush_kuhn_tucker_points(
    objective: ExpressionLike,
    inequality_constraints: Iterable[ExpressionLike],
    equality_constraints: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Any

lagrange_critical_points#

Default context

lagrange_critical_points(
    objective: ExpressionLike,
    constraints: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Any

The equality-constrained critical points via Lagrange multipliers: stationarity of L=f+∑iλigiL = f + \sum_i \lambda_i g_i together with each constraint = 0, classified by the bordered Hessian. The solved multiplier values appear in each point's multipliers.

Calling forms

Explicit context: Context.lagrange_critical_points

lagrange_critical_points(
    objective: ExpressionLike,
    constraints: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Any

linear_differential_operator#

Default context

linear_differential_operator(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> Optional[LinearDifferentialOperator]

Extract a rational-coefficient scalar linear differential operator from an ODE residual.

Calling forms

Explicit context: Context.linear_differential_operator

linear_differential_operator(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> Optional[LinearDifferentialOperator]

minimal_polynomial_of#

Default context

minimal_polynomial_of(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Optional[Expression]

Return an exact polynomial in the requested variable for a first-class polynomial-root atom. Its dense primitive integer coefficients are independent of the source variable, coefficient scale, and current isolation precision.

Calling forms

Explicit context: Context.minimal_polynomial_of

minimal_polynomial_of(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Optional[Expression]

ordinary_differential_equation_series#

Default context

ordinary_differential_equation_series(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    expansion_point: ExpressionLike,
    initial_derivatives: Iterable[ExpressionLike],
) -> Optional[OrdinaryDifferentialEquationSeries]

Derive an exact formal Taylor series from an ordinary-point initial-value problem.

Calling forms

Explicit context: Context.ordinary_differential_equation_series

ordinary_differential_equation_series(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    expansion_point: ExpressionLike,
    initial_derivatives: Iterable[ExpressionLike],
) -> Optional[OrdinaryDifferentialEquationSeries]

partial_differential_equation#

Default context

partial_differential_equation(
    equation: ExpressionLike,
    dependent_function: Any,
    independent_variables: Iterable[VariableLike],
    initial_conditions: Optional[Iterable[ExpressionLike]] = None,
    boundary_conditions: Optional[Iterable[ExpressionLike]] = None,
) -> PartialDifferentialEquationProblem

Construct a validated scalar partial differential equation in the default context, with an explicit dependent function and independent-variable order.

Calling forms

Explicit context: Context.partial_differential_equation

partial_differential_equation(
    equation: ExpressionLike,
    dependent_function: Any,
    independent_variables: Iterable[VariableLike],
    initial_conditions: Iterable[ExpressionLike] = None,
    boundary_conditions: Iterable[ExpressionLike] = None,
) -> PartialDifferentialEquationProblem

partial_differential_equation_arbitrary_function#

Explicit context

partial_differential_equation_arbitrary_function(
    preferred_name: str,
    arity: int,
) -> PartialDifferentialEquationArbitraryFunction

Allocate a collision-free arbitrary function for a PDE candidate family.

partial_differential_equation_point_symmetry_generator#

Default context

partial_differential_equation_point_symmetry_generator(
    problem: PartialDifferentialEquationProblem,
    coordinate_infinitesimals: Iterable[ExpressionLike],
    dependent_infinitesimal: ExpressionLike,
) -> PartialDifferentialEquationPointSymmetryGenerator

Construct a candidate point-symmetry generator of a PDE from its infinitesimals.

Calling forms

Explicit context: Context.partial_differential_equation_point_symmetry_generator

partial_differential_equation_point_symmetry_generator(
    problem: PartialDifferentialEquationProblem,
    coordinate_infinitesimals: Iterable[ExpressionLike],
    dependent_infinitesimal: ExpressionLike,
) -> PartialDifferentialEquationPointSymmetryGenerator

polynomial_root#

Default context

polynomial_root(
    input_expression: ExpressionLike,
    variable: VariableLike,
    index: int,
) -> Optional[Expression]

Construct the zero-based index-th exact root of a univariate rational polynomial. Roots use canonical mathematical order: increasing real roots first, then non-real roots ordered by exact real part and exact imaginary part; indexing counts multiplicity. Coefficient scale and the variable name do not affect the resulting atom. Invalid, constant, non-rational, out-of-range, or uncertifiable inputs return None.

Calling forms

Explicit context: Context.polynomial_root

polynomial_root(
    input_expression: ExpressionLike,
    variable: VariableLike,
    index: int,
) -> Optional[Expression]

real_root_count#

Default context

real_root_count(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: int,
    upper: int,
) -> Optional[int]

Number of distinct real roots of a univariate polynomial in the interval (lower, upper] via Sturm sequences. None when the expression is not a univariate polynomial over the rationals.

Calling forms

Explicit context: Context.real_root_count

real_root_count(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: int,
    upper: int,
) -> Optional[int]

real_root_sign#

Default context

real_root_sign(
    input_expression: ExpressionLike,
    variable: VariableLike,
    index: int,
) -> Optional[int]

The exact sign (-1, 0, or 1) of the index-th smallest real root of a univariate polynomial over the rationals, decided exactly through the real algebraic number layer rather than by numeric evaluation. None when the expression is not a univariate polynomial over the rationals or index is out of range.

Calling forms

Explicit context: Context.real_root_sign

real_root_sign(
    input_expression: ExpressionLike,
    variable: VariableLike,
    index: int,
) -> Optional[int]

reduce_ordinary_differential_equation_by_symmetry#

Default context

reduce_ordinary_differential_equation_by_symmetry(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    symmetry: OrdinaryDifferentialEquationPointSymmetry,
) -> Optional[FirstOrderNonlinearSolutionBranch]

Reduce an equation through a symmetry previously verified by this context.

Calling forms

Explicit context: Context.reduce_ordinary_differential_equation_by_symmetry

reduce_ordinary_differential_equation_by_symmetry(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    symmetry: OrdinaryDifferentialEquationPointSymmetry,
) -> Optional[FirstOrderNonlinearSolutionBranch]

roots_with_multiplicities#

Default context

roots_with_multiplicities(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Any

Roots of a polynomial with their multiplicities. Notes: Python returns a dict keyed by root; WASM returns an array of root_multiplicity objects.

Calling forms

Explicit context: Context.roots_with_multiplicities

roots_with_multiplicities(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Any

Expression method: Expression.roots_with_multiplicities

roots_with_multiplicities(variable: VariableLike) -> Any

separate_partial_differential_equation#

Default context

separate_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationSeparationResult

Separate a supported PDE in the default context into exact one-variable ODEs.

Calling forms

Explicit context: Context.separate_partial_differential_equation

separate_partial_differential_equation(problem: PartialDifferentialEquationProblem) -> PartialDifferentialEquationSeparationResult

solve#

Default context

solve(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> list[Expression]

Solve an equation (an equal node, or an expression implicitly equated to zero) for variable, returning a list of solutions. Solutions outside the solver's reach are simply absent — prefer solveset when you need an honest "unsolved" residue.

Calling forms

Explicit context: Context.solve

solve(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> list[Expression]

Expression method: Expression.solve

solve(variable: VariableLike) -> list[Expression]

solve_detailed#

Default context

solve_detailed(
    equation: ExpressionLike,
    variable: VariableLike,
    requested_domain: str,
    maximum_branches: int,
    maximum_nodes: int,
    maximum_algebraic_degree: int,
    proof_detail: str,
) -> Any

Solve an equation with certified roots, an exact unresolved residue, and proof metadata.

Calling forms

Explicit context: Context.solve_detailed

solve_detailed(
    equation: ExpressionLike,
    variable: VariableLike,
    requested_domain: str = ...,
    maximum_branches: int = ...,
    maximum_nodes: int = ...,
    maximum_algebraic_degree: int = ...,
    proof_detail: str = ...,
) -> Any

solve_linear_recurrence#

Default context

solve_linear_recurrence(
    equation: ExpressionLike,
    sequence_call: ExpressionLike,
    index_variable: VariableLike,
    initial_conditions: Optional[Iterable[tuple[ExpressionLike, ExpressionLike]]] = None,
) -> Expression

Solve a linear recurrence with polynomial coefficients for the unknown sequence named by sequence_call (e.g. a(n)), via Petkovšek's Hyper algorithm. The general solution carries one fresh symbolic constant per basis element; initial_conditions is a list of (index, value) pairs fitted by back-substitution. Constant-coefficient polynomial-exponential forcing and coefficients rational in n and c^n are also solved; other shapes return the unevaluated recurrence_equation placeholder. WASM passes a flat interleaved array.

Calling forms

Explicit context: Context.solve_linear_recurrence

solve_linear_recurrence(
    equation: ExpressionLike,
    sequence_call: ExpressionLike,
    index_variable: VariableLike,
    initial_conditions: Optional[Iterable[tuple[ExpressionLike, ExpressionLike]]] = None,
) -> Expression

solve_ordinary_differential_equation#

Default context

solve_ordinary_differential_equation(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    initial_conditions: Optional[Iterable[tuple[ExpressionLike, ExpressionLike]]] = None,
) -> Expression

Solve an ODE for the unknown function named by dependent_function_call (e.g. y(x)).

Calling forms

Explicit context: Context.solve_ordinary_differential_equation

solve_ordinary_differential_equation(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    initial_conditions: Optional[Iterable[tuple[ExpressionLike, ExpressionLike]]] = None,
) -> Expression

solve_ordinary_differential_equation_request#

Default context

solve_ordinary_differential_equation_request(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    scope: str,
    condition_residuals: Optional[Iterable[ExpressionLike]] = None,
    method: str = "automatic",
    regularity: str = "classical",
) -> OrdinaryDifferentialEquationSolveResult

Solve one scalar ODE request with its data, method, scope, and regularity, keeping the evidence behind the answer.

Calling forms

Explicit context: Context.solve_ordinary_differential_equation_request

solve_ordinary_differential_equation_request(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    scope: str,
    condition_residuals: Optional[Iterable[ExpressionLike]] = None,
    method: str = "automatic",
    regularity: str = "classical",
) -> OrdinaryDifferentialEquationSolveResult

solve_ordinary_differential_equation_system_request#

Default context

solve_ordinary_differential_equation_system_request(
    equations: Iterable[ExpressionLike],
    dependent_function_calls: Iterable[ExpressionLike],
    independent_variable: VariableLike,
    condition_residuals: Optional[Iterable[ExpressionLike]] = None,
    method: str = "automatic",
) -> OrdinaryDifferentialEquationSystemSolveResult

Solve a system of ODEs in one coordinate through the requested route, keeping the evidence behind the assignment.

Calling forms

Explicit context: Context.solve_ordinary_differential_equation_system_request

solve_ordinary_differential_equation_system_request(
    equations: Iterable[ExpressionLike],
    dependent_function_calls: Iterable[ExpressionLike],
    independent_variable: VariableLike,
    condition_residuals: Optional[Iterable[ExpressionLike]] = None,
    method: str = "automatic",
) -> OrdinaryDifferentialEquationSystemSolveResult

solve_ordinary_differential_equation_with_history#

Default context

solve_ordinary_differential_equation_with_history(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    history_value: ExpressionLike,
    history_start: ExpressionLike,
    history_end: ExpressionLike,
) -> OrdinaryDifferentialEquationSolveResult

Solve a retarded delay ODE from a constant history stated on an explicit interval.

Calling forms

Explicit context: Context.solve_ordinary_differential_equation_with_history

solve_ordinary_differential_equation_with_history(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    history_value: ExpressionLike,
    history_start: ExpressionLike,
    history_end: ExpressionLike,
) -> OrdinaryDifferentialEquationSolveResult

solve_ordinary_differential_equation_with_particular_solution#

Default context

solve_ordinary_differential_equation_with_particular_solution(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    particular_solution: ExpressionLike,
) -> Expression

Riccati-specific entry: with a known particular solution y1y_1, the substitution y=y1+1/vy = y_1 + 1/v reduces the Riccati equation to a linear first-order ODE. Falls back to the unevaluated placeholder when the shape is not Riccati.

Calling forms

Explicit context: Context.solve_ordinary_differential_equation_with_particular_solution

solve_ordinary_differential_equation_with_particular_solution(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
    particular_solution: ExpressionLike,
) -> Expression

solve_partial_differential_equation#

Default context

solve_partial_differential_equation(
    problem: PartialDifferentialEquationProblem,
    method: str = "automatic",
) -> PartialDifferentialEquationSolveResult

Run the sound partial differential equation dispatcher under a stable method name.

Calling forms

Explicit context: Context.solve_partial_differential_equation

solve_partial_differential_equation(
    problem: PartialDifferentialEquationProblem,
    method: str = "automatic",
) -> PartialDifferentialEquationSolveResult

solve_partial_differential_equation_by_similarity_reduction#

Default context

solve_partial_differential_equation_by_similarity_reduction(
    problem: PartialDifferentialEquationProblem,
    generator: PartialDifferentialEquationPointSymmetryGenerator,
) -> PartialDifferentialEquationSimilaritySolution

Reduce a two-variable PDE by a point symmetry, solve the reduction, and lift its family.

Calling forms

Explicit context: Context.solve_partial_differential_equation_by_similarity_reduction

solve_partial_differential_equation_by_similarity_reduction(
    problem: PartialDifferentialEquationProblem,
    generator: PartialDifferentialEquationPointSymmetryGenerator,
) -> PartialDifferentialEquationSimilaritySolution

solve_partial_differential_equation_request#

Default context

solve_partial_differential_equation_request(
    problem: PartialDifferentialEquationProblem,
    scope: str,
    geometric_domain: str = "whole_space",
    regularity: str = "unrestricted",
    solution_class: str = "unrestricted",
    method: str = "automatic",
) -> PartialDifferentialEquationSolveResult

Solve a PDE request whose scope, geometry, regularity, and solution class are part of the question.

Calling forms

Explicit context: Context.solve_partial_differential_equation_request

solve_partial_differential_equation_request(
    problem: PartialDifferentialEquationProblem,
    scope: str,
    geometric_domain: str = "whole_space",
    regularity: str = "unrestricted",
    solution_class: str = "unrestricted",
    method: str = "automatic",
) -> PartialDifferentialEquationSolveResult

solve_partial_differential_equation_with_transform_axis_specifications#

Default context

solve_partial_differential_equation_with_transform_axis_specifications(
    problem: PartialDifferentialEquationProblem,
    method: str,
    transform_axis_specifications: list[str],
) -> PartialDifferentialEquationSolveResult

Solve a PDE with ordered explicit transform-axis specifications.

Calling forms

Explicit context: Context.solve_partial_differential_equation_with_transform_axis_specifications

solve_partial_differential_equation_with_transform_axis_specifications(
    problem: PartialDifferentialEquationProblem,
    method: str,
    transform_axis_specifications: list[str],
) -> PartialDifferentialEquationSolveResult

solve_polynomial_system#

Default context

solve_polynomial_system(
    equations: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Any

Solve a multivariate polynomial system { equation_i = 0 } for the named unknowns. Every other free symbol is a parameter carried symbolically in the coefficient ring. The solver is sound and honestly incomplete: every returned tuple has been back-substituted into every equation and reduced to a provable zero, and the verdict never overstates completeness.

Calling forms

Explicit context: Context.solve_polynomial_system

solve_polynomial_system(
    equations: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Any

solve_semialgebraic#

Default context

solve_semialgebraic(
    matrix: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Expression

context.solve_semialgebraic(matrix, variables: list[VariableLike])

Calling forms

Explicit context: Context.solve_semialgebraic

solve_semialgebraic(
    matrix: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Expression

solve_system_detailed#

Default context

solve_system_detailed(
    equations: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    requested_domain: str,
    maximum_branches: int,
    maximum_nodes: int,
    maximum_algebraic_degree: int,
    proof_detail: str,
) -> Any

Solve a polynomial system with certified assignments, unresolved equations, and proof metadata.

Calling forms

Explicit context: Context.solve_system_detailed

solve_system_detailed(
    equations: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
    requested_domain: str = ...,
    maximum_branches: int = ...,
    maximum_nodes: int = ...,
    maximum_algebraic_degree: int = ...,
    proof_detail: str = ...,
) -> Any

solveset#

Default context

solveset(
    input_expression: ExpressionLike,
    variable: VariableLike,
    domain: Optional[ExpressionLike] = None,
) -> Expression

Solution set of the equation or inequality: a finite set, interval, union, image set (periodic families), or condition set (the honest "unsolved" residue).

Calling forms

Explicit context: Context.solveset

solveset(
    input_expression: ExpressionLike,
    variable: VariableLike,
    domain: Optional[ExpressionLike] = None,
) -> Expression

Expression method: Expression.solveset

solveset(
    variable: VariableLike,
    domain: Optional[ExpressionLike] = None,
) -> Expression

solveset_in_domain#

Default context

solveset_in_domain(
    equation: ExpressionLike,
    variable: VariableLike,
    domain: ExpressionLike,
) -> Expression

solveset restricted to an explicit domain set (e.g. real_line(), integer_set(), an interval).

Calling forms

Explicit context: Context.solveset_in_domain

solveset_in_domain(
    equation: ExpressionLike,
    variable: VariableLike,
    domain: ExpressionLike,
) -> Expression

unconstrained_critical_points#

Default context

unconstrained_critical_points(
    objective: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Any

The critical points of objective as the solutions of ∇f=0\nabla f = 0, each classified by the definiteness of the Hessian (Sylvester's criterion on the leading principal minors).

Calling forms

Explicit context: Context.unconstrained_critical_points

unconstrained_critical_points(
    objective: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Any

undefined_function#

Default context

undefined_function(name: str) -> UndefinedFunction

A callable proxy for a user-named function in the default context. Calling it with expression arguments builds the function-call expression.

Calling forms

Explicit context: Context.undefined_function

undefined_function(name: str) -> UndefinedFunction

verify_ordinary_differential_equation_system_solution#

Default context

verify_ordinary_differential_equation_system_solution(
    equations: Iterable[ExpressionLike],
    dependent_function_calls: Iterable[ExpressionLike],
    independent_variable: VariableLike,
    components: Iterable[ExpressionLike],
    generated_constants: Iterable[ExpressionLike],
    condition_residuals: Optional[Iterable[ExpressionLike]] = None,
) -> OrdinaryDifferentialEquationSystemVerificationReport

Verify a supplied assignment for a system of ODEs without solving it again.

Calling forms

Explicit context: Context.verify_ordinary_differential_equation_system_solution

verify_ordinary_differential_equation_system_solution(
    equations: Iterable[ExpressionLike],
    dependent_function_calls: Iterable[ExpressionLike],
    independent_variable: VariableLike,
    components: Iterable[ExpressionLike],
    generated_constants: Iterable[ExpressionLike],
    condition_residuals: Optional[Iterable[ExpressionLike]] = None,
) -> OrdinaryDifferentialEquationSystemVerificationReport

verify_partial_differential_equation_coordinate_transformation#

Default context

verify_partial_differential_equation_coordinate_transformation(
    problem: PartialDifferentialEquationProblem,
    transformation: PartialDifferentialEquationTransformationResult,
) -> PartialDifferentialEquationTransformationVerificationReport

Independently verify an exact PDE coordinate transformation.

Calling forms

Explicit context: Context.verify_partial_differential_equation_coordinate_transformation

verify_partial_differential_equation_coordinate_transformation(
    problem: PartialDifferentialEquationProblem,
    transformation: PartialDifferentialEquationTransformationResult,
) -> PartialDifferentialEquationTransformationVerificationReport

verify_partial_differential_equation_solution#

Default context

verify_partial_differential_equation_solution(
    problem: PartialDifferentialEquationProblem,
    solution: PartialDifferentialEquationSolutionFamily,
) -> PartialDifferentialEquationVerificationReport

Independently verify a partial differential equation candidate with exact residual reasoning.

Calling forms

Explicit context: Context.verify_partial_differential_equation_solution

verify_partial_differential_equation_solution(
    problem: PartialDifferentialEquationProblem,
    solution: PartialDifferentialEquationSolutionFamily,
) -> PartialDifferentialEquationVerificationReport

Expression#

Type

class Expression

A symbolic expression owned by the context that built it.

add#

Expression method

__add__(other: Any) -> Expression

Sum self + other, returning a new expression.

bool#

Expression method

__bool__() -> bool

Always raises: symbolic truth is three-valued, so use evaluate_truth instead.

complex#

Expression method

__complex__() -> complex

The certified value as a complex number; raises unless the value is certified.

eq#

Expression method

__eq__(other: Any) -> bool

Structural equality of two expressions from the same live context; use equal to build a relation.

float#

Expression method

__float__() -> float

The certified real value as a float; raises unless the value is certified and exactly real.

getattribute#

Expression method

__getattribute__(name: str) -> Any

Reject attribute access on a stale object before delegating to the default lookup.

hash#

Expression method

__hash__() -> int

Hash consistent with structural equality, so expressions can key a dict or set.

mul#

Expression method

__mul__(other: ExpressionLike) -> Expression

Product self * other, returning a new expression. A matrix operand is left to the matrix, which scales every entry by this expression.

ne#

Expression method

__ne__(other: Any) -> bool

Structural inequality, the negation of __eq__.

neg#

Expression method

__neg__() -> Expression

Negation -self, returning a new expression.

pow#

Expression method

__pow__(exponent: Any, modulo: Optional[Any] = ...) -> Expression

Power self ** exponent; the three-argument form is rejected.

radd#

Expression method

__radd__(other: Any) -> Expression

Sum other + self, returning a new expression.

repr#

Expression method

__repr__() -> str

The repr() text, which reports staleness instead of failing.

rmul#

Expression method

__rmul__(other: ExpressionLike) -> Expression

Product other * self, returning a new expression.

rpow#

Expression method

__rpow__(base: Any, modulo: Optional[Any] = ...) -> Expression

Power base ** self; the three-argument form is rejected.

rsub#

Expression method

__rsub__(other: Any) -> Expression

Difference other - self, returning a new expression.

rtruediv#

Expression method

__rtruediv__(other: Any) -> Expression

Quotient other / self, returning a new expression.

str#

Expression method

__str__() -> str

The mathematical text of the expression.

sub#

Expression method

__sub__(other: Any) -> Expression

Difference self - other, returning a new expression.

truediv#

Expression method

__truediv__(other: Any) -> Expression

Quotient self / other, returning a new expression.

cancel#

Default context

cancel(input_expression: ExpressionLike) -> Expression

Rational normal form: write as a single fraction and divide out the polynomial GCD of numerator and denominator.

Calling forms

Explicit context: Context.cancel

cancel(input_expression: ExpressionLike) -> Expression

Expression method: Expression.cancel

cancel() -> Expression

collect#

Default context

collect(
    input_expression: ExpressionLike,
    generator: ExpressionLike,
) -> Expression

Regroup the additive terms of expression by the numeric (integer or rational) powers of a single generator, which may be a variable or an arbitrary subexpression, writing the result as a sum of generator^k coefficient(k) terms without expanding the coefficients. For example, collecting ax^2 + bx^2 + ax - bx + c by x yields x^2(a + b) + x(a - b) + c.

Calling forms

Explicit context: Context.collect

collect(
    input_expression: ExpressionLike,
    generator: ExpressionLike,
) -> Expression

Expression method: Expression.collect

collect(generator: ExpressionLike) -> Expression

collect_radicals#

Default context

collect_radicals(input_expression: ExpressionLike) -> Expression

Collect like numeric radical kernels in a top-level sum. For example, a*sqrt(2) + b*sqrt(2) + 3 becomes (a + b)*sqrt(2) + 3.

Calling forms

Explicit context: Context.collect_radicals

collect_radicals(input_expression: ExpressionLike) -> Expression

Expression method: Expression.collect_radicals

collect_radicals() -> Expression

combine_logarithm#

Default context

combine_logarithm(input_expression: ExpressionLike) -> Expression

log⁡a+log⁡b→log⁡(ab)\log a + \log b \rightarrow \log(a b) and nlog⁡a→log⁡(an)n\log a \rightarrow \log(a^n) when the transformation preserves the expression's domain.

Calling forms

Explicit context: Context.combine_logarithm

combine_logarithm(input_expression: ExpressionLike) -> Expression

Expression method: Expression.combine_logarithm

combine_logarithm() -> Expression

combine_powers#

Default context

combine_powers(input_expression: ExpressionLike) -> Expression

Combine same-exponent powers into a single power of the merged base (x^a y^a -> (xy)^a) at every product node where the rewrite is provably valid. This identity is false across the branch cut of the complex logarithm — at x = y = -1 and a = 1/2 the left side is ii = -1 while the right side is sqrt(1) = 1 — so it fires only when the exponent is provably an integer or when every combined base is provably positive. Positivity of the merged base is not enough: (-2)^x (-3)^x is left alone, because at x = 1/2 combining it to 6^x would flip the sign of the result. Positive numeric-literal bases need no assumptions at all, so 2^x 3^x becomes 6^x and (1/2)^x 3^x becomes (3/2)^x.

Calling forms

Explicit context: Context.combine_powers

combine_powers(input_expression: ExpressionLike) -> Expression

Expression method: Expression.combine_powers

combine_powers() -> Expression

combine_trigonometric#

Default context

combine_trigonometric(input_expression: ExpressionLike) -> Expression

Inverse direction of expand_trigonometric: product-to-sum and angle-recombination rules.

Calling forms

Explicit context: Context.combine_trigonometric

combine_trigonometric(input_expression: ExpressionLike) -> Expression

Expression method: Expression.combine_trigonometric

combine_trigonometric() -> Expression

complete_the_square#

Default context

complete_the_square(
    input_expression: ExpressionLike,
    variable: ExpressionLike,
) -> Expression

Rewrite an expression that is quadratic in variable into the exact vertex form a*(variable - h)^2 + k, with h = -b/(2*a) and k = c - b^2/(4*a) built from the degree-2, degree-1 and degree-0 coefficients a, b, c of the expression collected in variable.

Calling forms

Explicit context: Context.complete_the_square

complete_the_square(
    input_expression: ExpressionLike,
    variable: ExpressionLike,
) -> Expression

Expression method: Expression.complete_the_square

complete_the_square(variable: ExpressionLike) -> Expression

denest_powers#

Default context

denest_powers(input_expression: ExpressionLike) -> Expression

Flatten a power of a power into a single power ((x^a)^b -> x^(a*b)) at every power node whose outer exponent is provably an integer, which is valid on the principal branch because an integer power never routes through log.

Calling forms

Explicit context: Context.denest_powers

denest_powers(input_expression: ExpressionLike) -> Expression

Expression method: Expression.denest_powers

denest_powers() -> Expression

denest_radicals#

Default context

denest_radicals(input_expression: ExpressionLike) -> Expression

Denest the bounded depth-two real-radical subset bottom-up: rational quadratic surds, up to three inner quadratic surds, and cbrt(a + b*sqrt(c)) when its exact resolvent has a rational root. For example, sqrt(3 + 2*sqrt(2)) becomes 1 + sqrt(2) and cbrt(2 + sqrt(5)) becomes (1 + sqrt(5))/2.

Calling forms

Explicit context: Context.denest_radicals

denest_radicals(input_expression: ExpressionLike) -> Expression

Expression method: Expression.denest_radicals

denest_radicals() -> Expression

denominator#

Default context

denominator(input_expression: ExpressionLike) -> Expression

Returns the structural denominator from numerator_denominator.

Calling forms

Explicit context: Context.denominator

denominator(input_expression: ExpressionLike) -> Expression

Expression method: Expression.denominator

denominator() -> Expression

duplicate#

Expression method

duplicate() -> Expression

An independent handle to the same underlying expression. The recommended JavaScript facade duplicates values before passing them through ownership-transferring raw WASM arrays, so ordinary facade calls are non-destructive. Callers using facade.raw directly must still duplicate a handle they intend to retain. Python arguments are borrowed.

equals#

Expression method

equals(other: ExpressionLike) -> bool

Mathematical equality test: simplify⁡(self⁡−other⁡)=0\operatorname{simplify}(\operatorname{self} - \operatorname{other}) = 0.

expand#

Default context

expand(input_expression: ExpressionLike) -> Expression

Expand products, integer powers, and supported algebraic forms.

Calling forms

Explicit context: Context.expand

expand(input_expression: ExpressionLike) -> Expression

Expression method: Expression.expand

expand() -> Expression

expand_complex#

Default context

expand_complex(input_expression: ExpressionLike) -> Expression

Decompose an expression exactly as real_part(expression) + i*imaginary_part(expression).

Calling forms

Explicit context: Context.expand_complex

expand_complex(input_expression: ExpressionLike) -> Expression

Expression method: Expression.expand_complex

expand_complex() -> Expression

expand_logarithm#

Default context

expand_logarithm(input_expression: ExpressionLike) -> Expression

log⁡(ab)→log⁡a+log⁡b\log(a b) \rightarrow \log a + \log b and log⁡(an)→nlog⁡a\log(a^n) \rightarrow n\log a, applied only where the operands are provably positive. Operands of unknown sign pass through unchanged.

Calling forms

Explicit context: Context.expand_logarithm

expand_logarithm(input_expression: ExpressionLike) -> Expression

Expression method: Expression.expand_logarithm

expand_logarithm() -> Expression

expand_power_base#

Default context

expand_power_base(input_expression: ExpressionLike) -> Expression

Split a power whose base is structurally a product into a product of powers ((xy)^a -> x^a y^a) at every power node whose exponent is provably an integer — the only unconditionally valid gate for this direction, since the split introduces x^a and y^a individually and each needs its own base off the cut. With n declared an integer, (xy)^n becomes x^n y^n.

Calling forms

Explicit context: Context.expand_power_base

expand_power_base(input_expression: ExpressionLike) -> Expression

Expression method: Expression.expand_power_base

expand_power_base() -> Expression

expand_trigonometric#

Default context

expand_trigonometric(input_expression: ExpressionLike) -> Expression

Expand trig/hyperbolic functions of sums and multiple angles.

Calling forms

Explicit context: Context.expand_trigonometric

expand_trigonometric(input_expression: ExpressionLike) -> Expression

Expression method: Expression.expand_trigonometric

expand_trigonometric() -> Expression

expression_type#

Expression method

expression_type() -> str

Top-level node kind: one of integer, rational, symbol, constant, sum, product, power, factorial, function_call, derivative, integral, summation, laplace_transform, inverse_laplace_transform, fourier_transform, inverse_fourier_transform, piecewise, ordinary_differential_equation, recurrence_equation, interval, finite_set, set_union, set_intersection, set_complement, image_set, condition_set.

factor#

Default context

factor(
    input_expression: ExpressionLike,
    gaussian: bool = False,
) -> Expression

Polynomial factorization over the rationals (full multivariate).

Calling forms

Explicit context: Context.factor

factor(
    input_expression: ExpressionLike,
    gaussian: bool = False,
) -> Expression

Expression method: Expression.factor

factor(gaussian: bool = False) -> Expression

factor_common_terms#

Default context

factor_common_terms(input_expression: ExpressionLike) -> Expression

Pull the greatest common monomial and exact rational content out of the terms of a general — not necessarily polynomial — sum, producing a single product of a common factor and a reduced sum, without invoking full polynomial factorization. For example, 6*x*y + 9*x^2*sin(z) becomes 3*x*(2*y + 3*x*sin(z)).

Calling forms

Explicit context: Context.factor_common_terms

factor_common_terms(input_expression: ExpressionLike) -> Expression

Expression method: Expression.factor_common_terms

factor_common_terms() -> Expression

free_variables#

Expression method

free_variables() -> list[str]

Sorted names of the free symbols. Bound binders (integration variables, image-set parameters) are excluded; the constants pi/e are not symbols.

image_set_domain#

Expression method

image_set_domain() -> Expression

The domain an image_set expression maps over.

image_set_lambda_expression#

Expression method

image_set_lambda_expression() -> Expression

The body an image_set expression applies to its bound variable.

image_set_variable#

Expression method

image_set_variable() -> str

The name of the variable an image_set expression binds.

imaginary_part#

Default context

imaginary_part(input_expression: ExpressionLike) -> Expression

Return the exact imaginary component of an expression. For example, if y is declared real, imaginary_part(exp(i*y)) is sin(y).

Calling forms

Explicit context: Context.imaginary_part

imaginary_part(input_expression: ExpressionLike) -> Expression

Expression method: Expression.imaginary_part

imaginary_part() -> Expression

integral_integrand#

Expression method

integral_integrand() -> Expression

The integrand of an unevaluated integral expression.

integral_lower_bound#

Expression method

integral_lower_bound() -> Optional[Expression]

None for indefinite integrals.

integral_upper_bound#

Expression method

integral_upper_bound() -> Optional[Expression]

The upper bound of an unevaluated integral, or None when it is indefinite.

integral_variable#

Expression method

integral_variable() -> str

The name of the variable an unevaluated integral integrates over.

interval_lower#

Expression method

interval_lower() -> Expression

Lower endpoint of an interval node; raises on other shapes.

interval_upper#

Expression method

interval_upper() -> Expression

The upper endpoint of an interval expression.

is_algebraic#

Expression method

is_algebraic() -> Optional[bool]

Whether the expression is known to be algebraic.

is_complex#

Expression method

is_complex() -> Optional[bool]

Whether the expression is known to be finite complex.

is_composite#

Expression method

is_composite() -> Optional[bool]

Whether the expression is known to be composite.

is_defined#

Expression method

is_defined() -> Optional[bool]

Whether the expression is known to denote one scalar value at the active point.

is_equality#

Expression method

is_equality() -> bool

True for equal(a, b) relation nodes.

is_even#

Expression method

is_even() -> Optional[bool]

Whether the expression is known to be even.

is_extended_real#

Expression method

is_extended_real() -> Optional[bool]

Whether the expression is known to be extended-real.

is_finite#

Expression method

is_finite() -> Optional[bool]

Whether the expression is known finite, or None when the assumptions cannot decide it.

is_finite_set#

Expression method

is_finite_set() -> bool

Whether this expression is a finite_set.

is_image_set#

Expression method

is_image_set() -> bool

Whether this expression is an image_set.

is_infinite#

Expression method

is_infinite() -> Optional[bool]

Whether the expression is known to be infinite.

is_integer#

Expression method

is_integer() -> Optional[bool]

Whether the expression is known to be an integer, or None when the assumptions cannot decide it.

is_integral#

Expression method

is_integral() -> bool

True for unevaluated integral nodes. (Distinct from the assumption query is_integer.)

is_interval#

Expression method

is_interval() -> bool

Whether this expression is an interval.

is_irrational#

Expression method

is_irrational() -> Optional[bool]

Whether the expression is known to be irrational.

is_matrix#

Expression method

is_matrix: bool

Always False on expressions and True on matrix objects, so mixed result streams can be discriminated.

is_natural#

Expression method

is_natural() -> Optional[bool]

Whether the expression is known to be natural.

is_negative#

Expression method

is_negative() -> Optional[bool]

Whether the expression is known to be negative, or None when the assumptions cannot decide it.

is_nonnegative#

Expression method

is_nonnegative() -> Optional[bool]

Answers whether the expression is nonnegative in the extended-real universe. Non-real values are refuted; unsupported real expressions remain None.

is_nonpositive#

Expression method

is_nonpositive() -> Optional[bool]

Whether the expression is known to be nonpositive.

is_nonzero#

Expression method

is_nonzero() -> Optional[bool]

Whether the expression is known to be nonzero, or None when the assumptions cannot decide it.

is_odd#

Expression method

is_odd() -> Optional[bool]

Whether the expression is known to be odd.

is_positive#

Expression method

is_positive() -> Optional[bool]

Whether the expression is known to be positive, or None when the assumptions cannot decide it.

is_positive_integer#

Expression method

is_positive_integer() -> Optional[bool]

Whether the expression is known to be a positive integer.

is_rational#

Expression method

is_rational() -> Optional[bool]

Whether the expression is known to be rational, or None when the assumptions cannot decide it.

is_real#

Expression method

is_real() -> Optional[bool]

Whether the expression is known to be real, or None when the assumptions cannot decide it.

is_stale#

Expression method

is_stale: bool

Reports whether resetting the owning context invalidated the expression. All other operations reject a stale receiver with an actionable error.

is_transcendental#

Expression method

is_transcendental() -> Optional[bool]

Whether the expression is known to be transcendental.

is_union#

Expression method

is_union() -> bool

Whether this expression is a union of sets.

is_zero#

Expression method

is_zero() -> Optional[bool]

Whether the expression is known to be zero.

node_count#

Expression method

node_count() -> int

Number of nodes in the expression tree — the size measure used by the simplifier; useful for comparing alternative forms.

numerator#

Default context

numerator(input_expression: ExpressionLike) -> Expression

Returns the structural numerator from numerator_denominator.

Calling forms

Explicit context: Context.numerator

numerator(input_expression: ExpressionLike) -> Expression

Expression method: Expression.numerator

numerator() -> Expression

numerator_denominator#

Default context

numerator_denominator(input_expression: ExpressionLike) -> tuple[Expression, Expression]

Returns the exact structural numerator and denominator without combining sums or cancelling factors. Python returns a two-tuple and the JavaScript facade returns a record.

Calling forms

Explicit context: Context.numerator_denominator

numerator_denominator(input_expression: ExpressionLike) -> tuple[Expression, Expression]

Expression method: Expression.numerator_denominator

numerator_denominator() -> tuple[Expression, Expression]

partial_fractions#

Default context

partial_fractions(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

Decompose a rational expression into polynomial and proper-fraction terms over the named variable.

Calling forms

Explicit context: Context.partial_fractions

partial_fractions(
    input_expression: ExpressionLike,
    variable: VariableLike,
) -> Expression

Expression method: Expression.partial_fractions

partial_fractions(variable: VariableLike) -> Expression

piecewise_fold#

Default context

piecewise_fold(input_expression: ExpressionLike) -> Expression

Expand abs, signum, and heaviside_step definitions recursively and fold piecewise operands of sums, products, powers, factorials, and ordinary function calls into one top-level piecewise expression. For example, x*abs(x - 1) becomes the exact two-branch definition with values x*(x - 1) and -x*(x - 1).

Calling forms

Explicit context: Context.piecewise_fold

piecewise_fold(input_expression: ExpressionLike) -> Expression

Expression method: Expression.piecewise_fold

piecewise_fold() -> Expression

presentation_normal_form#

Default context

presentation_normal_form(input_expression: ExpressionLike) -> Expression

The cheap, bounded display-oriented pass run at solver output seams: rational normal form only, kept only when the weighted complexity does not grow. Unlike simplify it never runs the full heuristic ladder, so it is fast and deterministic in shape.

Calling forms

Explicit context: Context.presentation_normal_form

presentation_normal_form(input_expression: ExpressionLike) -> Expression

Expression method: Expression.presentation_normal_form

presentation_normal_form() -> Expression

rationalize_denominator#

Default context

rationalize_denominator(input_expression: ExpressionLike) -> Expression

Rationalize a radical denominator through exact multiquadratic conjugation or extended-Euclidean inversion in one rational n-th-root extension. For example, 1 / (sqrt(3) - sqrt(2)) becomes sqrt(3) + sqrt(2), and 1 / (1 + 2^(1/3)) becomes (1 - 2^(1/3) + 2^(2/3))/3.

Calling forms

Explicit context: Context.rationalize_denominator

rationalize_denominator(input_expression: ExpressionLike) -> Expression

Expression method: Expression.rationalize_denominator

rationalize_denominator() -> Expression

real_part#

Default context

real_part(input_expression: ExpressionLike) -> Expression

Return the exact real component of an expression. For example, if y is declared real, real_part(exp(i*y)) is cos(y).

Calling forms

Explicit context: Context.real_part

real_part(input_expression: ExpressionLike) -> Expression

Expression method: Expression.real_part

real_part() -> Expression

rewrite_as_exponential#

Default context

rewrite_as_exponential(input_expression: ExpressionLike) -> Expression

Euler-form rewriter: replace every trigonometric/hyperbolic call with the equivalent complex-exponential expression (bottom-up).

Calling forms

Explicit context: Context.rewrite_as_exponential

rewrite_as_exponential(input_expression: ExpressionLike) -> Expression

Expression method: Expression.rewrite_as_exponential

rewrite_as_exponential() -> Expression

rewrite_as_trigonometric#

Default context

rewrite_as_trigonometric(input_expression: ExpressionLike) -> Expression

Inverse of rewrite_as_exponential.

Calling forms

Explicit context: Context.rewrite_as_trigonometric

rewrite_as_trigonometric(input_expression: ExpressionLike) -> Expression

Expression method: Expression.rewrite_as_trigonometric

rewrite_as_trigonometric() -> Expression

rewrite_in_terms_of#

Default context

rewrite_in_terms_of(
    target: ExpressionLike,
    source: ExpressionLike,
    replacement: ExpressionLike,
) -> Expression

Rewrite the target in terms of replacement under the caller-supplied formal relation replacement = source.

Calling forms

Explicit context: Context.rewrite_in_terms_of

rewrite_in_terms_of(
    target: ExpressionLike,
    source: ExpressionLike,
    replacement: ExpressionLike,
) -> Expression

Expression method: Expression.rewrite_in_terms_of

rewrite_in_terms_of(
    source: ExpressionLike,
    replacement: ExpressionLike,
) -> Expression

rewrite_special_functions#

Default context

rewrite_special_functions(
    input_expression: ExpressionLike,
    basis: str,
) -> Expression

Rewrite beta, gamma, binomial, factorial, and rising-factorial representations into the requested "gamma", "factorial", "binomial", or "rising_factorial" basis. The exact identities are applied only when their domain gates are proven: factorial and binomial conversions require the relevant non-negative integers, rising-factorial conversions additionally require a positive base, and beta-to-gamma requires two positive arguments. For example, with n declared a positive integer, n! may be rewritten into the gamma basis and gamma(n) into the factorial basis. A site with unconstrained arguments is returned unchanged. Gamma ratios with a literal non-negative argument offset are minimized to their exact shifted product.

Calling forms

Explicit context: Context.rewrite_special_functions

rewrite_special_functions(
    input_expression: ExpressionLike,
    basis: str,
) -> Expression

Expression method: Expression.rewrite_special_functions

rewrite_special_functions(basis: str) -> Expression

rewrite_trigonometric_basis#

Default context

rewrite_trigonometric_basis(
    input_expression: ExpressionLike,
    basis: str,
) -> Expression

Rewrite trigonometric and hyperbolic calls toward one of five named bases: sine_cosine, tangent, exponential, trigonometric, or hyperbolic.

Calling forms

Explicit context: Context.rewrite_trigonometric_basis

rewrite_trigonometric_basis(
    input_expression: ExpressionLike,
    basis: str,
) -> Expression

Expression method: Expression.rewrite_trigonometric_basis

rewrite_trigonometric_basis(basis: str) -> Expression

simplify#

Default context

simplify(input_expression: ExpressionLike) -> Expression

The full heuristic simplification ladder: weighted-complexity-guided search over rational normal form, radical denesting, trigonometric/log rewrites, parity and absolute-value rules. The result is never accepted if its weighted complexity grows. Principal square roots extract structural square content only under a realness proof: sqrt(x^2) becomes abs(x) for real x, while sqrt(z^2) remains unchanged for a default-complex z.

Calling forms and variants

Explicit context: Context.simplify

simplify(input_expression: ExpressionLike) -> Expression

Expression method: Expression.simplify

simplify() -> Expression

Variant using local assumptions — AssumptionScope method: AssumptionScope.simplify

simplify(input_expression: ExpressionLike) -> Expression

simplify_trigonometric#

Default context

simplify_trigonometric(input_expression: ExpressionLike) -> Expression

Fu-style trigonometric simplification toward fewer/cheaper trig calls.

Calling forms

Explicit context: Context.simplify_trigonometric

simplify_trigonometric(input_expression: ExpressionLike) -> Expression

Expression method: Expression.simplify_trigonometric

simplify_trigonometric() -> Expression

simplify_under_constraint#

Default context

simplify_under_constraint(
    input_expression: ExpressionLike,
    constraint: ExpressionLike,
) -> Expression

Simplify an expression under a local bounded logical constraint without changing symbol assumptions.

Calling forms

Explicit context: Context.simplify_under_constraint

simplify_under_constraint(
    input_expression: ExpressionLike,
    constraint: ExpressionLike,
) -> Expression

Expression method: Expression.simplify_under_constraint

simplify_under_constraint(constraint: ExpressionLike) -> Expression

substitute#

Expression method

substitute(variable: VariableLike, value: ExpressionLike) -> Expression

Replace every free occurrence of the named symbol with value, re-running auto-simplification.

symbol_name#

Expression method

symbol_name() -> str

Returns the name of a symbol expression and rejects every other expression kind.

to_list#

Expression method

to_list() -> list[Any]

Elements of a finite set; raises on other shapes. Python finite sets also support len() and iteration.

together#

Default context

together(input_expression: ExpressionLike) -> Expression

Combine a sum of fractions over a common denominator. On Symi's representation together and cancel coincide; both names exist because they are distinct user intents.

Calling forms

Explicit context: Context.together

together(input_expression: ExpressionLike) -> Expression

Expression method: Expression.together

together() -> Expression

union_components#

Expression method

union_components() -> list[Any]

The components of a set union, as a list of expressions.

Circle2d#

Circle2d constructor

Circle2d(center: Point2d, radius: Any)

Construct the circle with the given center and radius.

Circle2d.getattribute#

Circle2d method

__getattribute__(name: str) -> Any

Reject attribute access on a stale object before delegating to the default lookup.

Circle2d.repr#

Circle2d method

__repr__() -> str

The repr() text, which reports staleness instead of failing.

Circle2d.area#

Circle2d method

area() -> Expression

Area of the circle, πr2\pi r^2.

Circle2d.center#

Circle2d property

center: Point2d

The center of the circle.

Circle2d.circumference#

Circle2d method

circumference() -> Expression

Circumference of the circle.

Circle2d.equation#

Circle2d method

equation(variable_x: Any, variable_y: Any) -> Expression

The circle as an equal relation in x and y.

Circle2d.is_stale#

Circle2d property

is_stale: bool

Reports whether resetting the owning context invalidated the expression. All other operations reject a stale receiver with an actionable error.

Circle2d.radius#

Circle2d property

radius: Expression

The radius of the circle.

Point2d#

Point2d constructor

Point2d(x: Any, y: Any)

Construct the point (x, y).

Point2d.getattribute#

Point2d method

__getattribute__(name: str) -> Any

Reject attribute access on a stale object before delegating to the default lookup.

Point2d.repr#

Point2d method

__repr__() -> str

The repr() text, which reports staleness instead of failing.

Point2d.coordinates#

Point2d method

coordinates() -> tuple[Expression, Expression]

The (x, y) coordinate pair of the point.

Point2d.distance_to#

Point2d method

distance_to(other: Point2d) -> Expression

Euclidean distance, exact (a sqrt expression in general).

Point2d.intersection#

Point2d method

intersection(other: Geometry2D) -> list[GeometryIntersectionComponent]

Return the complete exact boundary intersection with another supported plane geometry.

Calling forms and variants

Variant for this object — Circle2d method: Circle2d.intersection

intersection(other: Geometry2D) -> list[GeometryIntersectionComponent]

Variant for this object — Polygon2d method: Polygon2d.intersection

intersection(other: Geometry2D) -> list[GeometryIntersectionComponent]

Variant for this object — Segment2d method: Segment2d.intersection

intersection(other: Geometry2D) -> list[GeometryIntersectionComponent]

Variant for this object — Triangle2d method: Triangle2d.intersection

intersection(other: Geometry2D) -> list[GeometryIntersectionComponent]

Point2d.is_stale#

Point2d property

is_stale: bool

Reports whether resetting the owning context invalidated the expression. All other operations reject a stale receiver with an actionable error.

Point2d.x#

Point2d property

x: Expression

The x coordinate of the point.

Point2d.y#

Point2d property

y: Expression

The y coordinate of the point.

Polygon2d#

Polygon2d constructor

Polygon2d(vertices: list[Point2d])

Simple polygon from its vertex list in order; degenerate inputs raise.

Polygon2d.getattribute#

Polygon2d method

__getattribute__(name: str) -> Any

Reject attribute access on a stale object before delegating to the default lookup.

Polygon2d.repr#

Polygon2d method

__repr__() -> str

The repr() text, which reports staleness instead of failing.

Polygon2d.area#

Polygon2d method

area() -> Expression

Shoelace area of the polygon.

Calling forms and variants

Variant for this object — Triangle2d method: Triangle2d.area

area() -> Expression

Polygon2d.centroid#

Polygon2d method

centroid() -> Point2d

Centroid of the polygon's vertices.

Calling forms and variants

Variant for this object — Triangle2d method: Triangle2d.centroid

centroid() -> Point2d

Polygon2d.interior_angles#

Polygon2d method

interior_angles() -> list[tuple[Point2d, Expression]]

Each vertex paired with its interior angle. Notes: WASM returns vertex_angle objects with vertex/angle getters.

Calling forms and variants

Variant for this object — Triangle2d method: Triangle2d.interior_angles

interior_angles() -> list[tuple[Point2d, Expression]]

Polygon2d.is_stale#

Polygon2d property

is_stale: bool

Reports whether resetting the owning context invalidated the expression. All other operations reject a stale receiver with an actionable error.

Polygon2d.perimeter#

Polygon2d method

perimeter() -> Expression

Perimeter of the polygon, the sum of its edge lengths.

Calling forms and variants

Variant for this object — Triangle2d method: Triangle2d.perimeter

perimeter() -> Expression

Segment2d#

Segment2d constructor

Segment2d(start: Point2d, end: Point2d)

Construct the segment running from start to end.

Segment2d.getattribute#

Segment2d method

__getattribute__(name: str) -> Any

Reject attribute access on a stale object before delegating to the default lookup.

Segment2d.repr#

Segment2d method

__repr__() -> str

The repr() text, which reports staleness instead of failing.

Segment2d.is_stale#

Segment2d property

is_stale: bool

Reports whether resetting the owning context invalidated the expression. All other operations reject a stale receiver with an actionable error.

Segment2d.length#

Segment2d method

length() -> Expression

Also the finite-set length accessor on expression in WASM; context disambiguates.

Segment2d.midpoint#

Segment2d method

midpoint() -> Point2d

Midpoint of the segment.

Segment2d.perpendicular_bisector_equation#

Segment2d method

perpendicular_bisector_equation(
    variable_x: Any,
    variable_y: Any,
) -> Expression

The bisector line as an equal relation in x and y.

Triangle2d#

Triangle2d constructor

Triangle2d(point_a: Point2d, point_b: Point2d, point_c: Point2d)

Collinear vertices raise.

Triangle2d.getattribute#

Triangle2d method

__getattribute__(name: str) -> Any

Reject attribute access on a stale object before delegating to the default lookup.

Triangle2d.repr#

Triangle2d method

__repr__() -> str

The repr() text, which reports staleness instead of failing.

Triangle2d.is_stale#

Triangle2d property

is_stale: bool

Reports whether resetting the owning context invalidated the expression. All other operations reject a stale receiver with an actionable error.

circle_2d#

Explicit context

circle_2d(center: Point2d, radius: Any) -> Circle2d

Construct the circle with the given center and radius.

point_2d#

Explicit context

point_2d(x: Any, y: Any) -> Point2d

Construct the point (x, y).

polygon_2d#

Explicit context

polygon_2d(vertices: list[Point2d]) -> Polygon2d

Simple polygon from its vertex list in order; degenerate inputs raise.

segment_2d#

Explicit context

segment_2d(start: Point2d, end: Point2d) -> Segment2d

Construct the segment running from start to end.

triangle_2d#

Explicit context

triangle_2d(
    point_a: Point2d,
    point_b: Point2d,
    point_c: Point2d,
) -> Triangle2d

Collinear vertices raise.

CompiledNumericFunction#

Type

class CompiledNumericFunction

An immutable binary64 function compiled from exact expressions.

CompiledNumericFunction.call#

CompiledNumericFunction method

__call__(*arguments: Any) -> Any

Evaluate every output at one point given as positional arguments, one per variable. A real function takes and returns floats. A complex function takes floats or complex numbers and returns complex numbers. The result has the compiled shape: one number for a scalar, a list for a vector, and a list of rows for a matrix. It raises if any output has no machine value.

CompiledNumericFunction.repr#

CompiledNumericFunction method

__repr__() -> str

The repr() text: the function's shape and domain. It reports staleness instead of failing.

CompiledNumericFunction.capabilities#

CompiledNumericFunction method

capabilities() -> NumericFunctionCapabilities

Report what this function can do and how; derivative and Jacobian availability come from compiling them once.

CompiledNumericFunction.derivative#

CompiledNumericFunction method

derivative(variable: VariableLike) -> CompiledNumericFunction

Compile the checked exact derivative of every output with respect to one input variable.

CompiledNumericFunction.domain#

CompiledNumericFunction property

domain: str

The input and result domain chosen at compilation: "real" or "complex".

CompiledNumericFunction.evaluate_batch_complex#

CompiledNumericFunction method

evaluate_batch_complex(
    real_coordinates: Any,
    imaginary_coordinates: Any,
    point_count: int,
) -> NumericFunctionBatch

Evaluate split real and imaginary contiguous float64 buffers at point_count points.

CompiledNumericFunction.evaluate_batch_real#

CompiledNumericFunction method

evaluate_batch_real(
    coordinates: Any,
    point_count: int,
) -> NumericFunctionBatch

Evaluate a contiguous native-endian float64 buffer of real coordinates at point_count points.

CompiledNumericFunction.evaluate_batch_real_list#

CompiledNumericFunction method

evaluate_batch_real_list(
    coordinates: list[float],
    point_count: int,
) -> NumericFunctionBatch

Allocate a real coordinate buffer from a Python list of floats, then evaluate it at point_count points.

CompiledNumericFunction.evaluate_detailed_complex#

CompiledNumericFunction method

evaluate_detailed_complex(
    real_arguments: list[float],
    imaginary_arguments: list[float],
) -> NumericFunctionEvaluation

Evaluate every output at one point given as split real and imaginary coordinate lists, keeping the value or the status of each.

CompiledNumericFunction.evaluate_detailed_real#

CompiledNumericFunction method

evaluate_detailed_real(arguments: list[float]) -> NumericFunctionEvaluation

Evaluate every output at one real point, keeping the value or the status of each.

CompiledNumericFunction.evaluate_intervals#

CompiledNumericFunction method

evaluate_intervals(
    lower_bounds: list[float],
    upper_bounds: list[float],
) -> NumericFunctionIntervalEvaluation

Enclose every output over one box of real inputs, given as one finite lower and upper bound for each variable in variable order.

CompiledNumericFunction.evaluate_real#

CompiledNumericFunction method

evaluate_real(arguments: list[float]) -> list[float]

Evaluate every output at one real point; raises if any output has no real machine value.

CompiledNumericFunction.interval_bridged_kernels#

CompiledNumericFunction property

interval_bridged_kernels: list[str]

The heads interval evaluation encloses through certified ball kernels.

CompiledNumericFunction.interval_directed_kernels#

CompiledNumericFunction property

interval_directed_kernels: list[str]

The heads interval evaluation encloses with outward-rounded binary64 arithmetic alone.

CompiledNumericFunction.interval_unsupported_kernels#

CompiledNumericFunction property

interval_unsupported_kernels: list[str]

The heads with no interval kernel; an output that reaches one has no enclosure.

CompiledNumericFunction.is_stale#

CompiledNumericFunction property

is_stale: bool

Whether resetting the owner context has retired this compiled function.

CompiledNumericFunction.jacobian#

CompiledNumericFunction method

jacobian() -> CompiledNumericFunction

Compile the checked exact Jacobian, flattened row-major as outputs by variables.

CompiledNumericFunction.output_count#

CompiledNumericFunction property

output_count: int

The ordered number of flattened scalar outputs.

CompiledNumericFunction.output_shape#

CompiledNumericFunction property

output_shape: list[int]

The dimensions of the output shape: [] for a scalar, [length] for a vector, and [rows, columns] for a matrix.

CompiledNumericFunction.variable_count#

CompiledNumericFunction property

variable_count: int

The ordered number of scalar input variables.

Matrix.evaluate_numeric#

Matrix method

evaluate_numeric(
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericMatrix

The numeric value of every entry; raises if any entry declines.

NumericEvaluationReport#

Type

class NumericEvaluationReport

Everything an explicit numeric evaluation found out, whether or not it produced a value.

NumericEvaluationReport.repr#

NumericEvaluationReport method

__repr__() -> str

The outcome in one line.

NumericEvaluationReport.absolute_bound#

NumericEvaluationReport property

absolute_bound: Optional[NumericValue]

A proved bound on the modulus, for a magnitude_below_resolution decline.

NumericEvaluationReport.best_enclosure#

NumericEvaluationReport property

best_enclosure: Optional[NumericValue]

The last certified enclosure reached before a decline.

NumericEvaluationReport.certified_attempts#

NumericEvaluationReport property

certified_attempts: int

The number of certified ball evaluations performed.

NumericEvaluationReport.decline_reason#

NumericEvaluationReport property

decline_reason: Optional[str]

Why no value was produced, when none was.

NumericEvaluationReport.estimated_heads#

NumericEvaluationReport property

estimated_heads: list[str]

The heads the estimated engine evaluated; empty unless the value is an estimate.

NumericEvaluationReport.exact_decisions#

NumericEvaluationReport property

exact_decisions: int

The number of undecided balls settled by an exact decision.

NumericEvaluationReport.heads#

NumericEvaluationReport property

heads: list[str]

The builtin heads and constants of the evaluated expression.

NumericEvaluationReport.responsible_heads#

NumericEvaluationReport property

responsible_heads: list[str]

The heads without a certified kernel, for a no_certified_kernel decline.

NumericEvaluationReport.status#

NumericEvaluationReport property

status: str

"evaluated" when a value was produced, "declined" otherwise.

NumericEvaluationReport.substitution_symbol#

NumericEvaluationReport property

substitution_symbol: Optional[str]

The symbol whose bound value was rejected, for a substitution decline.

NumericEvaluationReport.summary#

NumericEvaluationReport method

summary() -> str

A one-line description of the outcome.

NumericEvaluationReport.unbound_symbols#

NumericEvaluationReport property

unbound_symbols: list[str]

The free symbols left without a value, for an unbound_symbol decline.

NumericEvaluationReport.value#

NumericEvaluationReport property

value: Optional[NumericValue]

The value, when one was produced.

NumericEvaluationReport.working_precision_bits#

NumericEvaluationReport property

working_precision_bits: int

The last working precision used, in bits.

NumericFunctionBatch#

Type

class NumericFunctionBatch

The point-major results of one compiled-function batch evaluation.

NumericFunctionBatch.repr#

NumericFunctionBatch method

__repr__() -> str

The repr() text: the batch shape and whether every output was evaluated.

NumericFunctionBatch.all_evaluated#

NumericFunctionBatch property

all_evaluated: bool

Whether every output of every point has a machine value.

NumericFunctionBatch.bridge_used#

NumericFunctionBatch property

bridge_used: Any

Point-major observations, as a read-only byte buffer of zeros and ones aligned with real_values, of whether a certified bridge computed a value the output depends on.

NumericFunctionBatch.guard_refined#

NumericFunctionBatch property

guard_refined: Any

Point-major observations, as a read-only byte buffer of zeros and ones aligned with real_values, of whether a semantic guard the output depends on needed a working precision above its first one.

NumericFunctionBatch.imaginary_values#

NumericFunctionBatch property

imaginary_values: Any

Point-major imaginary parts as a read-only float64 buffer aligned with real_values.

NumericFunctionBatch.output_count#

NumericFunctionBatch property

output_count: int

The number of flattened scalar outputs each point carries.

NumericFunctionBatch.output_shape#

NumericFunctionBatch property

output_shape: list[int]

The dimensions of the output shape of each point: [] for a scalar, [length] for a vector, and [rows, columns] for a matrix.

NumericFunctionBatch.point_count#

NumericFunctionBatch property

point_count: int

The explicit number of points represented by this batch.

NumericFunctionBatch.real_values#

NumericFunctionBatch property

real_values: Any

Point-major real parts as a read-only float64 buffer; an entry whose status is not "evaluated" is a placeholder.

NumericFunctionBatch.require_all_evaluated#

NumericFunctionBatch method

require_all_evaluated() -> None

Raise for the first output that has no machine value; return nothing otherwise.

NumericFunctionBatch.status_codes#

NumericFunctionBatch property

status_codes: Any

Point-major output status codes as a read-only byte buffer aligned with real_values: zero for an evaluated output and the documented nonzero code of its status otherwise.

NumericFunctionBatch.statuses#

NumericFunctionBatch property

statuses: list[str]

Point-major output status names aligned with real_values.

NumericFunctionBatch.underflow_observed#

NumericFunctionBatch property

underflow_observed: Any

Point-major underflow observations as a read-only byte buffer of zeros and ones aligned with real_values.

NumericFunctionCapabilities#

Type

class NumericFunctionCapabilities

What a compiled function can do and how, derived from its program and the kernel registry.

NumericFunctionCapabilities.repr#

NumericFunctionCapabilities method

__repr__() -> str

The repr() text: the variables, the shape, the domain, and the direct heads.

NumericFunctionCapabilities.accuracy#

NumericFunctionCapabilities property

accuracy: str

The result category of every value: "machine_approximation", with no implied digits and no error radius.

NumericFunctionCapabilities.arithmetic_format#

NumericFunctionCapabilities property

arithmetic_format: str

The machine format of every input, intermediate, and result: "binary64".

NumericFunctionCapabilities.backends#

NumericFunctionCapabilities property

backends: list[str]

The backends that can run the function: "cpu_register" for point and batch evaluation, and "cpu_interval" for interval evaluation of a real-domain function.

NumericFunctionCapabilities.bridged_heads#

NumericFunctionCapabilities property

bridged_heads: list[str]

The heads the function runs through certified bridges, sorted: builtins by name, and "factorial" for the factorial of a computed argument.

NumericFunctionCapabilities.derivative_variables#

NumericFunctionCapabilities property

derivative_variables: list[str]

The variables, in argument order, with respect to which derivative compiles.

NumericFunctionCapabilities.direct_heads#

NumericFunctionCapabilities property

direct_heads: list[str]

The heads the function runs directly on binary64 registers, sorted: builtins by name, and "sum", "product", "power", and "factorial" for its own operations.

NumericFunctionCapabilities.domain#

NumericFunctionCapabilities property

domain: str

The input and result domain chosen at compilation: "real" or "complex".

NumericFunctionCapabilities.guard_kinds#

NumericFunctionCapabilities property

guard_kinds: list[str]

The kinds of checks made at an evaluation point, in a fixed order: "exact_input_comparison", "certified_predicate", "discontinuity", "pole_test", "branch_side", "realness_test", and "assumption_check".

NumericFunctionCapabilities.interval_bridged_kernels#

NumericFunctionCapabilities property

interval_bridged_kernels: list[str]

The heads interval evaluation encloses through certified ball kernels.

NumericFunctionCapabilities.interval_directed_kernels#

NumericFunctionCapabilities property

interval_directed_kernels: list[str]

The heads interval evaluation encloses with outward-rounded binary64 arithmetic alone.

NumericFunctionCapabilities.interval_unsupported_kernels#

NumericFunctionCapabilities property

interval_unsupported_kernels: list[str]

The heads with no interval kernel.

NumericFunctionCapabilities.jacobian_available#

NumericFunctionCapabilities property

jacobian_available: bool

Whether jacobian compiles.

NumericFunctionCapabilities.output_shape#

NumericFunctionCapabilities property

output_shape: list[int]

The dimensions of the output shape: [] for a scalar, [length] for a vector, and [rows, columns] for a matrix.

NumericFunctionCapabilities.requirement_symbols#

NumericFunctionCapabilities property

requirement_symbols: list[str]

The names of the symbols the outputs' captured requirements mention, sorted.

NumericFunctionCapabilities.unsupported_capabilities#

NumericFunctionCapabilities property

unsupported_capabilities: list[str]

The capabilities the function lacks, one per refusal, aligned with unsupported_reasons.

NumericFunctionCapabilities.unsupported_reasons#

NumericFunctionCapabilities property

unsupported_reasons: list[str]

Why each entry of unsupported_capabilities is unsupported.

NumericFunctionCapabilities.variables#

NumericFunctionCapabilities property

variables: list[str]

The names of the input variables, in argument order.

NumericFunctionEvaluation#

Type

class NumericFunctionEvaluation

The value or status of every output of a compiled function at one point.

NumericFunctionEvaluation.repr#

NumericFunctionEvaluation method

__repr__() -> str

The repr() text: the output count and the status of each output.

NumericFunctionEvaluation.all_evaluated#

NumericFunctionEvaluation property

all_evaluated: bool

Whether every output has a machine value.

NumericFunctionEvaluation.bridge_used#

NumericFunctionEvaluation property

bridge_used: list[bool]

Whether a certified bridge computed a value each output depends on.

NumericFunctionEvaluation.failure_path#

NumericFunctionEvaluation method

failure_path(output: int) -> Optional[list[int]]

The child indices from the root of output output to the node its failure arose at; None for an evaluated output and for a status decided before any operation.

NumericFunctionEvaluation.guard_refined#

NumericFunctionEvaluation property

guard_refined: list[bool]

Whether a semantic guard each output depends on needed a working precision above its first one.

NumericFunctionEvaluation.imaginary_values#

NumericFunctionEvaluation property

imaginary_values: list[float]

The imaginary part of each output, NaN where the output has no value.

NumericFunctionEvaluation.output_count#

NumericFunctionEvaluation property

output_count: int

The number of flattened scalar outputs; every list below has one entry per output.

NumericFunctionEvaluation.output_shape#

NumericFunctionEvaluation property

output_shape: list[int]

The dimensions of the output shape: [] for a scalar, [length] for a vector, and [rows, columns] for a matrix.

NumericFunctionEvaluation.real_values#

NumericFunctionEvaluation property

real_values: list[float]

The real part of each output, NaN where the output has no value.

NumericFunctionEvaluation.require_all_evaluated#

NumericFunctionEvaluation method

require_all_evaluated() -> None

Raise for the first output that has no machine value; return nothing otherwise.

NumericFunctionEvaluation.status_codes#

NumericFunctionEvaluation property

status_codes: list[int]

The status code of each output: zero for an evaluated output and the documented nonzero code of its status otherwise.

NumericFunctionEvaluation.statuses#

NumericFunctionEvaluation property

statuses: list[str]

The status name of each output.

NumericFunctionEvaluation.underflow_observed#

NumericFunctionEvaluation property

underflow_observed: list[bool]

Whether a nonzero quantity was observed as a subnormal or zero on the way to each output.

NumericFunctionIntervalEvaluation#

Type

class NumericFunctionIntervalEvaluation

The proved ranges of every output of a compiled function over one box of real inputs.

NumericFunctionIntervalEvaluation.repr#

NumericFunctionIntervalEvaluation method

__repr__() -> str

The repr() text: the output count and whether every output was enclosed.

NumericFunctionIntervalEvaluation.all_enclosed#

NumericFunctionIntervalEvaluation property

all_enclosed: bool

Whether every output has a valid enclosure.

NumericFunctionIntervalEvaluation.definedness#

NumericFunctionIntervalEvaluation property

definedness: list[str]

Where on the box each output has a real value: "everywhere", "somewhere", "nowhere", or "unknown".

NumericFunctionIntervalEvaluation.enclosure_valid#

NumericFunctionIntervalEvaluation property

enclosure_valid: list[bool]

Whether each output's bounds are a proved enclosure of every real value it takes on the box.

NumericFunctionIntervalEvaluation.lower_bounds#

NumericFunctionIntervalEvaluation property

lower_bounds: list[float]

The lower bound of each output's enclosure, possibly -inf; NaN where the enclosure is not valid.

NumericFunctionIntervalEvaluation.output_count#

NumericFunctionIntervalEvaluation property

output_count: int

The number of flattened scalar outputs; every list below has one entry per output.

NumericFunctionIntervalEvaluation.output_shape#

NumericFunctionIntervalEvaluation property

output_shape: list[int]

The dimensions of the output shape: [] for a scalar, [length] for a vector, and [rows, columns] for a matrix.

NumericFunctionIntervalEvaluation.proved_continuous#

NumericFunctionIntervalEvaluation property

proved_continuous: list[bool]

Whether each output is proved real and continuous at every point of the box; False means continuity was not established.

NumericFunctionIntervalEvaluation.statuses#

NumericFunctionIntervalEvaluation property

statuses: list[str]

The status name of each output: "evaluated" exactly where its enclosure is valid.

NumericFunctionIntervalEvaluation.upper_bounds#

NumericFunctionIntervalEvaluation property

upper_bounds: list[float]

The upper bound of each output's enclosure, possibly inf; NaN where the enclosure is not valid.

NumericMatrix#

Type

class NumericMatrix

The numeric values of every entry of an evaluated matrix.

NumericMatrix.repr#

NumericMatrix method

__repr__() -> str

The shape of the matrix.

NumericMatrix.columns#

NumericMatrix property

columns: int

The number of columns.

NumericMatrix.entries#

NumericMatrix method

entries() -> list[NumericValue]

Every entry in row-major order.

NumericMatrix.entry#

NumericMatrix method

entry(row: int, column: int) -> NumericValue

The numeric value of one entry.

NumericMatrix.rows#

NumericMatrix property

rows: int

The number of rows.

NumericPolynomialRootsResult#

Type

class NumericPolynomialRootsResult

Every root of a polynomial with its multiplicity, certified, or a decline with a reason.

NumericPolynomialRootsResult.repr#

NumericPolynomialRootsResult method

__repr__() -> str

The outcome in one line.

NumericPolynomialRootsResult.complete#

NumericPolynomialRootsResult property

complete: bool

Whether every root is listed: true exactly for a certified result.

NumericPolynomialRootsResult.decline_reason#

NumericPolynomialRootsResult property

decline_reason: Optional[str]

Why no roots were returned, when none were.

NumericPolynomialRootsResult.degree#

NumericPolynomialRootsResult property

degree: int

The exact degree of the polynomial; zero when the request declined.

NumericPolynomialRootsResult.iterations#

NumericPolynomialRootsResult property

iterations: int

The number of multiprecision iteration sweeps taken.

NumericPolynomialRootsResult.multiplicities#

NumericPolynomialRootsResult property

multiplicities: list[int]

The exact multiplicity of each root, in the order of the values.

NumericPolynomialRootsResult.status#

NumericPolynomialRootsResult property

status: str

"certified" or "declined".

NumericPolynomialRootsResult.summary#

NumericPolynomialRootsResult method

summary() -> str

The outcome in one line.

NumericPolynomialRootsResult.unbound_symbols#

NumericPolynomialRootsResult property

unbound_symbols: list[str]

The symbols other than the variable, for an unbound_symbol decline.

NumericPolynomialRootsResult.values#

NumericPolynomialRootsResult property

values: list[NumericValue]

Each distinct root once, real roots first in increasing order; empty when declined.

NumericPolynomialRootsResult.variable#

NumericPolynomialRootsResult property

variable: str

The name of the polynomial's variable.

NumericPolynomialRootsResult.working_precision_bits#

NumericPolynomialRootsResult property

working_precision_bits: int

The last working precision used, in bits.

NumericRootEnclosure#

Type

class NumericRootEnclosure

One certified enclosure of a real root, with exact rational bounds.

NumericRootEnclosure.lower#

NumericRootEnclosure property

lower: Expression

The exact rational lower bound of the enclosure.

NumericRootEnclosure.status#

NumericRootEnclosure property

status: str

What the search proved about the roots inside this enclosure.

NumericRootEnclosure.upper#

NumericRootEnclosure property

upper: Expression

The exact rational upper bound of the enclosure.

NumericRootFindingResult#

Type

class NumericRootFindingResult

The result of an explicit numerical root search: certified, converged but uncertified, or declined with a reason.

NumericRootFindingResult.repr#

NumericRootFindingResult method

__repr__() -> str

The outcome in one line.

NumericRootFindingResult.decline_reason#

NumericRootFindingResult property

decline_reason: Optional[str]

Why no root was returned, when none was.

NumericRootFindingResult.domain#

NumericRootFindingResult property

domain: str

The domain searched, "real" or "complex".

NumericRootFindingResult.iterations#

NumericRootFindingResult property

iterations: int

The number of iteration or bracketing steps taken.

NumericRootFindingResult.method#

NumericRootFindingResult property

method: str

The method that located the root, or the requested method of a declined search.

NumericRootFindingResult.multiplicity_estimate#

NumericRootFindingResult property

multiplicity_estimate: Optional[int]

For one equation, the estimated multiplicity of an estimated root.

NumericRootFindingResult.residuals#

NumericRootFindingResult property

residuals: list[NumericValue]

One residual per equation: certified over a certified root, or at an estimated one.

NumericRootFindingResult.status#

NumericRootFindingResult property

status: str

"certified", "converged_uncertified", or "declined".

NumericRootFindingResult.summary#

NumericRootFindingResult method

summary() -> str

The outcome in one line.

NumericRootFindingResult.unbound_symbols#

NumericRootFindingResult property

unbound_symbols: list[str]

The symbols that are not variables, for an unbound_symbol decline.

NumericRootFindingResult.value#

NumericRootFindingResult method

value(name: str) -> Optional[NumericValue]

The numeric value of one variable, by name, when a root was returned.

NumericRootFindingResult.values#

NumericRootFindingResult property

values: list[NumericValue]

One numeric value per variable; empty when the search declined.

NumericRootFindingResult.variable_values#

NumericRootFindingResult property

variable_values: Any

A dictionary from each variable name to its numeric value.

NumericRootFindingResult.variables#

NumericRootFindingResult property

variables: list[str]

The variable names, in the order of the values.

NumericRootFindingResult.working_precision_bits#

NumericRootFindingResult property

working_precision_bits: int

The last working precision used, in bits.

NumericRootIsolationResult#

Type

class NumericRootIsolationResult

The report from an explicitly requested certified numerical root search.

NumericRootIsolationResult.complete#

NumericRootIsolationResult property

complete: bool

Whether every root of the requested domain is accounted for by an enclosure.

NumericRootIsolationResult.coverage#

NumericRootIsolationResult property

coverage: Optional[str]

How much of the requested domain the enclosures account for.

NumericRootIsolationResult.decline_reason#

NumericRootIsolationResult property

decline_reason: Optional[str]

The reason, present exactly when the verdict is declined.

NumericRootIsolationResult.enclosures#

NumericRootIsolationResult property

enclosures: list[NumericRootEnclosure]

The disjoint certified enclosures, in ascending order.

NumericRootIsolationResult.precision_bits#

NumericRootIsolationResult property

precision_bits: Optional[int]

The working precision the accepted enclosures were produced at.

NumericRootIsolationResult.unresolved_regions#

NumericRootIsolationResult property

unresolved_regions: list[NumericRootUnresolvedRegion]

The regions the search could neither clear nor resolve into an enclosure.

NumericRootIsolationResult.verdict#

NumericRootIsolationResult property

verdict: str

Whether the search ran or declined.

NumericRootUnresolvedRegion#

Type

class NumericRootUnresolvedRegion

One region a certified numerical root search could neither clear nor resolve.

NumericRootUnresolvedRegion.lower#

NumericRootUnresolvedRegion property

lower: Optional[Expression]

The lower endpoint, absent when the region reaches negative infinity.

NumericRootUnresolvedRegion.upper#

NumericRootUnresolvedRegion property

upper: Optional[Expression]

The upper endpoint, absent when the region reaches positive infinity.

NumericValue#

Type

class NumericValue

A complex number approximated by a ball in each component, labelled certified or estimated.

NumericValue.complex#

NumericValue method

__complex__() -> complex

The nearest complex number to the midpoint.

NumericValue.float#

NumericValue method

__float__() -> float

The nearest float of a value known to be exactly real.

NumericValue.repr#

NumericValue method

__repr__() -> str

The value with its accuracy label.

NumericValue.str#

NumericValue method

__str__() -> str

The value at its requested digits.

NumericValue.accuracy#

NumericValue property

accuracy: str

Whether the radii are proved bounds ("certified") or estimates ("estimated").

NumericValue.achieved_relative_precision_bits#

NumericValue property

achieved_relative_precision_bits: Optional[int]

The relative accuracy in bits, or None when both components are exact.

NumericValue.certified_sign#

NumericValue method

certified_sign() -> Optional[int]

The proved sign of a real value as -1, 0, or 1, or None when it is not proved.

NumericValue.contains_zero#

NumericValue method

contains_zero() -> bool

Whether zero lies within the stated radius of both components.

NumericValue.error_bound#

NumericValue method

error_bound() -> Optional[NumericValue]

A proved bound on the error of a certified value, or None for an estimate.

NumericValue.error_estimate#

NumericValue method

error_estimate() -> Optional[NumericValue]

The estimated error of an estimate, or None for a certified value.

NumericValue.imaginary_part#

NumericValue method

imaginary_part() -> NumericValue

The imaginary part, as a real numeric value with the same accuracy.

NumericValue.is_exactly_real#

NumericValue method

is_exactly_real() -> bool

Whether the value is known to be real: its imaginary part is exactly zero.

NumericValue.is_exactly_zero#

NumericValue method

is_exactly_zero() -> bool

Whether the value is known to be exactly zero.

NumericValue.real_part#

NumericValue method

real_part() -> NumericValue

The real part, as a real numeric value with the same accuracy.

NumericValue.requested_significant_digits#

NumericValue property

requested_significant_digits: int

The number of significant digits the value was requested with.

NumericValue.summary#

NumericValue method

summary() -> str

The value at its requested digits followed by its accuracy.

NumericValue.to_complex_f64#

NumericValue method

to_complex_f64() -> tuple[float, float]

The nearest floats to the real and imaginary midpoints.

NumericValue.to_decimal_string#

NumericValue method

to_decimal_string(significant_digits: Optional[int] = ...) -> str

The value in decimal with at most significant_digits faithful digits per component, defaulting to the requested digits.

NumericValue.to_f64#

NumericValue method

to_f64() -> float

The nearest float to the midpoint of a value known to be exactly real.

NumericValue.to_latex#

NumericValue method

to_latex(significant_digits: Optional[int] = ...) -> str

The value in LaTeX with at most significant_digits faithful digits per component, defaulting to the requested digits.

NumericValue.to_rational#

NumericValue method

to_rational() -> Expression

The exact midpoint as an expression: the value of the approximation, not of the quantity.

NumericValue.to_simplest_rational#

NumericValue method

to_simplest_rational() -> Expression

The simplest rational inside each component's ball, as an expression.

compile_numeric_function#

Default context

compile_numeric_function(
    outputs: Union[ExpressionLike, Iterable[ExpressionLike], Matrix],
    variables: Iterable[VariableLike],
    domain: str = "real",
    fast_kernels_only: bool = False,
) -> CompiledNumericFunction

Compile a scalar, a vector, or a matrix of exact outputs in the default context for repeated binary64 evaluation.

Calling forms

Explicit context: Context.compile_numeric_function

compile_numeric_function(
    outputs: Union[ExpressionLike, Iterable[ExpressionLike], Matrix],
    variables: Iterable[VariableLike],
    domain: str = "real",
    fast_kernels_only: bool = False,
) -> CompiledNumericFunction

evaluate_numeric#

Default context

evaluate_numeric(
    input_expression: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
    substitutions: Optional[dict[Any, Any]] = ...,
) -> NumericValue

The numeric value of an expression in the thread's default context.

Calling forms

Explicit context: Context.evaluate_numeric

evaluate_numeric(
    input_expression: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
    substitutions: Optional[dict[Any, Any]] = ...,
) -> NumericValue

Expression method: Expression.evaluate_numeric

evaluate_numeric(
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
    substitutions: Optional[dict[Any, Any]] = ...,
) -> NumericValue

evaluate_numeric_detailed#

Default context

evaluate_numeric_detailed(
    input_expression: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
    substitutions: Optional[dict[Any, Any]] = ...,
) -> NumericEvaluationReport

The report of a numeric evaluation in the thread's default context.

Calling forms

Explicit context: Context.evaluate_numeric_detailed

evaluate_numeric_detailed(
    input_expression: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
    substitutions: Optional[dict[Any, Any]] = ...,
) -> NumericEvaluationReport

evaluate_numeric_with_substitutions#

Default context

evaluate_numeric_with_substitutions(
    input_expression: ExpressionLike,
    substitutions: dict[Any, Any],
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericValue

The numeric value of an expression with bound symbols in the thread's default context.

Calling forms

Explicit context: Context.evaluate_numeric_with_substitutions

evaluate_numeric_with_substitutions(
    input_expression: ExpressionLike,
    substitutions: dict[Any, Any],
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericValue

evaluate_to_float#

Expression method

evaluate_to_float() -> float

The nearest double to the certified real value; raises unless the value is certified and exactly real (free symbols, complex values, poles, and estimated-only heads all raise).

find_root_numeric#

Default context

find_root_numeric(
    equations: Any,
    variables: Any,
    start: Any,
    domain: str = ...,
    method: str = ...,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericRootFindingResult

Find one root of equations = 0 numerically from start in the thread's default context.

Calling forms

Explicit context: Context.find_root_numeric

find_root_numeric(
    equations: Any,
    variables: Any,
    start: Any,
    domain: str = ...,
    method: str = ...,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericRootFindingResult

find_root_numeric_in_bracket#

Default context

find_root_numeric_in_bracket(
    equation: ExpressionLike,
    variable: VariableLike,
    lower: Any,
    upper: Any,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericRootFindingResult

Find one real root of equation = 0 in a sign-changing bracket in the thread's default context.

Calling forms

Explicit context: Context.find_root_numeric_in_bracket

find_root_numeric_in_bracket(
    equation: ExpressionLike,
    variable: VariableLike,
    lower: Any,
    upper: Any,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericRootFindingResult

integrate_definite_numeric#

Default context

integrate_definite_numeric(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericValue

The numerical value of a definite integral in the thread's default context.

Calling forms

Explicit context: Context.integrate_definite_numeric

integrate_definite_numeric(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericValue

isolate_real_roots_numeric#

Default context

isolate_real_roots_numeric(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    precision_bits: int,
    work_budget: int,
) -> NumericRootIsolationResult

Isolate the real roots of an expression with certified rational enclosures.

Calling forms

Explicit context: Context.isolate_real_roots_numeric

isolate_real_roots_numeric(
    input_expression: ExpressionLike,
    variable: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericRootIsolationResult

polynomial_roots_numeric#

Default context

polynomial_roots_numeric(
    polynomial: ExpressionLike,
    variable: VariableLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericPolynomialRootsResult

Find every root of a polynomial numerically, with multiplicities, in the thread's default context.

Calling forms

Explicit context: Context.polynomial_roots_numeric

polynomial_roots_numeric(
    polynomial: ExpressionLike,
    variable: VariableLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericPolynomialRootsResult

rational_from_float#

Default context

rational_from_float(value: float, max_denominator: int) -> Expression

Closest rational with denominator ≤\leq max_denominator (the Fraction.limit_denominator algorithm).

Calling forms

Explicit context: Context.rational_from_float

rational_from_float(value: float, max_denominator: int) -> Expression

summation_numeric#

Default context

summation_numeric(
    summand: ExpressionLike,
    index: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericValue

The numerical value of a definite sum in the thread's default context.

Calling forms

Explicit context: Context.summation_numeric

summation_numeric(
    summand: ExpressionLike,
    index: VariableLike,
    lower: ExpressionLike,
    upper: ExpressionLike,
    significant_digits: int = ...,
    accuracy: str = ...,
    maximum_precision_bits: int = ...,
    work_budget: int = ...,
) -> NumericValue

affine_process_transformation#

Default context

affine_process_transformation(
    name: Any,
    source: Any,
    multiplier: Any,
    offset: Any,
) -> Expression

Construct the exact pointwise affine image of a certified Gaussian process.

Calling forms

Explicit context: Context.affine_process_transformation

affine_process_transformation(
    name: str,
    source: ExpressionLike,
    multiplier: ExpressionLike,
    offset: ExpressionLike,
) -> Expression

archimedean_copula#

Default context

archimedean_copula(
    family: str,
    marginals: Any,
    parameter: Any,
) -> Expression

Construct a supported Archimedean copula from continuous marginals and its parameter.

Calling forms

Explicit context: Context.archimedean_copula

archimedean_copula(
    family: str,
    marginals: Iterable[ExpressionLike],
    parameter: ExpressionLike,
) -> Expression

characteristic_function#

Default context

characteristic_function(
    random_variable: ExpressionLike,
    auxiliary_variable: VariableLike,
) -> Expression

Closed-form characteristic function φX(t)\varphi_X(t) of random_variable in the named auxiliary variable, when elementary; otherwise an unevaluated structural form.

Calling forms

Explicit context: Context.characteristic_function

characteristic_function(
    random_variable: ExpressionLike,
    auxiliary_variable: VariableLike,
) -> Expression

component#

Default context

component(random_vector: ExpressionLike, position: int) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.component

component(random_vector: ExpressionLike, position: int) -> Expression

conditional_process_slice_distribution#

Default context

conditional_process_slice_distribution(
    process: Any,
    selected_indices: Any,
    conditioning_indices: Any,
    conditioning_values: Any,
) -> Expression

Condition one finite process slice on another through the common continuous-law engine.

Calling forms

Explicit context: Context.conditional_process_slice_distribution

conditional_process_slice_distribution(
    process: ExpressionLike,
    selected_indices: Iterable[ExpressionLike],
    conditioning_indices: Iterable[ExpressionLike],
    conditioning_values: Iterable[ExpressionLike],
) -> Expression

covariance#

Default context

covariance(
    left: ExpressionLike,
    right: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

Covariance of left and right over the listed independent random variables; zero for independent operands.

Calling forms

Explicit context: Context.covariance

covariance(
    left: ExpressionLike,
    right: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

cumulant#

Default context

cumulant(
    random_variable: ExpressionLike,
    order: ExpressionLike,
) -> Expression

The order-th cumulant of random_variable.

Calling forms

Explicit context: Context.cumulant

cumulant(
    random_variable: ExpressionLike,
    order: ExpressionLike,
) -> Expression

cumulative_distribution#

Default context

cumulative_distribution(
    random_variable: ExpressionLike,
    point: ExpressionLike,
) -> Expression

Cumulative distribution function of random_variable evaluated at point.

Calling forms

Explicit context: Context.cumulative_distribution

cumulative_distribution(
    random_variable: ExpressionLike,
    point: ExpressionLike,
) -> Expression

density#

Default context

density(
    random_variable: ExpressionLike,
    point: ExpressionLike,
) -> Expression

Probability density (continuous families) or probability mass (discrete families) of random_variable evaluated at point.

Calling forms

Explicit context: Context.density

density(
    random_variable: ExpressionLike,
    point: ExpressionLike,
) -> Expression

dirichlet#

Default context

dirichlet(parameters: Iterable[ExpressionLike]) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.dirichlet

dirichlet(parameters: Iterable[ExpressionLike]) -> Expression

discrete_markov_chain#

Default context

discrete_markov_chain(
    name: Any,
    states: Any,
    transition_matrix: Any,
    initial_probabilities: Any,
) -> Expression

Construct an exact finite-state time-homogeneous Markov chain.

Calling forms

Explicit context: Context.discrete_markov_chain

discrete_markov_chain(
    name: Any,
    states: Any,
    transition_matrix: Any,
    initial_probabilities: Any,
) -> Expression

distribution#

Default context

distribution(
    name: str,
    parameters: Iterable[ExpressionLike],
) -> Expression

Build a distribution node from a family name and its ordered parameter list (e.g. distribution("normal", [mean, standard_deviation])).

Calling forms

Explicit context: Context.distribution

distribution(
    name: str,
    parameters: Iterable[ExpressionLike],
) -> Expression

estimate_archimedean_copula_parameter#

Default context

estimate_archimedean_copula_parameter(
    family: str,
    observations: Any,
) -> Expression

Estimate an exactly invertible Archimedean copula parameter from bivariate ranks.

Calling forms

Explicit context: Context.estimate_archimedean_copula_parameter

estimate_archimedean_copula_parameter(
    family: str,
    observations: Matrix,
) -> Expression

estimate_archimedean_copula_parameter_numeric#

Default context

estimate_archimedean_copula_parameter_numeric(
    family: str,
    observations: Any,
    parameter: Any,
    lower: Any,
    upper: Any,
    significant_digits: Any = ...,
    accuracy: Any = ...,
    maximum_precision_bits: Any = ...,
    work_budget: Any = ...,
) -> NumericRootFindingResult

Numerically estimate a Frank copula parameter from exact bivariate ranks in a requested bracket.

Calling forms

Explicit context: Context.estimate_archimedean_copula_parameter_numeric

estimate_archimedean_copula_parameter_numeric(
    family: str,
    observations: Matrix,
    parameter: VariableLike,
    lower: Any,
    upper: Any,
    significant_digits: Any = ...,
    accuracy: Any = ...,
    maximum_precision_bits: Any = ...,
    work_budget: Any = ...,
) -> NumericRootFindingResult

expectation#

Default context

expectation(
    target: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

Expectation of target over the listed independent random variables. Linearity and the constant-factor lift are applied; bare and power-of-random-variable leaves consume the distribution's mean and raw moments.

Calling forms

Explicit context: Context.expectation

expectation(
    target: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

expected_hitting_time#

Default context

expected_hitting_time(
    process: Any,
    start_state: Any,
    target_states: Any,
) -> Expression

Return the exact expected time to reach a target state set.

Calling forms

Explicit context: Context.expected_hitting_time

expected_hitting_time(
    process: Any,
    start_state: Any,
    target_states: Any,
) -> Expression

finite_dimensional_random_vector#

Default context

finite_dimensional_random_vector(
    process: Any,
    indices: Any,
    coordinate_names: Any,
) -> Expression

Construct a random vector from an ordered finite stochastic-process slice.

Calling forms

Explicit context: Context.finite_dimensional_random_vector

finite_dimensional_random_vector(
    process: ExpressionLike,
    indices: Iterable[ExpressionLike],
    coordinate_names: list[str],
) -> Expression

gaussian_copula#

Default context

gaussian_copula(
    marginals: Iterable[ExpressionLike],
    correlation: Matrix,
) -> Expression

Construct a Gaussian copula from continuous marginals and a correlation matrix.

Calling forms

Explicit context: Context.gaussian_copula

gaussian_copula(
    marginals: Iterable[ExpressionLike],
    correlation: Matrix,
) -> Expression

hitting_probability#

Default context

hitting_probability(
    process: Any,
    start_state: Any,
    target_states: Any,
) -> Expression

Return the exact probability of ever reaching a target state set.

Calling forms

Explicit context: Context.hitting_probability

hitting_probability(
    process: Any,
    start_state: Any,
    target_states: Any,
) -> Expression

independent_gaussian_process_sum#

Default context

independent_gaussian_process_sum(
    name: Any,
    first_source: Any,
    second_source: Any,
) -> Expression

Construct the pointwise sum of two explicitly independent Gaussian processes.

Calling forms

Explicit context: Context.independent_gaussian_process_sum

independent_gaussian_process_sum(
    name: str,
    first_source: ExpressionLike,
    second_source: ExpressionLike,
) -> Expression

independent_process_product#

Default context

independent_process_product(
    first_process: Any,
    first_indices: Any,
    second_process: Any,
    second_indices: Any,
) -> Expression

Construct the explicit independent block product of two finite process slices.

Calling forms

Explicit context: Context.independent_process_product

independent_process_product(
    first_process: ExpressionLike,
    first_indices: Iterable[ExpressionLike],
    second_process: ExpressionLike,
    second_indices: Iterable[ExpressionLike],
) -> Expression

independent_product#

Default context

independent_product(factors: Iterable[ExpressionLike]) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.independent_product

independent_product(factors: Iterable[ExpressionLike]) -> Expression

intrinsic_simplex_density#

Default context

intrinsic_simplex_density(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.intrinsic_simplex_density

intrinsic_simplex_density(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

joint_correlation_matrix#

Default context

joint_correlation_matrix(joint_distribution: ExpressionLike) -> Matrix

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_correlation_matrix

joint_correlation_matrix(joint_distribution: ExpressionLike) -> Matrix

joint_covariance_matrix#

Default context

joint_covariance_matrix(joint_distribution: ExpressionLike) -> Matrix

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_covariance_matrix

joint_covariance_matrix(joint_distribution: ExpressionLike) -> Matrix

joint_cumulative_distribution#

Default context

joint_cumulative_distribution(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_cumulative_distribution

joint_cumulative_distribution(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

joint_density#

Default context

joint_density(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_density

joint_density(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

joint_distribution#

Default context

joint_distribution(random_vector: ExpressionLike) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_distribution

joint_distribution(random_vector: ExpressionLike) -> Expression

joint_mean#

Default context

joint_mean(joint_distribution: ExpressionLike) -> list[Expression]

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_mean

joint_mean(joint_distribution: ExpressionLike) -> list[Expression]

joint_probability_mass_function#

Default context

joint_probability_mass_function(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_probability_mass_function

joint_probability_mass_function(
    joint_distribution: ExpressionLike,
    points: Iterable[ExpressionLike],
) -> Expression

joint_raw_moment#

Default context

joint_raw_moment(
    joint_distribution: ExpressionLike,
    orders: Iterable[ExpressionLike],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_raw_moment

joint_raw_moment(
    joint_distribution: ExpressionLike,
    orders: Iterable[ExpressionLike],
) -> Expression

joint_rectangle_probability#

Default context

joint_rectangle_probability(
    joint_distribution: ExpressionLike,
    lower_bounds: Iterable[ExpressionLike],
    upper_bounds: Iterable[ExpressionLike],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_rectangle_probability

joint_rectangle_probability(
    joint_distribution: ExpressionLike,
    lower_bounds: Iterable[ExpressionLike],
    upper_bounds: Iterable[ExpressionLike],
) -> Expression

joint_support#

Default context

joint_support(joint_distribution: ExpressionLike) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.joint_support

joint_support(joint_distribution: ExpressionLike) -> Expression

marginal#

Default context

marginal(
    joint_distribution: ExpressionLike,
    positions: list[int],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.marginal

marginal(
    joint_distribution: ExpressionLike,
    positions: list[int],
) -> Expression

maximum#

Default context

maximum(
    base_law: ExpressionLike,
    sample_size: ExpressionLike,
) -> Expression

Construct the maximum of an independent identically distributed sample.

Calling forms

Explicit context: Context.maximum

maximum(
    base_law: ExpressionLike,
    sample_size: ExpressionLike,
) -> Expression

minimum#

Default context

minimum(
    base_law: ExpressionLike,
    sample_size: ExpressionLike,
) -> Expression

Construct the minimum of an independent identically distributed sample.

Calling forms

Explicit context: Context.minimum

minimum(
    base_law: ExpressionLike,
    sample_size: ExpressionLike,
) -> Expression

moment#

Default context

moment(
    random_variable: ExpressionLike,
    order: ExpressionLike,
) -> Expression

The order-th raw moment E[X^order] of random_variable.

Calling forms

Explicit context: Context.moment

moment(
    random_variable: ExpressionLike,
    order: ExpressionLike,
) -> Expression

moment_generating_function#

Default context

moment_generating_function(
    random_variable: ExpressionLike,
    auxiliary_variable: VariableLike,
) -> Expression

Closed-form moment generating function M_X(t) of random_variable in the named auxiliary variable, when elementary; otherwise an unevaluated structural form.

Calling forms

Explicit context: Context.moment_generating_function

moment_generating_function(
    random_variable: ExpressionLike,
    auxiliary_variable: VariableLike,
) -> Expression

multinomial_distribution#

Default context

multinomial_distribution(
    trial_count: ExpressionLike,
    probabilities: Iterable[ExpressionLike],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.multinomial_distribution

multinomial_distribution(
    trial_count: ExpressionLike,
    probabilities: Iterable[ExpressionLike],
) -> Expression

multivariate_normal#

Default context

multivariate_normal(
    mean: Iterable[ExpressionLike],
    covariance: Matrix,
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.multivariate_normal

multivariate_normal(
    mean: Iterable[ExpressionLike],
    covariance: Matrix,
) -> Expression

order_statistic#

Default context

order_statistic(
    base_law: ExpressionLike,
    sample_size: ExpressionLike,
    rank: ExpressionLike,
) -> Expression

Construct the rank order statistic of an independent identically distributed sample.

Calling forms

Explicit context: Context.order_statistic

order_statistic(
    base_law: ExpressionLike,
    sample_size: ExpressionLike,
    rank: ExpressionLike,
) -> Expression

permute#

Default context

permute(
    joint_distribution: ExpressionLike,
    permutation: list[int],
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.permute

permute(
    joint_distribution: ExpressionLike,
    permutation: list[int],
) -> Expression

probability#

Default context

probability(
    predicate: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

Probability that predicate (a tail comparison such as X > t) holds over the listed independent random variables.

Calling forms

Explicit context: Context.probability

probability(
    predicate: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

product_copula#

Default context

product_copula(marginals: Iterable[ExpressionLike]) -> Expression

Construct the product copula of continuous scalar marginals.

Calling forms

Explicit context: Context.product_copula

product_copula(marginals: Iterable[ExpressionLike]) -> Expression

quantile_numeric#

Default context

quantile_numeric(
    distribution: ExpressionLike,
    probability: Any,
    variable: Any,
    lower: Any,
    upper: Any,
    significant_digits: Any = ...,
    accuracy: Any = ...,
    maximum_precision_bits: Any = ...,
    work_budget: Any = ...,
) -> NumericRootFindingResult

Numerically invert a scalar distribution CDF on an explicitly supplied exact bracket.

Calling forms

Explicit context: Context.quantile_numeric

quantile_numeric(
    distribution: ExpressionLike,
    probability: ExpressionLike,
    variable: VariableLike,
    lower: Any,
    upper: Any,
    significant_digits: Any = ...,
    accuracy: Any = ...,
    maximum_precision_bits: Any = ...,
    work_budget: Any = ...,
) -> NumericRootFindingResult

random_variable#

Default context

random_variable(name: str, distribution: ExpressionLike) -> Expression

Build a random variable named name drawn from distribution.

Calling forms

Explicit context: Context.random_variable

random_variable(name: str, distribution: ExpressionLike) -> Expression

random_vector#

Default context

random_vector(
    coordinate_names: list[str],
    joint_distribution: ExpressionLike,
) -> Expression

Expose the native joint-law operation on the default context.

Calling forms

Explicit context: Context.random_vector

random_vector(
    coordinate_names: list[str],
    joint_distribution: ExpressionLike,
) -> Expression

stationary_distributions#

Default context

stationary_distributions(process: Any) -> Matrix

Return the extreme stationary laws of a finite Markov chain.

Calling forms

Explicit context: Context.stationary_distributions

stationary_distributions(process: Any) -> Matrix

transition_probability#

Default context

transition_probability(
    process: Any,
    from_state: Any,
    to_state: Any,
    start_index: Any,
    end_index: Any,
) -> Expression

Return an exact transition probability for a finite Markov chain.

Calling forms

Explicit context: Context.transition_probability

transition_probability(
    process: Any,
    from_state: Any,
    to_state: Any,
    start_index: Any,
    end_index: Any,
) -> Expression

variance#

Default context

variance(
    target: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

Variance of target over the listed independent random variables.

Calling forms

Explicit context: Context.variance

variance(
    target: ExpressionLike,
    random_variables: Iterable[ExpressionLike],
) -> Expression

beta#

Default context

beta(x: Any, y: Any) -> Expression

The beta function B⁡(x,y)=Γ(x)Γ(y)/Γ(x+y)\operatorname{B}(x, y) = \Gamma(x)\Gamma(y)/\Gamma(x+y).

Calling forms

Explicit context: Context.beta

beta(x: Any, y: Any) -> Expression

carlson_rc#

Default context

carlson_rc(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
) -> Expression

Carlson's degenerate symmetric elliptic integral RC(x,y)R_C(x,y).

Calling forms

Explicit context: Context.carlson_rc

carlson_rc(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
) -> Expression

carlson_rd#

Default context

carlson_rd(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
    third_argument: ExpressionLike,
) -> Expression

Carlson's symmetric elliptic integral RD(x,y,z)R_D(x,y,z).

Calling forms

Explicit context: Context.carlson_rd

carlson_rd(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
    third_argument: ExpressionLike,
) -> Expression

carlson_rf#

Default context

carlson_rf(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
    third_argument: ExpressionLike,
) -> Expression

Carlson's symmetric elliptic integral RF(x,y,z)R_F(x,y,z).

Calling forms

Explicit context: Context.carlson_rf

carlson_rf(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
    third_argument: ExpressionLike,
) -> Expression

carlson_rj#

Default context

carlson_rj(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
    third_argument: ExpressionLike,
    fourth_argument: ExpressionLike,
) -> Expression

Carlson's symmetric elliptic integral RJ(x,y,z,p)R_J(x,y,z,p).

Calling forms

Explicit context: Context.carlson_rj

carlson_rj(
    first_argument: ExpressionLike,
    second_argument: ExpressionLike,
    third_argument: ExpressionLike,
    fourth_argument: ExpressionLike,
) -> Expression

chebyshev_polynomial_first_kind#

Default context

chebyshev_polynomial_first_kind(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The Chebyshev polynomial Tn(x)T_n(x).

Calling forms

Explicit context: Context.chebyshev_polynomial_first_kind

chebyshev_polynomial_first_kind(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

chebyshev_polynomial_second_kind#

Default context

chebyshev_polynomial_second_kind(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The Chebyshev polynomial Un(x)U_n(x).

Calling forms

Explicit context: Context.chebyshev_polynomial_second_kind

chebyshev_polynomial_second_kind(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

cosine_integral#

Default context

cosine_integral(x: Any) -> Expression

The cosine integral Ci⁡(x)\operatorname{Ci}(x), with Ci⁡′(x)=cos⁡(x)/x\operatorname{Ci}'(x) = \cos(x)/x.

Calling forms

Explicit context: Context.cosine_integral

cosine_integral(x: Any) -> Expression

digamma#

Default context

digamma(x: Any) -> Expression

The digamma function ψ(x)=Γ′(x)/Γ(x)\psi(x) = \Gamma'(x)/\Gamma(x).

Calling forms

Explicit context: Context.digamma

digamma(x: Any) -> Expression

elliptic_e#

Default context

elliptic_e(parameter: ExpressionLike) -> Expression

The complete second-kind elliptic integral E(m)E(m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.elliptic_e

elliptic_e(parameter: ExpressionLike) -> Expression

elliptic_e_incomplete#

Default context

elliptic_e_incomplete(
    amplitude: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

The incomplete second-kind elliptic integral E(ϕ∣m)E(\phi\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.elliptic_e_incomplete

elliptic_e_incomplete(
    amplitude: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

elliptic_f#

Default context

elliptic_f(
    amplitude: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

The incomplete first-kind elliptic integral F(ϕ∣m)F(\phi\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.elliptic_f

elliptic_f(
    amplitude: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

elliptic_k#

Default context

elliptic_k(parameter: ExpressionLike) -> Expression

The complete first-kind elliptic integral K(m)K(m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.elliptic_k

elliptic_k(parameter: ExpressionLike) -> Expression

elliptic_pi#

Default context

elliptic_pi(
    characteristic: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

The complete third-kind elliptic integral Π(n∣m)\Pi(n\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.elliptic_pi

elliptic_pi(
    characteristic: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

elliptic_pi_incomplete#

Default context

elliptic_pi_incomplete(
    characteristic: ExpressionLike,
    amplitude: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

The incomplete third-kind elliptic integral Π(n;ϕ∣m)\Pi(n;\phi\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.elliptic_pi_incomplete

elliptic_pi_incomplete(
    characteristic: ExpressionLike,
    amplitude: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

error_function#

Default context

error_function(x: Any) -> Expression

The error function erf⁡(x)=2π∫0xe−t2 dt\operatorname{erf}(x) = \frac{2}{\sqrt{\pi}}\int_0^x e^{-t^2}\,dt.

Calling forms

Explicit context: Context.error_function

error_function(x: Any) -> Expression

error_function_complementary#

Default context

error_function_complementary(x: Any) -> Expression

The complementary error function erfc⁡(x)=1−erf⁡(x)\operatorname{erfc}(x) = 1 - \operatorname{erf}(x).

Calling forms

Explicit context: Context.error_function_complementary

error_function_complementary(x: Any) -> Expression

exponential_integral#

Default context

exponential_integral(x: Any) -> Expression

The exponential integral Ei⁡(x)\operatorname{Ei}(x), with Ei⁡′(x)=ex/x\operatorname{Ei}'(x) = e^x/x.

Calling forms

Explicit context: Context.exponential_integral

exponential_integral(x: Any) -> Expression

fresnel_cosine_integral#

Default context

fresnel_cosine_integral(x: Any) -> Expression

The Fresnel cosine integral C(x)=∫0xcos⁡(πt2/2) dtC(x) = \int_0^x \cos(\pi t^2/2)\,dt.

Calling forms

Explicit context: Context.fresnel_cosine_integral

fresnel_cosine_integral(x: Any) -> Expression

fresnel_sine_integral#

Default context

fresnel_sine_integral(x: Any) -> Expression

The Fresnel sine integral S(x)=∫0xsin⁡(πt2/2) dtS(x) = \int_0^x \sin(\pi t^2/2)\,dt.

Calling forms

Explicit context: Context.fresnel_sine_integral

fresnel_sine_integral(x: Any) -> Expression

gamma#

Default context

gamma(x: Any) -> Expression

The gamma function Γ(x)\Gamma(x), the analytic continuation of (x-1)!.

Calling forms

Explicit context: Context.gamma

gamma(x: Any) -> Expression

gegenbauer_polynomial#

Default context

gegenbauer_polynomial(
    degree: ExpressionLike,
    parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The Gegenbauer polynomial Cn(λ)(x)C_n^{(\lambda)}(x).

Calling forms

Explicit context: Context.gegenbauer_polynomial

gegenbauer_polynomial(
    degree: ExpressionLike,
    parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

generalized_laguerre_polynomial#

Default context

generalized_laguerre_polynomial(
    degree: ExpressionLike,
    parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The generalized Laguerre polynomial Ln(α)(x)L_n^{(\alpha)}(x).

Calling forms

Explicit context: Context.generalized_laguerre_polynomial

generalized_laguerre_polynomial(
    degree: ExpressionLike,
    parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

hermite_polynomial#

Default context

hermite_polynomial(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The physicists' Hermite polynomial Hn(x)H_n(x).

Calling forms

Explicit context: Context.hermite_polynomial

hermite_polynomial(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

hurwitz_zeta#

Default context

hurwitz_zeta(s: Any, a: Any) -> Expression

The Hurwitz zeta function ζ(s,a)=∑k≥0(k+a)−s\zeta(s, a) = \sum_{k\geq 0} (k+a)^{-s}, the numeric primitive of the family. hurwitz_zeta(s, 1) folds to zeta(s); hurwitz_zeta(s, 1/2) to (2s−1)ζ(s)(2^s - 1)\zeta(s); a positive integer second argument reduces to zeta(s) minus the finite head; a non-positive integer first argument gives a Bernoulli polynomial in a.

Calling forms

Explicit context: Context.hurwitz_zeta

hurwitz_zeta(s: Any, a: Any) -> Expression

hypergeometric_0f1#

Default context

hypergeometric_0f1(lower_parameter: Any, argument: Any) -> Expression

The confluent limit 0F1(;b;z){}_0F_1(; b; z), lowered to hypergeometric_pfq.

Calling forms

Explicit context: Context.hypergeometric_0f1

hypergeometric_0f1(lower_parameter: Any, argument: Any) -> Expression

hypergeometric_1f1#

Default context

hypergeometric_1f1(
    upper_parameter: Any,
    lower_parameter: Any,
    argument: Any,
) -> Expression

Kummer's confluent hypergeometric function 1F1(a;b;z){}_1F_1(a; b; z).

Calling forms

Explicit context: Context.hypergeometric_1f1

hypergeometric_1f1(
    upper_parameter: Any,
    lower_parameter: Any,
    argument: Any,
) -> Expression

hypergeometric_2f1#

Default context

hypergeometric_2f1(
    first_upper_parameter: Any,
    second_upper_parameter: Any,
    lower_parameter: Any,
    argument: Any,
) -> Expression

The Gauss hypergeometric function 2F1(a,b;c;z){}_2F_1(a, b; c; z).

Calling forms

Explicit context: Context.hypergeometric_2f1

hypergeometric_2f1(
    first_upper_parameter: Any,
    second_upper_parameter: Any,
    lower_parameter: Any,
    argument: Any,
) -> Expression

hypergeometric_pfq#

Default context

hypergeometric_pfq(
    upper_parameters: Any,
    lower_parameters: Any,
    argument: Any,
) -> Expression

The generalized hypergeometric function pFq(a;b;z){}_pF_q(\mathbf a; \mathbf b; z). The two parameter groups are ordered sequences: order and repetition are significant, so a set or frozenset is rejected.

Calling forms

Explicit context: Context.hypergeometric_pfq

hypergeometric_pfq(
    upper_parameters: Any,
    lower_parameters: Any,
    argument: Any,
) -> Expression

imaginary_error_function#

Default context

imaginary_error_function(x: Any) -> Expression

The imaginary error function erfi⁡(x)=2π∫0xet2 dt=−ierf⁡(ix)\operatorname{erfi}(x) = \frac{2}{\sqrt{\pi}}\int_0^x e^{t^2}\,dt = -i\operatorname{erf}(ix).

Calling forms

Explicit context: Context.imaginary_error_function

imaginary_error_function(x: Any) -> Expression

jacobi_amplitude#

Default context

jacobi_amplitude(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

The pinned Jacobi amplitude am⁡(u∣m)\operatorname{am}(u\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.jacobi_amplitude

jacobi_amplitude(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

jacobi_cn#

Default context

jacobi_cn(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

Jacobi's elliptic function cn⁡(u∣m)\operatorname{cn}(u\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.jacobi_cn

jacobi_cn(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

jacobi_dn#

Default context

jacobi_dn(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

Jacobi's elliptic function dn⁡(u∣m)\operatorname{dn}(u\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.jacobi_dn

jacobi_dn(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

jacobi_polynomial#

Default context

jacobi_polynomial(
    degree: ExpressionLike,
    first_parameter: ExpressionLike,
    second_parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The Jacobi polynomial Pn(α,β)(x)P_n^{(\alpha,\beta)}(x).

Calling forms

Explicit context: Context.jacobi_polynomial

jacobi_polynomial(
    degree: ExpressionLike,
    first_parameter: ExpressionLike,
    second_parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

jacobi_sn#

Default context

jacobi_sn(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

Jacobi's elliptic function sn⁡(u∣m)\operatorname{sn}(u\mid m), with parameter m=k2m=k^2.

Calling forms

Explicit context: Context.jacobi_sn

jacobi_sn(
    argument: ExpressionLike,
    parameter: ExpressionLike,
) -> Expression

jacobi_theta_1#

Default context

jacobi_theta_1(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

Jacobi's first theta function θ1(z∣τ)\theta_1(z\mid\tau), with half-period ratio τ\tau.

Calling forms

Explicit context: Context.jacobi_theta_1

jacobi_theta_1(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

jacobi_theta_2#

Default context

jacobi_theta_2(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

Jacobi's second theta function θ2(z∣τ)\theta_2(z\mid\tau), with half-period ratio τ\tau.

Calling forms

Explicit context: Context.jacobi_theta_2

jacobi_theta_2(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

jacobi_theta_3#

Default context

jacobi_theta_3(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

Jacobi's third theta function θ3(z∣τ)\theta_3(z\mid\tau), with half-period ratio τ\tau.

Calling forms

Explicit context: Context.jacobi_theta_3

jacobi_theta_3(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

jacobi_theta_4#

Default context

jacobi_theta_4(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

Jacobi's fourth theta function θ4(z∣τ)\theta_4(z\mid\tau), with half-period ratio τ\tau.

Calling forms

Explicit context: Context.jacobi_theta_4

jacobi_theta_4(
    argument: ExpressionLike,
    tau: ExpressionLike,
) -> Expression

laguerre_polynomial#

Default context

laguerre_polynomial(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The Laguerre polynomial, lowered to generalized Laguerre with parameter zero.

Calling forms

Explicit context: Context.laguerre_polynomial

laguerre_polynomial(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

legendre_polynomial#

Default context

legendre_polynomial(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The Legendre polynomial Pn(x)P_n(x).

Calling forms

Explicit context: Context.legendre_polynomial

legendre_polynomial(
    degree: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

lerch_phi#

Default context

lerch_phi(argument: Any, order: Any, shift: Any) -> Expression

The principal Lerch transcendent Φ(z,s,a)\Phi(z, s, a).

Calling forms

Explicit context: Context.lerch_phi

lerch_phi(
    argument: ExpressionLike,
    order: ExpressionLike,
    shift: ExpressionLike,
) -> Expression

log_gamma#

Default context

log_gamma(x: Any) -> Expression

The principal-branch log-gamma function (not log(gamma(x)) off the real axis).

Calling forms

Explicit context: Context.log_gamma

log_gamma(x: Any) -> Expression

logarithmic_integral#

Default context

logarithmic_integral(x: Any) -> Expression

The logarithmic integral li⁡(x)\operatorname{li}(x), with li⁡′(x)=1/log⁡(x)\operatorname{li}'(x) = 1/\log(x).

Calling forms

Explicit context: Context.logarithmic_integral

logarithmic_integral(x: Any) -> Expression

meijer_g#

Default context

meijer_g(
    upper_numerator_parameters: Any,
    upper_denominator_parameters: Any,
    lower_numerator_parameters: Any,
    lower_denominator_parameters: Any,
    argument: Any,
) -> Expression

The Meijer G-function Gp,qm,nG_{p,q}^{m,n} from its four ordered parameter groups. The orders m, n, p, and q are read from the group lengths and are never supplied separately.

Calling forms

Explicit context: Context.meijer_g

meijer_g(
    upper_numerator_parameters: Any,
    upper_denominator_parameters: Any,
    lower_numerator_parameters: Any,
    lower_denominator_parameters: Any,
    argument: Any,
) -> Expression

polygamma#

Default context

polygamma(order: Any, x: Any) -> Expression

The polygamma function ψ(n)(x)\psi^{(n)}(x), the order-th derivative of digamma; polygamma(0, x) reduces to digamma(x).

Calling forms

Explicit context: Context.polygamma

polygamma(order: Any, x: Any) -> Expression

polylogarithm#

Default context

polylogarithm(order: Any, argument: Any) -> Expression

The principal-branch polylogarithm Li⁡s(z)\operatorname{Li}_s(z).

Calling forms

Explicit context: Context.polylogarithm

polylogarithm(order: Any, argument: Any) -> Expression

sine_integral#

Default context

sine_integral(x: Any) -> Expression

The sine integral Si⁡(x)=∫0xsin⁡(t)/t dt\operatorname{Si}(x) = \int_0^x \sin(t)/t\,dt.

Calling forms

Explicit context: Context.sine_integral

sine_integral(x: Any) -> Expression

ultraspherical_polynomial#

Default context

ultraspherical_polynomial(
    degree: ExpressionLike,
    parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

The ultraspherical polynomial, lowered to the Gegenbauer head.

Calling forms

Explicit context: Context.ultraspherical_polynomial

ultraspherical_polynomial(
    degree: ExpressionLike,
    parameter: ExpressionLike,
    argument: ExpressionLike,
) -> Expression

zeta#

Default context

zeta(s: Any) -> Expression

The Riemann zeta function ζ(s)=∑k≥1k−s\zeta(s) = \sum_{k\geq 1} k^{-s}.

Calling forms

Explicit context: Context.zeta

zeta(s: Any) -> Expression

curl#

Default context

curl(
    vector_components: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> list[Expression]

∇×F\nabla\times F.

Calling forms

Explicit context: Context.curl

curl(
    vector_components: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> list[Expression]

divergence#

Default context

divergence(
    vector_components: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Expression

∇⋅F=∑i∂Fi/∂xi\nabla\cdot F = \sum_i \partial F_i/\partial x_i; component and variable counts must match.

Calling forms

Explicit context: Context.divergence

divergence(
    vector_components: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Expression

gradient#

Default context

gradient(
    scalar_field: ExpressionLike,
    variables: Iterable[VariableLike],
) -> list[Expression]

∇f\nabla f: the partial derivatives in the order of variables.

Calling forms

Explicit context: Context.gradient

gradient(
    scalar_field: ExpressionLike,
    variables: Iterable[VariableLike],
) -> list[Expression]

hessian#

Default context

hessian(
    scalar_field: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Matrix

The n×nn\times n matrix of second partials, computed as the Jacobian of the gradient; structurally symmetric on smooth input.

Calling forms

Explicit context: Context.hessian

hessian(
    scalar_field: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Matrix

jacobian#

Default context

jacobian(
    vector_components: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Matrix

The matrix with entry (i,j)=∂Fi/∂xj(i, j) = \partial F_i/\partial x_j (rows index components, columns index variables).

Calling forms

Explicit context: Context.jacobian

jacobian(
    vector_components: Iterable[ExpressionLike],
    variables: Iterable[VariableLike],
) -> Matrix

laplacian#

Default context

laplacian(
    scalar_field: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Expression

Δf=∇⋅∇f\Delta f = \nabla\cdot\nabla f.

Calling forms

Explicit context: Context.laplacian

laplacian(
    scalar_field: ExpressionLike,
    variables: Iterable[VariableLike],
) -> Expression

Symi documentation · Python