Functional Derivative Ontology

flow "FunctionalDerivativeOntology" v1.0

# ============================================================
# FUNCTIONAL DERIVATIVE ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
FUNCTIONAL_DERIVATIVE := {
    type: VariationalDerivativeConcept,
    domain: CalculusOfVariations,
    purpose: "Represent the infinitesimal change of a functional produced by a local variation of its input function or field."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    FUNCTIONAL,
    FUNCTIONAL_DERIVATIVE,
    VARIATION,
    FIRST_VARIATION,
    GATEAUX_DERIVATIVE,
    FRECHET_DERIVATIVE,
    VARIATIONAL_DERIVATIVE,
    TEST_FUNCTION,
    EULER_LAGRANGE_OPERATOR,
    FUNCTION_SPACE,
    DISTRIBUTION,
    DELTA_FUNCTION,
    GRADIENT,
    FIELD_VARIATION
}

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

J:
    FUNCTION_SPACE
    -> SCALAR_FIELD

example:

J[f]
    :=
integral(
    F(
        x,
        f(x),
        f_prime(x)
    )
    dx
)

FUNCTIONAL
    -> scalar_dependent_on(ENTIRE_FUNCTION)

# ---------- VARIATION ----------
choose
    eta(x)
        -> admissible_variation

define

f_epsilon(x)
    :=
f(x)
+
epsilon*eta(x)

VARIATION
    -> direction_in(FUNCTION_SPACE)

# ---------- FIRST VARIATION ----------
delta_J[f;eta]
    :=
d/d_epsilon(
    J[f+epsilon*eta]
)
evaluated_at
    epsilon=0

FIRST_VARIATION
    -> directional_change_of(FUNCTIONAL)

# ---------- FUNCTIONAL DERIVATIVE DEFINITION ----------
FUNCTIONAL_DERIVATIVE
    :=
delta_J
/
delta_f(x)

defined through

delta_J
    =
integral(
    delta_J/delta_f(x)
    *
    eta(x)
    dx
)

for arbitrary admissible
    eta

FUNCTIONAL_DERIVATIVE
    -> density_of(FIRST_VARIATION_WITH_RESPECT_TO_FUNCTION_VARIATION)

# ---------- LOCAL FUNCTIONAL ----------
for

J[f]
    =
integral_from_a_to_b(
    F(
        x,
        f,
        f_prime
    )
    dx
)

first variation:

delta_J
    =
integral(
    F_f*eta
    +
    F_f_prime*eta_prime
    dx
)

# ---------- INTEGRATION BY PARTS ----------
integrate

F_f_prime*eta_prime

by parts:

delta_J
    =
[
    F_f_prime*eta
]_a^b

+
integral(
    [
        F_f
        -
        d/dx(F_f_prime)
    ]
    eta
    dx
)

for endpoint-vanishing variations:

BOUNDARY_TERM
    = 0

therefore

delta_J/delta_f
    =
F_f
-
d/dx(
    F_f_prime
)

# ---------- EULER-LAGRANGE OPERATOR ----------
EULER_LAGRANGE_OPERATOR
    :=
partial/partial_f
-
d/dx
*
partial/partial_f_prime

applied_to
    F

gives

delta_J/delta_f

VARIATIONAL_DERIVATIVE
    -> EULER_LAGRANGE_EXPRESSION

# ---------- STATIONARITY ----------
if

f_star
    -> stationary_point_of(J)

then

delta_J[f_star;eta]
    = 0

for_all
    admissible_eta

therefore

delta_J/delta_f
    = 0

under
    fundamental_lemma_conditions

FUNCTIONAL_DERIVATIVE_ZERO
    -> EULER_LAGRANGE_EQUATION

# ---------- MULTIPLE DERIVATIVES ----------
if

J[f]
    =
integral(
    F(
        x,
        f,
        f_prime,
        ...,
        f^(n)
    )
    dx
)

then

delta_J/delta_f
    =
sum_from_k_0_to_n(
    (-1)^k
    *
    d^k/dx^k(
        partial_F
        /
        partial_f^(k)
    )
)

HIGHER_ORDER_FUNCTIONAL
    -> generalized_functional_derivative

# ---------- MULTIPLE DIMENSIONS ----------
for field
    phi(x)

with
    x in R^n

J[phi]
    =
integral_Omega(
    L(
        x,
        phi,
        grad(phi)
    )
    dx
)

then

delta_J/delta_phi
    =
partial_L/partial_phi
-
div(
    partial_L
    /
    partial_grad_phi
)

FIELD_FUNCTIONAL_DERIVATIVE
    -> EULER_LAGRANGE_PDE_OPERATOR

# ---------- MULTIPLE FIELDS ----------
for
    phi_a

J[phi_a]
    =
integral(
    L(
        phi_a,
        partial_mu(phi_a),
        x
    )
    d^n x
)

functional derivative:

delta_J/delta_phi_a
    =
partial_L/partial_phi_a
-
partial_mu(
    partial_L
    /
    partial(partial_mu phi_a)
)

FIELD_INDEX
    -> preserved_in(VARIATIONAL_DERIVATIVE)

# ---------- GATEAUX DERIVATIVE ----------
GATEAUX_DERIVATIVE
    :=
D_G J[f](eta)

=
lim_(epsilon->0)
(
    J[f+epsilon*eta]
    -
    J[f]
)
/epsilon

if limit exists

GATEAUX_DERIVATIVE
    -> directional_derivative_in(FUNCTION_SPACE)

FIRST_VARIATION
    -> often_identified_with(GATEAUX_DERIVATIVE)

# ---------- FRECHET DERIVATIVE ----------
J
    -> FRECHET_DIFFERENTIABLE_AT(f)

if

exists bounded_linear_map
    A

such_that

J[f+h]
    =
J[f]
+
A[h]
+
o(||h||)

as
    ||h|| -> 0

FRECHET_DERIVATIVE
    -> stronger_uniform_linear_approximation_than(GATEAUX_DERIVATIVE)

# ---------- RELATION BETWEEN DERIVATIVES ----------
FRECHET_DIFFERENTIABLE
    -> GATEAUX_DIFFERENTIABLE

with

GATEAUX_DERIVATIVE
    -> induced_by(FRECHET_DERIVATIVE)

CONVERSE
    -/> generally_true

FUNCTIONAL_DERIVATIVE
    -> representation_of(DERIVATIVE_BY_INTEGRAL_PAIRING)
       when such representation exists

# ---------- FUNCTION-SPACE GRADIENT ----------
if
    derivative represented under inner product:

DJ[f](eta)
    =
<grad_J[f], eta>

then

grad_J[f]
    -> FUNCTION_SPACE_GRADIENT

GRADIENT
    -> depends_on(CHOSEN_INNER_PRODUCT)

FUNCTIONAL_DERIVATIVE
    -/> always_identical_to(GRADIENT_UNDER_ARBITRARY_METRIC)

# ---------- L2 GRADIENT ----------
under L2 pairing:

DJ[f](eta)
    =
integral(
    g(x)*eta(x)
    dx
)

then

grad_L2 J
    =
g

and

g
    ~= delta_J/delta_f

under
    standard_regular_context

# ---------- DELTA FUNCTION DEFINITION ----------
functional derivative of field value:

delta f(x)
/
delta f(y)
    =
delta(x-y)

DIRAC_DELTA
    -> identity_kernel_for(FUNCTIONAL_VARIATION)

# ---------- BASIC EXAMPLE ----------
J[f]
    :=
integral(
    1/2
    *
    f(x)^2
    dx
)

variation:

delta_J
    =
integral(
    f(x)
    *
    eta(x)
    dx
)

therefore

delta_J/delta_f(x)
    =
f(x)

# ---------- DERIVATIVE ENERGY EXAMPLE ----------
J[f]
    :=
integral(
    1/2
    *
    (f_prime(x))^2
    dx
)

variation:

delta_J
    =
integral(
    f_prime
    *
    eta_prime
    dx
)

after integration by parts:

delta_J
    =
-
integral(
    f_double_prime
    *
    eta
    dx
)

for valid boundary conditions

therefore

delta_J/delta_f
    =
-f_double_prime

# ---------- FIELD ENERGY EXAMPLE ----------
E[phi]
    :=
integral_Omega(
    [
        1/2
        *
        |grad(phi)|^2
        +
        V(phi)
    ]
    dx
)

then

delta_E/delta_phi
    =
-LAPLACIAN(phi)
+
V_prime(phi)

under
    appropriate_boundary_conditions

# ---------- NONLOCAL FUNCTIONAL ----------
J[f]
    :=
double_integral(
    K(x,y)
    *
    f(x)
    *
    f(y)
    dx dy
)

FUNCTIONAL_DERIVATIVE
    -> may_depend_on(INTEGRAL_OVER_OTHER_POINTS)

NONLOCAL_FUNCTIONAL
    -> nonlocal_variational_derivative

if K symmetric:

delta_J/delta_f(x)
    =
2
*
integral(
    K(x,y)
    *
    f(y)
    dy
)

subject_to
    normalisation_of_functional

# ---------- CONSTRAINT FUNCTIONAL ----------
constraint

C[f]
    = c

minimise
    J[f]

define

AUGMENTED_FUNCTIONAL
    :=
J[f]
+
lambda(
    C[f]-c
)

stationarity:

delta_J/delta_f
+
lambda
*
delta_C/delta_f
=
0

LAGRANGE_MULTIPLIER
    -> functional_constraint_equation

# ---------- BOUNDARY TERMS ----------
FUNCTIONAL_VARIATION
    -> generates(BOUNDARY_TERMS)

BOUNDARY_CONDITIONS
    -> determine(
        whether boundary terms vanish
        or generate natural conditions
    )

FUNCTIONAL_DERIVATIVE
    -> must_be_interpreted_with(BOUNDARY_CONTEXT)

# ---------- DISTRIBUTIONAL DERIVATIVE ----------
if
    fields_or_functionals_lack_classical_smoothness

then

FUNCTIONAL_DERIVATIVE
    -> may_be(DISTRIBUTION)

WEAK_FORM
    -> pairs(DERIVATIVE_WITH_TEST_FUNCTIONS)

DISTRIBUTION_THEORY
    -> extends(VARIATIONAL_DIFFERENTIATION)

# ---------- GRADIENT FLOW ----------
evolution:

partial_f/partial_t
    =
-
delta_J/delta_f

under
    L2_gradient_structure

GRADIENT_FLOW
    -> decreases(FUNCTIONAL)

dJ/dt
    <= 0

under
    suitable_conditions

# ---------- OPTIMISATION ----------
FUNCTIONAL_DERIVATIVE
    -> infinite_dimensional_analogue_of(GRADIENT_COMPONENT)

OPTIMISATION_ALGORITHM
    -> uses(FUNCTIONAL_GRADIENT)

examples:
    STEEPEST_DESCENT
    GRADIENT_FLOW
    ADJOINT_METHODS

# ---------- PHYSICS ----------
ACTION
    :=
S[phi]

FIELD_EQUATIONS
    -> obtained_from

delta_S
/
delta_phi
=
0

FUNCTIONAL_DERIVATIVE
    -> central_to(CLASSICAL_FIELD_THEORY)

# ---------- APPLICATIONS ----------
FUNCTIONAL_DERIVATIVE
    -> applied_to(CALCULUS_OF_VARIATIONS)
    -> applied_to(FIELD_THEORY)
    -> applied_to(PDEs)
    -> applied_to(OPTIMAL_CONTROL)
    -> applied_to(INVERSE_PROBLEMS)
    -> applied_to(MACHINE_LEARNING)
    -> applied_to(QUANTUM_FIELD_THEORY)
    -> applied_to(FUNCTIONAL_OPTIMISATION)

# ---------- RELATION GRAPH ----------
FUNCTIONAL
    -> perturbed_by(VARIATION)

VARIATION
    -> produces(FIRST_VARIATION)

FIRST_VARIATION
    -> represented_by(FUNCTIONAL_DERIVATIVE)

FUNCTIONAL_DERIVATIVE
    -> yields(EULER_LAGRANGE_OPERATOR)

FUNCTIONAL_DERIVATIVE_ZERO
    -> stationarity_condition

FRECHET_DERIVATIVE
    -> stronger_than(GATEAUX_DERIVATIVE)

INNER_PRODUCT
    -> converts(DERIVATIVE_TO_GRADIENT)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "functional derivative" ~= "derivative of a functional with respect to its input function or field",
    "variational derivative" ~= "functional derivative used in calculus of variations",
    "first variation" ~= "directional first-order change of a functional",
    "Gateaux derivative" ~= "directional derivative of a functional in a function space",
    "Frechet derivative" ~= "bounded linear first-order approximation of a functional",
    "Euler-Lagrange derivative" ~= "functional derivative of a local variational integral after integration by parts"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    functional_derivative_depends_on_function_space_and_pairing_context: true,
    boundary_terms_must_be_handled_before_identifying_local_Euler_Lagrange_derivative: true,
    Gateaux_differentiability_does_not_generally_imply_Frechet_differentiability: true,
    functional_derivative_and_gradient_depend_on_identification_via_inner_product: true,
    nonlocal_functionals_can_have_nonlocal_derivatives: true,
    weak_or_distributional_derivatives_may_be_required_without_classical_smoothness: true,
    constraints_require_augmented_variational_equations: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    first_variation_relation: 0.99,
    Euler_Lagrange_relation: 0.99,
    Gateaux_Frechet_relation: 0.99,
    gradient_relation: 0.99,
    field_derivative_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(functional_function_space_and_field)
    -> identify(admissible_variations_and_boundary_conditions)
    -> construct(perturbed_function)
    -> compute(Gateaux_or_first_variation)
    -> integrate_by_parts(if_derivatives_of_variation_present)
    -> isolate(test_function_or_variation)
    -> identify(functional_derivative)
    -> distinguish(derivative_from_gradient_using_inner_product)
    -> apply(stationarity_or_constraint_equations_if_requested)
    -> extend_to(distributional_or_nonlocal_context_if_required)
    -> validate(function_space_regularities_and_boundary_terms)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed functional-derivative semantic graph",
    primary_entity: FUNCTIONAL_DERIVATIVE,
    preserve: [
        functional,
        function_or_field,
        function_space,
        variation,
        boundary_conditions,
        pairing_or_inner_product,
        regularity,
        constraints
    ],
    infer_through: [
        first_variations,
        Gateaux_derivatives,
        Frechet_derivatives,
        Euler_Lagrange_operators,
        functional_gradients,
        delta_functions,
        weak_derivatives,
        gradient_flows
    ],
    avoid: [
        confusing_function_derivative_with functional derivative,
        discarding_boundary_terms_without conditions,
        treating_Gateaux_and_Frechet_derivatives_as automatically equivalent,
        equating_functional_derivative_with gradient_without metric context,
        assuming_all_functionals_are local,
        requiring_classical_derivatives_when weak formulation is appropriate
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + FUNCTIONAL_DERIVATIVE
    + FUNCTIONAL
    + VARIATION
    + FIRST_VARIATION
    + GATEAUX_DERIVATIVE
    + FRECHET_DERIVATIVE
    + EULER_LAGRANGE_OPERATOR
    + GRADIENT
    + DISTRIBUTION
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> FUNCTIONAL_DERIVATIVE
    -> FUNCTIONAL_SPACE_IDENTIFICATION
    -> VARIATION_BOUNDARY_ANALYSIS
    -> PERTURBATION_CONSTRUCTION
    -> FIRST_VARIATION_COMPUTATION
    -> INTEGRATION_BY_PARTS
    -> TEST_FUNCTION_ISOLATION
    -> FUNCTIONAL_DERIVATIVE_IDENTIFICATION
    -> DERIVATIVE_GRADIENT_ANALYSIS
    -> STATIONARITY_CONSTRAINT_ANALYSIS
    -> NONLOCAL_DISTRIBUTIONAL_ANALYSIS
    -> REGULARITY_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW