Lagrangian Ontology

flow "LagrangianOntology" v1.0

# ============================================================
# LAGRANGIAN ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
LAGRANGIAN := {
    type: VariationalDynamicalFunction,
    domain: VariationalCalculus,
    purpose: "Represent the integrand of an action or variational functional whose stationary paths satisfy Euler-Lagrange equations."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    LAGRANGIAN,
    ACTION,
    ACTION_FUNCTIONAL,
    GENERALIZED_COORDINATE,
    GENERALIZED_VELOCITY,
    EULER_LAGRANGE_EQUATION,
    GENERALIZED_MOMENTUM,
    KINETIC_ENERGY,
    POTENTIAL_ENERGY,
    SYMMETRY,
    CONSERVED_QUANTITY,
    CYCLIC_COORDINATE,
    LEGENDRE_TRANSFORM,
    HAMILTONIAN,
    LAGRANGIAN_DENSITY
}

# ---------- MECHANICAL LAGRANGIAN ----------
L
    :=
L(
    q_i,
    q_dot_i,
    t
)

q_i
    -> GENERALIZED_COORDINATE

q_dot_i
    -> GENERALIZED_VELOCITY

LAGRANGIAN
    -> function_of(CONFIGURATION_VELOCITY_AND_TIME)

# ---------- ACTION ----------
ACTION
    :=
S[q]

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

LAGRANGIAN
    -> integrand_of(ACTION_FUNCTIONAL)

STATIONARY_ACTION
    -> determines(PHYSICAL_TRAJECTORY)

# ---------- STANDARD NATURAL SYSTEM ----------
for many conservative mechanical systems:

L
    =
T - V

T
    -> KINETIC_ENERGY

V
    -> POTENTIAL_ENERGY

LAGRANGIAN
    -> difference_between(KINETIC_AND_POTENTIAL_ENERGY)
       in(STANDARD_NATURAL_MECHANICAL_SYSTEM)

L
    -/> universally_equal_to(T_MINUS_V)

# ---------- VARIATION ----------
q_i
    -> q_i + epsilon*eta_i

with
    eta_i(t1)=eta_i(t2)=0
       for fixed endpoints

delta_S
    = 0

-> EULER_LAGRANGE_EQUATIONS

# ---------- EULER-LAGRANGE ----------
for each generalized coordinate:

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

LAGRANGIAN
    -> generates(EQUATIONS_OF_MOTION)

# ---------- GENERALIZED MOMENTUM ----------
p_i
    :=
partial_L
/
partial_q_dot_i

GENERALIZED_MOMENTUM
    -> conjugate_to(q_i)

EULER_LAGRANGE:

p_dot_i
    =
partial_L/partial_q_i

# ---------- CYCLIC COORDINATE ----------
if

partial_L/partial_q_i
    = 0

then

p_dot_i
    = 0

therefore

p_i
    -> CONSERVED

CYCLIC_COORDINATE
    -> coordinate_absent_explicitly_from(L)

# ---------- ENERGY FUNCTION ----------
define

E_L
    :=
sum_i(
    q_dot_i
    *
    partial_L/partial_q_dot_i
)
-
L

if

partial_L/partial_t
    = 0

then

dE_L/dt
    = 0

ENERGY_FUNCTION
    -> conserved_for(TIME_INDEPENDENT_LAGRANGIAN)

for standard natural systems:

E_L
    = T + V

# ---------- TOTAL DERIVATIVE EQUIVALENCE ----------
let

L_prime
    =
L
+
dF(q,t)/dt

then

ACTION
    -> changes_by(BOUNDARY_TERM)

for fixed endpoint variations:

L_prime
    and
L
    -> yield(SAME_EULER_LAGRANGE_EQUATIONS)

LAGRANGIAN
    -> not_unique

TOTAL_DERIVATIVE
    -> variational_equivalence_under(APPROPRIATE_BOUNDARY_CONTEXT)

# ---------- COORDINATE TRANSFORMATION ----------
q
    -> Q(q,t)

L
    -> transformed_under(COORDINATE_CHANGE)

EULER_LAGRANGE_FORM
    -> covariant_under(REGULAR_GENERALIZED_COORDINATE_TRANSFORMATIONS)

LAGRANGIAN_MECHANICS
    -> naturally_handles(GENERALIZED_COORDINATES)

# ---------- CONSTRAINTS ----------
HOLONOMIC_CONSTRAINT
    :=
f_a(q,t)
    = 0

constraints
    -> reduce(CONFIGURATION_SPACE)
       or
    -> introduced_with(LAGRANGE_MULTIPLIERS)

AUGMENTED_LAGRANGIAN
    :=
L
+
sum_a(
    lambda_a
    *
    f_a
)

VARIATION
    -> yields(EQUATIONS_PLUS_CONSTRAINTS)

# ---------- NONHOLONOMIC CAUTION ----------
NONHOLONOMIC_CONSTRAINT
    -> may_depend_on(VELOCITIES)

VARIATIONAL_TREATMENT
    -> depends_on(CONSTRAINT_INTERPRETATION)

LAGRANGE_DALEMBERT
    -/> identical_to(NAIVE_MULTIPLIER_VARIATION_IN_ALL_CASES)

CONSTRAINT_TYPE
    -> must_be_preserved

# ---------- LEGENDRE TRANSFORM ----------
p_i
    :=
partial_L/partial_q_dot_i

if
    velocity_momentum_map
        -> invertible

then

H(q,p,t)
    :=
sum_i(
    p_i*q_dot_i
)
-
L

LEGENDRE_TRANSFORM
    -> maps(LAGRANGIAN_TO_HAMILTONIAN)

# ---------- REGULAR LAGRANGIAN ----------
velocity Hessian:

W_ij
    :=
partial^2 L
/
partial_q_dot_i partial_q_dot_j

if
    det(W) != 0

then

L
    -> REGULAR_LAGRANGIAN

REGULARITY
    -> permits(LOCAL_LEGENDRE_INVERSION)

# ---------- SINGULAR LAGRANGIAN ----------
if
    det(W)=0

then

L
    -> SINGULAR

MOMENTA
    -> may_satisfy(CONSTRAINTS)

SINGULAR_LAGRANGIAN
    -> requires(DIRAC_BERGMANN_OR_EQUIVALENT_CONSTRAINT_ANALYSIS)

# ---------- FIELD LAGRANGIAN ----------
for fields
    phi_a(x)

LAGRANGIAN_DENSITY
    :=
mathcal_L(
    phi_a,
    partial_mu(phi_a),
    x
)

ACTION
    =
integral(
    mathcal_L
    d^n x
)

FIELD_THEORY
    -> uses(LAGRANGIAN_DENSITY)

# ---------- FIELD EULER-LAGRANGE ----------
for each field phi_a:

partial_mathcal_L/partial_phi_a
-
partial_mu(
    partial_mathcal_L
    /
    partial(partial_mu phi_a)
)
=
0

LAGRANGIAN_DENSITY
    -> generates(FIELD_EQUATIONS)

# ---------- SCALAR FIELD ----------
example:

mathcal_L
    =
1/2
*
partial_mu(phi)
*
partial^mu(phi)
-
V(phi)

Euler-Lagrange
    ->

BOX(phi)
+
dV/dphi
=
0

subject_to
    metric_and_sign_convention

# ---------- ELECTROMAGNETIC FIELD ----------
standard electromagnetic Lagrangian density:

mathcal_L
    =
-1/4
*
F_mu_nu
*
F^mu_nu
-
J_mu*A^mu

up_to
    unit_and_sign_conventions

variation_with_respect_to(A_mu)
    -> MAXWELL_EQUATIONS

GAUGE_FIELD
    -> LAGRANGIAN_HAS_GAUGE_SYMMETRY

# ---------- SYMMETRY ----------
TRANSFORMATION
    -> symmetry_of(LAGRANGIAN_OR_ACTION)

if
    action_invariant
       up_to_allowed_boundary_term

then

NOETHER_THEOREM
    -> CONSERVED_QUANTITY_OR_CURRENT

LAGRANGIAN
    -> exposes(SYMMETRY_STRUCTURE)

# ---------- NOETHER EXAMPLES ----------
TIME_TRANSLATION
    -> ENERGY_CONSERVATION

SPACE_TRANSLATION
    -> LINEAR_MOMENTUM_CONSERVATION

ROTATION
    -> ANGULAR_MOMENTUM_CONSERVATION

CONTINUOUS_SYMMETRY
    -> CONSERVATION_LAW

# ---------- EXAMPLE: FREE PARTICLE ----------
L
    =
1/2
*
m*q_dot^2

Euler-Lagrange:

d/dt(
    m*q_dot
)
=
0

therefore

m*q_dot
    -> conserved_momentum

# ---------- EXAMPLE: HARMONIC OSCILLATOR ----------
L
    =
1/2*m*q_dot^2
-
1/2*m*omega^2*q^2

Euler-Lagrange:

m*q_double_dot
+
m*omega^2*q
=
0

therefore

q_double_dot
+
omega^2*q
=
0

# ---------- GEODESIC LAGRANGIAN ----------
for metric
    g_ij(q)

L
    =
1/2
*
g_ij
*
q_dot^i
*
q_dot^j

Euler-Lagrange
    -> GEODESIC_EQUATION

LAGRANGIAN
    -> encodes(GEOMETRIC_MOTION)

# ---------- DISSIPATION CAUTION ----------
ordinary Lagrangian
    -> naturally_describes(CONSERVATIVE_VARIATIONAL_SYSTEMS)

DISSIPATIVE_SYSTEM
    -> may_require(
        RAYLEIGH_DISSIPATION_FUNCTION,
        EXTENDED_FORMALISM,
        EFFECTIVE_ACTION
    )

DISSIPATION
    -/> always_representable_by(STANDARD_TIME_LOCAL_LAGRANGIAN)

# ---------- RAYLEIGH DISSIPATION ----------
for suitable viscous forces:

R
    -> RAYLEIGH_DISSIPATION_FUNCTION

modified equations:

d/dt(
    partial_L/partial_q_dot_i
)
-
partial_L/partial_q_i
+
partial_R/partial_q_dot_i
=
0

R
    -> not_part_of(STANDARD_CONSERVATIVE_LAGRANGIAN)

# ---------- APPLICATIONS ----------
LAGRANGIAN
    -> applied_to(CLASSICAL_MECHANICS)
    -> applied_to(FIELD_THEORY)
    -> applied_to(GENERAL_RELATIVITY)
    -> applied_to(ELECTROMAGNETISM)
    -> applied_to(PARTICLE_PHYSICS)
    -> applied_to(OPTIMAL_CONTROL)
    -> applied_to(GEOMETRIC_MECHANICS)

# ---------- RELATION GRAPH ----------
GENERALIZED_COORDINATES
    + GENERALIZED_VELOCITIES
    -> inputs_to(LAGRANGIAN)

LAGRANGIAN
    -> integrated_to(ACTION)

ACTION_VARIATION
    -> yields(EULER_LAGRANGE_EQUATIONS)

LAGRANGIAN
    -> differentiates_to(GENERALIZED_MOMENTA)

LEGENDRE_TRANSFORM
    -> maps(LAGRANGIAN_TO_HAMILTONIAN)

SYMMETRY
    -> yields(CONSERVED_QUANTITY)

LAGRANGIAN_DENSITY
    -> generates(FIELD_EQUATIONS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "Lagrangian" ~= "function whose action integral generates Euler-Lagrange equations",
    "mechanical Lagrangian" ~= "dynamical function of generalized coordinates, velocities and time",
    "Lagrangian density" ~= "field-theoretic action integrand per spacetime volume",
    "generalized momentum" ~= "partial derivative of the Lagrangian with respect to generalized velocity",
    "cyclic coordinate" ~= "coordinate absent explicitly from the Lagrangian",
    "equivalent Lagrangians" ~= "Lagrangians differing by an appropriate total derivative and yielding the same equations of motion"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    Lagrangian_is_not_universally_T_minus_V: true,
    Lagrangian_is_not_unique: true,
    total_derivative_equivalence_depends_on_boundary_context: true,
    Legendre_transform_requires_regular_or_constraint_aware_treatment: true,
    nonholonomic_constraints_require_correct_variational_interpretation: true,
    field_Lagrangian_sign_and_metric_conventions_must_be_preserved: true,
    stationary_action_does_not_imply_minimum_action: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    action_relation: 0.99,
    Euler_Lagrange_relation: 0.99,
    momentum_Hamiltonian_relation: 0.99,
    field_theory_relation: 0.99,
    symmetry_Noether_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(system_coordinates_velocities_or_fields)
    -> identify(candidate_Lagrangian_or_density)
    -> identify(action_domain_and_boundary_conditions)
    -> compute(Euler_Lagrange_equations)
    -> compute(generalized_momenta)
    -> identify(cyclic_coordinates_and_symmetries)
    -> derive(conserved_quantities_if_Noether_conditions_hold)
    -> test(Lagrangian_regularity)
    -> perform(Legendre_transform_if_valid)
    -> analyse(constraints_or_dissipation_if_present)
    -> validate(sign_metric_boundary_and_unit_conventions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed Lagrangian semantic graph",
    primary_entity: LAGRANGIAN,
    preserve: [
        coordinates,
        velocities,
        fields,
        time,
        Lagrangian,
        action,
        boundary_conditions,
        constraints,
        sign_conventions
    ],
    infer_through: [
        Euler_Lagrange_equations,
        generalized_momenta,
        cyclic_coordinates,
        conserved_quantities,
        Legendre_transforms,
        Hamiltonians,
        field_equations,
        Noether_symmetries
    ],
    avoid: [
        assuming_every_Lagrangian_is T_minus_V,
        treating_Lagrangian_as unique,
        ignoring_total_derivative_equivalence,
        performing_naive_Legendre_transform_on singular Lagrangian,
        treating_nonholonomic_constraints_as ordinary holonomic constraints,
        ignoring_metric_sign conventions_in field theory
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + LAGRANGIAN
    + ACTION
    + EULER_LAGRANGE_EQUATION
    + GENERALIZED_MOMENTUM
    + CYCLIC_COORDINATE
    + LEGENDRE_TRANSFORM
    + HAMILTONIAN
    + LAGRANGIAN_DENSITY
    + SYMMETRY
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> LAGRANGIAN
    -> SYSTEM_VARIABLE_IDENTIFICATION
    -> LAGRANGIAN_DENSITY_IDENTIFICATION
    -> ACTION_BOUNDARY_ANALYSIS
    -> EULER_LAGRANGE_DERIVATION
    -> MOMENTUM_ANALYSIS
    -> SYMMETRY_CONSERVATION_ANALYSIS
    -> REGULARITY_ANALYSIS
    -> LEGENDRE_TRANSFORM_ANALYSIS
    -> CONSTRAINT_DISSIPATION_ANALYSIS
    -> CONVENTION_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW