Bounded Operator Ontology

flow "BoundedOperatorOntology" v1.0

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

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

# ---------- CORE ENTITY ----------
BOUNDED_OPERATOR := {
    type: LinearOperatorProperty,
    domain: FunctionalAnalysis,
    purpose: "Represent a linear operator between normed spaces whose output norm is uniformly bounded by a constant multiple of the input norm."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    BOUNDED_OPERATOR,
    LINEAR_OPERATOR,
    NORMED_SPACE,
    OPERATOR_NORM,
    CONTINUITY,
    DOMAIN,
    CODOMAIN,
    UNIT_BALL,
    BANACH_SPACE,
    DUAL_SPACE,
    COMPOSITION,
    INVERSE_OPERATOR,
    SPECTRUM,
    COMPACT_OPERATOR
}

# ---------- BASIC DEFINITION ----------
let
    X,Y
        := NORMED_SPACES

and
    T: X -> Y
        := LINEAR_OPERATOR

T
    -> BOUNDED

iff

exists
    C >= 0

such_that

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

for_all
    x in X

# ---------- BOUND CONSTANT ----------
BOUND_CONSTANT
    := C

VALID_BOUND
    -> any_C_satisfying(
        ||T(x)|| <= C||x||
        for_all x
    )

SMALLEST_POSSIBLE_BOUND
    -> OPERATOR_NORM

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

equivalently

||T||
    =
sup(
    ||T(x)||_Y / ||x||_X :
    x != 0
)

T bounded
    iff
    ||T|| < infinity

# ---------- FUNDAMENTAL INEQUALITY ----------
for all x in X:

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

OPERATOR_NORM
    -> controls(MAXIMUM_LINEAR_AMPLIFICATION)

# ---------- CONTINUITY EQUIVALENCE ----------
for linear operator T between normed spaces:

T bounded
    iff
    T continuous

T continuous_at_zero
    iff
    T continuous_everywhere
    iff
    T bounded

BOUNDED_LINEAR_OPERATOR
    ~= CONTINUOUS_LINEAR_OPERATOR

# ---------- UNIT BALL CHARACTERISATION ----------
UNIT_BALL_X
    := {
        x in X :
        ||x||_X <= 1
    }

T bounded
    iff
    T(UNIT_BALL_X)
        -> bounded_subset_of(Y)

BOUNDEDNESS
    -> determined_by(BEHAVIOUR_ON_UNIT_BALL)

# ---------- LIPSCHITZ PROPERTY ----------
for
    x,y in X

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

BOUNDED_LINEAR_OPERATOR
    -> GLOBALLY_LIPSCHITZ

LIPSCHITZ_CONSTANT
    -> may_be(OPERATOR_NORM)

# ---------- ZERO OPERATOR ----------
ZERO_OPERATOR
    := 0

||0||
    = 0

ZERO_OPERATOR
    -> BOUNDED

# ---------- IDENTITY OPERATOR ----------
IDENTITY_OPERATOR
    := I_X

I_X(x)
    = x

||I_X||
    = 1

when
    X != ZERO_SPACE

IDENTITY_OPERATOR
    -> BOUNDED

# ---------- SCALAR MULTIPLE ----------
if
    T bounded
then

alpha*T
    -> bounded

||alpha*T||
    =
abs(alpha)*||T||

# ---------- SUM ----------
if
    S,T bounded
    from X to Y
then

S+T
    -> bounded

||S+T||
    <=
||S|| + ||T||

BOUNDED_OPERATORS
    -> closed_under(ADDITION)

# ---------- COMPOSITION ----------
if
    T: X -> Y
    bounded

and
    S: Y -> Z
    bounded

then

S composed_with T
    -> bounded

and

||S composed_with T||
    <=
||S|| * ||T||

OPERATOR_NORM
    -> SUBMULTIPLICATIVE_UNDER_COMPOSITION

# ---------- OPERATOR SPACE ----------
B(X,Y)
    := {
        T: X -> Y :
        T linear_and_bounded
    }

B(X,Y)
    -> NORMED_VECTOR_SPACE
       under(OPERATOR_NORM)

if
    Y Banach
then

B(X,Y)
    -> BANACH_SPACE

DOMAIN_SPACE_X
    -/> required_to_be_complete_for(B(X,Y)_COMPLETENESS)

# ---------- DUAL SPACE ----------
X_star
    := B(X,F)

DUAL_SPACE
    -> bounded_linear_functionals_on(X)

DUAL_NORM
    -> OPERATOR_NORM

X_star
    -> BANACH_SPACE
       for(any_normed_space_X)

# ---------- FINITE-DIMENSIONAL CASE ----------
if
    X finite_dimensional
    AND Y normed
then

every_linear_operator
    T: X -> Y
    -> bounded

FINITE_DIMENSION
    -> automatic_continuity_of(LINEAR_MAPS)

INFINITE_DIMENSION
    -> may_have(UNBOUNDED_LINEAR_OPERATORS)

# ---------- MATRIX OPERATOR ----------
for
    A: F^n -> F^m

A
    -> bounded_linear_operator

INDUCED_MATRIX_NORM
    :=
sup(
    ||Ax||_Y :
    ||x||_X <= 1
)

MATRIX_NORM
    -> depends_on(CHOSEN_VECTOR_NORMS)

# ---------- INVERSE OPERATOR ----------
if
    T: X -> Y
    bounded_linear_bijective
    and X,Y Banach
then

T_inverse
    -> bounded

BOUNDED_INVERSE_THEOREM
    -> guarantees(CONTINUOUS_INVERSE)

BIJECTIVITY_ALONE
    -/> guarantees_bounded_inverse
       without(APPROPRIATE_COMPLETE_SPACE_CONTEXT)

# ---------- PERTURBATION ----------
if
    T invertible
    AND
    ||T_inverse|| * ||S-T|| < 1
then

S
    -> invertible

NEUMANN_SERIES_ARGUMENT
    -> supports(STABILITY_OF_INVERTIBILITY)

SMALL_OPERATOR_NORM_PERTURBATION
    -> preserves(INVERTIBILITY)
       under(APPROPRIATE_BOUND)

# ---------- NEUMANN SERIES ----------
if
    ||A|| < 1
then

(I-A)^(-1)
    =
sum_from_n_0_to_infinity(
    A^n
)

with convergence_in(OPERATOR_NORM)

NEUMANN_SERIES
    -> constructs(INVERSE_OPERATOR)

# ---------- SPECTRAL RADIUS ----------
for bounded operator T
on complex Banach space:

SPECTRAL_RADIUS
    := r(T)

r(T)
    <=
||T||

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

BOUNDED_OPERATOR
    -> has(COMPACT_NONEMPTY_SPECTRUM)
       in(COMPLEX_BANACH_ALGEBRA_CONTEXT)

# ---------- ADJOINT ----------
for
    T in B(X,Y)

BANACH_ADJOINT
    := T_star: Y_star -> X_star

T_star(f)
    := f composed_with T

T_star
    -> bounded

||T_star||
    =
||T||

# ---------- HILBERT-SPACE ADJOINT ----------
if
    X,Y Hilbert_spaces
then

T_star
    -> unique_bounded_operator_satisfying

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

BOUNDED_OPERATOR
    -> everywhere_defined_on(X)

# ---------- COMPACT OPERATOR RELATION ----------
COMPACT_OPERATOR
    -> bounded
       when(linear_between_normed_spaces)

COMPACT_LINEAR_OPERATOR
    -> special_case_of(BOUNDED_LINEAR_OPERATOR)

BOUNDED_OPERATOR
    -/> necessarily(COMPACT)

# ---------- MULTIPLICATION OPERATOR ----------
on suitable function space:

(M_g f)(x)
    := g(x)f(x)

BOUNDEDNESS
    -> depends_on(g_and_space)

on Lp:
    if g in L_infinity
    then
    M_g bounded

with
    ||M_g||
    = ||g||_infinity
       under(STANDARD_Lp_CONTEXT)

# ---------- INTEGRAL OPERATOR ----------
(Tf)(x)
    :=
integral(
    K(x,y)f(y)
    dy
)

KERNEL_CONDITIONS
    -> may_imply(BOUNDEDNESS)

BOUNDEDNESS
    -> depends_on(FUNCTION_SPACES_AND_KERNEL)

# ---------- DIFFERENTIAL OPERATOR CAUTION ----------
DERIVATIVE_OPERATOR
    := D(f)=f_prime

D
    -> often_unbounded
       on(common_infinite_dimensional_normed_spaces)

DIFFERENTIAL_OPERATOR
    -> requires(DOMAIN_ANALYSIS)

NOT_ALL_LINEAR_OPERATORS
    -> bounded_in(INFINITE_DIMENSIONS)

# ---------- APPLICATIONS ----------
BOUNDED_OPERATOR
    -> applied_to(FUNCTIONAL_ANALYSIS)
    -> applied_to(OPERATOR_THEORY)
    -> applied_to(INTEGRAL_EQUATIONS)
    -> applied_to(PDEs)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(NUMERICAL_ANALYSIS)
    -> applied_to(CONTROL_THEORY)

# ---------- RELATION GRAPH ----------
LINEAR_OPERATOR
    + NORM_BOUND
    -> BOUNDED_OPERATOR

BOUNDED_OPERATOR
    -> CONTINUOUS_OPERATOR

BOUNDED_OPERATOR
    -> has(OPERATOR_NORM)

BOUNDED_OPERATORS
    -> form(B(X,Y))

B(X,F)
    -> DUAL_SPACE

BOUNDED_BIJECTION_BETWEEN_BANACH_SPACES
    -> has(BOUNDED_INVERSE)

COMPACT_OPERATOR
    -> BOUNDED_OPERATOR

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "bounded operator" ~= "bounded linear operator in standard functional-analysis usage",
    "bounded linear operator" ~= "continuous linear operator between normed spaces",
    "operator norm" ~= "least uniform amplification bound of a bounded linear operator",
    "continuous linear map" ~= "bounded linear map between normed spaces",
    "B(X,Y)" ~= "space of bounded linear operators from X to Y",
    "dual space" ~= "bounded linear functionals on a normed space"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    bounded_operator_usage_here_assumes_linearity: true,
    boundedness_depends_on_domain_and_codomain_norms: true,
    bounded_linear_equivalent_to_continuous_linear_on_normed_spaces: true,
    operator_norm_is_finite_exactly_for_bounded_linear_operator: true,
    all_linear_maps_from_finite_dimensional_domain_are_bounded: true,
    infinite_dimensional_linear_operators_may_be_unbounded: true,
    bounded_inverse_theorem_requires_banach_space_hypotheses: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    operator_norm_relation: 0.99,
    continuity_equivalence: 0.99,
    composition_relation: 0.99,
    operator_space_relation: 0.99,
    inverse_adjoint_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(linear_operator)
    -> identify(domain_and_codomain_norms)
    -> test(uniform_norm_bound)
    -> compute_or_estimate(operator_norm)
    -> classify(as_bounded_or_unbounded)
    -> infer(continuity_if_bounded)
    -> analyse(sum_composition_or_scalar_multiple_if_relevant)
    -> analyse(inverse_if_bijective)
    -> construct(adjoint_if_requested)
    -> compare(compactness_or_spectral_properties_if_relevant)
    -> verify(space_completeness_for_banach_theorems)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed bounded-operator semantic graph",
    primary_entity: BOUNDED_OPERATOR,
    preserve: [
        operator,
        domain,
        codomain,
        domain_norm,
        codomain_norm,
        bound_constant,
        operator_norm,
        linearity
    ],
    infer_through: [
        continuity,
        operator_spaces,
        dual_spaces,
        compositions,
        inverses,
        adjoints,
        compact_operators,
        spectra
    ],
    avoid: [
        calling_nonlinear_bounded_map a bounded_operator_without context,
        ignoring_domain_and_codomain norms,
        assuming_all_linear_operators_are bounded in infinite dimensions,
        assuming_bijective_bounded_map has bounded inverse without Banach hypotheses,
        confusing_bounded_operator_with compact operator
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + BOUNDED_OPERATOR
    + OPERATOR_NORM
    + CONTINUITY
    + "B(X,Y)"
    + DUAL_SPACE
    + BOUNDED_INVERSE_THEOREM
    + NEUMANN_SERIES
    + ADJOINT
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> BOUNDED_OPERATOR
    -> LINEAR_OPERATOR_IDENTIFICATION
    -> DOMAIN_CODOMAIN_NORM_ANALYSIS
    -> NORM_BOUND_ANALYSIS
    -> OPERATOR_NORM_ANALYSIS
    -> BOUNDEDNESS_CLASSIFICATION
    -> CONTINUITY_ANALYSIS
    -> ALGEBRAIC_OPERATION_ANALYSIS
    -> INVERSE_ADJOINT_ANALYSIS
    -> COMPACT_SPECTRAL_ANALYSIS
    -> BANACH_HYPOTHESIS_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW