Sturm–Liouville Ontology

flow "SturmLiouvilleOntology" v1.0

# ============================================================
# STURM-LIOUVILLE ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/differential-equations/sturm-liouville-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Differential Equations"
ENTITY := "Sturm-Liouville Problem"

# ---------- CORE ENTITY ----------
STURM_LIOUVILLE_PROBLEM := {
    type: DifferentialEigenvalueProblem,
    domain: DifferentialEquations,
    purpose: "Represent a second-order self-adjoint differential eigenvalue problem whose eigenvalues and weighted-orthogonal eigenfunctions support spectral analysis and function expansion."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    STURM_LIOUVILLE_PROBLEM,
    DIFFERENTIAL_OPERATOR,
    EIGENVALUE,
    EIGENFUNCTION,
    WEIGHT_FUNCTION,
    BOUNDARY_CONDITION,
    SELF_ADJOINT_OPERATOR,
    ORTHOGONALITY,
    NORMALISATION,
    SPECTRUM,
    EIGENFUNCTION_EXPANSION,
    GREEN_FUNCTION,
    SEPARATION_OF_VARIABLES
}

# ---------- STANDARD FORM ----------
STURM_LIOUVILLE_EQUATION:

-d/dx(
    p(x) * y_prime(x)
)
+
q(x) * y(x)
=
lambda * w(x) * y(x)

on
    x in [a,b]

with
    BOUNDARY_CONDITIONS

p(x)
    -> LEADING_COEFFICIENT

q(x)
    -> POTENTIAL_OR_COEFFICIENT_FUNCTION

w(x)
    -> WEIGHT_FUNCTION

lambda
    -> EIGENVALUE_PARAMETER

y(x)
    -> EIGENFUNCTION_CANDIDATE

# ---------- OPERATOR FORM ----------
L[y]
    := -d/dx(
        p(x)y_prime
    )
       + q(x)y

STURM_LIOUVILLE_PROBLEM
    := L[y]
       = lambda*w*y

L
    -> SECOND_ORDER_LINEAR_DIFFERENTIAL_OPERATOR

# ---------- REGULAR PROBLEM ----------
REGULAR_STURM_LIOUVILLE_PROBLEM
    -> typically_requires(
        finite_interval,
        p_positive,
        w_positive,
        suitable_continuity,
        regular_boundary_conditions
    )

REGULARITY_ASSUMPTIONS
    -> support(DISCRETE_SPECTRAL_THEORY)

# ---------- BOUNDARY CONDITIONS ----------
SEPARATED_BOUNDARY_CONDITIONS:

alpha_1*y(a)
+
alpha_2*y_prime(a)
= 0

beta_1*y(b)
+
beta_2*y_prime(b)
= 0

BOUNDARY_CONDITIONS
    -> homogeneous
       in(STANDARD_EIGENVALUE_PROBLEM)

BOUNDARY_CONDITIONS
    -> determine(ADMISSIBLE_EIGENVALUES)

# ---------- SELF-ADJOINTNESS ----------
SELF_ADJOINT_OPERATOR
    -> satisfies(
        inner_product(Lu,v)
        =
        inner_product(u,Lv)
    )
       under(APPROPRIATE_DOMAIN_AND_BOUNDARY_CONDITIONS)

STURM_LIOUVILLE_OPERATOR
    -> formally_self_adjoint

BOUNDARY_CONDITIONS
    -> required_to_obtain(SELF_ADJOINT_OPERATOR_DOMAIN)

# ---------- LAGRANGE IDENTITY ----------
u*L[v]
-
v*L[u]
    =
d/dx[
    p(x)
    * (
        v*u_prime
        - u*v_prime
      )
]

LAGRANGE_IDENTITY
    -> supports(SELF_ADJOINTNESS_AND_ORTHOGONALITY)

# ---------- EIGENVALUE ----------
EIGENVALUE
    := lambda
       for_which(
           nonzero_solution_exists
           satisfying(boundary_conditions)
       )

NONTRIVIAL_SOLUTION
    -> required

lambda
    -> determined_by(DIFFERENTIAL_EQUATION_AND_BOUNDARY_CONDITIONS)

# ---------- REAL EIGENVALUES ----------
for
    regular self-adjoint Sturm-Liouville problem:

EIGENVALUES
    -> REAL

SELF_ADJOINTNESS
    -> supports(REAL_SPECTRUM)

# ---------- DISCRETE SPECTRUM ----------
REGULAR_STURM_LIOUVILLE_PROBLEM
    -> has(DISCRETE_EIGENVALUE_SEQUENCE)

lambda_1
    < lambda_2
    < lambda_3
    < ...

under(standard_simple_eigenvalue_conditions)

EIGENVALUES
    -> tend_to(POSITIVE_INFINITY)
       under(STANDARD_REGULAR_ASSUMPTIONS)

# ---------- EIGENFUNCTION ----------
EIGENFUNCTION
    -> nonzero_solution_corresponding_to(EIGENVALUE)

SCALAR_MULTIPLE
    -> same_eigenvalue

NORMALISATION
    -> selects(CONVENIENT_REPRESENTATIVE)

# ---------- WEIGHTED INNER PRODUCT ----------
INNER_PRODUCT_w(f,g)
    := integral_from_a_to_b(
        w(x)
        * f(x)
        * conjugate(g(x))
        dx
    )

WEIGHT_FUNCTION
    -> defines(WEIGHTED_FUNCTION_SPACE_GEOMETRY)

# ---------- ORTHOGONALITY ----------
if
    y_m and y_n
        correspond_to(distinct_eigenvalues)
then

integral_from_a_to_b(
    w(x)
    * y_m(x)
    * conjugate(y_n(x))
    dx
)
    = 0

DISTINCT_EIGENFUNCTIONS
    -> WEIGHTED_ORTHOGONAL

# ---------- NORMALISATION ----------
NORMALISED_EIGENFUNCTION
    -> satisfies

integral_from_a_to_b(
    w(x)
    * abs(y_n(x))^2
    dx
)
    = 1

ORTHONORMAL_SET
    -> orthogonal
    -> unit_norm

# ---------- OSCILLATION PROPERTY ----------
for regular Sturm-Liouville problems:

NTH_EIGENFUNCTION
    -> has(ORDERED_ZERO_STRUCTURE)

higher_mode_index
    -> generally_more_internal_zeros

STURM_OSCILLATION_THEORY
    -> relates(EIGENVALUE_ORDER, ZERO_COUNT)

# ---------- EIGENFUNCTION EXPANSION ----------
if
    eigenfunctions form complete basis
then

f(x)
    = sum(
        c_n * y_n(x)
    )

where

c_n
    =
INNER_PRODUCT_w(f,y_n)
/
INNER_PRODUCT_w(y_n,y_n)

EIGENFUNCTION_EXPANSION
    -> generalises(FOURIER_SERIES)

# ---------- FOURIER SERIES RELATION ----------
CLASSICAL_FOURIER_PROBLEMS
    -> arise_as(SPECIAL_STURM_LIOUVILLE_PROBLEMS)

SINE_FUNCTIONS
    -> eigenfunctions_under(DIRICHLET_BOUNDARY_CONDITIONS)

COSINE_FUNCTIONS
    -> eigenfunctions_under(NEUMANN_TYPE_BOUNDARY_CONDITIONS)

FOURIER_EXPANSION
    -> spectral_expansion_in(EIGENFUNCTIONS)

# ---------- SEPARATION OF VARIABLES ----------
PDE
    -> may_be_separated_into(SPATIAL_AND_TEMPORAL_ODEs)

SPATIAL_ODE
    -> often(STURM_LIOUVILLE_PROBLEM)

BOUNDARY_CONDITIONS
    -> quantise(EIGENVALUES)

TEMPORAL_EQUATION
    -> depends_on(lambda_n)

SEPARATION_OF_VARIABLES
    -> generates(MODE_EXPANSIONS)

# ---------- HEAT EQUATION ----------
HEAT_EQUATION
    -> separation_produces(STURM_LIOUVILLE_SPATIAL_PROBLEM)

SOLUTION
    -> sum_of(EIGENMODES_WITH_TIME_DECAY)

EIGENVALUES
    -> determine(DECAY_RATES)

# ---------- WAVE EQUATION ----------
WAVE_EQUATION
    -> separation_produces(STURM_LIOUVILLE_SPATIAL_PROBLEM)

EIGENFUNCTIONS
    -> spatial_modes

EIGENVALUES
    -> determine(NATURAL_FREQUENCIES)

# ---------- GREEN FUNCTION RELATION ----------
for
    L[y] = f

GREENS_FUNCTION
    -> may_be_expanded_using(STURM_LIOUVILLE_EIGENFUNCTIONS)

G(x,xi)
    =
sum_n(
    y_n(x)
    * conjugate(y_n(xi))
    /
    lambda_n
)

subject_to
    normalisation,
    nonzero_eigenvalues,
    convergence_conditions

# ---------- RAYLEIGH QUOTIENT ----------
RAYLEIGH_QUOTIENT[y]
    :=
[
    integral(
        p*abs(y_prime)^2
        + q*abs(y)^2
        dx
    )
]
/
[
    integral(
        w*abs(y)^2
        dx
    )
]

under
    appropriate_boundary_conditions

RAYLEIGH_QUOTIENT
    -> estimates(EIGENVALUES)

VARIATIONAL_PRINCIPLE
    -> characterises(LOWEST_EIGENVALUE)
       under(STANDARD_SELF_ADJOINT_CONDITIONS)

# ---------- SINGULAR STURM-LIOUVILLE ----------
SINGULAR_PROBLEM
    -> may_have(INFINITE_INTERVAL)
    -> may_have(SINGULAR_ENDPOINT)
    -> may_have(VANISHING_OR_UNBOUNDED_COEFFICIENT)

SINGULAR_STURM_LIOUVILLE
    -> requires(MORE_ADVANCED_SPECTRAL_ANALYSIS)

SPECTRUM
    -> may_include(CONTINUOUS_COMPONENTS)

# ---------- APPLICATIONS ----------
STURM_LIOUVILLE_PROBLEM
    -> applied_to(HEAT_EQUATION)
    -> applied_to(WAVE_EQUATION)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(VIBRATION_ANALYSIS)
    -> applied_to(ELECTROMAGNETISM)
    -> applied_to(SPECTRAL_THEORY)
    -> applied_to(BOUNDARY_VALUE_PROBLEMS)

# ---------- RELATION GRAPH ----------
DIFFERENTIAL_OPERATOR
    + BOUNDARY_CONDITIONS
    -> STURM_LIOUVILLE_PROBLEM

SELF_ADJOINTNESS
    -> supports(REAL_EIGENVALUES)

DISTINCT_EIGENVALUES
    -> yield(ORTHOGONAL_EIGENFUNCTIONS)

WEIGHT_FUNCTION
    -> defines(ORTHOGONALITY)

EIGENFUNCTIONS
    -> form(SPECTRAL_BASIS)

SEPARATION_OF_VARIABLES
    -> produces(STURM_LIOUVILLE_PROBLEM)

EIGENFUNCTIONS
    -> expand(GREEN_FUNCTION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "Sturm-Liouville problem" ~= "self-adjoint second-order differential eigenvalue problem under standard conditions",
    "Sturm-Liouville operator" ~= "second-order differential operator in Sturm-Liouville form",
    "weight function" ~= "positive function defining the weighted eigenfunction inner product in regular theory",
    "Sturm-Liouville eigenfunction" ~= "nontrivial boundary-compatible solution associated with an admissible eigenvalue",
    "weighted orthogonality" ~= "orthogonality under the inner product containing the Sturm-Liouville weight",
    "eigenfunction expansion" ~= "spectral representation using Sturm-Liouville modes"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    eigenfunction_must_be_nonzero: true,
    boundary_conditions_are_part_of_problem_definition: true,
    self_adjointness_requires_operator_domain_and_boundary_conditions: true,
    orthogonality_of_distinct_modes_uses_weight_function: true,
    regular_problem_spectral_properties_require_regular_assumptions: true,
    singular_problems_may_have_different_spectral_structure: true,
    green_function_expansion_requires_nonzero_modes_and_convergence_conditions: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    standard_form: 0.99,
    self_adjoint_relation: 0.99,
    eigenvalue_relation: 0.99,
    orthogonality_relation: 0.99,
    eigenfunction_expansion_relation: 0.99,
    pde_separation_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(second_order_differential_operator)
    -> identify(interval_and_boundary_conditions)
    -> rewrite_in(sturm_liouville_form_if_possible)
    -> identify(p_q_and_weight_functions)
    -> verify(regularity_and_self_adjoint_conditions)
    -> solve(eigenvalue_equation)
    -> apply(boundary_conditions)
    -> identify(admissible_eigenvalues)
    -> construct(eigenfunctions)
    -> test(weighted_orthogonality)
    -> normalise(if_required)
    -> construct(spectral_expansion_if_requested)
    -> validate(problem_and_convergence_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed Sturm-Liouville semantic graph",
    primary_entity: STURM_LIOUVILLE_PROBLEM,
    preserve: [
        operator,
        interval,
        p_function,
        q_function,
        weight_function,
        boundary_conditions,
        eigenvalues,
        eigenfunctions
    ],
    infer_through: [
        self_adjoint_operators,
        weighted_inner_products,
        orthogonality,
        eigenfunction_expansions,
        pde_separation,
        green_functions,
        rayleigh_quotients
    ],
    avoid: [
        ignoring_boundary_conditions,
        treating_zero_function_as eigenfunction,
        assuming_regular spectral properties for singular problem,
        omitting_weight_in orthogonality,
        assuming_self_adjointness_without domain conditions,
        dividing_by_zero_eigenvalue_in green function expansion
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + STURM_LIOUVILLE_PROBLEM
    + L
    + WEIGHT_FUNCTION
    + SELF_ADJOINT_OPERATOR
    + EIGENVALUE
    + EIGENFUNCTION
    + ORTHOGONALITY
    + EIGENFUNCTION_EXPANSION
    + RAYLEIGH_QUOTIENT
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> STURM_LIOUVILLE_PROBLEM
    -> OPERATOR_IDENTIFICATION
    -> INTERVAL_BOUNDARY_ANALYSIS
    -> STANDARD_FORM_ANALYSIS
    -> REGULARITY_SELF_ADJOINT_ANALYSIS
    -> EIGENVALUE_EQUATION_SOLUTION
    -> BOUNDARY_CONDITION_APPLICATION
    -> EIGENVALUE_IDENTIFICATION
    -> EIGENFUNCTION_CONSTRUCTION
    -> ORTHOGONALITY_NORMALISATION_ANALYSIS
    -> SPECTRAL_EXPANSION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW