Functional Minimisation Ontology

flow "FunctionalMinimisationOntology" v1.0

# ============================================================
# FUNCTIONAL MINIMISATION ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
FUNCTIONAL_MINIMISATION := {
    type: VariationalOptimisationProcess,
    domain: CalculusOfVariations,
    purpose: "Determine a function, field, curve or other infinite-dimensional object that minimises a scalar-valued functional over an admissible class."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    FUNCTIONAL,
    MINIMISER,
    ADMISSIBLE_CLASS,
    INFIMUM,
    MINIMISING_SEQUENCE,
    FIRST_VARIATION,
    SECOND_VARIATION,
    COERCIVITY,
    LOWER_SEMICONTINUITY,
    WEAK_CONVERGENCE,
    COMPACTNESS,
    CONVEXITY,
    STRICT_CONVEXITY,
    DIRECT_METHOD,
    EULER_LAGRANGE_EQUATION
}

# ---------- FUNCTIONAL ----------
FUNCTIONAL
    := J

J:
    X -> R union {+infinity}

X
    -> FUNCTION_SPACE_OR_ADMISSIBLE_SPACE

J[u]
    -> scalar_objective_value

FUNCTIONAL_MINIMISATION
    -> seek(u_star)

such_that

J[u_star]
    <=
J[u]

for_all
    u in ADMISSIBLE_CLASS

# ---------- ADMISSIBLE CLASS ----------
ADMISSIBLE_CLASS
    := A subset_of X

A
    -> determined_by(
        BOUNDARY_CONDITIONS,
        CONSTRAINTS,
        REGULARITY,
        INTEGRABILITY,
        GEOMETRIC_REQUIREMENTS
    )

MINIMISATION
    -> performed_over(A)

# ---------- INFIMUM ----------
m
    :=
inf_{u in A}(
    J[u]
)

MINIMISER
    := u_star

if

u_star in A

and

J[u_star]
    = m

INFIMUM
    -/> necessarily_attained

EXISTENCE
    -> requires(ATTainment_OF_INFIMUM)

# ---------- GLOBAL MINIMISER ----------
u_star
    -> GLOBAL_MINIMISER

iff

J[u_star]
    <=
J[u]

for_all u in A

GLOBAL_MINIMUM
    -> strongest_minimisation_statement

# ---------- LOCAL MINIMISER ----------
u_star
    -> LOCAL_MINIMISER

if

exists neighbourhood U of u_star
in chosen topology

such_that

J[u_star]
    <=
J[u]

for_all
    u in A intersection U

LOCAL_MINIMUM
    -> topology_dependent

# ---------- STRICT MINIMISER ----------
u_star
    -> STRICT_MINIMISER

if

J[u_star]
    <
J[u]

for_all relevant
    u != u_star

STRICTNESS
    -> may_imply(UNIQUENESS)
       in(GLOBAL_CONTEXT)

# ---------- MINIMISING SEQUENCE ----------
sequence
    (u_n)
    subset_of A

-> MINIMISING_SEQUENCE

if

J[u_n]
    -> inf_A J

MINIMISING_SEQUENCE
    -> approximates(MINIMUM_VALUE)

DIRECT_METHOD
    -> begins_with(MINIMISING_SEQUENCE)

# ---------- DIRECT METHOD ----------
DIRECT_METHOD:
    choose(minimising_sequence)
    -> establish(boundedness_or_coercivity)
    -> extract(convergent_or_weakly_convergent_subsequence)
    -> prove(limit_is_admissible)
    -> apply(lower_semicontinuity)
    -> conclude(limit_attains_infimum)

DIRECT_METHOD
    -> existence_framework_for(FUNCTIONAL_MINIMISERS)

# ---------- COERCIVITY ----------
J
    -> COERCIVE

if

||u||
    -> infinity

implies

J[u]
    -> infinity

or appropriate equivalent
    on admissible class

COERCIVITY
    -> bounds(MINIMISING_SEQUENCES)

COERCIVITY
    -> prevents(ESCAPE_TO_INFINITY)

# ---------- COMPACTNESS ----------
BOUNDED_MINIMISING_SEQUENCE
    -> may_have(CONVERGENT_SUBSEQUENCE)
       under(COMPACTNESS)

in reflexive Banach spaces:

BOUNDED_SEQUENCE
    -> may_have(WEAKLY_CONVERGENT_SUBSEQUENCE)

WEAK_COMPACTNESS
    -> central_to(DIRECT_METHOD)

# ---------- WEAK CONVERGENCE ----------
u_n
    -> weakly_converges_to(u)

if

phi(u_n)
    -> phi(u)

for_all
    phi in X_star

WEAK_CONVERGENCE
    -> weaker_than(NORM_CONVERGENCE)

DIRECT_METHOD
    -> often_uses(WEAK_TOPOLOGY)

# ---------- LOWER SEMICONTINUITY ----------
J
    -> WEAKLY_LOWER_SEMICONTINUOUS

if

u_n
    -> weakly_converges_to(u)

implies

J[u]
    <=
liminf(
    J[u_n]
)

LOWER_SEMICONTINUITY
    -> ensures(LIMIT_DOES_NOT_INCREASE_BELOW_INFIMUM_STRUCTURE)

# ---------- EXISTENCE ----------
if
    A nonempty
    and weakly_sequentially_closed

and
    J coercive

and
    J weakly_lower_semicontinuous

and
    relevant weak compactness available

then

J
    -> attains(MINIMUM_ON_A)

under
    standard_direct_method_hypotheses

# ---------- CONVEXITY ----------
J
    -> CONVEX

if

J[
    theta*u
    +
    (1-theta)*v
]
<=
theta*J[u]
+
(1-theta)*J[v]

for
    theta in [0,1]

CONVEX_FUNCTIONAL
    -> local_minimiser_is_global
       on(CONVEX_ADMISSIBLE_SET)

# ---------- STRICT CONVEXITY ----------
J
    -> STRICTLY_CONVEX

if strict inequality holds
for
    u != v
    and 0 < theta < 1

STRICT_CONVEXITY
    -> at_most_one_global_minimiser
       on(CONVEX_SET)

STRICT_CONVEXITY
    -> supports(UNIQUENESS)

# ---------- FIRST VARIATION ----------
for admissible perturbation
    eta

u_epsilon
    :=
u + epsilon*eta

FIRST_VARIATION
    :=
delta_J[u;eta]

=
d/d_epsilon
J[u+epsilon*eta]
at
    epsilon=0

if
    u_star interior_local_minimiser
then

delta_J[u_star;eta]
    = 0

for_all admissible eta

# ---------- EULER-LAGRANGE ----------
for

J[u]
    =
integral(
    F(
        x,
        u,
        grad(u)
    )
    dx
)

FIRST_VARIATION_ZERO
    -> yields(
        partial_F/partial_u
        -
        div(
            partial_F/partial_grad_u
        )
        = 0
    )

EULER_LAGRANGE_EQUATION
    -> necessary_stationarity_condition

# ---------- SECOND VARIATION ----------
SECOND_VARIATION
    :=
delta_squared_J[u;eta]

if
    u_star local_minimiser
then

delta_squared_J[u_star;eta]
    >= 0

under
    suitable_differentiability_conditions

POSITIVE_DEFINITE_SECOND_VARIATION
    -> may_support(STRICT_LOCAL_MINIMUM)

# ---------- CONSTRAINTS ----------
MINIMISE
    J[u]

subject_to
    G[u]=0

introduce
    LAGRANGE_MULTIPLIER

AUGMENTED_FUNCTIONAL
    :=
J[u]
+
lambda*G[u]

CONSTRAINED_MINIMISATION
    -> stationarity_of(AUGMENTED_FUNCTIONAL)
       under(REGULARITY_CONDITIONS)

# ---------- BOUNDARY CONDITIONS ----------
DIRICHLET_CONDITION
    -> fixes(function_value_on_boundary)

NEUMANN_CONDITION
    -> constrains(normal_derivative_or_flux)

MIXED_CONDITION
    -> combines(BOUNDARY_TYPES)

ADMISSIBLE_CLASS
    -> incorporates(ESSENTIAL_BOUNDARY_CONDITIONS)

NATURAL_BOUNDARY_CONDITIONS
    -> may_emerge_from(VARIATION)

# ---------- ENERGY FUNCTIONAL ----------
example:

E[u]
    :=
integral_Omega(
    1/2 * |grad(u)|^2
    -
    f*u
    dx
)

MINIMISER
    -> weak_solution_of(
        -LAPLACIAN(u)=f
    )

under
    suitable_boundary_conditions

ENERGY_MINIMISATION
    -> variational_form_of(PDE)

# ---------- DIRICHLET PRINCIPLE ----------
harmonic_function
    -> minimises(DIRICHLET_ENERGY)

DIRICHLET_ENERGY
    :=
integral_Omega(
    |grad(u)|^2
    dx
)

subject_to
    fixed_boundary_values

DIRICHLET_PRINCIPLE
    -> links(HARMONIC_FUNCTIONS_AND_MINIMISATION)

# ---------- BEST APPROXIMATION ----------
in Hilbert space H:

minimise
    ||u-v||^2

over
    v in CLOSED_CONVEX_SET_C

PROJECTION_THEOREM
    -> unique_nearest_point

FUNCTIONAL_MINIMISATION
    -> generalises(BEST_APPROXIMATION)

# ---------- REGULARISATION ----------
objective:

J[u]
    :=
DATA_FIDELITY[u]
+
lambda
*
REGULARISATION[u]

lambda
    -> tradeoff_parameter

REGULARISATION
    -> stabilises(INVERSE_OR_ILL_POSED_PROBLEM)

FUNCTIONAL_MINIMISATION
    -> applied_to(INVERSE_PROBLEMS)

# ---------- NUMERICAL MINIMISATION ----------
FUNCTION_SPACE
    -> discretise
    -> FINITE_DIMENSIONAL_SPACE

FUNCTIONAL
    -> discrete_objective

then

OPTIMISATION_ALGORITHM
    -> approximate(MINIMISER)

examples:
    GRADIENT_DESCENT
    NEWTON_METHOD
    FINITE_ELEMENT_MINIMISATION

DISCRETISATION
    -> must_preserve(VARIATIONAL_STRUCTURE_WHEN_POSSIBLE)

# ---------- APPLICATIONS ----------
FUNCTIONAL_MINIMISATION
    -> applied_to(PDEs)
    -> applied_to(MECHANICS)
    -> applied_to(ELASTICITY)
    -> applied_to(OPTIMAL_CONTROL)
    -> applied_to(INVERSE_PROBLEMS)
    -> applied_to(IMAGE_PROCESSING)
    -> applied_to(MACHINE_LEARNING)
    -> applied_to(NUMERICAL_ANALYSIS)

# ---------- RELATION GRAPH ----------
FUNCTIONAL
    -> minimised_over(ADMISSIBLE_CLASS)

INFIMUM
    -> target_value_of(MINIMISATION)

MINIMISING_SEQUENCE
    -> approaches(INFIMUM)

COERCIVITY
    -> bounds(MINIMISING_SEQUENCE)

COMPACTNESS
    -> provides(CONVERGENT_SUBSEQUENCE)

LOWER_SEMICONTINUITY
    -> passes(MINIMALITY_TO_LIMIT)

CONVEXITY
    -> supports(GLOBAL_MINIMALITY)

STRICT_CONVEXITY
    -> supports(UNIQUENESS)

FIRST_VARIATION
    -> yields(STATIONARITY)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "functional minimisation" ~= "minimisation of a scalar-valued functional over an admissible function space",
    "minimiser" ~= "admissible object attaining the infimum of a functional",
    "minimising sequence" ~= "sequence whose functional values approach the infimum",
    "coercivity" ~= "growth condition preventing minimising sequences from escaping to infinity",
    "lower semicontinuity" ~= "property allowing functional values at limits to be controlled by liminf",
    "direct method" ~= "existence method using minimising sequences, compactness and lower semicontinuity"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    infimum_need_not_be_attained: true,
    local_minimum_depends_on_chosen_topology: true,
    first_variation_zero_is_not_generally_sufficient_for_minimum: true,
    existence_requires_compactness_or_equivalent_control_and_lower_semicontinuity: true,
    strict_convexity_supports_uniqueness_only_on_convex_admissible_domain: true,
    constraints_and_boundary_conditions_must_be_preserved_in_variations: true,
    discretised_minimiser_must_not_be_assumed_identical_to_continuum_minimiser: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    minimising_sequence_relation: 0.99,
    direct_method_relation: 0.99,
    coercivity_compactness_relation: 0.99,
    convexity_uniqueness_relation: 0.99,
    variational_PDE_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(functional_and_admissible_class)
    -> determine(infimum_and_candidate_minimiser)
    -> identify(topology_and_function_space)
    -> construct(minimising_sequence_if_existence_problem)
    -> test(coercivity_and_boundedness)
    -> obtain(compact_or_weakly_compact_subsequence)
    -> verify(limit_is_admissible)
    -> apply(lower_semicontinuity)
    -> test(convexity_or_strict_convexity_for_globality_and_uniqueness)
    -> compute(first_and_second_variations_if_stationarity_requested)
    -> derive(Euler_Lagrange_or_weak_equations_if_relevant)
    -> validate(all_boundary_constraint_and_regularities)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed functional-minimisation semantic graph",
    primary_entity: FUNCTIONAL_MINIMISATION,
    preserve: [
        functional,
        admissible_class,
        topology,
        function_space,
        constraints,
        boundary_conditions,
        infimum,
        candidate_minimiser
    ],
    infer_through: [
        minimising_sequences,
        coercivity,
        weak_convergence,
        compactness,
        lower_semicontinuity,
        convexity,
        first_variations,
        Euler_Lagrange_equations
    ],
    avoid: [
        assuming_infimum_is attained,
        treating_stationary_point_as guaranteed minimiser,
        ignoring_topology_in local minimality,
        claiming_uniqueness_without strict convexity_or_other argument,
        violating_constraints_during variation,
        conflating_numerical_approximation_with exact minimiser
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + FUNCTIONAL_MINIMISATION
    + FUNCTIONAL
    + MINIMISER
    + INFIMUM
    + MINIMISING_SEQUENCE
    + COERCIVITY
    + LOWER_SEMICONTINUITY
    + CONVEXITY
    + DIRECT_METHOD
    + EULER_LAGRANGE_EQUATION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> FUNCTIONAL_MINIMISATION
    -> FUNCTIONAL_ADMISSIBLE_CLASS_IDENTIFICATION
    -> INFIMUM_MINIMISER_ANALYSIS
    -> TOPOLOGY_FUNCTION_SPACE_ANALYSIS
    -> MINIMISING_SEQUENCE_ANALYSIS
    -> COERCIVITY_COMPACTNESS_ANALYSIS
    -> LOWER_SEMICONTINUITY_ANALYSIS
    -> CONVEXITY_UNIQUENESS_ANALYSIS
    -> VARIATION_STATIONARITY_ANALYSIS
    -> EULER_LAGRANGE_WEAK_FORM_ANALYSIS
    -> BOUNDARY_CONSTRAINT_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW