Infinite Series Ontology

flow "InfiniteSeriesOntology" v1.0

# ============================================================
# INFINITE SERIES ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
INFINITE_SERIES := {
    type: InfiniteSummationStructure,
    domain: RealAnalysis,
    purpose: "Represent an infinite sum whose mathematical value and convergence behaviour are defined through the limit of its finite partial sums."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    INFINITE_SERIES,
    SEQUENCE,
    SERIES_TERM,
    PARTIAL_SUM,
    LIMIT,
    CONVERGENCE,
    DIVERGENCE,
    ABSOLUTE_CONVERGENCE,
    CONDITIONAL_CONVERGENCE,
    POSITIVE_TERM_SERIES,
    ALTERNATING_SERIES,
    GEOMETRIC_SERIES,
    P_SERIES,
    CONVERGENCE_TEST,
    REMAINDER
}

# ---------- BASIC FORM ----------
given
    sequence (a_n)

INFINITE_SERIES
    := sum_from_n_1_to_infinity(a_n)

a_n
    -> SERIES_TERM

INFINITE_SUM_SYMBOL
    -> denotes(LIMIT_PROCESS)
       not(completed_finite_addition)

# ---------- PARTIAL SUM ----------
S_N
    :=
sum_from_n_1_to_N(a_n)

PARTIAL_SUM
    -> finite_sum

PARTIAL_SUM_SEQUENCE
    := (S_N)

INFINITE_SERIES
    -> defined_via(PARTIAL_SUM_SEQUENCE)

# ---------- CONVERGENCE ----------
sum(a_n)
    -> converges_to(S)

iff

lim_(N->infinity) S_N
    = S

S
    -> SUM_OF_INFINITE_SERIES

CONVERGENCE
    -> finite_partial_sum_limit_exists

# ---------- DIVERGENCE ----------
if
    partial_sum_sequence
        -> has_no_finite_limit
then

INFINITE_SERIES
    -> DIVERGENT

DIVERGENCE
    -> may_be(TO_POSITIVE_INFINITY)
    -> may_be(TO_NEGATIVE_INFINITY)
    -> may_be(OSCILLATORY)
    -> may_be(OTHER_NONCONVERGENT_BEHAVIOUR)

# ---------- NECESSARY CONDITION ----------
if
    sum(a_n)
        converges
then

a_n
    -> 0

DIVERGENCE_TEST:
    if
        lim(a_n)
        != 0
        or does_not_exist
    then

sum(a_n)
    -> DIVERGES

a_n -> 0
    -/> sufficient_for(CONVERGENCE)

# ---------- CAUCHY CRITERION ----------
INFINITE_SERIES
    -> converges

iff

for_every epsilon > 0
exists N
such_that

m > n >= N

implies

abs(
    sum_from_k_nplus1_to_m(a_k)
)
    < epsilon

under(COMPLETE_SCALAR_FIELD)

CAUCHY_CRITERION
    -> characterises(CONVERGENCE_WITHOUT_EXPLICIT_SUM)

# ---------- POSITIVE TERM SERIES ----------
if
    a_n >= 0
    eventually
then

PARTIAL_SUM_SEQUENCE
    -> eventually_monotone_increasing

POSITIVE_TERM_SERIES
    -> converges
       iff
       PARTIAL_SUMS_BOUNDED_ABOVE

MONOTONE_CONVERGENCE
    -> supports(POSITIVE_SERIES_ANALYSIS)

# ---------- ABSOLUTE CONVERGENCE ----------
sum(a_n)
    -> ABSOLUTELY_CONVERGENT

iff

sum(abs(a_n))
    -> converges

ABSOLUTE_CONVERGENCE
    -> implies(ORDINARY_CONVERGENCE)

ABSOLUTE_CONVERGENCE
    -> stable_under(REARRANGEMENT)

# ---------- CONDITIONAL CONVERGENCE ----------
sum(a_n)
    -> CONDITIONALLY_CONVERGENT

iff

sum(a_n)
    -> converges

and

sum(abs(a_n))
    -> diverges

CONDITIONAL_CONVERGENCE
    -> depends_on(CANCELLATION)

# ---------- REARRANGEMENT ----------
ABSOLUTELY_CONVERGENT_SERIES
    -> every_rearrangement_has(SAME_SUM)

CONDITIONALLY_CONVERGENT_REAL_SERIES
    -> rearrangement_may_change(SUM_OR_CONVERGENCE)

RIEMANN_REARRANGEMENT_THEOREM
    -> characterises(REARRANGEMENTS_OF_CONDITIONALLY_CONVERGENT_REAL_SERIES)

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

PARTIAL_SUM:
    S_N
        =
    a*(1-r^(N+1))/(1-r)
       when(r != 1)

if
    abs(r) < 1
then

SUM
    =
a/(1-r)

if
    abs(r) >= 1
then

SERIES
    -> diverges
       unless(a=0)

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

p > 1
    -> CONVERGENT

p <= 1
    -> DIVERGENT

P_SERIES
    -> benchmark_for(COMPARISON_TESTS)

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

HARMONIC_SERIES
    -> DIVERGENT

1/n
    -> 0

HARMONIC_SERIES
    -> counterexample_to(
        TERM_TO_ZERO_SUFFICIENT_FOR_CONVERGENCE
    )

# ---------- ALTERNATING SERIES ----------
ALTERNATING_SERIES
    := sum(
        (-1)^n b_n
    )

if
    b_n >= 0
    AND b_n eventually_nonincreasing
    AND b_n -> 0
then

ALTERNATING_SERIES
    -> CONVERGENT

ALTERNATING_SERIES_TEST
    ~= LEIBNIZ_TEST

# ---------- REMAINDER ----------
if
    S
        := series_sum
    AND S_N
        := partial_sum

REMAINDER
    := R_N
       = S-S_N

REMAINDER
    -> truncation_error_of(PARTIAL_SUM_APPROXIMATION)

# ---------- ALTERNATING REMAINDER ----------
under alternating-series-test hypotheses:

abs(R_N)
    <= b_(N+1)

REMAINDER_SIGN
    -> follows(FIRST_OMITTED_TERM)
       under(STANDARD_ALTERNATING_STRUCTURE)

# ---------- COMPARISON TEST ----------
for eventually nonnegative terms:

if
    0 <= a_n <= b_n

and

sum(b_n)
    converges

then

sum(a_n)
    -> converges

if
    0 <= b_n <= a_n

and

sum(b_n)
    diverges

then

sum(a_n)
    -> diverges

# ---------- LIMIT COMPARISON ----------
if
    a_n,b_n > 0
    eventually

and

lim(
    a_n/b_n
)
    = L

with
    0 < L < infinity

then

sum(a_n)
    and
sum(b_n)
    -> share(CONVERGENCE_STATUS)

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

L < 1
    -> ABSOLUTE_CONVERGENCE

L > 1
    -> DIVERGENCE

L = 1
    -> INCONCLUSIVE

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

L < 1
    -> ABSOLUTE_CONVERGENCE

L > 1
    -> DIVERGENCE

L = 1
    -> INCONCLUSIVE

# ---------- INTEGRAL TEST ----------
if
    f positive
    AND continuous
    AND decreasing
    on [1,infinity)

and

a_n = f(n)

then

sum_from_n_1_to_infinity(a_n)
    converges

iff

integral_from_1_to_infinity(
    f(x) dx
)
    converges

# ---------- CAUCHY CONDENSATION ----------
if
    a_n positive_nonincreasing
then

sum(a_n)
    converges

iff

sum_from_n_0_to_infinity(
    2^n * a_(2^n)
)
    converges

CONDENSATION
    -> useful_for(LOGARITHMIC_AND_SLOW_DECAY_SERIES)

# ---------- TELESCOPING SERIES ----------
if
    a_n
        = b_n-b_(n+1)

then

S_N
    =
b_1-b_(N+1)

TELESCOPING
    -> cancellation_reduces(PARTIAL_SUM)

if
    b_n -> L
then

SERIES_SUM
    =
b_1-L

# ---------- BLOCK GROUPING ----------
CONVERGENT_SERIES
    -> may_be_grouped_into(FINITE_BLOCKS)
       without_changing_order

GROUPING
    -> preserves(SUM)
       under(STANDARD_CONVERGENT_SERIES_CONTEXT)

REARRANGEMENT
    -> changes(ORDER)
    -> requires(SEPARATE_ANALYSIS)

# ---------- COMPLEX SERIES ----------
COMPLEX_SERIES
    := sum(z_n)

CONVERGENCE
    -> equivalent_to(CONVERGENCE_OF_REAL_AND_IMAGINARY_PART_SERIES)

ABSOLUTE_CONVERGENCE
    := sum(abs(z_n)) converges

ABSOLUTE_COMPLEX_CONVERGENCE
    -> implies(CONVERGENCE)

# ---------- VECTOR / BANACH SERIES ----------
for
    x_n in BANACH_SPACE X

SERIES
    := sum(x_n)

converges
    iff
    partial_sums_converge_in(NORM)

if
    sum(||x_n||)
        converges
then

sum(x_n)
    -> converges
       because(X_COMPLETE)

BANACH_SPACE_COMPLETENESS
    -> supports(ABSOLUTE_NORM_CONVERGENCE)

# ---------- APPLICATIONS ----------
INFINITE_SERIES
    -> applied_to(REAL_ANALYSIS)
    -> applied_to(POWER_SERIES)
    -> applied_to(FOURIER_SERIES)
    -> applied_to(APPROXIMATION)
    -> applied_to(NUMERICAL_ANALYSIS)
    -> applied_to(DIFFERENTIAL_EQUATIONS)
    -> applied_to(PROBABILITY)

# ---------- RELATION GRAPH ----------
SEQUENCE
    -> provides(TERMS)

TERMS
    -> generate(PARTIAL_SUMS)

PARTIAL_SUM_SEQUENCE
    -> determines(CONVERGENCE)

ABSOLUTE_CONVERGENCE
    -> implies(CONVERGENCE)

CONDITIONAL_CONVERGENCE
    -> permits(REARRANGEMENT_SENSITIVITY)

CONVERGENCE_TEST
    -> classifies(INFINITE_SERIES)

REMAINDER
    -> measures(PARTIAL_SUM_ERROR)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "infinite series" ~= "infinite sum defined as a limit of finite partial sums",
    "series sum" ~= "limit of the partial-sum sequence",
    "absolute convergence" ~= "convergence after replacing every term by its magnitude",
    "conditional convergence" ~= "convergence without absolute convergence",
    "remainder" ~= "difference between the full series sum and a finite partial sum",
    "divergence test" ~= "necessary-term test using failure of terms to approach zero"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    infinite_series_sum_is_defined_by_partial_sum_limit: true,
    term_to_zero_is_necessary_but_not_sufficient: true,
    absolute_convergence_implies_convergence: true,
    conditional_convergence_is_rearrangement_sensitive: true,
    convergence_tests_require_specific_hypotheses: true,
    ratio_and_root_test_boundary_value_one_is_inconclusive: true,
    banach_series_absolute_norm_convergence_uses_completeness: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    partial_sum_relation: 0.99,
    cauchy_relation: 0.99,
    absolute_conditional_relation: 0.99,
    standard_test_relations: 0.99,
    remainder_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(term_sequence)
    -> construct(partial_sums)
    -> test(term_limit)
    -> classify(sign_and_structure)
    -> select(convergence_test)
    -> verify(test_hypotheses)
    -> determine(convergence_or_divergence)
    -> classify(absolute_or_conditional_if_convergent)
    -> compute(sum_if_possible)
    -> estimate(remainder_if_requested)
    -> analyse(rearrangement_or_grouping_if_relevant)
    -> validate(space_completeness_if_vector_valued)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed infinite-series semantic graph",
    primary_entity: INFINITE_SERIES,
    preserve: [
        term_sequence,
        index_start,
        partial_sums,
        convergence_status,
        absolute_status,
        sign_structure,
        convergence_test,
        remainder
    ],
    infer_through: [
        cauchy_criteria,
        positive_series,
        geometric_series,
        p_series,
        alternating_series,
        comparison_tests,
        ratio_tests,
        root_tests,
        rearrangements
    ],
    avoid: [
        treating_infinite_sum_as finite arithmetic,
        declaring_convergence_from term_to_zero alone,
        confusing_term_sequence_limit_with series_sum,
        rearranging_conditionally_convergent_series_freely,
        treating_ratio_or_root_test_L_equals_one_as decisive,
        ignoring_completeness_for Banach-space series
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + INFINITE_SERIES
    + PARTIAL_SUM
    + CONVERGENCE
    + ABSOLUTE_CONVERGENCE
    + CONDITIONAL_CONVERGENCE
    + GEOMETRIC_SERIES
    + P_SERIES
    + ALTERNATING_SERIES
    + REMAINDER
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> INFINITE_SERIES
    -> TERM_SEQUENCE_IDENTIFICATION
    -> PARTIAL_SUM_CONSTRUCTION
    -> TERM_LIMIT_ANALYSIS
    -> SERIES_STRUCTURE_CLASSIFICATION
    -> CONVERGENCE_TEST_SELECTION
    -> TEST_HYPOTHESIS_VALIDATION
    -> CONVERGENCE_CLASSIFICATION
    -> ABSOLUTE_CONDITIONAL_ANALYSIS
    -> SUM_REMAINDER_ANALYSIS
    -> REARRANGEMENT_GROUPING_ANALYSIS
    -> SPACE_COMPLETENESS_VALIDATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW