Series Ontology

flow "SeriesOntology" v1.0

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

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

# ---------- CORE ENTITY ----------
SERIES := {
    type: InfiniteSummationStructure,
    domain: RealAnalysis,
    purpose: "Represent the infinite summation of terms of a sequence, with convergence defined through the limiting behaviour of its partial sums."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    SERIES,
    SEQUENCE,
    TERM,
    PARTIAL_SUM,
    CONVERGENCE,
    DIVERGENCE,
    ABSOLUTE_CONVERGENCE,
    CONDITIONAL_CONVERGENCE,
    GEOMETRIC_SERIES,
    P_SERIES,
    HARMONIC_SERIES,
    ALTERNATING_SERIES,
    POWER_SERIES,
    CONVERGENCE_TEST,
    CAUCHY_CRITERION
}

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

SERIES
    := sum_from_n_1_to_infinity(a_n)

a_n
    -> SERIES_TERM

SERIES
    -> infinite_formal_sum_of(SEQUENCE_TERMS)

# ---------- PARTIAL SUM ----------
PARTIAL_SUM
    := S_N

S_N
    =
sum_from_n_1_to_N(a_n)

PARTIAL_SUM_SEQUENCE
    := (S_N)

SERIES
    -> analysed_through(PARTIAL_SUM_SEQUENCE)

# ---------- CONVERGENCE ----------
SERIES
    -> converges_to(S)

iff

S_N
    -> S
       as(N -> infinity)

SERIES_SUM
    := S

CONVERGENCE
    -> property_of(PARTIAL_SUM_LIMIT)

# ---------- DIVERGENCE ----------
SERIES
    -> DIVERGENT

if
    PARTIAL_SUM_SEQUENCE
        has_no_finite_limit

DIVERGENCE
    -> may_result_from(UNBOUNDED_PARTIAL_SUMS)
    -> may_result_from(OSCILLATORY_PARTIAL_SUMS)

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

a_n
    -> 0

TERM_TEST:
    if
        a_n
        -/> 0
    then

sum(a_n)
    -> DIVERGES

a_n -> 0
    -/> sufficient_for(SERIES_CONVERGENCE)

# ---------- CAUCHY CRITERION ----------
SERIES
    -> converges

iff

for_every epsilon > 0
exists N
such_that

m > n >= N
    -> abs(
        sum_from_k_nplus1_to_m(a_k)
       ) < epsilon

in complete scalar field

CAUCHY_CRITERION
    -> convergence_without_known_sum

# ---------- ABSOLUTE CONVERGENCE ----------
SERIES
    -> ABSOLUTELY_CONVERGENT

if

sum(
    abs(a_n)
)
    converges

ABSOLUTE_CONVERGENCE
    -> implies(CONVERGENCE)

# ---------- CONDITIONAL CONVERGENCE ----------
SERIES
    -> CONDITIONALLY_CONVERGENT

if

sum(a_n)
    converges

AND

sum(abs(a_n))
    diverges

CONDITIONAL_CONVERGENCE
    -> sensitive_to(REARRANGEMENT)

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

CONDITIONALLY_CONVERGENT_REAL_SERIES
    -> may_change_sum_or_diverge_under(REARRANGEMENT)

RIEMANN_REARRANGEMENT_THEOREM
    -> describes(CONDITIONAL_REARRANGEMENT_BEHAVIOUR)

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

if
    abs(r) < 1
then

GEOMETRIC_SERIES
    -> converges_to(
        a/(1-r)
    )

if
    abs(r) >= 1
then

GEOMETRIC_SERIES
    -> diverges
       unless(trivial_zero_coefficient_context)

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

if
    p > 1
then

P_SERIES
    -> CONVERGES

if
    p <= 1
then

P_SERIES
    -> DIVERGES

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

HARMONIC_SERIES
    -> DIVERGES

TERMS
    -> tend_to(0)

HARMONIC_SERIES
    -> demonstrates(
        TERM_TO_ZERO_NOT_SUFFICIENT
    )

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

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

ALTERNATING_SERIES
    -> CONVERGES

LEIBNIZ_TEST
    -> alternating_series_test

# ---------- ALTERNATING ERROR ----------
under alternating-series-test conditions:

ERROR_AFTER_N_TERMS
    <=
b_(N+1)

ALTERNATING_SERIES_ESTIMATE
    -> controls(REMAINDER)

# ---------- COMPARISON TEST ----------
if
    0 <= a_n <= b_n
    eventually

and

sum(b_n)
    converges
then

sum(a_n)
    -> converges

if
    0 <= b_n <= a_n
    eventually

and

sum(b_n)
    diverges
then

sum(a_n)
    -> diverges

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

and

lim_(n->infinity)(
    a_n/b_n
)
    = L

where
    0 < L < infinity

then

sum(a_n)
    and
sum(b_n)
    -> have_same_convergence_behaviour

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

if
    L < 1
then

sum(a_n)
    -> ABSOLUTELY_CONVERGENT

if
    L > 1
then

sum(a_n)
    -> DIVERGENT

if
    L = 1
then

RATIO_TEST
    -> INCONCLUSIVE

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

if
    L < 1
then

sum(a_n)
    -> ABSOLUTELY_CONVERGENT

if
    L > 1
then

sum(a_n)
    -> DIVERGENT

if
    L = 1
then

ROOT_TEST
    -> INCONCLUSIVE

# ---------- INTEGRAL TEST ----------
if
    f
        -> positive_continuous_decreasing
       on([1,infinity))

and
    a_n = f(n)

then

sum_from_n_1_to_infinity(a_n)
    and
integral_from_1_to_infinity(f(x) dx)
    -> converge_or_diverge_together

# ---------- CONDENSATION TEST ----------
if
    a_n
        -> positive_nonincreasing

then

sum(a_n)
    converges

iff

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

CAUCHY_CONDENSATION_TEST
    -> useful_for(SLOWLY_DECAYING_POSITIVE_TERMS)

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

then

S_N
    =
b_1 - b_(N+1)

TELESCOPING_SERIES
    -> cancellation_simplifies(PARTIAL_SUMS)

CONVERGENCE
    -> depends_on(LIMIT_OF_REMAINING_TERM)

# ---------- POWER SERIES ----------
POWER_SERIES
    := sum_from_n_0_to_infinity(
        c_n*(x-a)^n
    )

a
    -> CENTRE

POWER_SERIES
    -> has(RADIUS_OF_CONVERGENCE_R)

if
    abs(x-a) < R
then

-> ABSOLUTE_CONVERGENCE

if
    abs(x-a) > R
then

-> DIVERGENCE

if
    abs(x-a) = R
then

-> ENDPOINT_ANALYSIS_REQUIRED

# ---------- RADIUS OF CONVERGENCE ----------
CAUCHY_HADAMARD:

1/R
    =
limsup(
    abs(c_n)^(1/n)
)

with
    extended_value_conventions

RADIUS_OF_CONVERGENCE
    -> determines(INTERIOR_CONVERGENCE_REGION)

# ---------- TERM-BY-TERM OPERATIONS ----------
inside radius of convergence:

POWER_SERIES
    -> may_be_differentiated_TERM_BY_TERM
    -> may_be_integrated_TERM_BY_TERM

DERIVED_POWER_SERIES
    -> same_radius_of_convergence

POWER_SERIES
    -> represents(ANALYTIC_FUNCTION_ON_INTERIOR)

# ---------- SERIES ALGEBRA ----------
if
    sum(a_n) -> A
    AND
    sum(b_n) -> B

then

sum(
    alpha*a_n + beta*b_n
)
    ->
alpha*A + beta*B

LINEARITY
    -> valid_for(CONVERGENT_SERIES)

# ---------- CAUCHY PRODUCT ----------
CAUCHY_PRODUCT
    := c_n
       = sum_from_k_0_to_n(
           a_k*b_(n-k)
         )

if
    both_series_absolutely_convergent
then

sum(c_n)
    =
(
    sum(a_n)
)
*
(
    sum(b_n)
)

CAUCHY_PRODUCT
    -> multiplication_of(SERIES)

# ---------- APPLICATIONS ----------
SERIES
    -> applied_to(APPROXIMATION)
    -> applied_to(POWER_SERIES)
    -> applied_to(FOURIER_ANALYSIS)
    -> applied_to(DIFFERENTIAL_EQUATIONS)
    -> applied_to(NUMERICAL_ANALYSIS)
    -> applied_to(PROBABILITY)
    -> applied_to(SPECIAL_FUNCTIONS)

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

SERIES
    -> has(PARTIAL_SUM_SEQUENCE)

PARTIAL_SUM_LIMIT
    -> determines(SERIES_CONVERGENCE)

ABSOLUTE_CONVERGENCE
    -> implies(CONVERGENCE)

CONDITIONAL_CONVERGENCE
    -> allows(REARRANGEMENT_SENSITIVITY)

POWER_SERIES
    -> has(RADIUS_OF_CONVERGENCE)

CONVERGENCE_TEST
    -> classifies(SERIES_BEHAVIOUR)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "series" ~= "infinite sum interpreted through the limit of partial sums",
    "partial sum" ~= "finite sum of the first N series terms",
    "absolute convergence" ~= "convergence of the series of absolute values",
    "conditional convergence" ~= "convergence without absolute convergence",
    "geometric series" ~= "series with constant ratio between successive terms",
    "radius of convergence" ~= "distance from power-series centre within which absolute convergence occurs"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    series_convergence_is_defined_by_partial_sum_convergence: true,
    term_tending_to_zero_is_necessary_but_not_sufficient: true,
    absolute_convergence_implies_convergence: true,
    conditional_series_rearrangement_can_change_behaviour: true,
    ratio_and_root_tests_are_inconclusive_at_boundary_value_one: true,
    power_series_endpoints_require_separate_analysis: true,
    convergence_tests_require_their_specific_hypotheses: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    partial_sum_relation: 0.99,
    absolute_conditional_relation: 0.99,
    standard_test_relations: 0.99,
    geometric_p_series_relations: 0.99,
    power_series_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(series_terms)
    -> construct(partial_sum_sequence)
    -> test(term_to_zero_condition)
    -> identify(sign_and_term_structure)
    -> classify(positive_alternating_power_or_general_series)
    -> select(convergence_test)
    -> verify(test_hypotheses)
    -> determine(convergence_or_divergence)
    -> determine(absolute_or_conditional_status_if_convergent)
    -> compute(sum_if_possible)
    -> analyse(remainder_or_radius_of_convergence_if_requested)
    -> validate(endpoint_or_rearrangement_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed series semantic graph",
    primary_entity: SERIES,
    preserve: [
        term_formula,
        index_start,
        partial_sums,
        convergence_status,
        absolute_status,
        sign_pattern,
        convergence_test,
        power_series_centre
    ],
    infer_through: [
        sequences,
        cauchy_criteria,
        comparison_tests,
        ratio_tests,
        root_tests,
        integral_tests,
        alternating_series,
        power_series
    ],
    avoid: [
        declaring_convergence_only_from term_to_zero,
        confusing_sequence_limit_with series sum,
        applying_comparison_without positivity conditions,
        treating_ratio_or_root_test_L_equals_one_as conclusion,
        ignoring_power_series endpoints,
        rearranging_conditionally_convergent_series_as if absolute
    ]
}

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

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

# ---------- EXECUTION ----------
INPUT(query)
    -> SERIES
    -> TERM_IDENTIFICATION
    -> PARTIAL_SUM_CONSTRUCTION
    -> NECESSARY_CONDITION_ANALYSIS
    -> SERIES_TYPE_CLASSIFICATION
    -> CONVERGENCE_TEST_SELECTION
    -> TEST_HYPOTHESIS_VALIDATION
    -> CONVERGENCE_CLASSIFICATION
    -> ABSOLUTE_CONDITIONAL_ANALYSIS
    -> SUM_REMAINDER_ANALYSIS
    -> POWER_SERIES_RADIUS_ENDPOINT_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW