Ordinary Differential Equation Ontology

flow "OrdinaryDifferentialEquationOntology" v1.0

# ============================================================
# ORDINARY DIFFERENTIAL EQUATION ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/differential-equations/ordinary-differential-equation-ontology-2.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Differential Equations"
ENTITY := "Ordinary Differential Equation"

# ---------- CORE ENTITY ----------
ORDINARY_DIFFERENTIAL_EQUATION := {
    type: DifferentialEquation,
    domain: DifferentialEquations,
    abbreviation: "ODE",
    purpose: "Represent an equation involving an unknown function of one independent variable and one or more ordinary derivatives of that function."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    ORDINARY_DIFFERENTIAL_EQUATION,
    UNKNOWN_FUNCTION,
    INDEPENDENT_VARIABLE,
    ORDINARY_DERIVATIVE,
    ORDER,
    DEGREE,
    LINEAR_ODE,
    NONLINEAR_ODE,
    AUTONOMOUS_ODE,
    INITIAL_VALUE_PROBLEM,
    GENERAL_SOLUTION,
    PARTICULAR_SOLUTION,
    EQUILIBRIUM,
    NUMERICAL_SOLUTION
}

# ---------- GENERAL FORM ----------
ODE
    := F(
        x,
        y,
        y_prime,
        y_double_prime,
        ...,
        y^(n)
    ) = 0

x
    -> INDEPENDENT_VARIABLE

y(x)
    -> UNKNOWN_DEPENDENT_FUNCTION

ORDINARY_DERIVATIVES
    -> taken_with_respect_to(x)

# ---------- ODE DISTINCTION ----------
ORDINARY_DIFFERENTIAL_EQUATION
    -> has(ONE_INDEPENDENT_VARIABLE)

PARTIAL_DIFFERENTIAL_EQUATION
    -> generally_has(MULTIPLE_INDEPENDENT_VARIABLES_AND_PARTIAL_DERIVATIVES)

ODE
    -/> PDE

# ---------- ORDER ----------
ORDER
    := highest_order_ordinary_derivative_present

example:

y_double_prime
    + 3*y_prime
    + 2*y
    = 0

ORDER
    = 2

ORDER
    -> structural_classification

# ---------- DEGREE ----------
DEGREE
    := exponent_of(HIGHEST_ORDER_DERIVATIVE)
       when(ODE_IS_POLYNOMIAL_IN_DERIVATIVES)

DEGREE
    -> may_be(UNDEFINED)

ORDER
    -/> same_as(DEGREE)

# ---------- EXPLICIT FORM ----------
NTH_ORDER_EXPLICIT_ODE
    := y^(n)
       = f(
           x,
           y,
           y_prime,
           ...,
           y^(n-1)
         )

EXPLICIT_FORM
    -> isolates(HIGHEST_DERIVATIVE)

# ---------- IMPLICIT FORM ----------
IMPLICIT_ODE
    := F(
        x,
        y,
        y_prime,
        ...,
        y^(n)
    ) = 0

IMPLICIT_FORM
    -> need_not_isolate(HIGHEST_DERIVATIVE)

# ---------- LINEAR ODE ----------
LINEAR_NTH_ORDER_ODE
    := a_n(x)y^(n)
       + a_(n-1)(x)y^(n-1)
       + ...
       + a_1(x)y_prime
       + a_0(x)y
       = g(x)

LINEAR_ODE
    -> unknown_function_and_derivatives_appear_linearly

# ---------- HOMOGENEOUS LINEAR ODE ----------
if
    g(x) = 0
then

LINEAR_ODE
    -> HOMOGENEOUS

if
    y1 and y2
        solve(HOMOGENEOUS_LINEAR_ODE)
then

c1*y1 + c2*y2
    -> also_solution

SUPERPOSITION
    -> property_of(HOMOGENEOUS_LINEAR_ODE)

# ---------- NONHOMOGENEOUS LINEAR ODE ----------
if
    g(x) != 0
then

LINEAR_ODE
    -> NONHOMOGENEOUS

GENERAL_SOLUTION
    =
HOMOGENEOUS_GENERAL_SOLUTION
+
PARTICULAR_SOLUTION

# ---------- NONLINEAR ODE ----------
NONLINEAR_ODE
    -> violates(LINEARITY_STRUCTURE)

examples:
    y*y_prime = x
    y_prime = y^2 + x
    y_double_prime + sin(y) = 0

NONLINEAR_ODE
    -> may_exhibit(MULTIPLE_EQUILIBRIA)
    -> may_exhibit(BIFURCATION)
    -> may_exhibit(COMPLEX_DYNAMICS)

# ---------- FIRST-ORDER ODE ----------
FIRST_ORDER_ODE
    := F(x,y,y_prime) = 0

common_explicit_form:
    y_prime = f(x,y)

FIRST_ORDER_METHODS := {
    SEPARATION_OF_VARIABLES,
    INTEGRATING_FACTOR,
    EXACT_EQUATION_METHOD,
    BERNOULLI_SUBSTITUTION,
    AUTONOMOUS_PHASE_ANALYSIS
}

# ---------- SEPARABLE ODE ----------
y_prime
    = g(x)h(y)

if
    h(y) != 0
then

dy/h(y)
    = g(x) dx

SEPARABLE_ODE
    -> solved_by(INTEGRATION)
       subject_to(SOLUTION_BRANCH_CHECKS)

# ---------- FIRST-ORDER LINEAR ----------
y_prime
    + P(x)y
    = Q(x)

INTEGRATING_FACTOR
    := exp(
        integral(P(x) dx)
    )

INTEGRATING_FACTOR_METHOD
    -> converts(EQUATION_TO_PRODUCT_DERIVATIVE)

# ---------- EXACT ODE ----------
M(x,y) dx
+
N(x,y) dy
= 0

if
    partial_M/partial_y
    =
    partial_N/partial_x

under(appropriate_domain_conditions)
then

ODE
    -> EXACT

exists(phi)
such_that

d(phi)
    = M dx + N dy

# ---------- AUTONOMOUS ODE ----------
AUTONOMOUS_ODE
    := y_prime = f(y)

x
    -> absent_explicitly_from(RIGHT_HAND_SIDE)

EQUILIBRIUM
    := y_star
       where
       f(y_star) = 0

AUTONOMOUS_ODE
    -> supports(PHASE_LINE_ANALYSIS)

# ---------- SECOND-ORDER CONSTANT COEFFICIENT ----------
a*y_double_prime
+
b*y_prime
+
c*y
= 0

CHARACTERISTIC_EQUATION
    := a*r^2 + b*r + c = 0

ROOT_CASES := {
    DISTINCT_REAL_ROOTS,
    REPEATED_REAL_ROOT,
    COMPLEX_CONJUGATE_ROOTS
}

ROOT_STRUCTURE
    -> determines(HOMOGENEOUS_SOLUTION_FORM)

# ---------- HIGHER-ORDER ODE ----------
NTH_ORDER_ODE
    -> may_be_transformed_into(FIRST_ORDER_SYSTEM)

define_state:

x1 = y
x2 = y_prime
...
xn = y^(n-1)

then

STATE_VECTOR
    := (x1,...,xn)

HIGHER_ORDER_ODE
    -> equivalent_to(FIRST_ORDER_SYSTEM)
       under(EXPLICIT_SOLVABLE_FORM)

# ---------- INITIAL VALUE PROBLEM ----------
INITIAL_VALUE_PROBLEM
    := ODE
       + initial_data

for nth-order ODE:

y(x0) = c0
y_prime(x0) = c1
...
y^(n-1)(x0) = c_(n-1)

INITIAL_DATA
    -> may_select(UNIQUE_LOCAL_SOLUTION)
       under(EXISTENCE_UNIQUENESS_CONDITIONS)

# ---------- EXISTENCE AND UNIQUENESS ----------
for
    y_prime = f(x,y)

if
    f continuous_near(x0,y0)
    AND f locally_lipschitz_in_y
then

PICARD_LINDELOF
    -> LOCAL_EXISTENCE_AND_UNIQUENESS

EXISTENCE
    -/> automatically_implies(UNIQUENESS)

# ---------- GENERAL SOLUTION ----------
GENERAL_SOLUTION
    -> family_of(ODE_SOLUTIONS)

for regular nth-order ODE:
    GENERAL_SOLUTION
        -> often_contains(n arbitrary_constants)

PARTICULAR_SOLUTION
    -> selected_by(INITIAL_OR_BOUNDARY_DATA)

# ---------- NUMERICAL METHODS ----------
EULER_METHOD:
    y_(n+1)
        = y_n
          + h*f(x_n,y_n)

RUNGE_KUTTA_METHODS
    -> higher_accuracy_time_stepping

NUMERICAL_ODE_SOLVER
    -> approximates(SOLUTION_TRAJECTORY)

STEP_SIZE
    -> affects(ACCURACY_AND_STABILITY)

# ---------- STIFFNESS ----------
STIFF_ODE
    -> contains(MULTIPLE_STRONGLY_DIFFERENT_TIME_SCALES)

EXPLICIT_METHOD
    -> may_require(VERY_SMALL_STEP_FOR_STABILITY)

IMPLICIT_METHOD
    -> often_used_for(STIFF_PROBLEMS)

# ---------- STABILITY ----------
AUTONOMOUS_SYSTEM
    := x_prime = F(x)

EQUILIBRIUM_POINT
    := x_star
       where
       F(x_star)=0

JACOBIAN(F)(x_star)
    -> supports(LOCAL_LINEAR_STABILITY_ANALYSIS)

EIGENVALUES
    -> inform(LOCAL_STABILITY)
       under(HYPERBOLIC_AND_RELEVANT_CONDITIONS)

# ---------- APPLICATIONS ----------
ODE
    -> applied_to(MECHANICS)
    -> applied_to(POPULATION_DYNAMICS)
    -> applied_to(CHEMICAL_KINETICS)
    -> applied_to(ELECTRICAL_CIRCUITS)
    -> applied_to(CONTROL_SYSTEMS)
    -> applied_to(EPIDEMIOLOGY)
    -> applied_to(ECONOMIC_DYNAMICS)

# ---------- RELATION GRAPH ----------
UNKNOWN_FUNCTION
    -> constrained_by(ODE)

ORDINARY_DERIVATIVES
    -> determine(ORDER)

LINEARITY
    -> determines(SUPERPOSITION_PROPERTIES)

INITIAL_DATA
    -> define(INITIAL_VALUE_PROBLEM)

AUTONOMOUS_ODE
    -> contains(EQUILIBRIA)

HIGHER_ORDER_ODE
    -> transforms_to(FIRST_ORDER_SYSTEM)

NUMERICAL_METHOD
    -> approximates(ODE_SOLUTION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "ordinary differential equation" ~= "differential equation with derivatives relative to one independent variable",
    "ODE" ~= "ordinary differential equation",
    "first-order ODE" ~= "ODE whose highest derivative is first order",
    "autonomous ODE" ~= "ODE with no explicit independent-variable dependence in its standard autonomous form",
    "initial value problem" ~= "ODE supplemented by initial conditions",
    "phase line" ~= "one-dimensional qualitative representation of an autonomous first-order ODE"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    ode_has_one_independent_variable: true,
    order_is_highest_ordinary_derivative_order: true,
    degree_may_be_undefined: true,
    superposition_applies_only_to_homogeneous_linear_odes: true,
    separation_may_lose_equilibrium_solutions_if_dividing_by_zero_factor: true,
    existence_uniqueness_require_hypotheses: true,
    numerical_solution_is_approximate_unless_exactness_proven: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    order_degree_structure: 0.99,
    linearity_structure: 0.99,
    first_order_methods: 0.99,
    initial_value_relation: 0.99,
    numerical_stability_relation: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(ode)
    -> identify(independent_and_dependent_variables)
    -> determine(order)
    -> determine(degree_if_defined)
    -> classify(linear_or_nonlinear)
    -> classify(autonomous_or_nonautonomous)
    -> identify(initial_or_boundary_data)
    -> classify(special_ode_type)
    -> select(analytical_or_numerical_method)
    -> solve_or_approximate()
    -> verify(solution_by_substitution_or_residual)
    -> analyse(stability_or_phase_behaviour_if_requested)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed ordinary-differential-equation semantic graph",
    primary_entity: ORDINARY_DIFFERENTIAL_EQUATION,
    preserve: [
        independent_variable,
        unknown_function,
        derivative_order,
        coefficients,
        linearity,
        initial_data,
        domain
    ],
    infer_through: [
        separable_equations,
        linear_first_order_equations,
        exact_equations,
        autonomous_systems,
        characteristic_equations,
        numerical_methods,
        stability
    ],
    avoid: [
        confusing_ode_with_pde,
        confusing_order_with_degree,
        applying_superposition_to nonlinear ode,
        losing_equilibrium_solutions_during separation,
        assuming_unique_solution_without hypotheses,
        treating_numerical_trajectory_as exact solution
    ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
    validate(new_information)
    -> identify(ode_context)
    -> compare(existing_relations)
    -> preserve(order_linearity_and_initial_data_invariants)
    -> update(affected_entities)
    -> update(affected_edges)
    -> recompute(CONFIDENCE)
    -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + ORDINARY_DIFFERENTIAL_EQUATION
    + ORDER
    + DEGREE
    + LINEAR_NTH_ORDER_ODE
    + AUTONOMOUS_ODE
    + INITIAL_VALUE_PROBLEM
    + PICARD_LINDELOF
    + NUMERICAL_ODE_SOLVER
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> ORDINARY_DIFFERENTIAL_EQUATION
    -> ODE_IDENTIFICATION
    -> VARIABLE_IDENTIFICATION
    -> ORDER_DEGREE_ANALYSIS
    -> LINEARITY_ANALYSIS
    -> AUTONOMY_ANALYSIS
    -> INITIAL_BOUNDARY_DATA_ANALYSIS
    -> ODE_TYPE_CLASSIFICATION
    -> METHOD_SELECTION
    -> SOLUTION_OR_APPROXIMATION
    -> SOLUTION_VALIDATION
    -> STABILITY_PHASE_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW