Number Entities

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA
NUMBER ENTITIES — INTEGRATED ONTOLOGY
Kireth Semantic Library | Version 1.0 | 2026-10-12
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/number-entities.html
Status: Expanded formalisation of the 17 child ontologies listed on the source page; not a transcription of embedded child specifications.

01. PURPOSE
flow NumberEntities v1.0:
  mode: typed_declarative_reasoning
  domain: mathematical_entities.number_entities
  interpretation: formal_rules_with_explicit_preconditions
  output: classifications, derivations, proofs, provenance

02. TYPE SYSTEM
  NumberEntity := value + representation + mathematical_context
  Natural := {1,2,3,...}                         # convention: excludes zero
  Whole := {0,1,2,3,...}
  Integer := {...,-2,-1,0,1,2,...}
  Rational := {p/q | p,q in Integer, q != 0}
  Irrational := Real \ Rational
  Real := complete_ordered_field
  Complex := {a+bi | a,b in Real, i*i=-1}
  PureImaginary := {bi | b in Real, b != 0}
  Algebraic := {z in Complex | exists nonzero p in Integer[x], p(z)=0}
  Transcendental := Complex \ Algebraic
  Prime := {n in Natural | n>1 and divisors(n)={1,n}}
  Composite := {n in Natural | n>1 and exists a,b in Natural, 1<a<n, 1<b<n, n=a*b}
  SignedNumber := NumberEntity with sign in {negative,zero,positive} where ordered
  Cardinal := equivalence_class_of_sets_under_bijection
  Ordinal := order_type_of_well_ordered_set
  InfiniteCardinal := cardinal_of_infinite_set
  InfiniteOrdinal := ordinal_not_equal_to_any_finite_ordinal

03. ONTOLOGY REGISTRY — 17 CHILD FAMILIES
  Number Ontology
  Natural Number Ontology
  Whole Number Ontology
  Integer Ontology
  Rational Number Ontology
  Irrational Number Ontology
  Real Number Ontology
  Complex Number Ontology
  Imaginary Number Ontology
  Algebraic Number Ontology
  Transcendental Number Ontology
  Cardinal Number Ontology
  Ordinal Number Ontology
  Prime Number Ontology
  Composite Number Ontology
  Signed Number Ontology
  Infinite Number Ontology

04. ENTITY SCHEMA
  entity Number:
    id: URI
    canonical_value: ExactValue | SymbolicExpression
    domain: NumberDomain
    representations: list[Representation]
    properties: set[Predicate]
    provenance: Provenance
    confidence: ConfidenceRecord
  entity Representation:
    notation: string
    radix: integer?                 # for positional numerals
    exact: boolean
    precision: integer?
  entity Proof:
    proposition: Formula
    premises: list[Formula]
    derivation: list[InferenceStep]
    verifier: ProofChecker
    status: {proved,disproved,unknown}

05. DOMAIN INCLUSION AND EXCLUSIONS
  Natural subset Whole subset Integer subset Rational subset Real subset Complex
  Irrational subset Real
  Algebraic subset Complex
  Transcendental subset Complex
  Rational subset Algebraic
  Real = Rational disjoint_union Irrational
  Complex = Algebraic disjoint_union Transcendental
  Prime subset Natural
  Composite subset Natural
  Prime intersect Composite = empty_set
  PureImaginary subset Complex
  Note: PureImaginary excludes zero by convention here.

06. IDENTIFICATION AND CANONICALISATION
  NORMALISE_RATIONAL(p,q):
    require q != 0
    d := gcd(abs(p),abs(q))
    p1 := p/d; q1 := q/d
    if q1 < 0: p1 := -p1; q1 := -q1
    return Rational(p1,q1)
  EQUAL_RATIONAL(p/q,r/s):
    require q != 0 and s != 0
    return p*s == r*q
  NORMALISE_COMPLEX(a,b): return Complex(a,b)
  Rule: different numeral strings may denote the same number.
  Rule: numerical approximation alone does not establish exact equality.

07. CLASSIFICATION RULES
  if n in Integer and n >= 1: infer Natural(n)
  if n in Integer and n >= 0: infer Whole(n)
  if n in Integer: infer Rational(n/1)
  if x in Rational: infer Real(x) and Algebraic(x)
  if x in Irrational: infer Real(x) and not Rational(x)
  if z in Transcendental: infer not Algebraic(z)
  if n in Integer and n > 1 and is_prime_verified(n): infer Prime(n)
  if n in Integer and n > 1 and exists verified_nontrivial_factor(n): infer Composite(n)
  if x in Real and x > 0: infer Sign(x,positive)
  if x in Real and x < 0: infer Sign(x,negative)
  if x in Real and x == 0: infer Sign(x,zero)
  Do not infer ordering of arbitrary complex numbers.

08. OPERATIONS AND CLOSURE
  Integer closed_under {addition,subtraction,multiplication}
  Rational closed_under {addition,subtraction,multiplication}
  Rational division closed if divisor != 0
  Real is complete ordered field
  Complex is algebraically closed field
  Natural subtraction not universally closed
  Prime numbers not closed under addition or multiplication
  CARDINAL_ADDITION(A,B): cardinal(disjoint_union(A,B))
  CARDINAL_MULTIPLICATION(A,B): cardinal(cartesian_product(A,B))
  ORDINAL_ADDITION(alpha,beta): order_type(concatenation(alpha,beta))
  Note: ordinal addition generally noncommutative.

09. NUMBER THEORY
  DIVIDES(a,b): exists k in Integer such that b=a*k
  GCD(a,b): greatest_nonnegative_common_divisor(a,b)
  EUCLIDEAN_DIVISION(a,b):
    require a,b in Integer and b != 0
    return q,r where a=b*q+r and 0<=r<abs(b)
  PRIME_TEST(n):
    require n in Integer and n>=2
    return verified_prime_or_composite_with_certificate
  FUNDAMENTAL_THEOREM_ARITHMETIC:
    for every n in Integer with n>1, unique prime factorisation up to ordering

10. REAL AND COMPLEX ANALYSIS
  COMPLEX_CONJUGATE(a+bi) := a-bi
  COMPLEX_MODULUS(a+bi) := sqrt(a*a+b*b)
  COMPLEX_MULTIPLY(a+bi,c+di) := (ac-bd)+(ad+bc)i
  REAL_COMPLETENESS: every nonempty bounded-above subset of Real has a supremum
  Algebraic real examples: sqrt(2), rational numbers
  Transcendental real examples: pi, e
  Note: classification of arbitrary expressions may be undecidable or unknown.

11. INFINITY AND SET THEORY
  Distinguish unbounded finite values from actual infinite cardinals/ordinals.
  CountablyInfinite(A): exists bijection A <-> Natural
  Equinumerous(A,B): exists bijection A <-> B
  CardinalLessEqual(A,B): exists injection A -> B
  CantorTheorem(A): cardinal(A) < cardinal(power_set(A))
  omega := first infinite ordinal
  aleph_0 := cardinality(Natural)
  omega and aleph_0 have different semantic types.
  Infinity is not treated as an ordinary real number.

12. GRAPH RELATIONSHIPS
  is_subtype_of(NumberDomain,NumberDomain)
  has_representation(NumberEntity,Representation)
  equivalent_value(NumberEntity,NumberEntity)
  has_property(NumberEntity,Predicate)
  is_operand_of(NumberEntity,Operation)
  is_result_of(NumberEntity,Operation)
  has_proof(Claim,Proof)
  derives_from(Claim,Premise)
  belongs_to(NumberEntity,NumberDomain)
  maps_to(Representation,CanonicalValue)
  contradicts(Claim,Claim)

13. SEMANTIC_EQUIVALENCE
  SEMANTIC_EQUIVALENCE(a,b):
    require same mathematical context and compatible types
    return PROVED if normal_forms_equal_or_equivalence_proof(a,b)
    return DISPROVED if verified_counterexample(a,b)
    return UNKNOWN otherwise
  Example: 1/2 equivalent_value 2/4
  Example: sqrt(4) equivalent_value 2 under principal real square root
  Nonexample: ordinal omega+1 is not ordinal 1+omega

14. INFERENCE AND PROOF CONTROL
  INFER(goal,premises):
    require premises are typed and provenance is retained
    choose sound inference rules
    produce proof object or UNKNOWN
    reject circular justification without independently grounded base case
  VERIFY(proof):
    check well_formedness
    check each premise and inference step
    check domain constraints and excluded cases
    return verified | invalid | unresolved
  Closed-world negation prohibited unless domain is explicitly complete.

15. CONFIDENCE
  CONFIDENCE(claim):
    proof_status: {verified,disproved,unresolved}
    evidence_quality: {formal,computed,empirical,unverified}
    numerical_certainty: [0,1]?
    provenance: list[Source]
  A verified theorem has logical status VERIFIED; probabilistic confidence
  must never replace a formal proof or conceal unresolved premises.

16. FLOW_HASH
  FLOW_HASH(flow):
    canonicalise schema, ontology version, premises, rules and output
    serialize deterministically as UTF-8
    digest := SHA-256(serialized_bytes)
    return lowercase_hex(digest)
  Exclude volatile execution timestamps from semantic content digest.
  Hash equality indicates byte-identical canonical inputs, not truth.

17. UPDATE_MODEL
  UPDATE_MODEL(change):
    validate typed change and source
    compute affected dependency subgraph
    invalidate stale classifications and proofs
    recompute derivations in dependency order
    preserve prior versions and provenance
    publish only verified or explicitly marked unresolved results

18. AI_CONSUMPTION
  AI_CONSUMPTION(request):
    parse requested mathematical context
    resolve symbols and conventions
    retrieve typed entities and rules
    check assumptions and boundary conditions
    execute sound inference or certified computation
    return result + proof_status + provenance + uncertainty
  Do not convert UNKNOWN to TRUE.
  Do not conflate mathematical existence with physical measurement.

19. VALIDATION INVARIANTS
  assert not Prime(1)
  assert not Composite(1)
  assert Whole(0) and not Natural(0) under this document's convention
  assert Rational(0) and Real(0) and Complex(0)
  assert Irrational(sqrt(2))
  assert Algebraic(sqrt(2))
  assert Transcendental(pi)
  assert Complex(i) and PureImaginary(i)
  assert not Real(i)
  assert ordinal_add(omega,1) != ordinal_add(1,omega)
  assert no_division_by_zero

20. INTEROPERABILITY
  aligns_with: Mathematical Entity Ontology
  aligns_with: Mathematical Object Ontology
  aligns_with: Mathematical Structure Ontology
  aligns_with: Mathematical Relation Ontology
  aligns_with: Mathematical Operation Ontology
  aligns_with: Mathematical Representation Ontology
  aligns_with: Set Theory Ontologies
  aligns_with: Mathematical Logic Ontologies
  mapping_policy: preserve mathematical type, domain, proof obligations and notation conventions

21. EXECUTION PIPELINE
  INPUT -> PARSE -> TYPE_CHECK -> CANONICALISE -> CLASSIFY
        -> INFER -> VERIFY -> PROVENANCE -> FLOW_HASH -> OUTPUT
  failure: emit typed error or unresolved result; never fabricate proof.

22. OUTPUT CONTRACT
  result:
    entity_id: URI
    canonical_value: ExactValue
    domain_memberships: list[NumberDomain]
    semantic_links: list[Relationship]
    proof_status: ProofStatus
    confidence: ConfidenceRecord
    flow_hash: SHA256
    version: string
    provenance: list[Source]

23. LIMITATIONS
  This flow is an executable-style formal specification, not a deployed proof engine.
  Actual evaluation requires implementations of exact arithmetic, symbolic
  manipulation, set theory and proof checking. Set-theoretic assertions assume
  conventional classical foundations (ZFC where relevant). Independent child
  ontologies may specify additional conventions requiring reconciliation.

24. AUTHORSHIP AND LICENCE NOTICE
  Mark Anthony Higgins — Sky (Recursive AI)
  Kireth Semantic Library | https://kirethresearch.org
  This text is a newly authored integration of the source page's visible taxonomy.
END FLOW ALGEBRA