Recursive Sequence Entity Ontology

FLOW ALGEBRA
Recursive Sequence Entity Ontology
Kireth Semantic Library | Mathematical Entities > Recursive Mathematical Entities
Version: 1.0 | Date: 2026-10-14 | Locale: en-GB
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/recursive-mathematical-entities/recursive-sequence-entity-ontology.html
Source alignment: PENDING (page not accessible for verification). This is a mathematically grounded proposed formalisation, not a transcription.
Authors: Mark Higgins — Sky (Recursive AI)

1. PURPOSE
Represent recursively defined sequences as typed mathematical entities with initial conditions, index domains, recurrence operators, dependency structure, well-definedness, inference, evaluation, and provenance.

2. TYPE SYSTEM
entity RecursiveSequence <: Sequence
entity IndexDomain : Subset(Integer)
entity ValueDomain : Set
entity SequenceTerm : (index: Integer, value: ValueDomain)
entity InitialCondition : (index: Integer, value: ValueDomain)
entity RecurrenceRule : (order: PositiveInteger, expression: -Expression)
entity RecurrenceDependency : (target_index: Integer, source_indices: List(Integer))
entity TerminationCriterion : Predicate
entity ConvergenceClaim : (limit: ValueDomain, assumptions: Set)
entity EvaluationTrace : List(SequenceTerm)
entity Provenance : (source_url: URI, version: String, verified: Boolean)

3. CORE SIGNATURE
flow RecursiveSequenceEntity(
  sequence_id: Identifier,
  index_domain: IndexDomain,
  value_domain: ValueDomain,
  initial_conditions: List(InitialCondition),
  recurrence: RecurrenceRule,
  assumptions: Set,
  requested_indices: List(Integer)
) -> (terms: List(SequenceTerm), trace: EvaluationTrace, validation: ValidationResult)

4. RELATIONSHIPS
RecursiveSequence HAS_INDEX_DOMAIN IndexDomain
RecursiveSequence HAS_VALUE_DOMAIN ValueDomain
RecursiveSequence HAS_INITIAL_CONDITION InitialCondition
RecursiveSequence DEFINED_BY RecurrenceRule
SequenceTerm DEPENDS_ON SequenceTerm
RecurrenceRule HAS_ORDER PositiveInteger
EvaluationTrace DERIVED_FROM RecurrenceRule
ConvergenceClaim REQUIRES Assumptions
RecursiveSequence IS_A MathematicalEntity

5. FORMAL SEMANTICS
For order k >= 1, an initial-value recurrence may be expressed as:
  a_n = F(n, a_(n-1), ..., a_(n-k)) for n >= n0 + k
with k supplied initial values a_(n0), ..., a_(n0+k-1).
The function F must be defined on every encountered input and map to the declared value domain.
A recurrence can be nonlinear, nonhomogeneous, nonautonomous, or vector-valued.
Recursively defined does not imply convergence or monotonicity.

6. INFERENCE RULES
RULE INITIAL: given InitialCondition(i,v), infer a_i = v.
RULE STEP: if all dependencies of a_n are established and F is defined, infer a_n = F(n, dependencies).
RULE UNIQUENESS: if the required initial conditions are fixed and F is single-valued and total on reachable states, the forward sequence is unique.
RULE INDUCTION: prove property P for initial indices and prove the recurrence preserves P; then infer P for all reachable indices.
RULE EQUIVALENCE: two recursive representations are equivalent only on a specified common index domain when their terms agree there; identical notation alone is insufficient.
RULE CONVERGENCE: infer convergence only from an independently justified theorem or proof with assumptions recorded.

7. VALIDATION CONSTRAINTS
V01: recurrence order k must be a positive integer.
V02: initial conditions must cover all required seed indices.
V03: no conflicting values for the same initial index.
V04: every dependency must be resolvable from earlier established terms for forward evaluation, unless a separate well-founded scheme is declared.
V05: every evaluated expression must be defined and its output belong to ValueDomain.
V06: indices must lie in IndexDomain.
V07: detect cyclic dependencies without a justified fixed-point interpretation.
V08: evaluation budgets must be bounded for computation; budget exhaustion means incomplete, not mathematically undefined.
V09: distinguish a finite requested prefix from an infinite sequence.
V10: claims about limits, closed forms, complexity and stability require independent evidence.

8. EXECUTION MODEL
validate_schema -> validate_seeds -> construct_dependency_graph -> check_well_foundedness -> evaluate_terms -> verify_domain -> record_trace -> emit_results
On failure, return a typed diagnostic and retain already verified terms without presenting uncomputed values as established.

9. WORKED EXAMPLES
EXAMPLE A: Fibonacci sequence
  domain: n >= 0; values: nonnegative integers
  a_0 = 0; a_1 = 1; a_n = a_(n-1) + a_(n-2) for n >= 2
  computed terms: 0, 1, 1, 2, 3, 5, 8, 13
  order: 2
EXAMPLE B: Geometric recurrence
  a_0 = 3; a_n = 2*a_(n-1) for n >= 1
  computed terms: 3, 6, 12, 24, 48
  closed form (verified by induction): a_n = 3*2^n
EXAMPLE C: Nonlinear recurrence
  a_0 = 1; a_n = (a_(n-1))^2 + 1 for n >= 1
  computed terms: 1, 2, 5, 26, 677
  nonlinear does not mean non-recursive.

10. SEMANTIC EQUIVALENCE
Aliases: recurrence-defined sequence; recursively specified sequence.
Related but distinct: recursive function, recurrence relation, iterative algorithm, generating function, closed-form sequence, fixed-point equation.
A recurrence relation is a rule; a recursive sequence is the indexed object specified by that rule together with suitable conditions.

11. CONFIDENCE AND PROVENANCE
CONFIDENCE:
  mathematical_examples: 1.00 (directly verifiable)
  formalisation_status: proposed
  source_page_alignment: unverified
  note: numeric confidence is not a substitute for proof.
PROVENANCE:
  origin: Kireth Semantic Library URL above
  retrieval: unavailable at creation
  validation: mathematical consistency review required before publication

12. FLOW HASH AND UPDATE MODEL
FLOW_HASH:
  algorithm: SHA-256
  canonicalisation: UTF-8; LF line endings; stable field order; exclude the FLOW_HASH value itself
  value: COMPUTE_ON_PUBLICATION
UPDATE_MODEL:
  version: 1.0
  revision_policy: semantic-versioning
  triggers: source-page alignment; corrected theorem; changed schema; additional examples
  backwards_compatibility: document any type or signature changes

13. AI_CONSUMPTION
machine_readable: true
entity_resolution: typed identifiers and explicit index domains
reasoning: forward recurrence evaluation; induction with explicit proof obligations
retrieval_keys: recursive sequence, recurrence, seed values, dependency, induction
safety_checks: no fabricated terms; no unsupported convergence claims; report unresolved dependencies
output_contract: terms + trace + validation + provenance + confidence status

END FLOW ALGEBRA