Optimal Path Ontology

flow "OptimalPathOntology" v1.0

# ============================================================
# OPTIMAL PATH ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/variational-calculus/optimal-path-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Variational Calculus"
ENTITY := "Optimal Path"

# ---------- CORE ENTITY ----------
OPTIMAL_PATH := {
    type: VariationalOptimisationObject,
    domain: VariationalCalculus,
    purpose: "Represent a curve, trajectory or path that minimises or extremises a specified functional subject to endpoint, geometric, dynamical or other admissibility constraints."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    PATH,
    TRAJECTORY,
    CURVE,
    FUNCTIONAL,
    COST_FUNCTIONAL,
    ADMISSIBLE_PATH,
    VARIATION,
    EXTREMAL,
    EULER_LAGRANGE_EQUATION,
    BOUNDARY_CONDITION,
    TRANSVERSALITY,
    GEODESIC,
    BRACHISTOCHRONE,
    SHORTEST_PATH,
    ACTION,
    OPTIMAL_CONTROL
}

# ---------- PATH ----------
PATH
    := gamma

gamma:
    [a,b]
    -> CONFIGURATION_SPACE

gamma(t)
    -> position_or_state_at(parameter_t)

PATH
    -> geometric_or_dynamical_object

# ---------- ADMISSIBLE PATH ----------
ADMISSIBLE_PATH
    -> satisfies(
        START_CONDITION,
        END_CONDITION,
        REGULARITY,
        GEOMETRIC_CONSTRAINTS,
        DYNAMICAL_CONSTRAINTS
    )

ADMISSIBLE_CLASS
    := A

OPTIMAL_PATH
    -> selected_from(A)

# ---------- FUNCTIONAL ----------
J[gamma]
    -> scalar_cost_of(PATH)

general form:

J[gamma]
    :=
integral_from_a_to_b(
    F(
        t,
        gamma(t),
        gamma_dot(t)
    )
    dt
)

FUNCTIONAL
    -> evaluates(ENTIRE_PATH)

# ---------- OPTIMALITY ----------
gamma_star
    -> GLOBAL_MINIMISER

if

J[gamma_star]
    <=
J[gamma]

for_all
    gamma in A

gamma_star
    -> LOCAL_MINIMISER

if inequality holds
for all admissible gamma
in neighbourhood_of(gamma_star)

OPTIMAL_PATH
    -> may_be(LOCAL_OR_GLOBAL)

# ---------- VARIATION ----------
choose
    eta(t)
        -> admissible_path_variation

define

gamma_epsilon(t)
    :=
gamma(t)
+
epsilon*eta(t)

for fixed endpoints:

eta(a)
    = 0

eta(b)
    = 0

VARIATION
    -> nearby_candidate_path

# ---------- FIRST VARIATION ----------
delta_J[gamma;eta]
    :=
d/d_epsilon(
    J[gamma_epsilon]
)
at
    epsilon=0

INTERIOR_OPTIMAL_PATH
    -> satisfies(
        delta_J = 0
        for_all_admissible_eta
    )

FIRST_VARIATION
    -> stationarity_condition

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

J[gamma]
    =
integral(
    F(t,gamma,gamma_dot)
    dt
)

stationarity gives:

d/dt(
    partial_F/partial_gamma_dot
)
-
partial_F/partial_gamma
=
0

EULER_LAGRANGE_EQUATION
    -> necessary_condition_for(SMOOTH_EXTREMAL_PATH)

# ---------- MULTIDIMENSIONAL PATH ----------
gamma(t)
    :=
(
    q_1(t),
    ...,
    q_n(t)
)

for each i:

d/dt(
    partial_F/partial_q_dot_i
)
-
partial_F/partial_q_i
=
0

OPTIMAL_PATH
    -> system_of(COUPLED_VARIATIONAL_EQUATIONS)

# ---------- FIXED ENDPOINTS ----------
gamma(a)
    = A

gamma(b)
    = B

FIXED_ENDPOINTS
    -> eta(a)=eta(b)=0

BOUNDARY_TERMS
    -> vanish_in(FIRST_VARIATION)

# ---------- FREE ENDPOINT ----------
if endpoint
    -> FREE

then

endpoint_variation
    -> nonzero

BOUNDARY_TERM
    -> yields(NATURAL_BOUNDARY_CONDITION)

FREE_ENDPOINT
    -> requires(BOUNDARY_STATIONARITY)

# ---------- TRANSVERSALITY ----------
if endpoint
    -> constrained_to(MANIFOLD_OR_CURVE)

then

variation_of_endpoint
    -> restricted_to(TANGENT_DIRECTIONS)

TRANSVERSALITY_CONDITION
    -> determines(OPTIMAL_INTERSECTION_GEOMETRY)

# ---------- SHORTEST PATH ----------
in Euclidean space:

LENGTH[gamma]
    :=
integral_from_a_to_b(
    ||gamma_dot(t)||
    dt
)

SHORTEST_PATH
    -> minimiser_of(LENGTH_FUNCTIONAL)

between two points in Euclidean space:

STRAIGHT_LINE
    -> global_shortest_path

# ---------- RIEMANNIAN GEODESIC ----------
on manifold with metric
    g_ij

LENGTH
    :=
integral(
    sqrt(
        g_ij
        *
        q_dot^i
        *
        q_dot^j
    )
    dt
)

or energy:

E
    :=
1/2
*
integral(
    g_ij
    *
    q_dot^i
    *
    q_dot^j
    dt
)

GEODESIC
    -> stationary_path_of(LENGTH_OR_ENERGY)

# ---------- GEODESIC EQUATION ----------
Euler-Lagrange
    ->

q_double_dot^k
+
Gamma^k_ij
*
q_dot^i
*
q_dot^j
=
0

GEODESIC
    -> locally_extremal_path

LOCAL_GEODESIC
    -/> necessarily_global_shortest_path

# ---------- BRACHISTOCHRONE ----------
objective:

TRAVEL_TIME[y]
    -> minimise

under
    uniform_gravity
    and frictionless_motion

Euler-Lagrange_or_Beltrami
    -> CYCLOID

BRACHISTOCHRONE
    -> fastest_descent_path

FASTEST_PATH
    -/> same_as(SHORTEST_DISTANCE_PATH)

# ---------- FERMAT PRINCIPLE ----------
OPTICAL_PATH_LENGTH:

J[gamma]
    :=
integral(
    n(x)
    ds
)

n(x)
    -> REFRACTIVE_INDEX

LIGHT_PATH
    -> stationary_optical_path

FERMAT_PRINCIPLE
    -> variational_path_principle

# ---------- SNELL LAW ----------
piecewise_constant_refractive_index

FERMAT_PRINCIPLE
    -> transversality_at(interface)
    -> SNELL_LAW

n_1*sin(theta_1)
    =
n_2*sin(theta_2)

OPTIMAL_PATH
    -> may_change_direction_at(MATERIAL_INTERFACE)

# ---------- ACTION PATH ----------
ACTION:

S[q]
    :=
integral(
    L(q,q_dot,t)
    dt
)

PHYSICAL_TRAJECTORY
    -> STATIONARY_ACTION_PATH

ACTION_EXTREMAL
    -> obeys(EULER_LAGRANGE_EQUATIONS)

STATIONARY_ACTION
    -/> universally_minimum_action

# ---------- CONSTRAINED PATH ----------
constraint:

G(
    t,
    gamma,
    gamma_dot
)
=
0

introduce
    lambda(t)

AUGMENTED_INTEGRAND
    :=
F
+
lambda*G

CONSTRAINED_PATH
    -> Euler_Lagrange_on(AUGMENTED_FUNCTIONAL)

# ---------- OBSTACLES ----------
PATH
    -> must_avoid(OBSTACLE_REGION)

OBSTACLE_CONSTRAINT
    -> inequality_or_geometric_constraint

OPTIMAL_PATH
    -> may_have(CONTACT_SEGMENTS_OR_ACTIVE_CONSTRAINTS)

ACTIVE_SET
    -> determines(PATH_STRUCTURE)

# ---------- OPTIMAL CONTROL RELATION ----------
state:

x_dot
    =
f(x,u,t)

control:
    u(t)

cost:

J[u]
    =
Phi(x(T))
+
integral(
    L(x,u,t)
    dt
)

OPTIMAL_CONTROL
    -> chooses(CONTROL_AND_RESULTING_PATH)

PONTRYAGIN_MAXIMUM_PRINCIPLE
    -> necessary_condition_for(CONTROLLED_OPTIMAL_PATH)

# ---------- HAMILTONIAN IN OPTIMAL CONTROL ----------
control_Hamiltonian:

H(
    x,
    u,
    lambda,
    t
)
    :=
L(x,u,t)
+
lambda_dotproduct_f(x,u,t)

COSTATE
    -> lambda

OPTIMAL_PATH
    -> coupled_with(COSTATE_DYNAMICS)

# ---------- DYNAMIC PROGRAMMING ----------
VALUE_FUNCTION
    :=
minimum_remaining_cost_from(state,time)

HAMILTON_JACOBI_BELLMAN_EQUATION
    -> characterises(OPTIMAL_COST)

OPTIMAL_PATH
    -> recoverable_from(OPTIMAL_POLICY)

VARIATIONAL_CALCULUS
    -> connects_to(DYNAMIC_PROGRAMMING)

# ---------- SECOND VARIATION ----------
STATIONARY_PATH
    -> candidate_only

SECOND_VARIATION
    -> investigates(LOCAL_MINIMALITY)

CONJUGATE_POINTS
    -> may_destroy(MINIMALITY_OF_GEODESIC)

JACOBI_EQUATION
    -> analyses(VARIATIONS_AROUND_GEODESIC)

# ---------- EXISTENCE ----------
OPTIMAL_PATH_EXISTENCE
    -> may_require(
        COMPACTNESS,
        COERCIVITY,
        LOWER_SEMICONTINUITY,
        CLOSED_ADMISSIBLE_SET
    )

FORMAL_EULER_LAGRANGE_SOLUTION
    -/> guarantees(EXISTENCE_OF_GLOBAL_OPTIMUM)

# ---------- UNIQUENESS ----------
STRICT_CONVEXITY_OF_COST
    + CONVEX_ADMISSIBLE_CLASS
    -> may_imply(UNIQUE_OPTIMAL_PATH)

NONCONVEX_GEOMETRY
    -> may_produce(MULTIPLE_LOCAL_OPTIMAL_PATHS)

UNIQUENESS
    -> separate_from(EXISTENCE)

# ---------- NUMERICAL PATH OPTIMISATION ----------
continuous_path
    -> discretise_into(NODES_OR_BASIS_COEFFICIENTS)

functional
    -> finite_dimensional_cost

constraints
    -> discrete_constraints

optimisation_algorithm
    -> approximate(OPTIMAL_PATH)

NUMERICAL_PATH
    -> requires(CONVERGENCE_AND_DISCRETISATION_VALIDATION)

# ---------- APPLICATIONS ----------
OPTIMAL_PATH
    -> applied_to(GEODESICS)
    -> applied_to(OPTICS)
    -> applied_to(CLASSICAL_MECHANICS)
    -> applied_to(ROBOTICS)
    -> applied_to(TRAJECTORY_PLANNING)
    -> applied_to(OPTIMAL_CONTROL)
    -> applied_to(NAVIGATION)
    -> applied_to(PDE_AND_GEOMETRIC_OPTIMISATION)

# ---------- RELATION GRAPH ----------
PATH
    -> belongs_to(ADMISSIBLE_CLASS)

FUNCTIONAL
    -> assigns(COST_TO_PATH)

VARIATION
    -> generates(NEARBY_PATH)

FIRST_VARIATION
    -> yields(EULER_LAGRANGE_EQUATION)

BOUNDARY_VARIATION
    -> yields(TRANSVERSALITY)

GEODESIC
    -> stationary_path_of(GEOMETRIC_FUNCTIONAL)

ACTION
    -> selects(PHYSICAL_TRAJECTORY)

OPTIMAL_CONTROL
    -> generates(CONTROLLED_OPTIMAL_PATH)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "optimal path" ~= "admissible curve or trajectory minimising or extremising a path functional",
    "extremal path" ~= "path satisfying a first-order variational stationarity condition",
    "shortest path" ~= "path minimising geometric length",
    "geodesic" ~= "locally stationary path for a metric length or energy functional",
    "brachistochrone" ~= "path of fastest descent under specified physical assumptions",
    "transversality condition" ~= "boundary stationarity condition for movable or constrained endpoints"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    stationary_path_is_not_automatically_global_optimum: true,
    shortest_path_fastest_path_and_stationary_action_path_are_distinct_objectives: true,
    admissible_variations_must_preserve_constraints: true,
    endpoint_type_determines_boundary_conditions: true,
    geodesic_need_not_be_globally_length_minimising: true,
    existence_and_uniqueness_require_separate_analysis: true,
    numerical_path_optimisation_requires_discretisation_validation: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    functional_variation_relation: 0.99,
    Euler_Lagrange_relation: 0.99,
    geodesic_relation: 0.99,
    boundary_transversality_relation: 0.99,
    optimal_control_relation: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(path_space_and_endpoints)
    -> identify(cost_or_action_functional)
    -> identify(geometric_dynamical_and_obstacle_constraints)
    -> construct(admissible_variation)
    -> compute(first_variation)
    -> derive(Euler_Lagrange_or_control_conditions)
    -> derive(boundary_or_transversality_conditions_if_needed)
    -> classify(stationary_path)
    -> analyse(second_variation_existence_and_uniqueness)
    -> compare(shortest_fastest_action_or_control_objective)
    -> validate(numerical_discretisation_if_applicable)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed optimal-path semantic graph",
    primary_entity: OPTIMAL_PATH,
    preserve: [
        path,
        parameter_domain,
        start_condition,
        end_condition,
        functional,
        constraints,
        metric_or_dynamics,
        optimality_type
    ],
    infer_through: [
        path_variations,
        Euler_Lagrange_equations,
        geodesics,
        transversality,
        brachistochrone_problems,
        action_principles,
        optimal_control,
        second_variations
    ],
    avoid: [
        equating_stationary_with globally optimal,
        confusing_shortest_and fastest paths,
        ignoring_endpoint_conditions,
        varying_path_through obstacles_or constraints,
        assuming_every_geodesic_is global minimum,
        treating_discretised_path_as exact continuum optimum
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + OPTIMAL_PATH
    + PATH
    + FUNCTIONAL
    + VARIATION
    + EULER_LAGRANGE_EQUATION
    + TRANSVERSALITY
    + GEODESIC
    + BRACHISTOCHRONE
    + ACTION
    + OPTIMAL_CONTROL
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> OPTIMAL_PATH
    -> PATH_ENDPOINT_IDENTIFICATION
    -> FUNCTIONAL_IDENTIFICATION
    -> CONSTRAINT_ANALYSIS
    -> VARIATION_CONSTRUCTION
    -> FIRST_VARIATION_ANALYSIS
    -> OPTIMALITY_EQUATION_DERIVATION
    -> BOUNDARY_TRANSVERSALITY_ANALYSIS
    -> STATIONARY_PATH_CLASSIFICATION
    -> SECOND_VARIATION_EXISTENCE_ANALYSIS
    -> OBJECTIVE_TYPE_ANALYSIS
    -> NUMERICAL_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW