Skip to content
Symi Docs
Python
On this page

Ordinary differential equations

An ordinary differential equation relates an unknown function of one variable to its derivatives. Write the unknown with undefined_function and its derivatives with the derivative method on that handle, both documented in Undefined functions:

Python
context = symi.Context()
x = context.symbol("x")
y = context.undefined_function("y")
y_of_x = y(x)
# \(y'(x) = y(x) \Rightarrow y' - y = 0\)
equation = y.derivative([1], [x]) - y_of_x
solution = context.solve_ordinary_differential_equation(equation, y_of_x, "x")
# log(abs(y(x))) - (C1 + x)   — an implicit solution

Solutions are returned in whatever form the closing route produces: an implicit zero-equated expression with fresh integration constants (first-order routes), or an explicit equal(y(x), …) form (constant-coefficient route).

The expression-returning entries below are compatibility projections. When the data, method, family scope, history, or regularity is part of the question, use the request entries, whose results keep the evidence behind the answer: the method that actually ran, the independent verifier's verdict, the rank verdict behind a complete-family claim, the constants the family treats as free, and a typed decline reason. A request that cannot be answered as stated declines; it is never projected onto a weaker question whose answer is then reported under the stronger one.

Solving a scalar equation#

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
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 an ODE for the unknown function named by dependent_function_call (e.g. y(x)). The classifier ladder covers separable, linear first-order, exact (with integrating factor), Bernoulli, Riccati (with particular solution via the dedicated entry below), Lie-symmetry patterns, Kovacic second-order linear, and constant-coefficient linear of any order. Equations outside the ladder return the unevaluated ordinary_differential_equation placeholder.

initial_conditions is a list of (point, value) pairs meaning y(point) = value. They constrain the request, rather than merely advising a preferred route: Symi fits the generated data and independently replays every supplied condition before returning a particular solution. If it cannot fit and verify those data, it declines instead of returning the unconstrained family. Notes: this compatibility entry can express value data only; use solve_ordinary_differential_equation_request for derivative data. WASM passes a flat interleaved array [point_0, value_0, ...].

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
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 one scalar ODE request. Each condition residual is read as equal to zero and states one value or derivative datum at a coordinate-free point: f(0) states f(0)=0f(0)=0 and f.derivative([1], [0]) - 2 states f′(0)=2f'(0)=2.

  • scope is required: general is the compatibility spelling for general_on_regular_chart, which asks for the complete local family and is answered only when the map from the generated constants to the initial jet has full rank; particular asks for one solution through the data. implicit_local_family additionally requires an established implicit-function chart and never accepts an explicit branch as a substitute.
  • method is automatic, laplace_transform, separable, linear_first_order, exact, bernoulli, constant_coefficient, euler_cauchy, order_reduction, lie_symmetry, or special_function. An explicit method runs only its named route and declines when it does not apply. Automatic compares the certified candidates by expression weight, explicitness, chart obligations, and stable route order. The transform method runs the forward transform, frequency-domain solve, and inversion; it never substitutes another route.
  • regularity is classical, piecewise_classical, or weak. An equation whose coefficient switches at a point (a sign or piecewise coefficient) must be requested as piecewise_classical: its solution is classical on each side and matched in value and slope across the switch, not twice differentiable there.
  • A residual that integrates the unknown (a finite-memory Volterra term) is answered by a memory-state reduction and replayed against the original integral equation. A residual that evaluates the unknown at a lag is refused here, because its history is part of the question: use solve_ordinary_differential_equation_with_history.

Errors: a regularity that does not match the equation, a lag with no history, or an unreadable condition residual is an invalid-argument error naming the offending parameter.

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
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

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.

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
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 a retarded delay ODE from a constant history on the stated interval [history_start, history_end], which must cover every lag. The interval is never inferred, so a delay equation cannot acquire a history it was not given. The supported class is a scalar first-order linear equation with constant lags and constant history; it is answered by an exact method-of-steps family valid for every time, certified by induction on the step index. One history is one solution, so the request is particular.

Nonlinear first-order analysis#

analyze_first_order_nonlinear_equation#

Default context

analyze_first_order_nonlinear_equation(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> Optional[FirstOrderNonlinearSolutionAnalysis]
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]

Classify a supported nonlinear first-order equation without projecting its solution set onto one branch. The returned analysis keeps a regular family, each singular or equilibrium solution, and every certified parameterized branch separate. None means no supported classification closed with its required exact proofs.

find_ordinary_differential_equation_symmetries#

Default context

find_ordinary_differential_equation_symmetries(
    equation: ExpressionLike,
    dependent_function_call: ExpressionLike,
    independent_variable: VariableLike,
) -> OrdinaryDifferentialEquationPointSymmetrySearch
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

Search the fixed, deterministic first-order point-symmetry templates. Every returned generator has an independently proved prolongation residual. A search that finds no generator reports a typed decline instead of treating an empty list as proof that no symmetry exists.

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]
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]

Reduce through a symmetry returned by the same context's verified search. A failed reduction is None; it does not invalidate the independently useful symmetry.

Solving a system#

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
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 a system of ODEs in one coordinate, one equation per declared unknown. Each condition residual states one datum on exactly one component. method is automatic, sequential (scalar requests solved one at a time, each with its own fresh integration datum; declines when no elimination order exists), or fundamental_matrix (the coupled route through a certified fundamental matrix of the first-order state form). Every returned assignment is verified against every equation and datum. The fundamental-matrix route accepts constant systems, exact scalar-times-fixed and pairwise-commuting variable-coefficient families, and triangular systems whose variation-of- constants integrals close exactly; it declines when a required commutator or integral cannot be proved.

Verifying a supplied solution#

Exact local series#

linear_differential_operator#

Default context

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

Explicit context: Context.linear_differential_operator

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

context.linear_differential_operator(equation, dependent_function_call, independent_variable) extracts a rational-coefficient scalar operator when the residual is linear in the declared unknown. Its coefficients are ascending by derivative order; forcing gives (L[y]=f), and restrictions lists denominators that must remain nonzero on its chart. It returns None when linearity or rational-coefficient extraction cannot be certified.

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]
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]

context.ordinary_differential_equation_series(equation, dependent_function_call, independent_variable, expansion_point, initial_derivatives) returns an exact formal Taylor series only at a certified ordinary point. The returned record carries normalized initial coefficients, the all-index recurrence, operator chart restrictions, and proof status. It is not a finite polynomial approximation; unsupported, singular, or inadequately initialized problems return None.

LinearDifferentialOperator#

order, coefficients, forcing, and restrictions serialize the normalized operator and its local chart obligations.

Type

class LinearDifferentialOperator

A normalized rational-coefficient scalar linear differential operator.

LinearDifferentialOperator property

coefficients: list[Expression]

Coefficients in ascending derivative order.

LinearDifferentialOperator property

forcing: Expression

The forcing in L[y] = forcing.

LinearDifferentialOperator property

order: int

The order of this differential operator.

LinearDifferentialOperator property

restrictions: list[Expression]

Denominators required to remain nonzero on the operator chart.

OrdinaryDifferentialEquationSeriesRecurrence#

index_start and order identify the recurrence. operator_coefficient_series is the derivative-order concatenation, whose segment lengths are in operator_coefficient_series_lengths; forcing_coefficients gives the shifted forcing series.

Type

class OrdinaryDifferentialEquationSeriesRecurrence

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

OrdinaryDifferentialEquationSeriesRecurrence property

forcing_coefficients: list[Expression]

Shifted forcing coefficients.

OrdinaryDifferentialEquationSeriesRecurrence property

index_start: int

The first nonnegative recurrence index.

OrdinaryDifferentialEquationSeriesRecurrence property

operator_coefficient_series: list[Expression]

Concatenated shifted coefficient series in derivative-order sequence.

OrdinaryDifferentialEquationSeriesRecurrence property

operator_coefficient_series_lengths: list[int]

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

OrdinaryDifferentialEquationSeriesRecurrence property

order: int

The order of the operator defining this recurrence.

OrdinaryDifferentialEquationSeries#

operator, expansion_point, initial_coefficients, recurrence, and proof_status retain the data and exact certificate of the formal solution.

Type

class OrdinaryDifferentialEquationSeries

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

OrdinaryDifferentialEquationSeries property

expansion_point: Expression

The expansion point.

OrdinaryDifferentialEquationSeries property

initial_coefficients: list[Expression]

Normalized Taylor coefficients from the supplied initial derivative jet.

OrdinaryDifferentialEquationSeries property

operator: LinearDifferentialOperator

The normalized operator defining this local problem.

OrdinaryDifferentialEquationSeries property

proof_status: str

The exact proof status of this series.

OrdinaryDifferentialEquationSeries property

recurrence: OrdinaryDifferentialEquationSeriesRecurrence

The all-index recurrence proved by formal coefficient comparison.

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
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

Check a supplied assignment without solving: no solver runs, so a swapped component or a missing mode is reported against the assignment as given rather than repaired. The report carries verdict, generality (the rank verdict on the map from generated_constants to the initial jet), and required_rank.

Results#

Every request entry above returns one of these records. A record reports the route that actually ran and the independent verifier's verdict alongside the solution, so a caller can tell a proved answer from an unproved one, and carries a typed decline rather than a weaker answer when the request could not be met.

OrdinaryDifferentialEquationSolveResult#

verdict (solved/declined), method, solution, form (explicit/implicit), generated_constants, verification (verified/rejected/inconclusive), generality (full_rank/deficient/inconclusive), decline, and, for a Laplace transform solution, frequency_domain_equation and image.

Type

class OrdinaryDifferentialEquationSolveResult

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

OrdinaryDifferentialEquationSolveResult property

decline: Optional[str]

The typed reason no certified candidate was produced.

OrdinaryDifferentialEquationSolveResult property

form: Optional[str]

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

OrdinaryDifferentialEquationSolveResult property

frequency_domain_equation: Optional[Expression]

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

OrdinaryDifferentialEquationSolveResult property

generality: Optional[str]

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

OrdinaryDifferentialEquationSolveResult property

generated_constants: list[Expression]

Exactly the constants the solution treats as free.

OrdinaryDifferentialEquationSolveResult property

image: Optional[Expression]

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

OrdinaryDifferentialEquationSolveResult property

method: str

The method the request actually ran.

OrdinaryDifferentialEquationSolveResult property

solution: Optional[Expression]

The certified solution, which no declined request carries.

OrdinaryDifferentialEquationSolveResult property

verdict: str

Whether the request was solved or declined.

OrdinaryDifferentialEquationSolveResult property

verification: Optional[str]

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

OrdinaryDifferentialEquationSystemSolveResult#

verdict, method, route (sequential, fundamental_matrix, or dependency_blocks), components in declaration order, generated_constants, verification, generality, and decline.

Type

class OrdinaryDifferentialEquationSystemSolveResult

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

OrdinaryDifferentialEquationSystemSolveResult property

components: list[Expression]

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

OrdinaryDifferentialEquationSystemSolveResult property

decline: Optional[str]

The typed reason no certified assignment was produced.

OrdinaryDifferentialEquationSystemSolveResult property

generality: Optional[str]

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

OrdinaryDifferentialEquationSystemSolveResult property

generated_constants: list[Expression]

Exactly the constants the assignment treats as free.

OrdinaryDifferentialEquationSystemSolveResult property

method: str

The method the system request actually ran.

OrdinaryDifferentialEquationSystemSolveResult property

route: Optional[str]

The route the certified assignment came from.

OrdinaryDifferentialEquationSystemSolveResult property

verdict: str

Whether the system was solved or declined.

OrdinaryDifferentialEquationSystemSolveResult property

verification: Optional[str]

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

OrdinaryDifferentialEquationSystemVerificationReport#

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

verdict, generality, and required_rank.

FirstOrderNonlinearSolutionAnalysis#

regular_family, singular_solutions, and parametric_solutions. Singular and equilibrium branches are individually residual-checked but are not advertised as the regular general family.

Type

class FirstOrderNonlinearSolutionAnalysis

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

FirstOrderNonlinearSolutionBranch#

form, expression, and generated_constants for one separately certified explicit or implicit branch.

Type

class FirstOrderNonlinearSolutionBranch

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

FirstOrderNonlinearParametricSolution#

parameter, coordinate, value, and generated_constants for one certified parameterization.

Type

class FirstOrderNonlinearParametricSolution

One separately certified parameterized nonlinear first-order solution branch.

OrdinaryDifferentialEquationPointSymmetry#

horizontal_component and vertical_component are the infinitesimal generator components whose prolongation was proved invariant.

Type

class OrdinaryDifferentialEquationPointSymmetry

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

OrdinaryDifferentialEquationPointSymmetrySearch#

symmetries and decline. A nonempty symmetry list has no decline; an empty list is accompanied by its typed bounded-search reason.

Type

class OrdinaryDifferentialEquationPointSymmetrySearch

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

Request vocabulary#

A request entry names its scope, method, and regularity by one of these values. Naming a method runs that route only: it declines when the route does not apply, rather than falling through to another one.

OrdinaryDifferentialEquationMethod#

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

The route a scalar ordinary differential equation request must take.

Cases: Automatic, LaplaceTransform, Separable, LinearFirstOrder, Exact, Bernoulli, ConstantCoefficient, EulerCauchy, OrderReduction, LieSymmetry, SpecialFunction.

OrdinaryDifferentialEquationSystemMethod#

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

The route a system of ordinary differential equations must take.

Cases: Automatic, FundamentalMatrix, Sequential.

OrdinaryDifferentialEquationRegularity#

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

The differentiability a scalar ordinary differential equation answer must have.

Cases: Classical, PiecewiseClassical, Weak.

Outcome vocabulary#

A result reports its outcome through these values. generality is the rank decision behind a complete-family claim and is separate from verification, the independent verifier's decision about the solution itself: a solution can be verified and still not be the general family.

OrdinaryDifferentialEquationSolveVerdict#

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

Whether a scalar ordinary differential equation request was solved.

Cases: Declined, Solved.

OrdinaryDifferentialEquationSystemRoute#

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

The route a solved system of ordinary differential equations actually ran.

Cases: DependencyBlocks, FundamentalMatrix, Sequential.

OrdinaryDifferentialEquationSolutionForm#

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

Whether a returned ordinary differential equation solution gives the unknown or a relation.

Cases: Explicit, Implicit.

OrdinaryDifferentialEquationVerificationVerdict#

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

The exact decision an independent ordinary differential equation verifier reached.

Cases: Inconclusive, Rejected, Verified.

OrdinaryDifferentialEquationGeneralityVerdict#

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

The exact rank decision behind a complete-family claim.

Cases: Deficient, FullRank, Inconclusive.

Declines#

A request that cannot be met carries one of these reasons instead of a weaker answer. The reason names the step that did not close, so a decline can be acted on rather than merely retried.

OrdinaryDifferentialEquationSolveDecline#

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

Why a scalar ordinary differential equation request produced no certified candidate.

Cases: AccumulatedOccurrenceNotSupported, CandidateNotVerified, ConditionsNotFitted, DelayFamilyNotAvailable, DelayFamilyNotCertified, DisplacedOccurrenceNotSupported, DistributionalForcingNotSupported, GeneralFamilyNotEstablished, GeneralFamilyRankUndecided, NoRouteRecognizedTheEquation, SwitchedCoefficientsNotSolved, TransformDidNotReachTheFrequencyDomain, TransformInversionDeclined, TransformRequiresCompleteOriginData, TransformRequiresScalarSignature, TransformedEquationNotSolvable, UnprovedDomain, UnprovedResidual, UnsupportedClass, VolterraEndpointDataIncompatible, VolterraEndpointDataMissing, VolterraKernelNotSupported.

OrdinaryDifferentialEquationSystemSolveDecline#

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

Why a system of ordinary differential equations produced no certified assignment.

Cases: ComponentRequestDeclined, ComponentSolutionIsNotExplicit, ConditionsDoNotDetermineTheConstants, ForcingHasNoExactParticularState, FundamentalMatrixUnavailable, NoSequentialOrderingExists, SolutionNotVerified, StateFormUnavailable.

OrdinaryDifferentialEquationPointSymmetrySearchDecline#

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

Why the bounded first-order point-symmetry search returned no generator.

Cases: NoSymmetryProved, DeterminingSystemUndecidable.

Additional API#

FirstOrderNonlinearParametricSolution#

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#

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#

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.

OrdinaryDifferentialEquationPointSymmetry#

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#

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.

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.

Symi documentation · Python