Sequence Ontology

flow "SequenceOntology" v1.0

# ============================================================
# SEQUENCE ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
SEQUENCE := {
    type: OrderedMathematicalObject,
    domain: RealAnalysis,
    purpose: "Represent an ordered list of terms indexed by the natural numbers, providing a fundamental structure for limits, convergence and infinite processes."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    SEQUENCE,
    INDEX,
    TERM,
    NATURAL_NUMBERS,
    LIMIT,
    CONVERGENCE,
    DIVERGENCE,
    BOUNDED_SEQUENCE,
    MONOTONE_SEQUENCE,
    CAUCHY_SEQUENCE,
    SUBSEQUENCE,
    LIMSUP,
    LIMINF,
    ACCUMULATION_POINT,
    SERIES
}

# ---------- BASIC DEFINITION ----------
SEQUENCE
    := mapping(
        NATURAL_NUMBERS -> SET_X
    )

n
    -> INDEX

a_n
    -> TERM_AT_INDEX_n

notation:
    (a_n)_(n=1)^infinity

SEQUENCE
    -> ORDERED_BY(INDEX)

# ---------- REAL SEQUENCE ----------
REAL_SEQUENCE
    := mapping(
        NATURAL_NUMBERS -> REAL_NUMBERS
    )

REAL_ANALYSIS
    -> studies(REAL_SEQUENCES)

# ---------- FINITE INITIAL SEGMENT ----------
a_1, a_2, ..., a_N
    -> FINITE_INITIAL_SEGMENT

SEQUENCE
    -> infinite_object
       in(STANDARD_ANALYSIS_CONTEXT)

FINITE_LIST
    -/> infinite_sequence
       unless(EXTENSION_RULE_SPECIFIED)

# ---------- EXPLICIT SEQUENCE ----------
EXPLICIT_SEQUENCE
    -> term_defined_by(FORMULA_IN_n)

example:

a_n
    = 1/n

EXPLICIT_FORMULA
    -> determines(EACH_TERM)

# ---------- RECURSIVE SEQUENCE ----------
RECURSIVE_SEQUENCE
    -> defined_by(INITIAL_TERMS_AND_RECURRENCE)

example:

a_1
    = 1

a_(n+1)
    = (a_n + 2/a_n)/2

RECURRENCE
    -> determines(NEXT_TERM_FROM_PREVIOUS_INFORMATION)

# ---------- CONVERGENCE ----------
a_n
    -> converges_to(L)

iff

for_every epsilon > 0
exists N
such_that

n >= N
    -> abs(a_n-L) < epsilon

L
    -> LIMIT_OF_SEQUENCE

notation:
    lim_(n->infinity) a_n
        = L

# ---------- UNIQUENESS OF LIMIT ----------
if
    a_n -> L
    AND
    a_n -> M
then

L = M

CONVERGENT_SEQUENCE
    -> has(UNIQUE_LIMIT)

# ---------- BOUNDEDNESS ----------
SEQUENCE
    -> BOUNDED

if

exists M > 0
such_that

abs(a_n)
    <= M

for_all n

CONVERGENT_SEQUENCE
    -> BOUNDED_SEQUENCE

BOUNDED_SEQUENCE
    -/> necessarily(CONVERGENT_SEQUENCE)

# ---------- DIVERGENCE ----------
SEQUENCE
    -> DIVERGENT

if
    no_finite_limit_exists

DIVERGENCE
    -> may_be(UNBOUNDED)
    -> may_be(OSCILLATORY)
    -> may_have(MULTIPLE_ACCUMULATION_POINTS)

# ---------- INFINITE LIMIT ----------
a_n
    -> tends_to(+infinity)

iff

for_every M in R
exists N
such_that

n >= N
    -> a_n > M

INFINITE_LIMIT
    -/> finite_real_limit

# ---------- MONOTONE SEQUENCE ----------
INCREASING_SEQUENCE:
    a_(n+1) >= a_n

DECREASING_SEQUENCE:
    a_(n+1) <= a_n

MONOTONE_SEQUENCE
    -> increasing_or_decreasing

STRICT_MONOTONICITY
    -> uses(>, <)

# ---------- MONOTONE CONVERGENCE ----------
if
    a_n increasing
    AND bounded_above
then

a_n
    -> converges_to(
        sup{a_n : n in N}
    )

if
    a_n decreasing
    AND bounded_below
then

a_n
    -> converges_to(
        inf{a_n : n in N}
    )

MONOTONE_CONVERGENCE_THEOREM
    -> depends_on(REAL_COMPLETENESS)

# ---------- CAUCHY SEQUENCE ----------
a_n
    -> CAUCHY

iff

for_every epsilon > 0
exists N
such_that

m,n >= N
    -> abs(a_m-a_n) < epsilon

in R:

CAUCHY_SEQUENCE
    <-> CONVERGENT_SEQUENCE

CAUCHY_CRITERION
    -> does_not_require(KNOWN_LIMIT)

# ---------- SUBSEQUENCE ----------
SUBSEQUENCE
    := a_(n_k)

where

n_1 < n_2 < n_3 < ...

INDEX_MAP
    -> strictly_increasing

SUBSEQUENCE
    -> preserves(ORIGINAL_TERM_ORDER)

# ---------- SUBSEQUENCE OF CONVERGENT SEQUENCE ----------
if
    a_n -> L
then

every_subsequence
    a_(n_k)
        -> L

CONVERGENCE
    -> inherited_by(SUBSEQUENCES)

# ---------- BOLZANO-WEIERSTRASS ----------
if
    a_n
        -> bounded_sequence_in(R^m)
then

exists
    convergent_subsequence

BOUNDED_SEQUENCE
    -> has(ACCUMULATION_POINT)
       in(FINITE_DIMENSIONAL_EUCLIDEAN_SPACE)

# ---------- ACCUMULATION POINT ----------
L
    -> SUBSEQUENTIAL_LIMIT

if
    exists subsequence
    a_(n_k) -> L

SUBSEQUENTIAL_LIMIT
    ~= ACCUMULATION_POINT_OF_SEQUENCE

DIVERGENT_SEQUENCE
    -> may_have(SUBSEQUENTIAL_LIMITS)

# ---------- LIMSUP ----------
LIMSUP(a_n)
    :=
lim_(n->infinity)(
    sup{a_k : k >= n}
)

when defined in extended reals

LIMSUP
    -> largest_subsequential_limit
       under(BOUNDED_REAL_SEQUENCE_CONTEXT)

# ---------- LIMINF ----------
LIMINF(a_n)
    :=
lim_(n->infinity)(
    inf{a_k : k >= n}
)

when defined in extended reals

LIMINF
    -> smallest_subsequential_limit
       under(BOUNDED_REAL_SEQUENCE_CONTEXT)

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

a_n -> L

iff

LIMSUP(a_n)
    =
LIMINF(a_n)
    =
L

# ---------- ALGEBRA OF LIMITS ----------
if
    a_n -> A
    AND
    b_n -> B

then

a_n + b_n
    -> A+B

a_n*b_n
    -> A*B

alpha*a_n
    -> alpha*A

if
    B != 0
    AND b_n != 0 eventually
then

a_n/b_n
    -> A/B

# ---------- ORDER LIMIT THEOREM ----------
if
    a_n <= b_n
    eventually

and

a_n -> A
b_n -> B

then

A <= B

ORDER
    -> preserved_under(LIMIT)

# ---------- SQUEEZE THEOREM ----------
if
    a_n <= b_n <= c_n
    eventually

and

a_n -> L
c_n -> L

then

b_n -> L

SQUEEZE_THEOREM
    -> determines(LIMIT_BY_BOUNDS)

# ---------- CONTINUOUS FUNCTION OF SEQUENCE ----------
if
    a_n -> L
    AND f continuous_at(L)
then

f(a_n)
    -> f(L)

CONTINUITY
    -> commutes_with(SEQUENCE_LIMIT)

# ---------- SERIES RELATION ----------
given sequence
    a_n

SERIES
    := sum_from_n_1_to_infinity(a_n)

PARTIAL_SUM_SEQUENCE
    := S_N
       = sum_from_n_1_to_N(a_n)

SERIES_CONVERGES
    iff

PARTIAL_SUM_SEQUENCE
    -> converges

SERIES
    -> analysed_via(SEQUENCE_OF_PARTIAL_SUMS)

# ---------- GEOMETRIC SEQUENCE ----------
GEOMETRIC_SEQUENCE
    := a*r^(n-1)

ratio
    := r

if
    abs(r) < 1
then

a*r^n
    -> 0

GEOMETRIC_BEHAVIOUR
    -> fundamental_limit_example

# ---------- ARITHMETIC SEQUENCE ----------
ARITHMETIC_SEQUENCE
    := a + (n-1)d

common_difference
    := d

if
    d != 0
then

ARITHMETIC_SEQUENCE
    -> generally_unbounded_in_one_direction

# ---------- APPLICATIONS ----------
SEQUENCE
    -> applied_to(LIMIT_THEORY)
    -> applied_to(SERIES)
    -> applied_to(CONTINUITY)
    -> applied_to(COMPACTNESS)
    -> applied_to(NUMERICAL_APPROXIMATION)
    -> applied_to(ITERATIVE_METHODS)
    -> applied_to(FUNCTIONAL_ANALYSIS)

# ---------- RELATION GRAPH ----------
NATURAL_NUMBER
    -> indexes(SEQUENCE_TERM)

SEQUENCE
    -> may_have(LIMIT)

CONVERGENCE
    -> implies(BOUNDEDNESS)

MONOTONICITY
    + BOUNDEDNESS
    -> implies(CONVERGENCE_IN_R)

CAUCHY_PROPERTY
    -> equivalent_to(CONVERGENCE_IN_R)

SEQUENCE
    -> contains(SUBSEQUENCES)

SUBSEQUENCES
    -> determine(ACCUMULATION_POINTS)

SERIES
    -> defined_via(PARTIAL_SUM_SEQUENCE)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "sequence" ~= "function from the natural numbers into a target set",
    "real sequence" ~= "sequence whose terms are real numbers",
    "subsequence" ~= "sequence obtained using a strictly increasing index selection",
    "Cauchy sequence" ~= "sequence whose terms become arbitrarily close to each other",
    "subsequential limit" ~= "limit of a subsequence",
    "bounded sequence" ~= "sequence whose terms remain within a fixed finite magnitude"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    sequence_order_is_determined_by_index: true,
    convergent_real_sequence_is_bounded: true,
    bounded_sequence_need_not_converge: true,
    every_subsequence_of_convergent_sequence_has_same_limit: true,
    cauchy_equivalent_to_convergent_requires_complete_space: true,
    bolzano_weierstrass_bounded_subsequence_result_depends_on_finite_dimensional_context: true,
    infinite_limit_is_not_finite_real_limit: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    convergence_relation: 0.99,
    boundedness_relation: 0.99,
    monotone_convergence_relation: 0.99,
    cauchy_relation: 0.99,
    subsequence_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(sequence)
    -> identify(index_set_and_target_space)
    -> identify(explicit_or_recursive_definition)
    -> test(boundedness)
    -> test(monotonicity)
    -> analyse(limit_if_requested)
    -> test(cauchy_property_if_relevant)
    -> inspect(subsequences_and_accumulation_points)
    -> compute(limsup_or_liminf_if_requested)
    -> apply(limit_algebra_or_squeeze_theorem_if_valid)
    -> validate(completeness_and_dimension_assumptions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed sequence semantic graph",
    primary_entity: SEQUENCE,
    preserve: [
        index_set,
        target_space,
        term_definition,
        boundedness,
        monotonicity,
        convergence_status,
        limit,
        subsequence_structure
    ],
    infer_through: [
        limits,
        cauchy_sequences,
        monotone_convergence,
        subsequences,
        accumulation_points,
        limsup,
        liminf,
        series
    ],
    avoid: [
        assuming_bounded_sequence_converges,
        confusing_sequence_with unordered set,
        treating_infinite_limit_as finite real limit,
        assuming_cauchy_implies convergence outside complete space,
        selecting_subsequence_indices_without strict increase,
        applying_bolzano_weierstrass_without relevant compactness context
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + SEQUENCE
    + CONVERGENCE
    + BOUNDED_SEQUENCE
    + MONOTONE_SEQUENCE
    + CAUCHY_SEQUENCE
    + SUBSEQUENCE
    + LIMSUP
    + LIMINF
    + SERIES
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> SEQUENCE
    -> SEQUENCE_IDENTIFICATION
    -> INDEX_TARGET_ANALYSIS
    -> DEFINITION_ANALYSIS
    -> BOUNDEDNESS_ANALYSIS
    -> MONOTONICITY_ANALYSIS
    -> LIMIT_ANALYSIS
    -> CAUCHY_ANALYSIS
    -> SUBSEQUENCE_ACCUMULATION_ANALYSIS
    -> LIMSUP_LIMINF_ANALYSIS
    -> LIMIT_THEOREM_APPLICATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW