Spectral Theory Ontology

flow "SpectralTheoryOntology" v1.0

# ============================================================
# SPECTRAL THEORY ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/functional-analysis/spectral-theory-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Functional Analysis"
ENTITY := "Spectral Theory"

# ---------- CORE ENTITY ----------
SPECTRAL_THEORY := {
    type: MathematicalTheory,
    domain: FunctionalAnalysis,
    purpose: "Study the spectral values and decomposition of linear operators, generalising eigenvalue analysis from finite-dimensional linear algebra to infinite-dimensional spaces."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    LINEAR_OPERATOR,
    BOUNDED_OPERATOR,
    UNBOUNDED_OPERATOR,
    SPECTRUM,
    RESOLVENT,
    EIGENVALUE,
    EIGENVECTOR,
    EIGENFUNCTION,
    POINT_SPECTRUM,
    CONTINUOUS_SPECTRUM,
    RESIDUAL_SPECTRUM,
    SPECTRAL_RADIUS,
    SELF_ADJOINT_OPERATOR,
    NORMAL_OPERATOR,
    SPECTRAL_THEOREM
}

# ---------- OPERATOR CONTEXT ----------
let
    X
        := BANACH_OR_HILBERT_SPACE

and
    T
        := LINEAR_OPERATOR_ON(X)

SPECTRAL_THEORY
    -> studies(T)
    -> studies(T - lambda*I)
    -> studies(INVERTIBILITY)
    -> studies(DECOMPOSITION_INTO_SPECTRAL_COMPONENTS)

# ---------- SPECTRUM ----------
for bounded operator T:

SPECTRUM(T)
    := {
        lambda in SCALAR_FIELD :
        T - lambda*I
        is_not_boundedly_invertible
    }

SPECTRUM
    -> complement_of(RESOLVENT_SET)

lambda
    -> SPECTRAL_VALUE
       if(lambda in SPECTRUM(T))

# ---------- RESOLVENT SET ----------
RESOLVENT_SET(T)
    := {
        lambda :
        T - lambda*I
        has_bounded_everywhere_defined_inverse
    }

for
    lambda in RESOLVENT_SET(T)

RESOLVENT_OPERATOR
    := R(lambda,T)
       = (T-lambda*I)^(-1)

# ---------- RESOLVENT IDENTITY ----------
R(lambda,T)
-
R(mu,T)
    =
(lambda-mu)
*
R(lambda,T)
*
R(mu,T)

subject_to
    lambda,mu in RESOLVENT_SET

RESOLVENT_IDENTITY
    -> central_relation_of(SPECTRAL_THEORY)

# ---------- EIGENVALUE ----------
lambda
    -> EIGENVALUE

iff

exists
    x != 0

such_that

T(x)
    = lambda*x

equivalently

KERNEL(T-lambda*I)
    != {0}

EIGENVALUES
    -> POINT_SPECTRUM

# ---------- EIGENVECTOR ----------
x
    -> EIGENVECTOR_OF(T)

if
    x != 0
    AND
    T(x)=lambda*x

EIGENSPACE(lambda)
    := KERNEL(T-lambda*I)

EIGENSPACE
    -> LINEAR_SUBSPACE

# ---------- POINT SPECTRUM ----------
POINT_SPECTRUM
    := {
        lambda :
        T-lambda*I
        not_injective
    }

POINT_SPECTRUM
    -> consists_of(EIGENVALUES)

# ---------- CONTINUOUS SPECTRUM ----------
CONTINUOUS_SPECTRUM
    -> spectral_values_where(
        T-lambda*I
        is_injective,
        has_dense_range,
        but_inverse_not_bounded_or_not_everywhere_defined
    )

CONTINUOUS_SPECTRUM
    -> has(NO_EIGENVECTOR_FOR_lambda)

# ---------- RESIDUAL SPECTRUM ----------
RESIDUAL_SPECTRUM
    -> spectral_values_where(
        T-lambda*I
        is_injective
        AND range_not_dense
    )

SPECTRUM
    -> may_decompose_into(
        POINT_SPECTRUM,
        CONTINUOUS_SPECTRUM,
        RESIDUAL_SPECTRUM
    )
       under(STANDARD_OPERATOR_CLASSIFICATION)

# ---------- FINITE-DIMENSIONAL CASE ----------
for
    matrix A in C^(n x n)

SPECTRUM(A)
    = set_of(EIGENVALUES)

det(
    A-lambda*I
)
    = 0

CHARACTERISTIC_POLYNOMIAL
    -> determines(SPECTRUM)

FINITE_DIMENSION
    -> no_continuous_or_residual_spectrum_in(STANDARD_MATRIX_CONTEXT)

# ---------- INFINITE-DIMENSIONAL DISTINCTION ----------
INFINITE_DIMENSION
    -> spectrum_may_include(NON_EIGENVALUE_SPECTRAL_VALUES)

SPECTRUM
    -/> equivalent_to(EIGENVALUE_SET)

SPECTRAL_THEORY
    -> generalises(MATRIX_EIGENVALUE_THEORY)

# ---------- SPECTRAL RADIUS ----------
SPECTRAL_RADIUS(T)
    := sup(
        abs(lambda) :
        lambda in SPECTRUM(T)
    )

for bounded operator on complex Banach space:

r(T)
    =
limit_n_to_infinity(
    ||T^n||^(1/n)
)

SPECTRAL_RADIUS
    <=
||T||

# ---------- BASIC SPECTRUM PROPERTIES ----------
for bounded operator T
on complex Banach space:

SPECTRUM(T)
    -> NONEMPTY
    -> COMPACT

and

SPECTRUM(T)
    -> subset_of(
        {lambda : abs(lambda) <= ||T||}
    )

# ---------- SELF-ADJOINT OPERATOR ----------
on Hilbert space:

T
    -> SELF_ADJOINT

if
    T=T_star
    with(domain_conditions_for_unbounded_case)

SELF_ADJOINT_OPERATOR
    -> spectrum_subset_of(REAL_NUMBERS)

RESIDUAL_SPECTRUM
    -> empty
       for(self_adjoint_operator_under_standard_definition)

# ---------- NORMAL OPERATOR ----------
T
    -> NORMAL

iff

T*T_star
    =
T_star*T

SELF_ADJOINT
    -> NORMAL

UNITARY
    -> NORMAL

NORMAL_OPERATOR
    -> supports(SPECTRAL_THEOREM)

# ---------- UNITARY SPECTRUM ----------
if
    U unitary
then

SPECTRUM(U)
    -> subset_of(UNIT_CIRCLE)

UNITARY_OPERATOR
    -> norm_preserving

# ---------- COMPACT OPERATOR ----------
if
    T compact
    on infinite-dimensional Banach space

then

nonzero_spectrum
    -> consists_of(EIGENVALUES)
       with(FINITE_MULTIPLICITY)

possible_accumulation_point
    -> ZERO

COMPACT_OPERATOR
    -> finite_dimensional_like_spectral_structure

# ---------- COMPACT SELF-ADJOINT ----------
if
    T compact_self_adjoint
    on Hilbert space
then

H
    -> admits(ORTHONORMAL_EIGENVECTOR_DECOMPOSITION)
       on(appropriate_subspace)

EIGENVALUES
    -> REAL

SPECTRAL_THEOREM
    -> diagonalises(T)
       in(ORTHONORMAL_BASIS_SENSE)

# ---------- SPECTRAL THEOREM ----------
for bounded normal operator T
on complex Hilbert space:

T
    =
integral_over_spectrum(
    lambda dE(lambda)
)

E
    -> PROJECTION_VALUED_MEASURE

SPECTRAL_THEOREM
    -> generalises(UNITARY_DIAGONALISATION)

# ---------- FUNCTIONAL CALCULUS ----------
given suitable function f
on spectrum(T):

f(T)
    :=
integral_over_spectrum(
    f(lambda)
    dE(lambda)
)

FUNCTIONAL_CALCULUS
    -> constructs(NEW_OPERATORS_FROM_SPECTRAL_DATA)

examples:
    sqrt(T)
    exp(T)
    spectral_projections

# ---------- POLYNOMIAL SPECTRAL MAPPING ----------
for polynomial p:

SPECTRUM(p(T))
    =
p(SPECTRUM(T))

SPECTRAL_MAPPING_THEOREM
    -> relates(OPERATOR_FUNCTION, SPECTRUM_TRANSFORMATION)

# ---------- UNBOUNDED OPERATORS ----------
UNBOUNDED_OPERATOR
    -> requires(DENSE_DOMAIN)
       in(many_spectral_contexts)

SPECTRUM
    -> defined_using(RESOLVENT_AND_OPERATOR_DOMAIN)

UNBOUNDED_SELF_ADJOINT_OPERATOR
    -> may_have(UNBOUNDED_REAL_SPECTRUM)

DOMAIN
    -> essential_to(SPECTRAL_DEFINITION)

# ---------- DIFFERENTIAL OPERATORS ----------
DIFFERENTIAL_OPERATOR
    -> may_have(DISCRETE_SPECTRUM)
    -> may_have(CONTINUOUS_SPECTRUM)
    -> may_have(MIXED_SPECTRUM)

BOUNDARY_CONDITIONS
    -> alter(OPERATOR_DOMAIN)
    -> alter(SPECTRUM)

same_differential_expression
    + different_boundary_conditions
    -> different_operator_and_spectrum

# ---------- LAPLACIAN ----------
-LAPLACIAN
    -> self_adjoint_under(APPROPRIATE_BOUNDARY_CONDITIONS)

LAPLACIAN_SPECTRUM
    -> encodes(GEOMETRIC_AND_PHYSICAL_INFORMATION)

EIGENFUNCTIONS
    -> spatial_modes

# ---------- QUANTUM MECHANICS ----------
OBSERVABLE
    -> represented_by(SELF_ADJOINT_OPERATOR)

SPECTRUM
    -> possible_measurement_values
       in(STANDARD_QUANTUM_FORMALISM)

DISCRETE_SPECTRUM
    -> bound_state_like_contexts

CONTINUOUS_SPECTRUM
    -> scattering_like_contexts

# ---------- STABILITY ----------
for linear dynamical system:

x_prime
    = A*x

SPECTRUM(A)
    -> informs(STABILITY_AND_GROWTH)

SPECTRAL_BOUND
    -> related_to(DYNAMICAL_BEHAVIOUR)

STABILITY_CONCLUSIONS
    -> depend_on(SYSTEM_AND_SPACE_CONTEXT)

# ---------- APPLICATIONS ----------
SPECTRAL_THEORY
    -> applied_to(DIFFERENTIAL_EQUATIONS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(FOURIER_ANALYSIS)
    -> applied_to(DYNAMICAL_SYSTEMS)
    -> applied_to(NUMERICAL_ANALYSIS)
    -> applied_to(GRAPH_THEORY)
    -> applied_to(SIGNAL_PROCESSING)

# ---------- RELATION GRAPH ----------
OPERATOR
    -> has(SPECTRUM)

RESOLVENT_SET
    -> complement_of(SPECTRUM)

POINT_SPECTRUM
    -> contains(EIGENVALUES)

SELF_ADJOINT_OPERATOR
    -> has(REAL_SPECTRUM)

NORMAL_OPERATOR
    -> governed_by(SPECTRAL_THEOREM)

COMPACT_OPERATOR
    -> has(DISCRETE_NONZERO_SPECTRAL_STRUCTURE)

BOUNDARY_CONDITIONS
    -> affect(OPERATOR_DOMAIN)
    -> affect(SPECTRUM)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "spectral theory" ~= "study of spectra and spectral decomposition of operators",
    "spectrum of an operator" ~= "scalar values where the shifted operator fails to have an appropriate bounded inverse",
    "point spectrum" ~= "set of eigenvalues",
    "resolvent" ~= "inverse of T minus lambda I on the resolvent set",
    "spectral radius" ~= "maximum modulus scale of the spectrum",
    "spectral theorem" ~= "operator decomposition theorem generalising diagonalisation for normal or self-adjoint operators"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    spectrum_depends_on_operator_and_domain: true,
    spectrum_is_not_generally_equal_to_eigenvalue_set: true,
    bounded_complex_banach_operator_has_nonempty_compact_spectrum: true,
    self_adjoint_operator_has_real_spectrum: true,
    unbounded_operator_spectral_analysis_requires_domain_handling: true,
    boundary_conditions_can_change_spectrum: true,
    spectral_theorem_form_depends_on_operator_class: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    spectrum_resolvent_relation: 0.99,
    spectral_classification: 0.99,
    spectral_radius_relation: 0.99,
    self_adjoint_normal_relation: 0.99,
    spectral_theorem_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(operator)
    -> identify(space_and_operator_domain)
    -> classify(bounded_or_unbounded)
    -> construct(T_minus_lambda_I)
    -> test(injectivity_surjectivity_density_and_inverse_boundedness)
    -> classify(resolvent_or_spectral_value)
    -> classify(point_continuous_or_residual_spectrum_if_relevant)
    -> analyse(self_adjoint_normal_or_compact_structure)
    -> compute_or_bound(spectral_radius_if_requested)
    -> apply(spectral_theorem_or_functional_calculus_if_valid)
    -> verify(operator_domain_and_theorem_hypotheses)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed spectral-theory semantic graph",
    primary_entity: SPECTRAL_THEORY,
    preserve: [
        operator,
        operator_domain,
        underlying_space,
        boundedness,
        spectrum,
        resolvent_set,
        spectral_type,
        boundary_conditions
    ],
    infer_through: [
        eigenvalues,
        point_spectrum,
        continuous_spectrum,
        residual_spectrum,
        spectral_radius,
        self_adjoint_operators,
        compact_operators,
        spectral_theorems
    ],
    avoid: [
        treating_spectrum_as only eigenvalues,
        ignoring_operator_domain,
        assuming_spectrum_nonempty_without complex Banach context,
        applying_bounded_operator formulas to unbounded operators without care,
        assuming_real_spectrum_without self_adjoint_or equivalent structure,
        ignoring_boundary_conditions
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + SPECTRAL_THEORY
    + SPECTRUM
    + RESOLVENT_SET
    + POINT_SPECTRUM
    + CONTINUOUS_SPECTRUM
    + RESIDUAL_SPECTRUM
    + SPECTRAL_RADIUS
    + SELF_ADJOINT_OPERATOR
    + SPECTRAL_THEOREM
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> SPECTRAL_THEORY
    -> OPERATOR_IDENTIFICATION
    -> SPACE_DOMAIN_ANALYSIS
    -> BOUNDEDNESS_ANALYSIS
    -> SHIFTED_OPERATOR_ANALYSIS
    -> INVERTIBILITY_ANALYSIS
    -> SPECTRAL_CLASSIFICATION
    -> OPERATOR_CLASS_ANALYSIS
    -> SPECTRAL_RADIUS_ANALYSIS
    -> SPECTRAL_THEOREM_ANALYSIS
    -> DOMAIN_HYPOTHESIS_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW