Triple Integral Ontology

flow "TripleIntegralOntology" v1.0

# ============================================================
# TRIPLE INTEGRAL ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/integral-calculus/triple-integral-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Integral Calculus"
ENTITY := "Triple Integral"

# ---------- CORE ENTITY ----------
TRIPLE_INTEGRAL := {
    type: MultipleIntegral,
    domain: MultivariableCalculus,
    purpose: "Represent accumulation of a three-variable function over a three-dimensional region."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    TRIPLE_INTEGRAL,
    THREE_VARIABLE_FUNCTION,
    REGION_OF_INTEGRATION,
    ITERATED_INTEGRAL,
    VOLUME_ELEMENT,
    FUBINI_THEOREM,
    TONELLI_THEOREM,
    ORDER_OF_INTEGRATION,
    CHANGE_OF_VARIABLES,
    JACOBIAN_DETERMINANT,
    CYLINDRICAL_COORDINATES,
    SPHERICAL_COORDINATES,
    VOLUME_DENSITY
}

# ---------- BASIC STRUCTURE ----------
TRIPLE_INTEGRAL
    := integral_integral_integral_V(
        f(x,y,z) dV
    )

f(x,y,z)
    -> INTEGRAND

V
    -> THREE_DIMENSIONAL_REGION

dV
    -> VOLUME_ELEMENT

TRIPLE_INTEGRAL
    -> accumulates(FUNCTION_VALUES_OVER_VOLUME)

# ---------- RIEMANN-SUM INTERPRETATION ----------
REGION_V
    -> partitioned_into(SMALL_SUBVOLUMES)

DELTA_V_i
    -> volume_of(SUBVOLUME_i)

SAMPLE_POINT_i
    -> selected_in(SUBVOLUME_i)

TRIPLE_RIEMANN_SUM
    := sum(
        f(SAMPLE_POINT_i) * DELTA_V_i
    )

TRIPLE_INTEGRAL
    := limit(TRIPLE_RIEMANN_SUM)
       under(REGION_REFINEMENT)
       when(INTEGRABLE)

# ---------- RECTANGULAR BOX ----------
BOX
    := [a,b] x [c,d] x [e,f]

TRIPLE_INTEGRAL_OVER_BOX
    = integral_from_a_to_b(
        integral_from_c_to_d(
            integral_from_e_to_f(
                F(x,y,z) dz
            ) dy
        ) dx
      )

under(FUBINI_CONDITIONS)

BOX_REGION
    -> permits(CONSTANT_BOUNDS)

# ---------- GENERAL ITERATED FORM ----------
TRIPLE_INTEGRAL
    -> may_be_written_as(ITERATED_INTEGRAL)

example_order:
    dz dy dx

INNER_INTEGRAL
    -> evaluated_first

MIDDLE_INTEGRAL
    -> evaluated_second

OUTER_INTEGRAL
    -> evaluated_last

ORDER_OF_INTEGRATION
    -> determines(BOUND_DEPENDENCIES)

# ---------- REGION DESCRIPTION ----------
GENERAL_REGION
    -> may_be_described_by(NESTED_BOUNDS)

example:

a <= x <= b

g1(x) <= y <= g2(x)

h1(x,y) <= z <= h2(x,y)

then

TRIPLE_INTEGRAL
    = integral_from_a_to_b(
        integral_from_g1(x)_to_g2(x)(
            integral_from_h1(x,y)_to_h2(x,y)(
                f(x,y,z) dz
            ) dy
        ) dx
      )

# ---------- FUBINI THEOREM ----------
if
    f integrable_over(V)
    under(FUBINI_CONDITIONS)
then

TRIPLE_INTEGRAL
    -> equals(APPROPRIATE_ITERATED_INTEGRALS)

ORDER_OF_INTEGRATION
    -> may_be_changed
       when(REGION_AND_THEOREM_CONDITIONS_HOLD)

FUBINI_THEOREM
    -> connects(TRIPLE_INTEGRAL, ITERATED_INTEGRATION)

# ---------- TONELLI THEOREM ----------
if
    f >= 0
    AND measurable
then

TONELLI_THEOREM
    -> permits(ITERATED_INTEGRATION)
       possibly_with(INFINITE_VALUE)

TONELLI_THEOREM
    -> supports(ORDER_INTERCHANGE_FOR_NONNEGATIVE_FUNCTIONS)

# ---------- CHANGE OF ORDER ----------
CHANGE_ORDER:
    identify(THREE_DIMENSIONAL_REGION)
    -> determine(PROJECTION_FOR_NEW_OUTER_VARIABLES)
    -> reconstruct(NESTED_BOUNDS)
    -> rewrite(ITERATED_INTEGRAL)

CHANGING_ORDER
    -/> merely_permute(dx,dy,dz)

BOUNDS
    -> must_match(REGION_GEOMETRY)

# ---------- VOLUME ----------
if
    f(x,y,z) = 1
then

triple_integral_V(1 dV)
    = VOLUME(V)

TRIPLE_INTEGRAL
    -> generalises(VOLUME_MEASUREMENT)

# ---------- MASS ----------
if
    rho(x,y,z)
        := VOLUME_DENSITY
then

MASS
    = triple_integral_V(
        rho(x,y,z) dV
      )

TRIPLE_INTEGRAL
    -> converts(VOLUME_DENSITY, TOTAL_MASS)

# ---------- CENTRE OF MASS ----------
M
    := triple_integral_V(rho dV)

x_bar
    := 1/M
       * triple_integral_V(
           x*rho dV
         )

y_bar
    := 1/M
       * triple_integral_V(
           y*rho dV
         )

z_bar
    := 1/M
       * triple_integral_V(
           z*rho dV
         )

CENTRE_OF_MASS
    -> computed_from(WEIGHTED_TRIPLE_INTEGRALS)

# ---------- AVERAGE VALUE ----------
AVERAGE_VALUE
    := 1/VOLUME(V)
       * triple_integral_V(
           f(x,y,z) dV
         )

AVERAGE_VALUE
    -> normalised(THREE_DIMENSIONAL_ACCUMULATION)

# ---------- CHANGE OF VARIABLES ----------
TRANSFORMATION
    := T(u,v,w)
       = (x(u,v,w), y(u,v,w), z(u,v,w))

JACOBIAN_DETERMINANT
    := det(
        partial(x,y,z) /
        partial(u,v,w)
    )

dV
    = abs(JACOBIAN_DETERMINANT)
      du dv dw

CHANGE_OF_VARIABLES
    -> transforms(REGION_AND_INTEGRAND)
    -> requires(JACOBIAN_VOLUME_SCALE_FACTOR)

# ---------- CYLINDRICAL COORDINATES ----------
x
    = r*cos(theta)

y
    = r*sin(theta)

z
    = z

JACOBIAN_DETERMINANT
    = r

dV
    = r dr dtheta dz

CYLINDRICAL_COORDINATES
    -> useful_for(AXIAL_OR_CYLINDRICAL_SYMMETRY)

# ---------- SPHERICAL COORDINATES ----------
under common convention:

x
    = rho*sin(phi)*cos(theta)

y
    = rho*sin(phi)*sin(theta)

z
    = rho*cos(phi)

JACOBIAN_DETERMINANT
    = rho^2*sin(phi)

dV
    = rho^2*sin(phi)
      d_rho d_phi d_theta

SPHERICAL_COORDINATES
    -> useful_for(SPHERICAL_OR_RADIAL_SYMMETRY)

COORDINATE_CONVENTION
    -> must_be_specified

# ---------- PROBABILITY ----------
if
    p(x,y,z)
        := JOINT_PROBABILITY_DENSITY
then

P((X,Y,Z) in V)
    = triple_integral_V(
        p(x,y,z) dV
      )

NORMALISATION
    -> triple_integral_over_support(p dV) = 1

# ---------- MOMENTS ----------
MOMENT_OF_INERTIA
    -> may_be_computed_by(TRIPLE_INTEGRAL)

example_about_z_axis:

I_z
    = triple_integral_V(
        (x^2 + y^2) * rho(x,y,z) dV
      )

TRIPLE_INTEGRAL
    -> supports(MECHANICAL_MOMENT_CALCULATIONS)

# ---------- IMPROPER TRIPLE INTEGRAL ----------
TRIPLE_INTEGRAL
    -> may_be(IMPROPER)

IMPROPER_CASE
    -> may_involve(UNBOUNDED_REGION)
    -> may_involve(UNBOUNDED_INTEGRAND)

CONVERGENCE
    -> requires(LIMIT_OR_MEASURE_THEORETIC_ANALYSIS)

# ---------- APPLICATIONS ----------
TRIPLE_INTEGRAL
    -> applied_to(VOLUME)
    -> applied_to(MASS)
    -> applied_to(CENTRE_OF_MASS)
    -> applied_to(MOMENTS_OF_INERTIA)
    -> applied_to(PROBABILITY)
    -> applied_to(EXPECTED_VALUE)
    -> applied_to(THREE_DIMENSIONAL_FIELDS)

# ---------- RELATION GRAPH ----------
THREE_VARIABLE_FUNCTION
    -> integrated_by(TRIPLE_INTEGRAL)

REGION_OF_INTEGRATION
    -> determines(BOUNDS)

FUBINI_THEOREM
    -> enables(ITERATED_INTEGRATION)

ORDER_CHANGE
    -> requires(REGION_REDESCRIPTION)

CHANGE_OF_VARIABLES
    -> uses(JACOBIAN_DETERMINANT)

CYLINDRICAL_COORDINATES
    -> introduce(VOLUME_FACTOR_r)

SPHERICAL_COORDINATES
    -> introduce(VOLUME_FACTOR_rho_squared_sin_phi)

VOLUME_DENSITY
    -> integrated_to(MASS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "triple integral" ~= "three-dimensional accumulation of a three-variable function",
    "iterated triple integral" ~= "successive single-variable integrations representing a triple integral under suitable conditions",
    "region of integration" ~= "three-dimensional domain over which the triple integral is taken",
    "dV" ~= "volume element",
    "cylindrical volume element" ~= "r dr dtheta dz under standard cylindrical coordinates",
    "spherical volume element" ~= "rho squared sin(phi) d rho d phi d theta under the stated convention",
    "triple integral of one" ~= "volume of the integration region"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    triple_integral_requires_three_dimensional_region: true,
    integration_variables_are_bound: true,
    order_change_requires_bound_reconstruction: true,
    fubini_interchange_requires_appropriate_conditions: true,
    cylindrical_coordinates_require_factor_r: true,
    spherical_coordinates_require_correct_jacobian_factor: true,
    general_coordinate_change_requires_absolute_jacobian_determinant: true,
    improper_triple_integrals_require_convergence_analysis: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    iterated_integral_relation: 0.99,
    region_bound_structure: 0.99,
    fubini_tonelli_relations: 0.99,
    change_of_variables_relation: 0.99,
    cylindrical_spherical_relations: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(three_variable_integrand)
    -> identify(region_of_integration)
    -> classify(region_geometry)
    -> select(order_of_integration)
    -> derive(nested_bounds)
    -> test(fubini_or_tonelli_conditions_if_relevant)
    -> select(cartesian_or_transformed_coordinates)
    -> include(jacobian_factor_if_transformed)
    -> evaluate(inner_integral)
    -> evaluate(middle_integral)
    -> evaluate(outer_integral)
    -> validate(region_and_convergence_conditions)
    -> interpret(volume_mass_probability_or_field_context)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed triple-integral semantic graph",
    primary_entity: TRIPLE_INTEGRAL,
    preserve: [
        integrand,
        three_dimensional_region,
        integration_order,
        nested_bounds,
        coordinate_system,
        jacobian_factor,
        convergence_conditions
    ],
    infer_through: [
        iterated_integrals,
        fubini_theorem,
        tonelli_theorem,
        order_changes,
        cylindrical_coordinates,
        spherical_coordinates,
        coordinate_transformations,
        density_integrals
    ],
    avoid: [
        permuting_integration_order_without rebuilding bounds,
        omitting_cylindrical_factor_r,
        omitting_spherical_jacobian_factor,
        omitting_absolute_jacobian_in_general_change_of_variables,
        assuming_fubini_conditions_without verification,
        ignoring_improper_integral_convergence
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + TRIPLE_INTEGRAL
    + TRIPLE_RIEMANN_SUM
    + FUBINI_THEOREM
    + TONELLI_THEOREM
    + CHANGE_OF_VARIABLES
    + CYLINDRICAL_COORDINATES
    + SPHERICAL_COORDINATES
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> TRIPLE_INTEGRAL
    -> INTEGRAND_IDENTIFICATION
    -> REGION_IDENTIFICATION
    -> REGION_GEOMETRY_CLASSIFICATION
    -> ORDER_SELECTION
    -> NESTED_BOUND_CONSTRUCTION
    -> FUBINI_TONELLI_ANALYSIS
    -> COORDINATE_SYSTEM_ANALYSIS
    -> JACOBIAN_ANALYSIS
    -> ITERATED_INTEGRATION
    -> CONVERGENCE_ANALYSIS
    -> APPLICATION_INTERPRETATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW