Calculus Ontology

flow "CalculusOntology" v1.0

# ============================================================
# CALCULUS ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/foundations-of-calculus/calculus-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Foundations of Calculus"
ENTITY := "Calculus"

# ---------- CORE ENTITY ----------
CALCULUS := {
    type: MathematicalDiscipline,
    domain: Mathematics,
    purpose: "Formal analysis of change, rates of change, accumulation, limits and continuous variation."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    FUNCTION,
    VARIABLE,
    LIMIT,
    CONTINUITY,
    DERIVATIVE,
    DIFFERENTIATION,
    INTEGRAL,
    INTEGRATION,
    SEQUENCE,
    SERIES,
    RATE_OF_CHANGE,
    ACCUMULATION,
    INFINITESIMAL_CHANGE
}

# ---------- FOUNDATIONAL STRUCTURE ----------
CALCULUS
    -> depends_on(ALGEBRA)
    -> depends_on(GEOMETRY)
    -> depends_on(REAL_NUMBER_SYSTEM)
    -> uses(FUNCTIONS)
    -> formalised_by(LIMITS)

CALCULUS
    -> contains(DIFFERENTIAL_CALCULUS)
    -> contains(INTEGRAL_CALCULUS)
    -> extends_to(MULTIVARIABLE_CALCULUS)
    -> extends_to(VECTOR_CALCULUS)
    -> supports(MATHEMATICAL_ANALYSIS)

# ---------- FUNCTIONS ----------
FUNCTION
    -> maps(INPUT, OUTPUT)
    -> represents(DEPENDENT_RELATIONSHIP)
    -> may_be(CONTINUOUS)
    -> may_be(DIFFERENTIABLE)
    -> may_be(INTEGRABLE)

VARIABLE
    -> represents(CHANGING_QUANTITY)

INDEPENDENT_VARIABLE
    -> determines(INPUT)

DEPENDENT_VARIABLE
    -> determined_by(FUNCTION)

# ---------- LIMITS ----------
LIMIT
    -> describes(BEHAVIOUR_AS_VARIABLE_APPROACHES_VALUE)
    -> foundation_of(CONTINUITY)
    -> foundation_of(DERIVATIVE)
    -> foundation_of(INTEGRAL)
    -> foundation_of(CONVERGENCE)

limit(f(x), x -> a) = L

iff

forall epsilon > 0
    exists delta > 0
        such_that
        0 < abs(x-a) < delta
        -> abs(f(x)-L) < epsilon

# ---------- CONTINUITY ----------
continuous(f, a)
    iff
    defined(f(a))
    AND limit(f(x), x -> a) exists
    AND limit(f(x), x -> a) = f(a)

CONTINUITY
    -> describes(UNBROKEN_LOCAL_BEHAVIOUR)
    -> supports(INTERMEDIATE_VALUE_PROPERTIES)
    -> relevant_to(DIFFERENTIABILITY)
    -> relevant_to(INTEGRABILITY)

DIFFERENTIABLE_AT(f, a)
    -> implies(CONTINUOUS_AT(f, a))

CONTINUOUS_AT(f, a)
    -/> necessarily_implies(DIFFERENTIABLE_AT(f, a))

# ---------- DIFFERENTIAL CALCULUS ----------
DERIVATIVE(f, x)
    := limit(
        (f(x+h)-f(x))/h,
        h -> 0
    )

DERIVATIVE
    -> measures(INSTANTANEOUS_RATE_OF_CHANGE)
    -> represents(TANGENT_SLOPE)
    -> describes(LOCAL_BEHAVIOUR)

DIFFERENTIATION
    -> transforms(FUNCTION, DERIVATIVE_FUNCTION)
    -> supports(OPTIMISATION)
    -> supports(MOTION_ANALYSIS)
    -> supports(SENSITIVITY_ANALYSIS)
    -> supports(APPROXIMATION)

SECOND_DERIVATIVE
    -> measures(CHANGE_IN_RATE_OF_CHANGE)
    -> supports(CONCAVITY_ANALYSIS)
    -> supports(ACCELERATION_ANALYSIS)

# ---------- INTEGRAL CALCULUS ----------
RIEMANN_SUM
    := sum(
        f(x_i_star) * delta_x_i,
        i = 1..n
    )

DEFINITE_INTEGRAL
    := limit(RIEMANN_SUM, max(delta_x_i) -> 0)

INTEGRAL
    -> measures(ACCUMULATION)
    -> represents(SIGNED_AREA)
    -> aggregates(LOCAL_CONTRIBUTIONS)

INDEFINITE_INTEGRAL
    -> represents(FAMILY_OF_ANTIDERIVATIVES)

INTEGRATION
    -> transforms(RATE_INFORMATION, ACCUMULATED_QUANTITY)

# ---------- FUNDAMENTAL THEOREM ----------
FUNDAMENTAL_THEOREM_OF_CALCULUS
    -> connects(DIFFERENTIATION, INTEGRATION)

if
    F(x) := integral(f(t), t=a..x)
then
    derivative(F(x)) = f(x)

and

integral(f(x), x=a..b)
    = F(b) - F(a)

where
    derivative(F) = f

# ---------- SEQUENCES AND SERIES ----------
SEQUENCE
    -> consists_of(ORDERED_TERMS)
    -> may_have(LIMIT)

converges(a_n, L)
    iff
    forall epsilon > 0
        exists N
            such_that
            n >= N
            -> abs(a_n-L) < epsilon

SERIES
    := sum(a_n, n=1..infinity)

SERIES
    -> evaluated_through(PARTIAL_SUMS)
    -> may_be(CONVERGENT)
    -> may_be(DIVERGENT)

# ---------- CHANGE AND ACCUMULATION ----------
CHANGE
    -> quantified_locally_by(DERIVATIVE)

ACCUMULATION
    -> quantified_globally_by(INTEGRAL)

AVERAGE_RATE_OF_CHANGE
    := (f(b)-f(a))/(b-a)

INSTANTANEOUS_RATE_OF_CHANGE
    := limit(
        AVERAGE_RATE_OF_CHANGE,
        interval_width -> 0
    )

# ---------- CALCULUS RELATION GRAPH ----------
LIMIT
    -> defines(DERIVATIVE)

LIMIT
    -> defines(DEFINITE_INTEGRAL)

LIMIT
    -> determines(CONTINUITY)

DERIVATIVE
    -> models(LOCAL_CHANGE)

INTEGRAL
    -> models(TOTAL_ACCUMULATION)

DERIVATIVE
    <-> linked_by(FUNDAMENTAL_THEOREM_OF_CALCULUS)
    <-> INTEGRAL

CALCULUS
    -> applied_to(PHYSICS)
    -> applied_to(ENGINEERING)
    -> applied_to(ECONOMICS)
    -> applied_to(BIOLOGY)
    -> applied_to(COMPUTER_SCIENCE)
    -> applied_to(STATISTICS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "instantaneous rate of change" ~= "derivative",
    "tangent slope" ~= "derivative at a point",
    "accumulated quantity" ~= "integral under appropriate conditions",
    "antiderivative" ~= "indefinite integral component",
    "area under a curve" ~= "definite integral when interpreted with signed area",
    "approaching a value" ~= "limit process"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    derivative_requires_limit_exist: true,
    differentiability_implies_continuity: true,
    continuity_does_not_always_imply_differentiability: true,
    infinite_series_not_assumed_convergent: true,
    infinity_not_treated_as_real_number: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    calculus_classification: 0.99,
    limit_relations: 0.99,
    derivative_relations: 0.99,
    integral_relations: 0.99,
    theorem_relations: 0.99,
    semantic_equivalence: 0.96
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(query.entity)
    -> classify(query.entity)
    -> resolve(calculus_branch)
    -> traverse(dependencies)
    -> select(relevant_definition)
    -> evaluate(domain_conditions)
    -> apply(limit_reasoning)
    -> apply(differential_or_integral_reasoning)
    -> validate(mathematical_consistency)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed mathematical semantic graph",
    primary_entity: CALCULUS,
    preserve: [
        formal_definitions,
        dependency_edges,
        implication_direction,
        theorem_relations,
        convergence_conditions
    ],
    infer_through: [
        limits,
        continuity,
        derivatives,
        integrals,
        sequences,
        series
    ],
    avoid: [
        reversing_one_way_implications,
        confusing_average_and_instantaneous_change,
        assuming_continuity_implies_differentiability,
        assuming_every_integral_has_an_elementary_antiderivative,
        assuming_every_infinite_series_converges
    ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
    validate(new_information)
    -> compare_with(CALCULUS)
    -> preserve(mathematical_invariants)
    -> update(affected_entities)
    -> update(affected_relations)
    -> recompute(CONFIDENCE)
    -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + LIMIT
    + CONTINUITY
    + DERIVATIVE
    + INTEGRAL
    + FUNDAMENTAL_THEOREM_OF_CALCULUS
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> CALCULUS
    -> CONCEPT_IDENTIFICATION
    -> LIMIT_ANALYSIS
    -> CONTINUITY_ANALYSIS
    -> DIFFERENTIAL_ANALYSIS
    -> INTEGRAL_ANALYSIS
    -> CONVERGENCE_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW