Discontinuity Ontology

flow "DiscontinuityOntology" v1.0

# ============================================================
# DISCONTINUITY ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
DISCONTINUITY := {
    type: MathematicalProperty,
    domain: Mathematics,
    purpose: "Represent failure of a function to satisfy continuity conditions at a point, boundary, interval or within a specified mathematical domain."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    DISCONTINUITY,
    CONTINUITY,
    FUNCTION,
    LIMIT,
    FUNCTION_VALUE,
    LEFT_HAND_LIMIT,
    RIGHT_HAND_LIMIT,
    REMOVABLE_DISCONTINUITY,
    JUMP_DISCONTINUITY,
    INFINITE_DISCONTINUITY,
    OSCILLATORY_DISCONTINUITY,
    DOMAIN,
    ASYMPTOTE
}

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

DISCONTINUOUS_AT(f, a)
    iff
    NOT continuous(f, a)
    relative_to(RELEVANT_DOMAIN)

DISCONTINUITY
    -> failure_of(ONE_OR_MORE_CONTINUITY_CONDITIONS)

# ---------- FAILURE MODES ----------
DISCONTINUITY_AT_POINT
    -> may_result_from(FUNCTION_UNDEFINED)
    -> may_result_from(LIMIT_DOES_NOT_EXIST)
    -> may_result_from(LIMIT_NOT_EQUAL_TO_FUNCTION_VALUE)
    -> may_result_from(UNBOUNDED_BEHAVIOUR)
    -> may_result_from(OSCILLATORY_BEHAVIOUR)

# ---------- REMOVABLE DISCONTINUITY ----------
REMOVABLE_DISCONTINUITY_AT(f, a)

requires
    limit(f(x), x -> a) = L
    AND (
        f(a) undefined
        OR f(a) != L
    )

REMOVABLE_DISCONTINUITY
    -> can_be_repaired_by(DEFINING_OR_REDEFINING_f(a)=L)

REMOVABLE_DISCONTINUITY
    -> often_visualised_as(HOLE_IN_GRAPH)

# ---------- JUMP DISCONTINUITY ----------
JUMP_DISCONTINUITY_AT(f, a)

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

    LEFT_HAND_LIMIT exists_finitely
    AND RIGHT_HAND_LIMIT exists_finitely
    AND LEFT_HAND_LIMIT != RIGHT_HAND_LIMIT

JUMP_DISCONTINUITY
    -> causes(TWO_SIDED_LIMIT_NOT_TO_EXIST)

# ---------- INFINITE DISCONTINUITY ----------
INFINITE_DISCONTINUITY_AT(f, a)
    -> occurs_when(FUNCTION_BECOMES_UNBOUNDED_NEAR_a)

limit(f(x), x -> a_side)
    = positive_or_negative_infinity

INFINITE_DISCONTINUITY
    -> may_be_associated_with(VERTICAL_ASYMPTOTE)

INFINITY
    -/> treated_as(FINITE_REAL_LIMIT_VALUE)

# ---------- OSCILLATORY DISCONTINUITY ----------
OSCILLATORY_DISCONTINUITY
    -> occurs_when(FUNCTION_FAILS_TO_APPROACH_SINGLE_LIMIT)
       because_of(PERSISTENT_OSCILLATION)

example_pattern:
    sin(1/x)
    as x -> 0

OSCILLATORY_BEHAVIOUR
    -> may_prevent(LIMIT_EXISTENCE)

# ---------- ONE-SIDED ANALYSIS ----------
LEFT_HAND_LIMIT
    -> analyses(APPROACH_FROM_BELOW)

RIGHT_HAND_LIMIT
    -> analyses(APPROACH_FROM_ABOVE)

if
    LEFT_HAND_LIMIT != RIGHT_HAND_LIMIT
then
    TWO_SIDED_LIMIT
        -> does_not_exist

ONE_SIDED_ANALYSIS
    -> essential_for(JUMP_DISCONTINUITY)
    -> useful_for(BOUNDARY_BEHAVIOUR)

# ---------- DOMAIN RELATIVITY ----------
CONTINUITY
    -> evaluated_relative_to(DOMAIN)

DISCONTINUITY
    -> must_be_interpreted_relative_to(DOMAIN)

DOMAIN_BOUNDARY
    -> may_require(ONE_SIDED_CONTINUITY)

FUNCTION_UNDEFINED_OUTSIDE_DOMAIN
    -/> automatically_implies(DISCONTINUITY_AT_BOUNDARY)

# ---------- PIECEWISE FUNCTIONS ----------
PIECEWISE_FUNCTION
    -> may_have(DISCONTINUITIES_AT_PIECE_BOUNDARIES)

PIECEWISE_BOUNDARY_ANALYSIS:
    compute(LEFT_HAND_LIMIT)
    -> compute(RIGHT_HAND_LIMIT)
    -> compare(LIMITS)
    -> compare_with(FUNCTION_VALUE)
    -> classify(CONTINUITY_OR_DISCONTINUITY)

# ---------- RATIONAL FUNCTIONS ----------
RATIONAL_FUNCTION
    := P(x) / Q(x)

Q(a) = 0
    -> potential(DISCONTINUITY_AT_a)

if
    common_factor_cancels
    AND reduced_function_has_finite_limit_at(a)
then
    original_function
        -> may_have(REMOVABLE_DISCONTINUITY)

if
    denominator_tends_to_zero
    AND function_is_unbounded
then
    -> may_have(INFINITE_DISCONTINUITY)

# ---------- DIFFERENTIABILITY RELATION ----------
DIFFERENTIABLE_AT(f, a)
    -> implies(CONTINUOUS_AT(f, a))

DISCONTINUOUS_AT(f, a)
    -> implies(NOT_DIFFERENTIABLE_AT(f, a))

NOT_DIFFERENTIABLE_AT(f, a)
    -/> necessarily_implies(DISCONTINUOUS_AT(f, a))

# ---------- INTEGRABILITY RELATION ----------
DISCONTINUITY
    -/> automatically_implies(NONINTEGRABILITY)

BOUNDED_FUNCTION_WITH_FINITELY_MANY_DISCONTINUITIES
    -> may_remain(RIEMANN_INTEGRABLE)
       under(appropriate_conditions)

INTEGRABILITY
    -> requires(SEPARATE_ANALYSIS)

# ---------- LIMIT RELATION ----------
LIMIT
    -> primary_tool_for(CLASSIFYING_DISCONTINUITY)

if
    limit(f(x), x -> a) exists
    AND limit != f(a)
then
    -> REMOVABLE_DISCONTINUITY_CANDIDATE

if
    one_sided_limits_exist
    AND differ
then
    -> JUMP_DISCONTINUITY

if
    function_unbounded_near(a)
then
    -> INFINITE_DISCONTINUITY_CANDIDATE

if
    no_single_limit_due_to_oscillation
then
    -> OSCILLATORY_DISCONTINUITY_CANDIDATE

# ---------- RELATION GRAPH ----------
CONTINUITY
    <-> contrasted_with(DISCONTINUITY)

LIMIT_FAILURE
    -> may_cause(DISCONTINUITY)

FUNCTION_VALUE_MISMATCH
    -> may_cause(REMOVABLE_DISCONTINUITY)

UNEQUAL_ONE_SIDED_LIMITS
    -> cause(JUMP_DISCONTINUITY)

UNBOUNDED_LOCAL_BEHAVIOUR
    -> may_cause(INFINITE_DISCONTINUITY)

PERSISTENT_OSCILLATION
    -> may_cause(OSCILLATORY_DISCONTINUITY)

DISCONTINUITY
    -> prevents(DIFFERENTIABILITY_AT_SAME_POINT)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "removable discontinuity" ~= "discontinuity repairable by assigning the limiting value at the point",
    "hole discontinuity" ~= "informal graphical description often corresponding to removable discontinuity",
    "jump discontinuity" ~= "finite unequal left-hand and right-hand limits",
    "infinite discontinuity" ~= "unbounded local behaviour associated with an infinite one-sided or two-sided limit context",
    "oscillatory discontinuity" ~= "failure to approach one value because oscillation persists",
    "break in a graph" ~= "informal visual description, not a complete formal definition"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    discontinuity_is_domain_relative: true,
    undefined_function_value_does_not_alone_classify_discontinuity_type: true,
    unequal_one_sided_limits_imply_no_two_sided_limit: true,
    discontinuity_implies_non_differentiability_at_same_point: true,
    non_differentiability_does_not_imply_discontinuity: true,
    discontinuity_does_not_automatically_imply_nonintegrability: true,
    infinity_is_not_a_finite_real_limit: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    removable_classification: 0.99,
    jump_classification: 0.99,
    infinite_classification: 0.98,
    oscillatory_classification: 0.98,
    calculus_relations: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function)
    -> determine(domain)
    -> identify(target_point)
    -> evaluate(function_value)
    -> compute_or_reason_about(left_hand_limit)
    -> compute_or_reason_about(right_hand_limit)
    -> determine(two_sided_limit)
    -> test(boundedness)
    -> test(oscillatory_behaviour)
    -> classify(discontinuity_type)
    -> analyse(differentiability_and_integrability_relations)
    -> validate(mathematical_consistency)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed mathematical discontinuity graph",
    primary_entity: DISCONTINUITY,
    preserve: [
        domain_context,
        one_sided_limit_direction,
        classification_conditions,
        implication_direction,
        boundedness_status,
        function_value_status
    ],
    infer_through: [
        limits,
        continuity,
        piecewise_functions,
        rational_functions,
        differentiability,
        integrability
    ],
    avoid: [
        classifying_every_undefined_point_as_removable,
        treating_infinity_as_a_finite_limit,
        assuming_non_differentiability_means_discontinuity,
        assuming_discontinuity_prevents_integration,
        ignoring_domain_boundaries
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + DISCONTINUITY
    + REMOVABLE_DISCONTINUITY
    + JUMP_DISCONTINUITY
    + INFINITE_DISCONTINUITY
    + OSCILLATORY_DISCONTINUITY
    + LEFT_HAND_LIMIT
    + RIGHT_HAND_LIMIT
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> DISCONTINUITY
    -> DOMAIN_IDENTIFICATION
    -> POINT_IDENTIFICATION
    -> FUNCTION_VALUE_ANALYSIS
    -> ONE_SIDED_LIMIT_ANALYSIS
    -> TWO_SIDED_LIMIT_ANALYSIS
    -> BOUNDEDNESS_ANALYSIS
    -> DISCONTINUITY_CLASSIFICATION
    -> CALCULUS_RELATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW