Function Space Ontology

flow "FunctionSpaceOntology" v1.0

# ============================================================
# FUNCTION SPACE ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
FUNCTION_SPACE := {
    type: MathematicalSpace,
    domain: FunctionalAnalysis,
    purpose: "Represent a collection of functions treated as mathematical points or vectors and equipped with algebraic, metric, norm, inner-product or topological structure."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    FUNCTION_SPACE,
    FUNCTION,
    DOMAIN,
    CODOMAIN,
    VECTOR_SPACE,
    NORM,
    METRIC,
    INNER_PRODUCT,
    TOPOLOGY,
    BANACH_SPACE,
    HILBERT_SPACE,
    LP_SPACE,
    CONTINUOUS_FUNCTION_SPACE,
    SOBOLEV_SPACE,
    DUAL_SPACE
}

# ---------- BASIC STRUCTURE ----------
FUNCTION_SPACE
    := {
        f :
        f maps DOMAIN_TO_CODOMAIN
        AND f satisfies(SPECIFIED_PROPERTIES)
    }

FUNCTION
    -> element_of(FUNCTION_SPACE)

FUNCTION_SPACE
    -> set_whose_elements_are(FUNCTIONS)

# ---------- DOMAIN / CODOMAIN ----------
for
    f in FUNCTION_SPACE

f:
    X -> Y

X
    -> FUNCTION_DOMAIN

Y
    -> FUNCTION_CODOMAIN

FUNCTION_SPACE_DEFINITION
    -> depends_on(DOMAIN)
    -> depends_on(CODOMAIN)
    -> depends_on(REGULARITY_OR_INTEGRABILITY_REQUIREMENTS)

# ---------- VECTOR SPACE STRUCTURE ----------
if
    codomain_is_scalar_field
    AND function_class_closed_under_linear_combinations
then

FUNCTION_SPACE
    -> VECTOR_SPACE

for
    f,g in FUNCTION_SPACE

(f+g)(x)
    := f(x)+g(x)

(alpha*f)(x)
    := alpha*f(x)

VECTOR_OPERATIONS
    -> defined_pointwise

# ---------- SUBSPACE ----------
FUNCTION_SUBSPACE
    -> subset_of(FUNCTION_SPACE)
    -> closed_under(VECTOR_ADDITION)
    -> closed_under(SCALAR_MULTIPLICATION)

examples:
    POLYNOMIAL_SPACE
    ZERO_BOUNDARY_FUNCTION_SPACE
    FINITE_DIMENSIONAL_SPAN

# ---------- NORMED FUNCTION SPACE ----------
FUNCTION_SPACE
    + NORM
    -> NORMED_FUNCTION_SPACE

NORM
    -> measures(SIZE_OF_FUNCTION)

NORM
    -> induces(METRIC)

d(f,g)
    := ||f-g||

# ---------- SUPREMUM NORM ----------
SUP_NORM(f)
    := sup(
        abs(f(x)) :
        x in DOMAIN
    )

C(K)
    -> continuous_functions_on(COMPACT_SPACE_K)

with sup norm:

C(K)
    -> BANACH_SPACE

SUP_NORM
    -> measures(MAXIMUM_POINTWISE_MAGNITUDE)

# ---------- Lp NORM ----------
for
    1 <= p < infinity

||f||_p
    := (
        integral(
            abs(f)^p
            dmu
        )
    )^(1/p)

for
    p = infinity

||f||_infinity
    := ESSENTIAL_SUPREMUM(abs(f))

LP_SPACE
    -> equivalence_classes_of(MEASURABLE_FUNCTIONS)
       modulo(ALMOST_EVERYWHERE_EQUALITY)

# ---------- Lp SPACE ----------
L^p
    := {
        measurable f :
        integral(abs(f)^p dmu) < infinity
    }
       modulo(AE_EQUALITY)

for
    1 <= p <= infinity

L^p
    -> BANACH_SPACE

# ---------- L2 SPACE ----------
L^2
    -> HILBERT_SPACE

INNER_PRODUCT
    := integral(
        f(x)
        * conjugate(g(x))
        dmu
    )

L2_NORM
    := sqrt(
        INNER_PRODUCT(f,f)
    )

L2
    -> central_to(FOURIER_AND_SPECTRAL_ANALYSIS)

# ---------- SEQUENCE SPACES ----------
l^p
    := {
        sequence x_n :
        sum(abs(x_n)^p) < infinity
    }

l^infinity
    := bounded_sequences

SEQUENCE_SPACE
    -> function_space_on(DISCRETE_DOMAIN)

l2
    -> HILBERT_SPACE

# ---------- CONTINUOUS FUNCTION SPACE ----------
C(X,Y)
    -> set_of(CONTINUOUS_FUNCTIONS_FROM_X_TO_Y)

if
    X compact
    AND Y scalar_field
then

C(X)
    with SUP_NORM
    -> BANACH_SPACE

CONTINUITY
    -> defining_property_of(C_SPACE)

# ---------- DIFFERENTIABLE FUNCTION SPACES ----------
C^k(Omega)
    -> functions_with(CONTINUOUS_DERIVATIVES_UP_TO_ORDER_k)

C^infinity(Omega)
    -> SMOOTH_FUNCTIONS

DIFFERENTIABLE_FUNCTION_SPACE
    -> carries(REGULARITY_INFORMATION)

# ---------- SOBOLEV SPACE ----------
W^(k,p)(Omega)
    -> functions_with(WEAK_DERIVATIVES_UP_TO_ORDER_k_IN_Lp)

SOBOLEV_SPACE
    -> combines(INTEGRABILITY, WEAK_DIFFERENTIABILITY)

H^k
    := W^(k,2)

H^k
    -> HILBERT_SPACE
       under(STANDARD_SOBOLEV_INNER_PRODUCT)

# ---------- WEAK DERIVATIVE ----------
g
    -> weak_derivative_of(f)

if

integral(
    f * derivative(test_function)
)
=
-negative_sign_adjusted_integral(
    g * test_function
)

for_all
    smooth_compactly_supported_test_functions

WEAK_DERIVATIVE
    -> extends(CLASSICAL_DERIVATIVE)

# ---------- TEST FUNCTION SPACE ----------
C_c^infinity(Omega)
    -> smooth_compactly_supported_functions

TEST_FUNCTION_SPACE
    -> used_to_define(DISTRIBUTIONS)
    -> used_to_define(WEAK_DERIVATIVES)

# ---------- DISTRIBUTION SPACE ----------
D_prime(Omega)
    -> continuous_linear_functionals_on(TEST_FUNCTION_SPACE)

DISTRIBUTION
    -> generalised_function

DISTRIBUTION_SPACE
    -> extends(CLASSICAL_FUNCTION_FRAMEWORK)

# ---------- INNER PRODUCT FUNCTION SPACE ----------
FUNCTION_SPACE
    + INNER_PRODUCT
    -> INNER_PRODUCT_SPACE

if complete
then

-> HILBERT_SPACE

ORTHOGONALITY
    := INNER_PRODUCT(f,g) = 0

# ---------- BASIS ----------
FUNCTION_SPACE
    -> may_have(HAMEL_BASIS)
    -> may_have(SCHAUDER_BASIS)
    -> may_have(ORTHONORMAL_BASIS)

INFINITE_DIMENSIONAL_SPACE
    -> basis_concept_depends_on(TYPE_OF_EXPANSION)

ORTHONORMAL_BASIS
    -> central_to(HILBERT_SPACE)

# ---------- CONVERGENCE ----------
FUNCTION_SEQUENCE
    := f_n

CONVERGENCE
    -> may_be(POINTWISE)
    -> may_be(UNIFORM)
    -> may_be(NORM)
    -> may_be(WEAK)
    -> may_be(WEAK_STAR)
    -> may_be(ALMOST_EVERYWHERE)
    -> may_be(IN_MEASURE)

CONVERGENCE_MODE
    -> must_be_specified

# ---------- POINTWISE CONVERGENCE ----------
f_n
    -> pointwise_converges_to(f)

iff

for_all x:
    f_n(x) -> f(x)

# ---------- UNIFORM CONVERGENCE ----------
f_n
    -> uniformly_converges_to(f)

iff

sup_x(
    abs(f_n(x)-f(x))
)
    -> 0

UNIFORM_CONVERGENCE
    -> stronger_than(POINTWISE_CONVERGENCE)

# ---------- NORM CONVERGENCE ----------
f_n
    -> norm_converges_to(f)

iff

||f_n-f||
    -> 0

NORM_CONVERGENCE
    -> depends_on(CHOSEN_NORM)

# ---------- WEAK CONVERGENCE ----------
f_n
    -> weakly_converges_to(f)

iff

ell(f_n)
    -> ell(f)

for_all
    ell in DUAL_SPACE

WEAK_CONVERGENCE
    -> depends_on(DUAL_PAIRING)

# ---------- DUAL SPACE ----------
FUNCTION_SPACE X
    -> has(DUAL_SPACE X_star)

X_star
    := CONTINUOUS_LINEAR_FUNCTIONALS_ON_X

DUAL_FUNCTIONAL
    -> maps(FUNCTION_TO_SCALAR)

DUALITY
    -> central_to(FUNCTIONAL_ANALYSIS)

# ---------- OPERATOR BETWEEN FUNCTION SPACES ----------
OPERATOR
    := T: X -> Y

where
    X,Y
        -> FUNCTION_SPACES

DIFFERENTIAL_OPERATOR
    -> maps(REGULARITY_SPACE_TO_ANOTHER_SPACE)

INTEGRAL_OPERATOR
    -> maps(FUNCTION_TO_FUNCTION)

FUNCTION_SPACE_SELECTION
    -> determines(OPERATOR_DOMAIN_AND_CODOMAIN)

# ---------- COMPLETENESS ----------
COMPLETE_FUNCTION_SPACE
    -> every_Cauchy_sequence_converges_within_space

BANACH_FUNCTION_SPACE
    := complete_normed_function_space

HILBERT_FUNCTION_SPACE
    := complete_inner_product_function_space

COMPLETENESS
    -> essential_for(MANY_EXISTENCE_THEOREMS)

# ---------- DENSITY ----------
SUBSET A
    -> dense_in(X)

if
    closure(A) = X

DENSE_SUBSPACE
    -> permits(APPROXIMATION_OF_GENERAL_ELEMENTS)

example:
    smooth_functions
        -> dense_in(many_Lp_and_Sobolev_spaces)
           under(APPROPRIATE_DOMAIN_CONDITIONS)

# ---------- APPLICATIONS ----------
FUNCTION_SPACE
    -> applied_to(DIFFERENTIAL_EQUATIONS)
    -> applied_to(FOURIER_ANALYSIS)
    -> applied_to(QUANTUM_MECHANICS)
    -> applied_to(APPROXIMATION_THEORY)
    -> applied_to(OPTIMISATION)
    -> applied_to(PROBABILITY)
    -> applied_to(NUMERICAL_ANALYSIS)

# ---------- RELATION GRAPH ----------
FUNCTION
    -> element_of(FUNCTION_SPACE)

FUNCTION_SPACE
    + NORM
    -> NORMED_FUNCTION_SPACE

NORMED_FUNCTION_SPACE
    + COMPLETENESS
    -> BANACH_FUNCTION_SPACE

INNER_PRODUCT_FUNCTION_SPACE
    + COMPLETENESS
    -> HILBERT_FUNCTION_SPACE

FUNCTION_SPACE
    -> has(DUAL_SPACE)

OPERATOR
    -> maps_between(FUNCTION_SPACES)

CONVERGENCE_MODE
    -> determined_by(STRUCTURE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "function space" ~= "set of functions equipped with specified mathematical structure",
    "normed function space" ~= "function space equipped with a norm",
    "Banach function space" ~= "complete normed function space",
    "Hilbert function space" ~= "complete inner-product function space",
    "Lp space" ~= "space of p-integrable measurable functions modulo almost-everywhere equality",
    "Sobolev space" ~= "function space defined by integrability of functions and weak derivatives"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    function_space_definition_requires_domain_codomain_and_membership_conditions: true,
    vector_space_structure_requires_closure_under_linear_combinations: true,
    norm_convergence_depends_on_selected_norm: true,
    lp_elements_are_equivalence_classes_modulo_almost_everywhere_equality: true,
    convergence_mode_must_not_be_assumed_without specification: true,
    completeness_is_structure_dependent: true,
    operator_domain_and_codomain_must_be_preserved: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    vector_space_relation: 0.99,
    normed_banach_hilbert_relations: 0.99,
    lp_relation: 0.99,
    sobolev_relation: 0.98,
    convergence_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function_collection)
    -> identify(domain_and_codomain)
    -> identify(membership_conditions)
    -> test(vector_space_structure_if_relevant)
    -> identify(norm_metric_inner_product_or_topology)
    -> test(completeness_if_required)
    -> classify(function_space_type)
    -> identify(convergence_mode)
    -> identify(dual_space_or_operator_structure_if_requested)
    -> validate(equivalence_class_and_domain_conditions)
    -> connect_to(application_context)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed function-space semantic graph",
    primary_entity: FUNCTION_SPACE,
    preserve: [
        function_domain,
        function_codomain,
        membership_conditions,
        scalar_field,
        norm,
        inner_product,
        topology,
        equivalence_relation
    ],
    infer_through: [
        normed_spaces,
        banach_spaces,
        hilbert_spaces,
        lp_spaces,
        sobolev_spaces,
        dual_spaces,
        convergence_modes,
        operators
    ],
    avoid: [
        treating_arbitrary_function_set_as vector space,
        assuming_completeness,
        ignoring_almost_everywhere equivalence in Lp,
        confusing_pointwise_uniform_and_norm convergence,
        ignoring_operator domains,
        assuming_all_function_spaces_have same topology
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + FUNCTION_SPACE
    + NORMED_FUNCTION_SPACE
    + BANACH_FUNCTION_SPACE
    + HILBERT_FUNCTION_SPACE
    + LP_SPACE
    + SOBOLEV_SPACE
    + DUAL_SPACE
    + CONVERGENCE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> FUNCTION_SPACE
    -> FUNCTION_COLLECTION_IDENTIFICATION
    -> DOMAIN_CODOMAIN_ANALYSIS
    -> MEMBERSHIP_CONDITION_ANALYSIS
    -> VECTOR_SPACE_ANALYSIS
    -> STRUCTURE_ANALYSIS
    -> COMPLETENESS_ANALYSIS
    -> FUNCTION_SPACE_CLASSIFICATION
    -> CONVERGENCE_ANALYSIS
    -> DUAL_OPERATOR_ANALYSIS
    -> APPLICATION_RELATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW