Vector Field Ontology

flow "VectorFieldOntology" v1.0

# ============================================================
# VECTOR FIELD ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
VECTOR_FIELD := {
    type: MathematicalField,
    domain: VectorCalculus,
    purpose: "Assign a vector to each point in a domain, representing spatially or parametrically varying magnitude and direction."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    VECTOR_FIELD,
    DOMAIN,
    VECTOR,
    COMPONENT_FUNCTION,
    SCALAR_FIELD,
    DIVERGENCE,
    CURL,
    GRADIENT_FIELD,
    CONSERVATIVE_FIELD,
    SOLENOIDAL_FIELD,
    LINE_INTEGRAL,
    FLUX,
    FLOW_LINE,
    JACOBIAN
}

# ---------- BASIC STRUCTURE ----------
VECTOR_FIELD
    := F: D -> R^m

where
    D subset_of(R^n)

F(x)
    := (
        F1(x),
        F2(x),
        ...,
        Fm(x)
    )

F_i
    -> COMPONENT_FUNCTION

VECTOR_FIELD
    -> assigns(VECTOR_VALUE_TO_EACH_DOMAIN_POINT)

# ---------- COMMON SPATIAL FORM ----------
in R^3:

F(x,y,z)
    := (
        P(x,y,z),
        Q(x,y,z),
        R(x,y,z)
    )

P,Q,R
    -> SCALAR_COMPONENT_FIELDS

VECTOR_FIELD
    -> may_represent(
        VELOCITY,
        FORCE,
        ELECTRIC_FIELD,
        MAGNETIC_FIELD,
        FLUID_FLOW
    )

# ---------- MAGNITUDE ----------
FIELD_MAGNITUDE
    := norm(F(x))

FIELD_MAGNITUDE
    -> SCALAR_FIELD

DIRECTION
    := F(x)/norm(F(x))
       when(F(x) != ZERO_VECTOR)

# ---------- VISUAL REPRESENTATION ----------
VECTOR_FIELD
    -> may_be_visualised_by(ARROWS_AT_SAMPLE_POINTS)

ARROW_DIRECTION
    -> represents(VECTOR_DIRECTION)

ARROW_LENGTH_OR_COLOUR
    -> may_represent(VECTOR_MAGNITUDE)

VISUAL_SAMPLING
    -/> equivalent_to(CONTINUOUS_FIELD_DEFINITION)

# ---------- JACOBIAN ----------
JACOBIAN(F)
    := matrix(
        partial_F_i/partial_x_j
    )

JACOBIAN
    -> encodes(FIRST_ORDER_LOCAL_CHANGE_OF_VECTOR_FIELD)

VECTOR_FIELD
    -> differentiable_when(TOTAL_DERIVATIVE_EXISTS)

# ---------- DIVERGENCE ----------
for
    F = (P,Q,R)

DIVERGENCE(F)
    := partial_P/partial_x
      + partial_Q/partial_y
      + partial_R/partial_z

DIVERGENCE
    -> SCALAR_FIELD

DIVERGENCE
    -> measures(LOCAL_NET_OUTFLOW_DENSITY)
       in(STANDARD_EUCLIDEAN_INTERPRETATION)

# ---------- CURL ----------
for
    F = (P,Q,R)

CURL(F)
    := (
        partial_R/partial_y - partial_Q/partial_z,
        partial_P/partial_z - partial_R/partial_x,
        partial_Q/partial_x - partial_P/partial_y
    )

CURL
    -> VECTOR_FIELD
       in(STANDARD_R3_CONTEXT)

CURL
    -> measures(LOCAL_ROTATIONAL_TENDENCY)

# ---------- GRADIENT FIELD ----------
if
    phi
        := SCALAR_FIELD
then

GRADIENT(phi)
    -> VECTOR_FIELD

if
    F = GRADIENT(phi)
then

F
    -> GRADIENT_FIELD
    -> CONSERVATIVE_FIELD
       under(standard terminology)

phi
    -> POTENTIAL_FUNCTION

# ---------- CONSERVATIVE FIELD ----------
CONSERVATIVE_FIELD
    -> admits(POTENTIAL_FUNCTION)

if
    F conservative
then

LINE_INTEGRAL
    -> path_independent
       on(APPROPRIATE_DOMAIN)

and

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

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

CURL(F)
    = ZERO_VECTOR

CURL_FREE
    -/> necessarily_implies(GLOBAL_CONSERVATIVE_FIELD)
       without(DOMAIN_TOPOLOGY_CONDITIONS)

# ---------- SOLENOIDAL FIELD ----------
SOLENOIDAL_FIELD
    := vector_field_with(
        DIVERGENCE(F) = 0
    )

SOLENOIDAL
    -> locally_source_free
       in(STANDARD_FLUX_INTERPRETATION)

DIVERGENCE_FREE
    ~= SOLENOIDAL

# ---------- LINE INTEGRAL ----------
LINE_INTEGRAL
    := integral_C(
        F dot dr
    )

LINE_INTEGRAL
    -> accumulates(TANGENTIAL_COMPONENT_ALONG_CURVE)

WORK
    -> may_be_computed_by(LINE_INTEGRAL_OF_FORCE_FIELD)

# ---------- FLUX ----------
FLUX_THROUGH_SURFACE
    := surface_integral_S(
        F dot n_hat dS
    )

FLUX
    -> accumulates(NORMAL_COMPONENT_THROUGH_SURFACE)

SURFACE_ORIENTATION
    -> determines(FLUX_SIGN)

# ---------- FLOW LINES ----------
FLOW_LINE
    := curve r(t)
       satisfying

r_prime(t)
    = F(r(t))

FLOW_LINE
    -> tangent_to(VECTOR_FIELD)

STREAMLINE
    -> flow_line_in(FLUID_VELOCITY_FIELD_CONTEXT)

# ---------- EQUILIBRIUM ----------
EQUILIBRIUM_POINT
    := point x_star
       where
       F(x_star) = ZERO_VECTOR

DYNAMICAL_SYSTEM
    := x_prime = F(x)

JACOBIAN_AT_EQUILIBRIUM
    -> supports(LOCAL_STABILITY_ANALYSIS)
       under(APPROPRIATE_CONDITIONS)

# ---------- VECTOR POTENTIAL ----------
if
    F
        -> DIVERGENCE_FREE
       on(appropriate_domain)
then

F
    -> may_admit(VECTOR_POTENTIAL_A)

such_that

F
    = CURL(A)

VECTOR_POTENTIAL_EXISTENCE
    -> depends_on(DOMAIN_AND_REGULARITY_CONDITIONS)

# ---------- INTEGRAL THEOREMS ----------
DIVERGENCE_THEOREM
    -> relates(VECTOR_FIELD_FLUX, DIVERGENCE_VOLUME_INTEGRAL)

STOKES_THEOREM
    -> relates(VECTOR_FIELD_CIRCULATION, CURL_SURFACE_INTEGRAL)

GREEN_THEOREM
    -> planar_special_relation_for(VECTOR_FIELD_COMPONENTS)

VECTOR_FIELD
    -> central_object_of(VECTOR_CALCULUS_INTEGRAL_THEOREMS)

# ---------- COORDINATE SYSTEMS ----------
VECTOR_FIELD
    -> may_be_expressed_in(CARTESIAN_COORDINATES)
    -> may_be_expressed_in(CYLINDRICAL_COORDINATES)
    -> may_be_expressed_in(SPHERICAL_COORDINATES)

COMPONENTS
    -> depend_on(COORDINATE_BASIS)

GEOMETRIC_VECTOR_FIELD
    -> independent_of(COORDINATE_REPRESENTATION)

# ---------- APPLICATIONS ----------
VECTOR_FIELD
    -> applied_to(FLUID_DYNAMICS)
    -> applied_to(ELECTROMAGNETISM)
    -> applied_to(GRAVITATION)
    -> applied_to(MECHANICS)
    -> applied_to(DYNAMICAL_SYSTEMS)
    -> applied_to(CONTINUUM_PHYSICS)

# ---------- RELATION GRAPH ----------
DOMAIN_POINT
    -> mapped_to(VECTOR)

COMPONENT_FUNCTIONS
    -> compose(VECTOR_FIELD)

JACOBIAN
    -> differentiates(VECTOR_FIELD)

DIVERGENCE
    -> extracts(LOCAL_OUTFLOW)

CURL
    -> extracts(LOCAL_ROTATION)

POTENTIAL_FUNCTION
    -> generates(CONSERVATIVE_VECTOR_FIELD)

VECTOR_FIELD
    -> integrated_along(CURVE)

VECTOR_FIELD
    -> integrated_through(SURFACE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "vector field" ~= "function assigning a vector to each point in a domain",
    "vector-valued field" ~= "vector field",
    "conservative field" ~= "vector field admitting a scalar potential under the relevant domain",
    "solenoidal field" ~= "divergence-free vector field",
    "streamline" ~= "curve tangent to a fluid velocity field",
    "field magnitude" ~= "norm of the vector assigned at a point"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    vector_field_requires_domain_and_vector_codomain: true,
    component_functions_depend_on_coordinate_representation: true,
    divergence_and_curl_require_relevant_differentiability: true,
    curl_free_does_not_guarantee_global_conservativity_without_domain_conditions: true,
    flux_requires_surface_orientation: true,
    vector_potential_existence_requires_domain_and_regularity_conditions: true,
    sampled_arrow_plot_is_not_the_field_itself: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    component_structure: 0.99,
    divergence_relation: 0.99,
    curl_relation: 0.99,
    conservative_field_relation: 0.99,
    integral_relations: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(vector_field)
    -> determine(domain_and_codomain)
    -> identify(coordinate_system)
    -> extract(component_functions)
    -> compute(jacobian_if_required)
    -> compute(divergence_or_curl_if_requested)
    -> test(conservative_or_solenoidal_properties_if_relevant)
    -> construct(line_or_surface_integral_if_required)
    -> analyse(flow_lines_or_equilibria_if_relevant)
    -> verify(domain_orientation_and_regularity_conditions)
    -> interpret(geometric_or_physical_meaning)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed vector-field semantic graph",
    primary_entity: VECTOR_FIELD,
    preserve: [
        domain,
        codomain,
        coordinate_system,
        component_functions,
        orientation,
        differentiability,
        topology_conditions
    ],
    infer_through: [
        jacobians,
        divergence,
        curl,
        potentials,
        line_integrals,
        surface_flux,
        flow_lines,
        integral_theorems
    ],
    avoid: [
        confusing_vector_field_with_single_vector,
        assuming_components_are coordinate invariant,
        assuming_curl_free means globally conservative,
        ignoring_surface_orientation_for_flux,
        asserting_vector_potential_without domain conditions,
        treating_visual_samples_as complete field
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + VECTOR_FIELD
    + JACOBIAN
    + DIVERGENCE
    + CURL
    + CONSERVATIVE_FIELD
    + SOLENOIDAL_FIELD
    + LINE_INTEGRAL
    + FLUX_THROUGH_SURFACE
    + FLOW_LINE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> VECTOR_FIELD
    -> DOMAIN_CODOMAIN_IDENTIFICATION
    -> COORDINATE_SYSTEM_ANALYSIS
    -> COMPONENT_ANALYSIS
    -> DIFFERENTIAL_OPERATOR_ANALYSIS
    -> FIELD_PROPERTY_ANALYSIS
    -> LINE_SURFACE_INTEGRAL_ANALYSIS
    -> FLOW_ANALYSIS
    -> DOMAIN_ORIENTATION_VALIDATION
    -> GEOMETRIC_PHYSICAL_INTERPRETATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW