Arithmetic Sequence Ontology

FLOW ALGEBRA
ARITHMETIC SEQUENCE ONTOLOGY
Kireth Semantic Library | Entity Graph | Mathematical Entities | Sequence and Series Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/sequence-and-series-entities/arithmetic-sequence-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Specification: 1.0 | 2026-10-13 | Locale: en-GB

AI INTERPRETATION NOTE
Interpret the following as typed declarative rules with explicit preconditions, not as executable programming code. Preserve distinctions between finite and infinite sequences and between exact and approximate equality.

01. ONTOLOGY IDENTITY
ontology.id := kireth:ArithmeticSequenceOntology
ontology.parent := kireth:SequenceAndSeriesEntities
ontology.entity := ArithmeticSequence
ontology.aliases := {arithmetic progression, AP}
ontology.definition := a sequence whose consecutive differences are a constant in an additive group, conventionally real or complex numbers

02. TYPES
Index := Integer
Scalar := Real | Complex | Rational | Integer | SymbolicScalar
Sequence := (index_set, value_map)
ArithmeticSequence := Sequence with common_difference:Scalar
IndexSet := {n in Integer | n >= start} OR {start,...,end}
Constraint: start and end are integers; end >= start for nonempty finite sequences
Constraint: all values and common_difference inhabit a compatible additive structure

03. CANONICAL ENTITY
entity ArithmeticSequence S:
  first_index: Integer
  first_term: Scalar
  common_difference: Scalar
  last_index: Integer? 
  indexing_convention: zero_based | one_based | custom
  domain: IndexSet
  term(n): Scalar
  provenance: SourceReference?
  exactness: exact | approximate

04. CORE FORMULA
For n in S.domain:
  S.term(n) = S.first_term + (n - S.first_index) * S.common_difference
When first_index = 1:
  a_n = a_1 + (n - 1)d
When first_index = 0:
  a_n = a_0 + nd

05. DIFFERENCE INVARIANT
For consecutive n and n+1 in domain:
  a_(n+1) - a_n = d
For all n and n+2 in domain:
  a_(n+2) - 2a_(n+1) + a_n = 0
If at least two terms exist, d = a_(n+1) - a_n
A one-term sequence does not determine a unique d without additional information.

06. RECURSIVE FORM
base: a_start = first_term
step: a_(n+1) = a_n + d
precondition: n and n+1 belong to domain
The recursive and closed forms are extensionally equivalent over the same index set.

07. CLASSIFICATION
If ordered real values and d > 0: strictly_increasing
If ordered real values and d < 0: strictly_decreasing
If d = 0: constant
If d != 0 and at least two terms: nonconstant
For complex-valued sequences, increasing/decreasing requires an explicitly defined order; do not infer one.

08. FINITE SEQUENCE LENGTH
For nonempty contiguous domain {s,...,t}:
  length = t - s + 1
  last_term = first_term + (length - 1)d
For empty domain, length = 0 and first/last terms are undefined.

09. PARTIAL SUM
For N >= 1 consecutive terms starting at s:
  sum_N = N * (2*a_s + (N-1)*d) / 2
  sum_N = N * (a_s + a_(s+N-1)) / 2
For N = 0: sum_0 = 0
These formulas require scalar multiplication and division by 2 in the value domain or an appropriate equivalent construction.

10. ARITHMETIC MEAN
For three consecutive terms in a compatible field:
  2*a_(n+1) = a_n + a_(n+2)
  a_(n+1) = (a_n + a_(n+2))/2
For an odd-length finite arithmetic sequence, the central term equals the arithmetic mean of all terms.

11. INDEX RECOVERY
If d != 0 and x is a term candidate:
  n = s + (x - a_s)/d
Membership requires n to be an integer in the declared index set.
If d = 0: x belongs to the image iff x = a_s for a nonempty sequence.
For complex or symbolic values, verify division and integer-index membership explicitly.

12. SUBSEQUENCES
Selecting indices s + mk for integer m >= 1 and k >= 0 produces an arithmetic subsequence with difference m*d.
An arbitrary subsequence need not be arithmetic.
A finite contiguous slice retains the original difference d.

13. TRANSFORMATIONS
Translation: b_n = a_n + c => difference(b) = d
Scaling: b_n = c*a_n => difference(b) = c*d
Pointwise sum: c_n = a_n + b_n => difference(c) = d_a + d_b
Pointwise difference: c_n = a_n - b_n => difference(c) = d_a - d_b
These operations require aligned index domains and compatible scalar types.
Reversal of a finite sequence => common_difference = -d

14. LIMIT AND BOUNDEDNESS
For infinite real-valued sequences:
  d = 0 => converges to a_s and is bounded
  d > 0 => diverges to +infinity; unbounded above
  d < 0 => diverges to -infinity; unbounded below
For infinite complex-valued sequences:
  d = 0 => convergent
  d != 0 => modulus tends to infinity; not convergent in Complex
Finite sequences are bounded when their values are finite scalars.

15. RELATION TO LINEAR FUNCTIONS
An arithmetic sequence is the restriction of an affine function f(x) = a_s + (x-s)d to a discrete index set.
The graph of (n,a_n) for real values is collinear.
Do not conflate discrete sequence domain with the full continuous domain of the affine extension.

16. RELATION TO SERIES
An arithmetic series is the sum of terms of an arithmetic sequence.
The sequence of partial sums is generally quadratic in N when d != 0.
For an infinite real/complex arithmetic series, convergence requires all terms to tend to zero; hence it converges only for the identically zero sequence.

17. SEMANTIC GRAPH
ArithmeticSequence --isA--> Sequence
ArithmeticSequence --hasTerm--> SequenceTerm
ArithmeticSequence --hasIndexSet--> IndexSet
ArithmeticSequence --hasFirstTerm--> Scalar
ArithmeticSequence --hasCommonDifference--> Scalar
ArithmeticSequence --supportsOperation--> PartialSum
ArithmeticSequence --hasClosedForm--> AffineExpression
ArithmeticSequence --hasRecurrence--> RecurrenceRelation
ArithmeticSequence --relatedTo--> ArithmeticSeries
ArithmeticSequence --relatedTo--> LinearFunction
ArithmeticSequence --relatedTo--> FiniteSequence
ArithmeticSequence --relatedTo--> InfiniteSequence

18. SEMANTIC EQUIVALENCE
arithmetic progression == arithmetic sequence [terminological equivalence]
'a_n = a_1+(n-1)d' == 'a_n = a_0+nd' ONLY when a_0 = a_1-d and indexing conventions are reconciled
Two arithmetic sequences are extensionally equal iff their index domains coincide and all corresponding terms agree.
For domains containing at least two consecutive indices, equality follows from matching first terms and common differences.
For singleton domains, differing d values may describe the same extensional sequence.

19. INFERENCE RULES
RULE AP_DIFF:
  IF for all adjacent indices, a_(n+1)-a_n = d
  THEN classify sequence as ArithmeticSequence
RULE AP_CLOSED:
  IF a_s and d are known AND n is valid
  THEN derive a_n = a_s+(n-s)d
RULE AP_SECOND_DIFF:
  IF second differences vanish on a contiguous domain with at least three terms
  THEN arithmetic progression holds on that domain
RULE AP_SUM:
  IF N is a nonnegative integer and first term and d are known
  THEN derive partial sum formula
RULE AP_EQUALITY:
  IF domains agree AND first terms and common differences agree
  THEN sequences agree extensionally

20. VALIDATION
check indexing_convention consistency
check declared index_set and term values
check constant consecutive difference where observations suffice
check field and arithmetic type compatibility
check no division by zero in index recovery
check sum length is nonnegative integer
check finite versus infinite properties are not conflated
check exactness and tolerances before asserting equality
check zero and singleton cases explicitly

21. CONFIDENCE
confidence.definition := 1.0 for the mathematical definition under stated axioms
confidence.derived_result := 1.0 when symbolic preconditions are proved
confidence.observed_pattern := provisional until universal/structural conditions are established
confidence.approximate_data := conditional on error bounds and measurement provenance

22. PROVENANCE AND UPDATE MODEL
source_page := https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/sequence-and-series-entities/arithmetic-sequence-ontology.html
source_access_note := Page title and authorship verified; this specification is a mathematical expansion, not a verbatim transcription.
update_model := versioned_semantic_revision
on_update: validate schema; compare rules; record changed axioms; regenerate flow hash; preserve prior version

23. FLOW HASH
FLOW_HASH.algorithm := SHA-256
FLOW_HASH.input := UTF-8 canonicalised ontology content excluding the FLOW_HASH output field
FLOW_HASH.value := COMPUTE_ON_PUBLICATION
Do not treat a placeholder as a computed digest.

24. AI CONSUMPTION
AI_CONSUMPTION.mode := typed_semantic_reasoning
AI_CONSUMPTION.input := {sequence description, index domain, known terms, optional common difference}
AI_CONSUMPTION.output := {classification, canonical form, derived terms, proofs, partial sums, validation, provenance, confidence}
AI_CONSUMPTION.rules := enforce preconditions; distinguish proofs from hypotheses; preserve exact arithmetic; surface index assumptions; reject unsupported inferences

25. TEST CASES
CASE A: a_1=3, d=4 => a_5=19; S_5=55
CASE B: a_0=10, d=-2 => a_3=4
CASE C: [2,5,8,11] => d=3; arithmetic=true
CASE D: [2,5,9] => differences 3,4; arithmetic=false
CASE E: [7] => arithmetic under any chosen d; d not uniquely inferable
CASE F: empty sequence => length=0; sum=0; no first term
CASE G: a_n=2n+1, n>=0 => d=2
CASE H: a_n=5, n>=1 => d=0; infinite sequence converges to 5

26. TERMINATION
status := COMPLETE
ontology := ArithmeticSequenceOntology
all_sections_present := true
END FLOW ALGEBRA