Linear Differential Equation Ontology

flow "LinearDifferentialEquationOntology" v1.0

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

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

# ---------- CORE ENTITY ----------
LINEAR_DIFFERENTIAL_EQUATION := {
    type: DifferentialEquation,
    domain: DifferentialEquations,
    purpose: "Represent a differential equation in which the unknown function and its derivatives occur linearly, enabling linear-operator methods and superposition in the homogeneous case."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    LINEAR_DIFFERENTIAL_EQUATION,
    LINEAR_DIFFERENTIAL_OPERATOR,
    UNKNOWN_FUNCTION,
    DERIVATIVE,
    COEFFICIENT_FUNCTION,
    HOMOGENEOUS_EQUATION,
    NONHOMOGENEOUS_EQUATION,
    SUPERPOSITION,
    GENERAL_SOLUTION,
    PARTICULAR_SOLUTION,
    INITIAL_VALUE_PROBLEM,
    BOUNDARY_VALUE_PROBLEM,
    WRONSKIAN
}

# ---------- GENERAL OPERATOR FORM ----------
LINEAR_DIFFERENTIAL_EQUATION
    := L[y] = g

L
    -> LINEAR_DIFFERENTIAL_OPERATOR

LINEARITY:
    L[alpha*y1 + beta*y2]
    =
    alpha*L[y1]
    + beta*L[y2]

# ---------- NTH-ORDER LINEAR ODE ----------
L[y]
    :=
a_n(x)y^(n)
+
a_(n-1)(x)y^(n-1)
+
...
+
a_1(x)y_prime
+
a_0(x)y

LINEAR_ODE
    := L[y] = g(x)

COEFFICIENT_FUNCTIONS
    := {
        a_0(x),
        a_1(x),
        ...,
        a_n(x)
    }

# ---------- LINEARITY CONDITIONS ----------
UNKNOWN_FUNCTION
    -> appears_to(FIRST_POWER)

DERIVATIVES
    -> appear_to(FIRST_POWER)

PRODUCTS_OF_UNKNOWN_AND_ITS_DERIVATIVES
    -> not_allowed_in(LINEAR_STRUCTURE)

NONLINEAR_FUNCTIONS_OF_UNKNOWN
    -> not_allowed_in(LINEAR_STRUCTURE)

COEFFICIENTS
    -> may_depend_on(INDEPENDENT_VARIABLES)
    -/> depend_on(UNKNOWN_FUNCTION)

# ---------- HOMOGENEOUS EQUATION ----------
if
    g = 0
then

L[y]
    = 0

-> HOMOGENEOUS_LINEAR_DIFFERENTIAL_EQUATION

HOMOGENEOUS_SOLUTION_SET
    -> VECTOR_SPACE

# ---------- SUPERPOSITION ----------
if
    L[y1] = 0
    AND L[y2] = 0
then

for constants c1,c2:

L[c1*y1 + c2*y2]
    = 0

SUPERPOSITION_PRINCIPLE
    -> applies_to(HOMOGENEOUS_LINEAR_EQUATIONS)

SUPERPOSITION
    -/> directly_applies_to(NONLINEAR_EQUATIONS)

# ---------- NONHOMOGENEOUS EQUATION ----------
if
    g != 0
then

L[y]
    = g

-> NONHOMOGENEOUS_LINEAR_DIFFERENTIAL_EQUATION

if
    y_p
        := PARTICULAR_SOLUTION
    AND y_h
        := HOMOGENEOUS_SOLUTION
then

y
    = y_h + y_p

-> GENERAL_NONHOMOGENEOUS_SOLUTION

# ---------- DIFFERENCE OF PARTICULAR SOLUTIONS ----------
if
    L[y1] = g
    AND L[y2] = g
then

L[y1-y2]
    = 0

PARTICULAR_SOLUTIONS
    -> differ_by(HOMOGENEOUS_SOLUTION)

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

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

mu(x)
    := INTEGRATING_FACTOR

then

d/dx[
    mu(x)y(x)
]
    =
mu(x)Q(x)

INTEGRATING_FACTOR_METHOD
    -> solves(FIRST_ORDER_LINEAR_ODE)

# ---------- SECOND-ORDER CONSTANT COEFFICIENT ----------
a*y_double_prime
+
b*y_prime
+
c*y
=
g(x)

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

ROOT_STRUCTURE
    -> determines(HOMOGENEOUS_SOLUTION_BASIS)

# ---------- DISTINCT REAL ROOTS ----------
if
    r1 != r2
    AND both_real
then

y_h
    = c1*exp(r1*x)
      + c2*exp(r2*x)

# ---------- REPEATED ROOT ----------
if
    r repeated
then

y_h
    = (c1 + c2*x)
      * exp(r*x)

# ---------- COMPLEX ROOTS ----------
if
    roots
        = alpha +/- i*beta
then

y_h
    =
exp(alpha*x)
*
[
    c1*cos(beta*x)
    + c2*sin(beta*x)
]

# ---------- PARTICULAR SOLUTION METHODS ----------
PARTICULAR_SOLUTION_METHODS := {
    UNDETERMINED_COEFFICIENTS,
    VARIATION_OF_PARAMETERS,
    GREEN_FUNCTION,
    LAPLACE_TRANSFORM
}

METHOD_SELECTION
    -> depends_on(COEFFICIENTS_AND_FORCING_STRUCTURE)

# ---------- WRONSKIAN ----------
for functions
    y1,...,yn

WRONSKIAN
    := determinant(
        derivative_matrix_of_solution_candidates
    )

WRONSKIAN_NONZERO_AT_POINT
    -> supports(LINEAR_INDEPENDENCE)
       under(STANDARD_LINEAR_ODE_CONDITIONS)

FUNDAMENTAL_SOLUTION_SET
    -> spans(HOMOGENEOUS_SOLUTION_SPACE)

# ---------- INITIAL VALUE PROBLEM ----------
INITIAL_VALUE_PROBLEM
    := LINEAR_ODE
       + INITIAL_CONDITIONS

for nth order:

y(x0)
y_prime(x0)
...
y^(n-1)(x0)

INITIAL_DATA
    -> determine(CONSTANTS)
       when(UNIQUE_SOLUTION_EXISTS)

# ---------- EXISTENCE AND UNIQUENESS ----------
if
    coefficients_and_forcing
        satisfy_required_continuity_conditions
    AND leading_coefficient_nonzero
then

LINEAR_ODE_IVP
    -> has(LOCAL_OR_INTERVAL_UNIQUE_SOLUTION)
       under(STANDARD_THEOREM_CONDITIONS)

# ---------- LINEAR PDE ----------
LINEAR_PDE
    := L[u] = f

L
    -> LINEAR_PARTIAL_DIFFERENTIAL_OPERATOR

if
    L[u1] = 0
    AND L[u2] = 0
then

L[c1*u1 + c2*u2]
    = 0

SUPERPOSITION
    -> extends_to(HOMOGENEOUS_LINEAR_PDEs)

# ---------- EIGENVALUE PROBLEMS ----------
LINEAR_DIFFERENTIAL_OPERATOR
    -> may_define(EIGENVALUE_PROBLEM)

L[y]
    = lambda*y

EIGENFUNCTION
    -> nonzero_function_satisfying(OPERATOR_EQUATION)

EIGENVALUE
    -> scalar_parameter

# ---------- BOUNDARY VALUE PROBLEM ----------
BOUNDARY_VALUE_PROBLEM
    := LINEAR_DIFFERENTIAL_EQUATION
       + BOUNDARY_CONDITIONS

BOUNDARY_CONDITIONS
    -> may_affect(EXISTENCE)
    -> may_affect(UNIQUENESS)
    -> may_generate(EIGENVALUE_SPECTRUM)

# ---------- SYSTEMS ----------
LINEAR_SYSTEM_OF_ODES
    := x_prime
       = A(t)x + b(t)

HOMOGENEOUS_SYSTEM:
    x_prime
        = A(t)x

FUNDAMENTAL_MATRIX
    -> spans(SOLUTION_SPACE)

MATRIX_EXPONENTIAL
    -> solves(CONSTANT_COEFFICIENT_HOMOGENEOUS_SYSTEM)

# ---------- APPLICATIONS ----------
LINEAR_DIFFERENTIAL_EQUATION
    -> applied_to(OSCILLATIONS)
    -> applied_to(ELECTRICAL_CIRCUITS)
    -> applied_to(CONTROL_SYSTEMS)
    -> applied_to(HEAT_AND_WAVE_MODELS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(SIGNAL_PROCESSING)
    -> applied_to(LINEARISED_PHYSICAL_SYSTEMS)

# ---------- RELATION GRAPH ----------
LINEAR_OPERATOR
    -> defines(LINEAR_DIFFERENTIAL_EQUATION)

ZERO_FORCING
    -> defines(HOMOGENEOUS_EQUATION)

NONZERO_FORCING
    -> defines(NONHOMOGENEOUS_EQUATION)

HOMOGENEOUS_SOLUTIONS
    -> obey(SUPERPOSITION)

PARTICULAR_SOLUTION
    + HOMOGENEOUS_SOLUTION
    -> GENERAL_NONHOMOGENEOUS_SOLUTION

WRONSKIAN
    -> tests(SOLUTION_INDEPENDENCE)

INITIAL_OR_BOUNDARY_DATA
    -> selects(SOLUTION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "linear differential equation" ~= "differential equation linear in the unknown function and its derivatives",
    "linear ODE" ~= "ordinary differential equation defined by a linear differential operator",
    "homogeneous linear equation" ~= "linear differential equation with zero forcing term",
    "nonhomogeneous linear equation" ~= "linear differential equation with nonzero forcing term",
    "superposition principle" ~= "closure of homogeneous linear solutions under linear combination",
    "particular solution" ~= "one solution of the nonhomogeneous equation"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    unknown_and_derivatives_must_enter_linearly: true,
    coefficients_may_depend_on_independent_variables: true,
    coefficients_must_not_depend_on_unknown_function_for_linear_structure: true,
    superposition_applies_to_homogeneous_linear_equation: true,
    nonhomogeneous_general_solution_is_particular_plus_homogeneous: true,
    existence_uniqueness_requires_coefficient_and_domain_conditions: true,
    wronskian_interpretation_depends_on_solution_context: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    operator_linearity: 0.99,
    homogeneous_superposition_relation: 0.99,
    nonhomogeneous_solution_structure: 0.99,
    integrating_factor_relation: 0.99,
    constant_coefficient_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(differential_equation)
    -> identify(unknown_function_and_independent_variables)
    -> test(linearity_conditions)
    -> construct(linear_operator)
    -> classify(homogeneous_or_nonhomogeneous)
    -> determine(order_and_coefficients)
    -> identify(initial_or_boundary_conditions)
    -> select(solution_method)
    -> construct(homogeneous_solution_space)
    -> construct(particular_solution_if_required)
    -> combine_and_apply(conditions)
    -> verify(solution_by_substitution)
    -> validate(existence_uniqueness_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed linear-differential-equation semantic graph",
    primary_entity: LINEAR_DIFFERENTIAL_EQUATION,
    preserve: [
        unknown_function,
        independent_variables,
        derivative_order,
        coefficient_functions,
        forcing_term,
        homogeneous_status,
        initial_boundary_conditions
    ],
    infer_through: [
        linear_operators,
        superposition,
        integrating_factors,
        characteristic_equations,
        wronskians,
        particular_solutions,
        eigenvalue_problems
    ],
    avoid: [
        classifying_nonlinear_equation_as linear,
        applying_superposition_to nonhomogeneous solutions without adjustment,
        omitting_homogeneous_component_from general nonhomogeneous solution,
        assuming_unique_solution_without coefficient conditions,
        confusing forcing_term_with coefficient
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + LINEAR_DIFFERENTIAL_EQUATION
    + LINEAR_DIFFERENTIAL_OPERATOR
    + HOMOGENEOUS_EQUATION
    + NONHOMOGENEOUS_EQUATION
    + SUPERPOSITION
    + INTEGRATING_FACTOR
    + WRONSKIAN
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> LINEAR_DIFFERENTIAL_EQUATION
    -> EQUATION_IDENTIFICATION
    -> LINEARITY_VALIDATION
    -> OPERATOR_CONSTRUCTION
    -> HOMOGENEOUS_CLASSIFICATION
    -> ORDER_COEFFICIENT_ANALYSIS
    -> CONDITION_ANALYSIS
    -> METHOD_SELECTION
    -> HOMOGENEOUS_SOLUTION_CONSTRUCTION
    -> PARTICULAR_SOLUTION_CONSTRUCTION
    -> CONDITION_APPLICATION
    -> SOLUTION_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW