Operator Ontology

flow "OperatorOntology" v1.0

# ============================================================
# OPERATOR ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
OPERATOR := {
    type: MathematicalMapping,
    domain: FunctionalAnalysis,
    purpose: "Represent a mapping between mathematical spaces, especially function or vector spaces, that transforms one mathematical object into another."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    OPERATOR,
    DOMAIN,
    CODOMAIN,
    RANGE,
    KERNEL,
    LINEAR_OPERATOR,
    NONLINEAR_OPERATOR,
    BOUNDED_OPERATOR,
    CONTINUOUS_OPERATOR,
    DIFFERENTIAL_OPERATOR,
    INTEGRAL_OPERATOR,
    COMPACT_OPERATOR,
    ADJOINT_OPERATOR,
    SELF_ADJOINT_OPERATOR,
    SPECTRUM
}

# ---------- BASIC STRUCTURE ----------
OPERATOR
    := T: X -> Y

X
    -> DOMAIN_SPACE

Y
    -> CODOMAIN_SPACE

for
    x in DOMAIN(T)

T(x)
    -> OUTPUT_ELEMENT

OPERATOR
    -> maps(INPUT_OBJECT_TO_OUTPUT_OBJECT)

# ---------- DOMAIN ----------
DOMAIN(T)
    := set_of(INPUTS_FOR_WHICH_OPERATOR_IS_DEFINED)

OPERATOR_DOMAIN
    -> essential_part_of(OPERATOR_DEFINITION)

same_formula
    + different_domain
    -> may_define(DIFFERENT_OPERATOR)

# ---------- CODOMAIN ----------
CODOMAIN(T)
    -> declared_output_space

RANGE(T)
    := {
        T(x) :
        x in DOMAIN(T)
    }

RANGE(T)
    -> subset_of(CODOMAIN(T))

# ---------- KERNEL ----------
for linear operator T:

KERNEL(T)
    := {
        x in DOMAIN(T) :
        T(x)=0
    }

KERNEL
    -> LINEAR_SUBSPACE

KERNEL
    -> measures(NONINJECTIVITY)

# ---------- LINEAR OPERATOR ----------
T
    -> LINEAR

iff

T(alpha*x + beta*y)
    =
alpha*T(x)
+
beta*T(y)

LINEAR_OPERATOR
    -> preserves(LINEAR_COMBINATIONS)

# ---------- NONLINEAR OPERATOR ----------
NONLINEAR_OPERATOR
    -> violates(LINEARITY)

examples:
    T(f) = f^2
    T(u) = sin(u)
    nonlinear_differential_operator

NONLINEAR_OPERATOR
    -> may_require(NONLINEAR_ANALYSIS)

# ---------- BOUNDED LINEAR OPERATOR ----------
for normed spaces X,Y:

T
    -> BOUNDED

iff

exists C >= 0
such_that

||T(x)||_Y
    <=
C||x||_X

for_all x

BOUNDED_LINEAR_OPERATOR
    <-> CONTINUOUS_LINEAR_OPERATOR

# ---------- OPERATOR NORM ----------
||T||
    :=
sup(
    ||T(x)||_Y :
    ||x||_X <= 1
)

OPERATOR_NORM
    -> finite_for(BOUNDED_LINEAR_OPERATOR)

||T(x)||_Y
    <=
||T|| * ||x||_X

# ---------- COMPOSITION ----------
if
    T: X -> Y
    AND S: Y -> Z
then

S composed_with T
    : X -> Z

OPERATOR_COMPOSITION
    -> associative

(S composed_with T)(x)
    =
S(T(x))

# ---------- IDENTITY OPERATOR ----------
IDENTITY_OPERATOR
    := I

I(x)
    = x

I composed_with T
    = T

T composed_with I
    = T

# ---------- INVERSE OPERATOR ----------
T_inverse
    -> exists_if(T_is_bijective)

T_inverse composed_with T
    = I

T composed_with T_inverse
    = I

for bounded bijective linear operators between Banach spaces:

BOUNDED_INVERSE_THEOREM
    -> T_inverse_bounded

# ---------- DIFFERENTIAL OPERATOR ----------
DIFFERENTIAL_OPERATOR
    -> maps(FUNCTION_TO_DERIVATIVE_BASED_EXPRESSION)

example:

D(f)
    := f_prime

L(f)
    := a_n f^(n)
       + ...
       + a_0 f

DIFFERENTIAL_OPERATOR
    -> often(UNBOUNDED_ON_NATURAL_NORMED_SPACES)

DOMAIN_SELECTION
    -> essential_for(DIFFERENTIAL_OPERATOR)

# ---------- INTEGRAL OPERATOR ----------
INTEGRAL_OPERATOR
    := T

(Tf)(x)
    =
integral(
    K(x,y)f(y)
    dy
)

K(x,y)
    -> INTEGRAL_KERNEL

INTEGRAL_OPERATOR
    -> maps(FUNCTION_TO_FUNCTION)

# ---------- MULTIPLICATION OPERATOR ----------
for function m(x):

(M_m f)(x)
    := m(x)f(x)

MULTIPLICATION_OPERATOR
    -> pointwise_operator

BOUNDEDNESS
    -> depends_on(m_and_function_space)

# ---------- SHIFT OPERATOR ----------
on sequence space:

RIGHT_SHIFT(
    x_1,x_2,...
)
    :=
(0,x_1,x_2,...)

SHIFT_OPERATOR
    -> important_example_in(OPERATOR_THEORY)

# ---------- PROJECTION OPERATOR ----------
P
    -> PROJECTION

iff

P^2
    = P

RANGE(P)
    -> projected_subspace

in Hilbert space:
    ORTHOGONAL_PROJECTION
        -> self_adjoint_projection

# ---------- COMPACT OPERATOR ----------
COMPACT_OPERATOR
    -> maps(BOUNDED_SETS_TO_RELATIVELY_COMPACT_SETS)

equivalently in metric context:
    bounded_sequence
        -> image_has(CONVERGENT_SUBSEQUENCE)

FINITE_RANK_OPERATOR
    -> COMPACT

COMPACT_OPERATOR
    -> spectral_behaviour_resembles(FINITE_DIMENSIONAL_LINEAR_MAP)

# ---------- ADJOINT OPERATOR ----------
for Hilbert-space operator T:

ADJOINT_OPERATOR
    := T_star

satisfying

<Tx,y>
    =
<x,T_star y>

for
    x in DOMAIN(T)
    y in DOMAIN(T_star)

ADJOINT_DOMAIN
    -> essential_for(UNBOUNDED_OPERATOR)

# ---------- SELF-ADJOINT OPERATOR ----------
T
    -> SELF_ADJOINT

iff

T = T_star

including
    DOMAIN(T) = DOMAIN(T_star)

SELF_ADJOINT_OPERATOR
    -> has(REAL_SPECTRUM)

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

iff

T*T_star
    =
T_star*T

SELF_ADJOINT
    -> NORMAL

UNITARY
    -> NORMAL

NORMAL_OPERATOR
    -> supports(SPECTRAL_THEOREM)
       in(APPROPRIATE_HILBERT_CONTEXT)

# ---------- UNITARY OPERATOR ----------
U
    -> UNITARY

iff

U_star*U
    = I

and

U*U_star
    = I

UNITARY_OPERATOR
    -> preserves(INNER_PRODUCT)
    -> preserves(NORM)

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

SPECTRUM(T)
    := {
        lambda :
        T - lambda*I
        fails_to_have(APPROPRIATE_BOUNDED_INVERSE)
    }

SPECTRUM
    -> may_include(POINT_SPECTRUM)
    -> may_include(CONTINUOUS_SPECTRUM)
    -> may_include(RESIDUAL_SPECTRUM)

EIGENVALUE
    -> element_of(POINT_SPECTRUM)

# ---------- RESOLVENT ----------
RESOLVENT_SET(T)
    := SCALAR_FIELD minus SPECTRUM(T)

for
    lambda in RESOLVENT_SET

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

RESOLVENT_OPERATOR
    -> central_to(SPECTRAL_THEORY)

# ---------- EIGENVALUE ----------
lambda
    -> EIGENVALUE_OF(T)

if
    exists x != 0
    such_that

T(x)
    = lambda*x

x
    -> EIGENVECTOR_OR_EIGENFUNCTION

# ---------- CLOSED OPERATOR ----------
T
    -> CLOSED_OPERATOR

iff

GRAPH(T)
    -> closed_in(X x Y)

UNBOUNDED_OPERATORS
    -> often_studied_as(CLOSED_OR_CLOSABLE_OPERATORS)

CLOSEDNESS
    -/> same_as(BOUNDEDNESS)
       for(unbounded_operator_context)

# ---------- DENSELY DEFINED OPERATOR ----------
DOMAIN(T)
    -> dense_in(X)

then

T
    -> DENSELY_DEFINED

DENSE_DOMAIN
    -> important_for(ADJOINT_THEORY)

# ---------- OPERATOR EQUATION ----------
OPERATOR_EQUATION
    := T(x) = y

SOLVABILITY
    -> depends_on(RANGE(T))

UNIQUENESS
    -> depends_on(KERNEL(T))

if
    KERNEL(T) = {0}
then

T
    -> INJECTIVE

# ---------- APPLICATIONS ----------
OPERATOR
    -> applied_to(FUNCTIONAL_ANALYSIS)
    -> applied_to(DIFFERENTIAL_EQUATIONS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(FOURIER_ANALYSIS)
    -> applied_to(CONTROL_THEORY)
    -> applied_to(NUMERICAL_ANALYSIS)
    -> applied_to(INTEGRAL_EQUATIONS)

# ---------- RELATION GRAPH ----------
DOMAIN
    -> input_space_of(OPERATOR)

CODOMAIN
    -> declared_output_space_of(OPERATOR)

OPERATOR
    -> has(RANGE)

LINEAR_OPERATOR
    -> has(KERNEL)

BOUNDED_LINEAR_OPERATOR
    -> CONTINUOUS

HILBERT_OPERATOR
    -> may_have(ADJOINT)

OPERATOR
    -> has(SPECTRUM)

COMPACT_OPERATOR
    -> has(SPECIAL_SPECTRAL_STRUCTURE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "operator" ~= "mapping acting on mathematical objects, especially vectors or functions",
    "linear operator" ~= "operator preserving linear combinations",
    "bounded linear operator" ~= "continuous linear operator between normed spaces",
    "operator kernel" ~= "set of inputs mapped to zero",
    "operator range" ~= "set of attained output values",
    "adjoint operator" ~= "operator defined through inner-product or duality relation"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    operator_definition_requires_domain_and_codomain: true,
    same_formula_with_different_domain_may_define_different_operator: true,
    bounded_equivalent_to_continuous_only_for_linear_maps_between_normed_spaces: true,
    unbounded_operators_require_domain_analysis: true,
    self_adjointness_requires_operator_and_adjoint_domains_to_match: true,
    spectrum_need_not_consist_only_of_eigenvalues: true,
    inverse_operator_requires_bijectivity_and_bounded_inverse_requires_additional_context: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    domain_codomain_relation: 0.99,
    linear_bounded_relation: 0.99,
    compact_operator_relation: 0.99,
    adjoint_relation: 0.99,
    spectral_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(operator_formula)
    -> identify(domain_and_codomain)
    -> determine(linear_or_nonlinear)
    -> test(boundedness_or_continuity_if_relevant)
    -> determine(kernel_and_range)
    -> analyse(invertibility_if_requested)
    -> classify(differential_integral_compact_or_projection_structure)
    -> construct(adjoint_if_hilbert_context_and_defined)
    -> analyse(spectrum_resolvent_or_eigenvalues_if_requested)
    -> verify(domain_and_operator_hypotheses)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed operator semantic graph",
    primary_entity: OPERATOR,
    preserve: [
        operator_formula,
        domain,
        codomain,
        range,
        kernel,
        linearity,
        boundedness,
        topology_or_norm_structure
    ],
    infer_through: [
        compositions,
        inverses,
        differential_operators,
        integral_operators,
        compact_operators,
        adjoints,
        self_adjoint_operators,
        spectra,
        resolvents
    ],
    avoid: [
        ignoring_operator_domain,
        assuming_linear_operator_is bounded,
        assuming_inverse_is bounded_without hypotheses,
        confusing_closed_operator_with bounded operator,
        treating_all_spectral_values_as eigenvalues,
        declaring_self_adjointness_without domain equality
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + OPERATOR
    + DOMAIN
    + KERNEL
    + LINEAR_OPERATOR
    + BOUNDED_OPERATOR
    + COMPACT_OPERATOR
    + ADJOINT_OPERATOR
    + SELF_ADJOINT_OPERATOR
    + SPECTRUM
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> OPERATOR
    -> FORMULA_IDENTIFICATION
    -> DOMAIN_CODOMAIN_ANALYSIS
    -> LINEARITY_ANALYSIS
    -> BOUNDEDNESS_CONTINUITY_ANALYSIS
    -> KERNEL_RANGE_ANALYSIS
    -> INVERTIBILITY_ANALYSIS
    -> OPERATOR_TYPE_CLASSIFICATION
    -> ADJOINT_ANALYSIS
    -> SPECTRAL_ANALYSIS
    -> DOMAIN_HYPOTHESIS_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW