Divergence Ontology

flow "DivergenceRealAnalysisOntology" v1.0

# ============================================================
# DIVERGENCE ONTOLOGY — REAL ANALYSIS — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/real-analysis/divergence-ontology-2.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Real Analysis"
ENTITY := "Divergence"

# ---------- CORE ENTITY ----------
DIVERGENCE := {
    type: NonConvergenceProperty,
    domain: RealAnalysis,
    purpose: "Represent the failure of a sequence, series, function sequence or iterative process to converge to a finite limiting object under a specified notion of convergence."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    DIVERGENCE,
    CONVERGENCE,
    LIMIT,
    SEQUENCE,
    SERIES,
    PARTIAL_SUM,
    UNBOUNDEDNESS,
    OSCILLATION,
    INFINITE_LIMIT,
    SUBSEQUENCE,
    ACCUMULATION_POINT,
    POINTWISE_DIVERGENCE,
    UNIFORM_DIVERGENCE,
    NUMERICAL_DIVERGENCE,
    DIVERGENCE_TEST
}

# ---------- BASIC DEFINITION ----------
OBJECT
    -> DIVERGES

iff

OBJECT
    -/> converges_under(SPECIFIED_CONVERGENCE_MODE)

DIVERGENCE
    -> negation_of(CONVERGENCE_PROPERTY)
       relative_to(SPACE_AND_MODE)

# ---------- REAL SEQUENCE DIVERGENCE ----------
for
    sequence (a_n) in R

a_n
    -> DIVERGENT

if

there_does_not_exist
    L in R

such_that

a_n -> L

SEQUENCE_DIVERGENCE
    -> no_finite_real_limit

# ---------- UNBOUNDED DIVERGENCE ----------
if
    for_every M > 0
    exists n
    such_that

abs(a_n) > M

then

sequence
    -> UNBOUNDED

UNBOUNDED_SEQUENCE
    -> DIVERGENT_AS(FINITE_REAL_SEQUENCE)

UNBOUNDEDNESS
    -> sufficient_for(NO_FINITE_LIMIT)

# ---------- POSITIVE INFINITY ----------
a_n
    -> +infinity

iff

for_every M in R
exists N
such_that

n >= N
    -> a_n > M

TENDS_TO_POSITIVE_INFINITY
    -> divergent_in(FINITE_REAL_LIMIT_SENSE)

INFINITE_LIMIT
    -> extended_real_limit_concept

# ---------- NEGATIVE INFINITY ----------
a_n
    -> -infinity

iff

for_every M in R
exists N
such_that

n >= N
    -> a_n < M

TENDS_TO_NEGATIVE_INFINITY
    -> no_finite_real_limit

# ---------- OSCILLATORY DIVERGENCE ----------
example:

a_n
    = (-1)^n

SUBSEQUENCE_even
    -> 1

SUBSEQUENCE_odd
    -> -1

distinct_subsequential_limits
    -> prove(DIVERGENCE)

OSCILLATION
    -> may_occur_while(BOUNDED)

# ---------- SUBSEQUENCE CRITERION ----------
if
    sequence has_two_subsequences

a_(n_k) -> L

and

a_(m_k) -> M

with
    L != M

then

original_sequence
    -> DIVERGENT

CONVERGENT_SEQUENCE
    -> all_subsequences_have(SAME_LIMIT)

# ---------- CAUCHY FAILURE ----------
in complete metric space:

if
    sequence_not_Cauchy
then

sequence
    -> DIVERGENT

CONVERGENT_SEQUENCE
    -> CAUCHY

NOT_CAUCHY
    -> sufficient_for(DIVERGENCE)

CAUCHY
    -/> guarantees_convergence_without(COMPLETENESS)

# ---------- LIMSUP / LIMINF ----------
for bounded real sequence:

if

LIMSUP(a_n)
    !=
LIMINF(a_n)

then

a_n
    -> DIVERGENT

if

LIMSUP
    =
LIMINF
    =
L

then

a_n
    -> L

LIMSUP_LIMINF
    -> characterise(CONVERGENCE_FOR_BOUNDED_REAL_SEQUENCES)

# ---------- SERIES DIVERGENCE ----------
for
    series
    sum(a_n)

define

S_N
    := sum_from_n_1_to_N(a_n)

SERIES
    -> DIVERGES

iff

PARTIAL_SUM_SEQUENCE
    -> DIVERGES

SERIES_DIVERGENCE
    -> failure_of(PARTIAL_SUM_LIMIT)

# ---------- TERM DIVERGENCE TEST ----------
if

a_n
    -/> 0

then

sum(a_n)
    -> DIVERGES

TERM_TEST
    -> sufficient_for(SERIES_DIVERGENCE)

a_n -> 0
    -/> sufficient_for(SERIES_CONVERGENCE)

# ---------- HARMONIC SERIES ----------
HARMONIC_SERIES
    := sum_from_n_1_to_infinity(
        1/n
    )

1/n
    -> 0

but

HARMONIC_SERIES
    -> DIVERGES

HARMONIC_SERIES
    -> canonical_example_of(
        TERM_TO_ZERO_WITH_SERIES_DIVERGENCE
    )

# ---------- GEOMETRIC SERIES ----------
sum_from_n_0_to_infinity(
    a*r^n
)

if
    abs(r) >= 1
    AND a != 0
then

GEOMETRIC_SERIES
    -> DIVERGES

if
    abs(r) < 1
then

-> CONVERGES

# ---------- P-SERIES ----------
sum_from_n_1_to_infinity(
    1/n^p
)

if
    p <= 1
then

P_SERIES
    -> DIVERGES

if
    p > 1
then

P_SERIES
    -> CONVERGES

# ---------- COMPARISON FOR DIVERGENCE ----------
for eventually nonnegative sequences:

if
    0 <= b_n <= a_n

and

sum(b_n)
    -> DIVERGES

then

sum(a_n)
    -> DIVERGES

COMPARISON_TEST
    -> transfers(DIVERGENCE_FROM_SMALLER_POSITIVE_SERIES)

# ---------- RATIO TEST DIVERGENCE ----------
L
    :=
limsup(
    abs(a_(n+1)/a_n)
)

if
    L > 1
then

sum(a_n)
    -> DIVERGES

if
    L = 1
then

RATIO_TEST
    -> INCONCLUSIVE

# ---------- ROOT TEST DIVERGENCE ----------
L
    :=
limsup(
    abs(a_n)^(1/n)
)

if
    L > 1
then

sum(a_n)
    -> DIVERGES

if
    L = 1
then

ROOT_TEST
    -> INCONCLUSIVE

# ---------- FUNCTION SEQUENCE DIVERGENCE ----------
f_n
    -> may_fail_to_converge(POINTWISE)
    -> may_fail_to_converge(UNIFORMLY)
    -> may_fail_to_converge(IN_NORM)
    -> may_fail_to_converge(WEAKLY)

DIVERGENCE
    -> MODE_DEPENDENT

not_uniformly_convergent
    -/> implies(not_pointwise_convergent)

# ---------- POINTWISE DIVERGENCE ----------
if
    exists x in DOMAIN
    such_that

f_n(x)
    -> does_not_converge

then

f_n
    -> not_pointwise_convergent_on_entire_domain

POINTWISE_CONVERGENCE
    -> requires(CONVERGENCE_AT_EVERY_DOMAIN_POINT)

# ---------- UNIFORM NONCONVERGENCE ----------
f_n
    -> not_uniformly_convergent_to(f)

if

sup_x(
    abs(f_n(x)-f(x))
)
    -/> 0

UNIFORM_DIVERGENCE_FROM_f
    -> does_not_rule_out(POINTWISE_CONVERGENCE_TO_f)

# ---------- NORM DIVERGENCE ----------
in normed space:

x_n
    -> does_not_norm_converge_to(x)

if

||x_n-x||
    -/> 0

NORM_DIVERGENCE
    -> relative_to(CANDIDATE_LIMIT_AND_NORM)

# ---------- ITERATIVE DIVERGENCE ----------
ITERATION
    := x_(n+1)=F(x_n)

ITERATION
    -> DIVERGENT

if
    generated_sequence
        -> does_not_converge_under(SPECIFIED_MODE)

ITERATIVE_DIVERGENCE
    -> may_be(UNBOUNDED)
    -> may_be(OSCILLATORY)
    -> may_be(CHAOTIC)
    -> may_enter(CYCLE)

# ---------- NUMERICAL DIVERGENCE ----------
NUMERICAL_METHOD
    -> may_diverge_if(STABILITY_CONDITIONS_FAIL)

ERROR_SEQUENCE
    := e_n

if
    e_n
        -> grows_or_fails_to_zero
then

NUMERICAL_APPROXIMATION
    -> fails_to_converge_to(TARGET_SOLUTION)

NUMERICAL_DIVERGENCE
    -> may_depend_on(STEP_SIZE)

# ---------- IMPROPER INTEGRAL DIVERGENCE ----------
IMPROPER_INTEGRAL
    := limit_of(PROPER_INTEGRALS)

if
    defining_limit
        -> does_not_exist_finitely
then

IMPROPER_INTEGRAL
    -> DIVERGES

DIVERGENCE
    -> applies_to(INTEGRAL_LIMIT_PROCESSES)

# ---------- DIVERGENT FUNCTION LIMIT ----------
for
    lim_(x->a) f(x)

if
    no finite L satisfies(epsilon_delta_definition)
then

FUNCTION_LIMIT
    -> DIVERGES_OR_FAILS_TO_EXIST

failure_modes:
    unequal_one_sided_limits
    unbounded_growth
    oscillation

# ---------- ONE-SIDED LIMIT TEST ----------
if

lim_(x->a-) f(x)
    = L

and

lim_(x->a+) f(x)
    = M

with
    L != M

then

two_sided_limit
    -> DOES_NOT_EXIST

DISTINCT_ONE_SIDED_LIMITS
    -> prove(DIVERGENCE_OF_TWO_SIDED_LIMIT)

# ---------- APPLICATIONS ----------
DIVERGENCE
    -> applied_to(SEQUENCE_ANALYSIS)
    -> applied_to(SERIES_ANALYSIS)
    -> applied_to(FUNCTION_LIMITS)
    -> applied_to(IMPROPER_INTEGRALS)
    -> applied_to(NUMERICAL_METHODS)
    -> applied_to(ITERATIVE_ALGORITHMS)
    -> applied_to(FUNCTIONAL_ANALYSIS)

# ---------- RELATION GRAPH ----------
CONVERGENCE
    -> opposite_property_of(DIVERGENCE)

UNBOUNDEDNESS
    -> implies(NO_FINITE_SEQUENCE_LIMIT)

DISTINCT_SUBSEQUENTIAL_LIMITS
    -> imply(DIVERGENCE)

SERIES
    -> diverges_if(PARTIAL_SUM_SEQUENCE_DIVERGES)

TERM_NOT_TO_ZERO
    -> implies(SERIES_DIVERGENCE)

CONVERGENCE_MODE
    -> determines(DIVERGENCE_MEANING)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "divergence" ~= "failure to converge under a specified limiting process",
    "divergent sequence" ~= "sequence without a finite limit in the stated space",
    "divergent series" ~= "series whose partial sums fail to approach a finite limit",
    "oscillatory divergence" ~= "nonconvergence caused by persistent oscillation",
    "divergence to infinity" ~= "unbounded limiting behaviour in the extended-real sense",
    "nth-term divergence test" ~= "series test showing divergence when terms fail to approach zero"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    divergence_is_relative_to_convergence_mode_and_space: true,
    bounded_sequence_can_still_diverge: true,
    unbounded_sequence_has_no_finite_real_limit: true,
    distinct_subsequence_limits_prove_divergence: true,
    series_term_to_zero_failure_proves_divergence: true,
    series_term_to_zero_does_not_prove_convergence: true,
    failure_of_stronger_convergence_mode_does_not_imply_failure_of_weaker_mode: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    sequence_divergence_relation: 0.99,
    subsequence_relation: 0.99,
    series_divergence_relation: 0.99,
    function_mode_relation: 0.99,
    numerical_divergence_relation: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(object_and_limit_process)
    -> identify(underlying_space)
    -> identify(convergence_mode)
    -> test(candidate_limit_if_given)
    -> test(boundedness_and_cauchy_properties)
    -> inspect(subsequences_or_one_sided_limits)
    -> for_series_construct(partial_sums_and_test_terms)
    -> select(divergence_test_if_applicable)
    -> distinguish(unbounded_oscillatory_and_mode_specific_failure)
    -> validate(test_hypotheses)
    -> classify(divergence_type)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed real-analysis divergence semantic graph",
    primary_entity: DIVERGENCE,
    preserve: [
        object_type,
        underlying_space,
        convergence_mode,
        candidate_limit,
        boundedness,
        subsequence_structure,
        partial_sums,
        failure_type
    ],
    infer_through: [
        sequence_divergence,
        series_divergence,
        infinite_limits,
        oscillation,
        subsequences,
        convergence_tests,
        function_limit_failure,
        numerical_divergence
    ],
    avoid: [
        confusing_vector_calculus_divergence_with real-analysis divergence,
        assuming_boundedness_implies convergence,
        treating_infinite_limit_as finite convergence,
        claiming_series_convergence_from term_to_zero,
        assuming_failure_of_uniform convergence means failure_of_pointwise convergence,
        applying_divergence_tests_without hypotheses
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + DIVERGENCE
    + CONVERGENCE
    + UNBOUNDEDNESS
    + SUBSEQUENCE
    + SERIES
    + PARTIAL_SUM
    + DIVERGENCE_TEST
    + POINTWISE_DIVERGENCE
    + NUMERICAL_DIVERGENCE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> DIVERGENCE
    -> OBJECT_LIMIT_PROCESS_IDENTIFICATION
    -> SPACE_MODE_IDENTIFICATION
    -> CANDIDATE_LIMIT_ANALYSIS
    -> BOUNDEDNESS_CAUCHY_ANALYSIS
    -> SUBSEQUENCE_LIMIT_ANALYSIS
    -> SERIES_PARTIAL_SUM_ANALYSIS
    -> DIVERGENCE_TEST_SELECTION
    -> FAILURE_MODE_CLASSIFICATION
    -> HYPOTHESIS_VALIDATION
    -> DIVERGENCE_CLASSIFICATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW