Eigenvalue Problem Ontology

flow "EigenvalueProblemOntology" v1.0

# ============================================================
# EIGENVALUE PROBLEM ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
EIGENVALUE_PROBLEM := {
    type: DifferentialOperatorProblem,
    domain: DifferentialEquations,
    purpose: "Determine nonzero functions or vectors that are scaled by a linear operator, together with the scalar eigenvalues that produce admissible solutions under specified domain and boundary conditions."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    EIGENVALUE_PROBLEM,
    LINEAR_OPERATOR,
    EIGENVALUE,
    EIGENFUNCTION,
    EIGENVECTOR,
    BOUNDARY_CONDITION,
    SPECTRUM,
    STURM_LIOUVILLE_PROBLEM,
    SELF_ADJOINT_OPERATOR,
    ORTHOGONALITY,
    NORMALISATION,
    CHARACTERISTIC_EQUATION,
    SPECTRAL_DECOMPOSITION
}

# ---------- ABSTRACT OPERATOR FORM ----------
EIGENVALUE_PROBLEM
    := L[phi]
       = lambda * phi

L
    -> LINEAR_OPERATOR

lambda
    -> EIGENVALUE

phi
    -> EIGENFUNCTION

constraint:
    phi != ZERO_FUNCTION

# ---------- FINITE-DIMENSIONAL FORM ----------
for matrix A:

A*v
    = lambda*v

v
    -> EIGENVECTOR

lambda
    -> EIGENVALUE

v != ZERO_VECTOR

MATRIX_EIGENVALUE_PROBLEM
    -> finite_dimensional_analogue_of(OPERATOR_EIGENVALUE_PROBLEM)

# ---------- CHARACTERISTIC EQUATION ----------
for finite-dimensional matrix A:

det(
    A - lambda*I
)
    = 0

CHARACTERISTIC_EQUATION
    -> determines(EIGENVALUE_CANDIDATES)

NULLSPACE(
    A - lambda*I
)
    -> determines(EIGENVECTORS)

# ---------- DIFFERENTIAL OPERATOR FORM ----------
DIFFERENTIAL_EIGENVALUE_PROBLEM
    := L[y]
       = lambda*w(x)*y

where
    L
        -> DIFFERENTIAL_OPERATOR
    w(x)
        -> WEIGHT_FUNCTION

BOUNDARY_CONDITIONS
    -> restrict(ADMISSIBLE_EIGENVALUES_AND_EIGENFUNCTIONS)

# ---------- STURM-LIOUVILLE FORM ----------
STURM_LIOUVILLE_PROBLEM:

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

with
    boundary_conditions

p(x)
    -> positive_under_standard_regular_conditions

w(x)
    -> positive_weight_under_standard_regular_conditions

STURM_LIOUVILLE
    -> structured_self_adjoint_eigenvalue_problem

# ---------- BOUNDARY CONDITIONS ----------
BOUNDARY_CONDITIONS
    -> may_be(DIRICHLET)
    -> may_be(NEUMANN)
    -> may_be(ROBIN)
    -> may_be(PERIODIC)
    -> may_be(MIXED)

BOUNDARY_CONDITIONS
    -> part_of(EIGENVALUE_PROBLEM_DEFINITION)

same_operator
    + different_boundary_conditions
    -> may_produce(DIFFERENT_SPECTRUM)

# ---------- EIGENVALUE ----------
EIGENVALUE
    -> scalar_parameter_for_nontrivial_solution

ADMISSIBLE_lambda
    -> value_for_which(HOMOGENEOUS_OPERATOR_EQUATION_HAS_NONZERO_SOLUTION)

NONTRIVIAL_SOLUTION
    -> essential_to(EIGENVALUE_DEFINITION)

# ---------- EIGENFUNCTION ----------
EIGENFUNCTION
    -> nonzero_function
    -> satisfies(OPERATOR_EQUATION)
    -> satisfies(BOUNDARY_CONDITIONS)

SCALAR_MULTIPLE_OF_EIGENFUNCTION
    -> same_eigenvalue

EIGENFUNCTION
    -> usually_normalised_when(COMPARISON_OR_EXPANSION_REQUIRED)

# ---------- SPECTRUM ----------
SPECTRUM(L)
    -> set_of(SPECTRAL_VALUES)

POINT_SPECTRUM
    -> eigenvalues_with(EIGENFUNCTIONS)

CONTINUOUS_SPECTRUM
    -> may_occur_in(INFINITE_DIMENSIONAL_OPERATOR_THEORY)

SPECTRUM
    -/> always_discrete

# ---------- DISCRETE SPECTRUM ----------
REGULAR_STURM_LIOUVILLE_PROBLEM
    -> typically_has(DISCRETE_REAL_EIGENVALUES)

EIGENVALUES
    -> may_form(SEQUENCE)

lambda_1
    <= lambda_2
    <= ...

under(appropriate_ordering_and_problem_conditions)

# ---------- SELF-ADJOINT OPERATOR ----------
SELF_ADJOINT_OPERATOR
    -> satisfies(
        inner_product(Lu,v)
        =
        inner_product(u,Lv)
    )
       on(APPROPRIATE_DOMAIN)

SELF_ADJOINTNESS
    -> supports(REAL_SPECTRUM)

EIGENFUNCTIONS_WITH_DISTINCT_EIGENVALUES
    -> ORTHOGONAL
       under(SELF_ADJOINT_WEIGHTED_INNER_PRODUCT)

# ---------- WEIGHTED ORTHOGONALITY ----------
for Sturm-Liouville eigenfunctions
    phi_m, phi_n

if
    lambda_m != lambda_n
then

integral(
    w(x)
    * phi_m(x)
    * phi_n(x)
    dx
)
    = 0

WEIGHT_FUNCTION
    -> defines(WEIGHTED_INNER_PRODUCT)

# ---------- NORMALISATION ----------
NORMALISED_EIGENFUNCTION
    -> scaled_to(unit_norm)

integral(
    w(x)
    * abs(phi_n(x))^2
    dx
)
    = 1

NORMALISATION
    -> removes(ARBITRARY_SCALAR_MAGNITUDE)

# ---------- MULTIPLICITY ----------
ALGEBRAIC_MULTIPLICITY
    -> multiplicity_as_root_of(CHARACTERISTIC_POLYNOMIAL)
       in(FINITE_DIMENSIONAL_CONTEXT)

GEOMETRIC_MULTIPLICITY
    -> dimension_of(EIGENSPACE)

GEOMETRIC_MULTIPLICITY
    <= ALGEBRAIC_MULTIPLICITY
       in(FINITE_DIMENSIONAL_LINEAR_ALGEBRA)

# ---------- EIGENSPACE ----------
EIGENSPACE(lambda)
    := {
        v :
        L[v] = lambda*v
    }

including
    ZERO_ELEMENT

NONZERO_ELEMENTS
    -> EIGENVECTORS_OR_EIGENFUNCTIONS

EIGENSPACE
    -> linear_subspace

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

f
    = sum(
        c_n * phi_n
    )

coefficients:
    c_n
        -> determined_by(INNER_PRODUCTS)

SPECTRAL_EXPANSION
    -> decomposes(FUNCTION_IN_EIGENMODES)

# ---------- PDE SEPARATION OF VARIABLES ----------
assume
    u(x,t)
        = X(x)T(t)

SEPARATION_OF_VARIABLES
    -> produces(SPATIAL_EIGENVALUE_PROBLEM)

BOUNDARY_CONDITIONS
    -> determine(SPATIAL_EIGENFUNCTIONS)

TIME_EQUATION
    -> depends_on(EIGENVALUE)

# ---------- LAPLACIAN EIGENVALUE PROBLEM ----------
-LAPLACIAN(phi)
    = lambda*phi

with
    boundary_conditions

LAPLACIAN_EIGENFUNCTIONS
    -> spatial_modes

LAPLACIAN_EIGENVALUES
    -> associated_with(SPATIAL_FREQUENCY_OR_ENERGY_SCALE)

# ---------- VIBRATION ----------
STRUCTURAL_VIBRATION
    -> may_lead_to(GENERALISED_EIGENVALUE_PROBLEM)

K*phi
    = lambda*M*phi

K
    -> STIFFNESS_MATRIX

M
    -> MASS_MATRIX

EIGENVALUES
    -> related_to(NATURAL_FREQUENCIES)

EIGENVECTORS
    -> MODE_SHAPES

# ---------- QUANTUM MECHANICS ----------
H*psi
    = E*psi

H
    -> HAMILTONIAN_OPERATOR

E
    -> ENERGY_EIGENVALUE

psi
    -> ENERGY_EIGENSTATE

QUANTUM_EIGENVALUE_PROBLEM
    -> determines(ALLOWED_STATIONARY_ENERGIES)

# ---------- NUMERICAL EIGENVALUE PROBLEMS ----------
DISCRETISATION
    -> converts(DIFFERENTIAL_OPERATOR_EIGENPROBLEM, MATRIX_EIGENPROBLEM)

FINITE_DIFFERENCE
    -> approximates(OPERATOR)

FINITE_ELEMENT_METHOD
    -> produces(GENERALISED_MATRIX_EIGENPROBLEM)

NUMERICAL_EIGENVALUES
    -> approximate(CONTINUOUS_SPECTRUM_COMPONENTS_OR_DISCRETE_EIGENVALUES)

# ---------- APPLICATIONS ----------
EIGENVALUE_PROBLEM
    -> applied_to(VIBRATIONS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(HEAT_AND_WAVE_EQUATIONS)
    -> applied_to(STABILITY_ANALYSIS)
    -> applied_to(SPECTRAL_GEOMETRY)
    -> applied_to(FLUID_MECHANICS)
    -> applied_to(STRUCTURAL_ENGINEERING)

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

EIGENVALUE
    -> permits(NONTRIVIAL_EIGENFUNCTION)

BOUNDARY_CONDITIONS
    -> restrict(SPECTRUM)

SELF_ADJOINTNESS
    -> supports(REAL_EIGENVALUES_AND_ORTHOGONALITY)

EIGENFUNCTIONS
    -> form(MODES)

SPECTRAL_EXPANSION
    -> represents(FUNCTION_AS_MODE_SUM)

DISCRETISATION
    -> maps(OPERATOR_PROBLEM_TO_MATRIX_PROBLEM)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "eigenvalue problem" ~= "problem of finding scalar values and nonzero states satisfying an operator scaling equation",
    "eigenfunction" ~= "nonzero function mapped to a scalar multiple of itself by an operator",
    "eigenvector" ~= "finite-dimensional eigenstate of a matrix or linear transformation",
    "spectrum" ~= "set of spectral values associated with an operator",
    "mode shape" ~= "eigenvector or eigenfunction describing a natural spatial mode",
    "Sturm-Liouville problem" ~= "self-adjoint second-order differential eigenvalue problem under standard conditions"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    eigenfunction_or_eigenvector_must_be_nonzero: true,
    boundary_conditions_are_part_of_differential_eigenproblem: true,
    same_operator_with_different_boundary_conditions_may_have_different_spectrum: true,
    spectrum_need_not_be_purely_discrete: true,
    real_eigenvalues_and_orthogonality_require_relevant_self_adjoint_conditions: true,
    numerical_eigenvalues_are_approximations_to_continuous_problem_values: true,
    normalisation_does_not_change_eigenvalue: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    operator_matrix_relation: 0.99,
    sturm_liouville_relation: 0.99,
    boundary_spectrum_relation: 0.99,
    self_adjoint_relation: 0.99,
    spectral_expansion_relation: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(operator_or_matrix)
    -> identify(domain_and_boundary_conditions)
    -> determine(linearity)
    -> formulate(eigenvalue_equation)
    -> solve(characteristic_or_differential_condition)
    -> identify(admissible_eigenvalues)
    -> construct(eigenvectors_or_eigenfunctions)
    -> test(nontriviality)
    -> normalise(if_required)
    -> analyse(orthogonality_and_multiplicity)
    -> construct(spectral_expansion_if_supported)
    -> validate(operator_domain_and_boundary_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed eigenvalue-problem semantic graph",
    primary_entity: EIGENVALUE_PROBLEM,
    preserve: [
        operator,
        operator_domain,
        boundary_conditions,
        eigenvalue,
        eigenfunction,
        eigenspace,
        weight_function,
        multiplicity
    ],
    infer_through: [
        characteristic_equations,
        sturm_liouville_problems,
        self_adjoint_operators,
        orthogonality,
        spectral_expansions,
        pde_separation,
        numerical_discretisation
    ],
    avoid: [
        accepting_zero_function_as eigenfunction,
        ignoring_boundary_conditions,
        assuming_spectrum_is always discrete,
        assuming_real_eigenvalues_without self_adjoint context,
        confusing_eigenvalue_with eigenfunction,
        treating_numerical eigenvalues as exact without validation
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + EIGENVALUE_PROBLEM
    + LINEAR_OPERATOR
    + EIGENVALUE
    + EIGENFUNCTION
    + STURM_LIOUVILLE_PROBLEM
    + SELF_ADJOINT_OPERATOR
    + SPECTRUM
    + SPECTRAL_EXPANSION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> EIGENVALUE_PROBLEM
    -> OPERATOR_IDENTIFICATION
    -> DOMAIN_BOUNDARY_ANALYSIS
    -> LINEARITY_ANALYSIS
    -> EIGENVALUE_EQUATION_FORMULATION
    -> SPECTRAL_CONDITION_ANALYSIS
    -> EIGENVALUE_IDENTIFICATION
    -> EIGENFUNCTION_CONSTRUCTION
    -> NONTRIVIALITY_VALIDATION
    -> NORMALISATION_ORTHOGONALITY_ANALYSIS
    -> SPECTRAL_EXPANSION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW