Mathematical Limit Ontology

flow "MathematicalLimitOntology" v1.0

# ============================================================
# MATHEMATICAL LIMIT ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
MATHEMATICAL_LIMIT := {
    type: MathematicalConcept,
    domain: Mathematics,
    purpose: "Describe the value or behaviour approached by a function, sequence or mathematical process as its input, index or controlling variable approaches a specified point or condition."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    LIMIT,
    FUNCTION_LIMIT,
    SEQUENCE_LIMIT,
    ONE_SIDED_LIMIT,
    FINITE_LIMIT,
    INFINITE_LIMIT,
    LIMIT_AT_INFINITY,
    CONVERGENCE,
    DIVERGENCE,
    CONTINUITY,
    DERIVATIVE,
    INTEGRAL,
    EPSILON,
    DELTA,
    NEIGHBOURHOOD
}

# ---------- GENERAL STRUCTURE ----------
LIMIT
    -> describes(APPROACH_BEHAVIOUR)
    -> may_apply_to(FUNCTION)
    -> may_apply_to(SEQUENCE)
    -> may_apply_to(SERIES_VIA_PARTIAL_SUMS)
    -> underpins(CALCULUS)
    -> underpins(MATHEMATICAL_ANALYSIS)

LIMIT
    -/> requires(FUNCTION_VALUE_AT_LIMIT_POINT)

LIMIT_VALUE
    -> determined_by(ARBITRARILY_NEAR_BEHAVIOUR)

# ---------- FUNCTION LIMIT ----------
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

FUNCTION_LIMIT
    -> relates(INPUT_APPROACH, OUTPUT_APPROACH)

x -> a
    -> f(x) -> L
       under(LIMIT_CONDITIONS)

# ---------- EPSILON-DELTA STRUCTURE ----------
EPSILON
    -> represents(POSITIVE_OUTPUT_TOLERANCE)

DELTA
    -> represents(POSITIVE_INPUT_TOLERANCE)

forall epsilon > 0
    -> exists delta > 0
       such_that(INPUT_CLOSENESS_IMPLIES_OUTPUT_CLOSENESS)

EPSILON_DELTA_DEFINITION
    -> provides(RIGOROUS_FUNCTION_LIMIT_DEFINITION)

# ---------- ONE-SIDED LIMITS ----------
LEFT_HAND_LIMIT
    := limit(f(x), x -> a_minus)

RIGHT_HAND_LIMIT
    := limit(f(x), x -> a_plus)

TWO_SIDED_LIMIT_EXISTS
    iff
    LEFT_HAND_LIMIT_EXISTS
    AND RIGHT_HAND_LIMIT_EXISTS
    AND LEFT_HAND_LIMIT = RIGHT_HAND_LIMIT

ONE_SIDED_LIMIT
    -> useful_at(DOMAIN_BOUNDARIES)
    -> useful_at(DISCONTINUITIES)

# ---------- SEQUENCE LIMIT ----------
SEQUENCE := {a_n}

limit(a_n, n -> infinity) = L

iff

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

SEQUENCE
    -> converges_to(L)
       iff(SEQUENCE_LIMIT_EQUALS_L)

NO_FINITE_LIMIT
    -> may_indicate(DIVERGENCE)

# ---------- LIMIT AT INFINITY ----------
limit(f(x), x -> infinity) = L
    -> describes(END_BEHAVIOUR)

limit(f(x), x -> negative_infinity) = L
    -> describes(NEGATIVE_END_BEHAVIOUR)

FINITE_LIMIT_AT_INFINITY
    -> may_define(HORIZONTAL_ASYMPTOTE)

# ---------- INFINITE LIMITS ----------
limit(f(x), x -> a) = infinity
    -> indicates(UNBOUNDED_POSITIVE_GROWTH_NEAR_a)

limit(f(x), x -> a) = negative_infinity
    -> indicates(UNBOUNDED_NEGATIVE_GROWTH_NEAR_a)

INFINITE_LIMIT
    -/> treats(INFINITY_AS_REAL_NUMBER)

VERTICAL_ASYMPTOTE
    -> may_be_associated_with(INFINITE_LIMIT_BEHAVIOUR)

# ---------- LIMIT LAWS ----------
if
    limit(f(x), x -> a) = L
    AND limit(g(x), x -> a) = M
then
    limit(f+g, x -> a) = L+M

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

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

    limit(f*g, x -> a) = L*M

if
    M != 0
then
    limit(f/g, x -> a) = L/M

LIMIT_LAWS
    -> support(COMPOSITIONAL_LIMIT_REASONING)

# ---------- UNIQUENESS ----------
if
    limit(f(x), x -> a) exists
then
    LIMIT_VALUE
    -> unique

LIMIT_UNIQUENESS
    -> prevents(MULTIPLE_DISTINCT_LIMIT_VALUES_FOR_SAME_LIMIT_CONTEXT)

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

LIMIT
    -> foundation_of(CONTINUITY)

DISCONTINUITY
    -> may_occur_when(LIMIT_DOES_NOT_EXIST)
    -> may_occur_when(FUNCTION_VALUE_DIFFERS_FROM_LIMIT)
    -> may_occur_when(FUNCTION_UNDEFINED_AT_POINT)

# ---------- DERIVATIVE ----------
DERIVATIVE(f, a)
    := limit(
        (f(a+h)-f(a))/h,
        h -> 0
    )

DERIVATIVE
    -> defined_by(LIMIT_OF_DIFFERENCE_QUOTIENT)

LIMIT
    -> converts(AVERAGE_CHANGE, INSTANTANEOUS_CHANGE)

# ---------- INTEGRAL ----------
DEFINITE_INTEGRAL
    -> may_be_defined_as(LIMIT_OF_RIEMANN_SUMS)

RIEMANN_SUM
    -> approximates(ACCUMULATION)

PARTITION_REFINEMENT
    -> drives(RIEMANN_SUM_TOWARD_INTEGRAL)
       when(INTEGRABILITY_CONDITIONS_HOLD)

LIMIT
    -> connects(FINITE_APPROXIMATION, CONTINUOUS_ACCUMULATION)

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

PARTIAL_SUM
    := sum(a_k, k=1..n)

SERIES_CONVERGES
    iff
    limit(PARTIAL_SUM, n -> infinity)
        exists_and_is_finite

SERIES_DIVERGES
    -> when(PARTIAL_SUM_SEQUENCE_FAILS_TO_CONVERGE)

# ---------- INDETERMINATE FORMS ----------
INDETERMINATE_FORM
    -> may_include(0/0)
    -> may_include(infinity/infinity)
    -> may_include(0*infinity)
    -> may_include(infinity-infinity)
    -> may_include(1^infinity)
    -> may_include(0^0)
    -> may_include(infinity^0)

INDETERMINATE_FORM
    -/> determines(LIMIT_VALUE_BY_FORM_ALONE)

LIMIT_EVALUATION
    -> requires(FURTHER_ANALYSIS)

# ---------- SQUEEZE PRINCIPLE ----------
if
    g(x) <= f(x) <= h(x)
    near(a)

AND
    limit(g(x), x -> a) = L
    AND limit(h(x), x -> a) = L
then
    limit(f(x), x -> a) = L

SQUEEZE_THEOREM
    -> derives(LIMIT_FROM_BOUNDING_FUNCTIONS)

# ---------- SEMANTIC RELATION GRAPH ----------
LIMIT
    -> describes(APPROACH)

FUNCTION_LIMIT
    -> maps(INPUT_APPROACH, OUTPUT_APPROACH)

SEQUENCE_LIMIT
    -> determines(CONVERGENCE)

LIMIT
    -> defines(CONTINUITY)

LIMIT
    -> defines(DERIVATIVE)

LIMIT
    -> defines_or_supports(INTEGRAL)

PARTIAL_SUM_LIMIT
    -> defines(SERIES_CONVERGENCE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "limit of a function" ~= "value approached by function outputs under specified input approach conditions",
    "sequence tends to L" ~= "sequence converges to L",
    "left-hand limit" ~= "limit approached from values below the target input",
    "right-hand limit" ~= "limit approached from values above the target input",
    "end behaviour" ~= "behaviour as the independent variable tends toward positive or negative infinity",
    "limiting value" ~= "limit when existence and context conditions are satisfied"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    function_value_need_not_equal_limit: true,
    function_need_not_be_defined_at_limit_point: true,
    two_sided_limit_requires_matching_one_sided_limits: true,
    finite_limit_is_unique: true,
    infinity_is_not_treated_as_real_number: true,
    indeterminate_form_does_not_determine_limit: true,
    limit_context_must_specify_approach: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_limit_definition: 0.99,
    epsilon_delta_structure: 0.99,
    sequence_limit_structure: 0.99,
    continuity_relation: 0.99,
    derivative_relation: 0.99,
    integral_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(limit_object)
    -> classify(function | sequence | series | other_process)
    -> identify(approach_variable)
    -> identify(target_point_or_infinity)
    -> determine(one_sided_or_two_sided_context)
    -> apply(limit_definition)
    -> apply(limit_laws_if_valid)
    -> test(existence)
    -> test(finiteness)
    -> evaluate(continuity_or_convergence_relations)
    -> validate(mathematical_consistency)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed mathematical limit graph",
    primary_entity: MATHEMATICAL_LIMIT,
    preserve: [
        quantifier_order,
        epsilon_delta_dependency,
        approach_direction,
        limit_context,
        implication_direction,
        convergence_conditions
    ],
    infer_through: [
        function_limits,
        sequence_limits,
        one_sided_limits,
        continuity,
        derivatives,
        integrals,
        series
    ],
    avoid: [
        substituting_function_value_for_limit_without justification,
        treating_infinity_as_an ordinary real value,
        assuming_matching_magnitude_means_matching_one_sided_limits,
        resolving_indeterminate_forms by notation alone,
        assuming_limit_exists_without checking approach conditions
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + FUNCTION_LIMIT
    + SEQUENCE_LIMIT
    + EPSILON_DELTA_DEFINITION
    + ONE_SIDED_LIMIT
    + LIMIT_LAWS
    + CONTINUITY
    + DERIVATIVE
    + DEFINITE_INTEGRAL
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> MATHEMATICAL_LIMIT
    -> LIMIT_OBJECT_IDENTIFICATION
    -> APPROACH_CONTEXT_ANALYSIS
    -> ONE_SIDED_TWO_SIDED_ANALYSIS
    -> LIMIT_EXISTENCE_ANALYSIS
    -> CONVERGENCE_ANALYSIS
    -> CONTINUITY_RELATION_ANALYSIS
    -> CALCULUS_RELATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW