Conservative Field Ontology

flow "ConservativeFieldOntology" v1.0

# ============================================================
# CONSERVATIVE FIELD ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/vector-calculus/conservative-field-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Vector Calculus"
ENTITY := "Conservative Field"

# ---------- CORE ENTITY ----------
CONSERVATIVE_FIELD := {
    type: VectorFieldProperty,
    domain: VectorCalculus,
    purpose: "Represent a vector field that is the gradient of a scalar potential, giving path-independent line integrals under the relevant domain conditions."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    CONSERVATIVE_FIELD,
    VECTOR_FIELD,
    SCALAR_POTENTIAL,
    GRADIENT,
    LINE_INTEGRAL,
    PATH_INDEPENDENCE,
    CLOSED_CURVE,
    CURL,
    IRROTATIONAL_FIELD,
    SIMPLY_CONNECTED_DOMAIN,
    FUNDAMENTAL_THEOREM_FOR_LINE_INTEGRALS,
    POTENTIAL_ENERGY
}

# ---------- CORE DEFINITION ----------
VECTOR_FIELD
    := F: D -> R^n

F
    -> CONSERVATIVE
       iff
       exists(SCALAR_POTENTIAL phi)
       such_that
       F = GRADIENT(phi)

SCALAR_POTENTIAL
    -> generates(CONSERVATIVE_FIELD)

# ---------- POTENTIAL FUNCTION ----------
if
    F = GRADIENT(phi)
then

phi
    -> POTENTIAL_FUNCTION_FOR(F)

POTENTIAL_FUNCTION
    -> unique_up_to(ADDITIVE_CONSTANT)
       on(CONNECTED_DOMAIN)

if
    phi and psi
        both potentials_for(F)
then

phi - psi
    = CONSTANT
       on(each_connected_component)

# ---------- PATH INDEPENDENCE ----------
if
    F conservative
    AND C runs_from(A,to=B)
then

integral_C(
    F dot dr
)
    = phi(B) - phi(A)

LINE_INTEGRAL
    -> depends_only_on(ENDPOINTS)

CONSERVATIVE_FIELD
    -> implies(PATH_INDEPENDENCE)

# ---------- FUNDAMENTAL THEOREM ----------
FUNDAMENTAL_THEOREM_FOR_LINE_INTEGRALS:

if
    F = GRADIENT(phi)
then

integral_C(
    F dot dr
)
    = phi(B) - phi(A)

FUNDAMENTAL_THEOREM_FOR_LINE_INTEGRALS
    -> connects(GRADIENT_FIELD, POTENTIAL_DIFFERENCE)

# ---------- CLOSED CURVES ----------
if
    F conservative
then

integral_closed_C(
    F dot dr
)
    = 0

ZERO_CLOSED_LOOP_INTEGRAL
    -> consequence_of(PATH_INDEPENDENCE)

# ---------- EQUIVALENCE UNDER DOMAIN CONDITIONS ----------
on
    open_connected_domain
    with suitable regularity:

F conservative
    -> line_integrals_path_independent
    -> closed_curve_integrals_zero

conversely

PATH_INDEPENDENCE
    -> supports(EXISTENCE_OF_POTENTIAL)

ZERO_CLOSED_CURVE_INTEGRALS
    -> supports(CONSERVATIVITY)
       under(APPROPRIATE_DOMAIN_CONDITIONS)

# ---------- CURL RELATION ----------
if
    F = GRADIENT(phi)
    AND phi sufficiently_smooth
then

CURL(F)
    = ZERO_VECTOR

CONSERVATIVE_FIELD
    -> IRROTATIONAL

IRROTATIONAL_FIELD
    := CURL(F) = 0

# ---------- CURL-FREE CONVERSE ----------
if
    CURL(F) = 0
    AND domain_is_simply_connected
    AND required_smoothness_holds
then

F
    -> CONSERVATIVE

CURL_ZERO
    -/> sufficient_without(DOMAIN_TOPOLOGY_CONDITIONS)

# ---------- SIMPLY CONNECTED DOMAIN ----------
SIMPLY_CONNECTED_DOMAIN
    -> contains(NO_TOPOLOGICAL_HOLES_RELEVANT_TO_LOOP_CONTRACTION)

SIMPLY_CONNECTEDNESS
    -> supports(
        CURL_FREE => CONSERVATIVE
    )

DOMAIN_TOPOLOGY
    -> essential_to(GLOBAL_CONSERVATIVITY)

# ---------- TWO-DIMENSIONAL TEST ----------
for
    F = (P(x,y), Q(x,y))

if
    partial_P/partial_y
    = partial_Q/partial_x

and
    domain_is_appropriate_simply_connected_region
    and
    partials_are_continuous
then

F
    -> CONSERVATIVE

CROSS_PARTIAL_EQUALITY
    -> planar_curl_zero_condition

# ---------- THREE-DIMENSIONAL TEST ----------
for
    F = (P,Q,R)

CURL(F)
    = ZERO_VECTOR

plus
    appropriate_domain_conditions

-> supports(CONSERVATIVITY)

# ---------- FINDING POTENTIAL ----------
given
    F = (P,Q,R)

seek
    phi

such_that

partial_phi/partial_x = P
partial_phi/partial_y = Q
partial_phi/partial_z = R

POTENTIAL_RECOVERY:
    integrate(P with_respect_to x)
    -> add(unknown_function_of_remaining_variables)
    -> compare_with(Q)
    -> compare_with(R)
    -> solve(remaining_functions)
    -> verify(GRADIENT(phi)=F)

# ---------- WORK ----------
if
    F
        := force_field
    AND F conservative
then

WORK_FROM_A_TO_B
    = integral_C(F dot dr)
    = phi(B) - phi(A)

WORK
    -> independent_of(PATH)

# ---------- POTENTIAL ENERGY ----------
in mechanics often:

F
    = -GRADIENT(U)

U
    -> POTENTIAL_ENERGY

WORK_BY_CONSERVATIVE_FORCE
    = U(A) - U(B)

SIGN_CONVENTION
    -> distinguishes(SCALAR_POTENTIAL, POTENTIAL_ENERGY)

# ---------- ENERGY CONSERVATION ----------
CONSERVATIVE_FORCE
    -> supports(MECHANICAL_ENERGY_CONSERVATION)
       under(APPROPRIATE_CLOSED_SYSTEM_ASSUMPTIONS)

KINETIC_ENERGY
    + POTENTIAL_ENERGY
    -> constant
       when(ONLY_CONSERVATIVE_FORCES_DO_WORK)

# ---------- ELECTROSTATICS ----------
ELECTROSTATIC_FIELD
    = -GRADIENT(ELECTRIC_POTENTIAL)

in electrostatic regime:

CURL(E)
    = ZERO_VECTOR

ELECTRIC_POTENTIAL_DIFFERENCE
    -> determines(WORK_PER_UNIT_CHARGE)

# ---------- GRAVITATION ----------
GRAVITATIONAL_FIELD
    = -GRADIENT(GRAVITATIONAL_POTENTIAL)

GRAVITATIONAL_FIELD
    -> conservative
       under(standard_static_newtonian_context)

# ---------- NON-CONSERVATIVE FIELD ----------
NON_CONSERVATIVE_FIELD
    -> may_have(PATH_DEPENDENT_LINE_INTEGRAL)

CLOSED_LOOP_INTEGRAL
    -> may_be(NONZERO)

NONZERO_CIRCULATION_AROUND_CLOSED_LOOP
    -> proves(NOT_CONSERVATIVE_ON_DOMAIN_CONTAINING_LOOP)

# ---------- RELATION GRAPH ----------
SCALAR_POTENTIAL
    -> gradient_generates(CONSERVATIVE_FIELD)

CONSERVATIVE_FIELD
    -> implies(PATH_INDEPENDENCE)

PATH_INDEPENDENCE
    -> implies(ZERO_CLOSED_LOOP_INTEGRALS)

CONSERVATIVE_FIELD
    -> implies(CURL_ZERO)
       under(SMOOTHNESS)

CURL_ZERO
    + SIMPLY_CONNECTED_DOMAIN
    -> supports(CONSERVATIVE_FIELD)

LINE_INTEGRAL
    -> evaluated_by(POTENTIAL_ENDPOINT_DIFFERENCE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "conservative field" ~= "vector field admitting a scalar potential",
    "gradient field" ~= "conservative field in standard terminology",
    "path-independent field" ~= "field whose line integral depends only on endpoints",
    "irrotational field" ~= "curl-free vector field",
    "potential function" ~= "scalar function whose gradient gives the field",
    "closed-loop integral zero" ~= "characteristic of conservative fields under the relevant domain conditions"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    conservative_field_requires_scalar_potential: true,
    potential_is_unique_up_to_constant_on_connected_component: true,
    conservative_implies_path_independent: true,
    conservative_implies_curl_free_under_smoothness: true,
    curl_free_does_not_guarantee_conservative_without_domain_conditions: true,
    nonzero_closed_loop_integral_proves_nonconservative_on_that_domain: true,
    potential_energy_may_use_negative_gradient_sign_convention: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    potential_relation: 0.99,
    path_independence_relation: 0.99,
    closed_curve_relation: 0.99,
    curl_relation: 0.99,
    domain_topology_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(vector_field)
    -> determine(domain)
    -> inspect(domain_topology)
    -> verify(required_differentiability)
    -> compute(curl_if_relevant)
    -> test(path_independence_or_closed_loop_conditions_if_available)
    -> attempt(potential_recovery)
    -> verify(gradient_of_potential_equals_field)
    -> evaluate(line_integral_by_endpoints_if_conservative)
    -> preserve(sign_convention_for_physical_potential)
    -> validate(global_domain_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed conservative-field semantic graph",
    primary_entity: CONSERVATIVE_FIELD,
    preserve: [
        vector_field,
        domain,
        topology,
        potential_function,
        path_endpoints,
        curl_status,
        sign_convention
    ],
    infer_through: [
        gradients,
        line_integrals,
        path_independence,
        closed_curves,
        curl,
        simply_connected_domains,
        potential_energy
    ],
    avoid: [
        declaring_field_conservative_from_curl_zero_without domain conditions,
        ignoring_domain_holes,
        confusing_scalar_potential_sign_with potential_energy convention,
        assuming_path_independence for arbitrary vector fields,
        omitting_additive_constant_in potential recovery
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + CONSERVATIVE_FIELD
    + SCALAR_POTENTIAL
    + PATH_INDEPENDENCE
    + CLOSED_CURVE
    + CURL
    + SIMPLY_CONNECTED_DOMAIN
    + FUNDAMENTAL_THEOREM_FOR_LINE_INTEGRALS
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> CONSERVATIVE_FIELD
    -> VECTOR_FIELD_IDENTIFICATION
    -> DOMAIN_IDENTIFICATION
    -> TOPOLOGY_ANALYSIS
    -> DIFFERENTIABILITY_ANALYSIS
    -> CURL_ANALYSIS
    -> PATH_INDEPENDENCE_ANALYSIS
    -> POTENTIAL_RECOVERY
    -> POTENTIAL_VERIFICATION
    -> LINE_INTEGRAL_EVALUATION
    -> PHYSICAL_SIGN_CONVENTION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW