Countability Ontology

FLOW ALGEBRA
TITLE: Countability Ontology
VERSION: 1.0
DOMAIN: Discrete Mathematics / Foundations / Countability
SOURCE_URL: https://kirethresearch.org/booksai-core/discrete-mathematics-ontologies/foundations-of-discrete-mathematics/countability-ontology.html
STATUS: Domain-based formalisation; source page content not independently verified.
AUTHORS: Mark Higgins — Sky (Recursive AI)
SITE: https://kirethresearch.org

1. ONTOLOGY
flow CountabilityOntology v1.0 {
  entity Set { id: URI; members: Collection<O-bject>; }
  entity NaturalNumber { value: Integer where value >= 0; }
  entity Mapping { domain: Set; codomain: Set; rule: -Expression; }
  entity Enumeration { target: Set; sequence: Mapping; }
  entity Cardinality { set: Set; size: CardinalValue; }
  entity Proof { proposition: Proposition; premises: List<Proposition>; derivation: List<Step>; }
  enum CardinalClass { FINITE, COUNTABLY_INFINITE, UNCOUNTABLE, UNKNOWN }
  relation MEMBER_OF(Object, Set)
  relation SUBSET_OF(Set, Set)
  relation INJECTION(Mapping, Set, Set)
  relation SURJECTION(Mapping, Set, Set)
  relation BIJECTION(Mapping, Set, Set)
  relation EQUINUMEROUS(Set, Set)
  relation ENUMERATES(Enumeration, Set)
}

2. SEMANTICS
COUNTABLE(S) := FINITE(S) OR EXISTS f: N -> S WHERE SURJECTION(f, N, S).
COUNTABLY_INFINITE(S) := EXISTS f: N -> S WHERE BIJECTION(f, N, S).
UNCOUNTABLE(S) := NOT COUNTABLE(S).
EQUINUMEROUS(A,B) := EXISTS f: A -> B WHERE BIJECTION(f,A,B).
FINITE(S) := EXISTS n IN N WHERE EQUINUMEROUS(S,{0,...,n-1}).
N := {0,1,2,...}.

3. INFERENCE RULES
R1: FINITE(S) => COUNTABLE(S).
R2: BIJECTION(f,N,S) => COUNTABLY_INFINITE(S).
R3: COUNTABLY_INFINITE(S) => COUNTABLE(S) AND NOT FINITE(S).
R4: SUBSET_OF(A,B) AND COUNTABLE(B) => COUNTABLE(A).
R5: COUNTABLE(A) AND COUNTABLE(B) => COUNTABLE(A UNION B).
R6: COUNTABLE(A) AND COUNTABLE(B) => COUNTABLE(A CROSS B).
R7: COUNTABLE(A_i) FOR EACH i IN N => COUNTABLE(UNION_{i IN N} A_i), with an explicit countable indexed family.
R8: SURJECTION(f,N,S) => COUNTABLE(S).
R9: INJECTION(f,S,N) => COUNTABLE(S).
R10: EXISTS injection f:N->S AND EXISTS injection g:S->N => COUNTABLY_INFINITE(S), by Cantor–Bernstein.
R11: FOR ANY S, NOT EXISTS surjection f:S->POWERSET(S), by Cantor's theorem.
R12: COUNTABLY_INFINITE(S) => UNCOUNTABLE(POWERSET(S)).
R13: BIJECTION(f,A,B) => EQUINUMEROUS(A,B).
R14: EQUINUMEROUS(A,B) AND EQUINUMEROUS(B,C) => EQUINUMEROUS(A,C).

4. VALIDATION
- Verify function domain, codomain and totality before classifying a mapping.
- Injection: distinct inputs yield distinct outputs.
- Surjection: every codomain element has a preimage.
- Bijection: injection AND surjection.
- Do not infer uncountability from failure to find an enumeration.
- Distinguish finite, countably infinite, and uncountable sets.
- Require a proof or an explicitly cited theorem for cardinality classification.
- Preserve assumptions and the chosen definition of natural numbers.

5. EXAMPLES
N: COUNTABLY_INFINITE.
Z: COUNTABLY_INFINITE (e.g. 0,1,-1,2,-2,...).
Q: COUNTABLY_INFINITE (enumeration by reduced numerator/denominator pairs).
R: UNCOUNTABLE (Cantor diagonal argument).
POWERSET(N): UNCOUNTABLE.
Any finite alphabet's finite strings: COUNTABLE; countably infinite for a nonempty alphabet.

6. CONFIDENCE
CONFIDENCE(claim) := {score: Real[0,1], evidence: List<Proof|Reference>, method: String}.
A numerical confidence score describes evidence assessment, not mathematical truth.
Formal derivations must be checked independently of confidence estimates.

7. SEMANTIC_EQUIVALENCE
SEMANTIC_EQUIVALENCE("denumerable", "countably infinite") := true in standard set-theoretic usage.
SEMANTIC_EQUIVALENCE("at most countable", "countable") := true under the definition in section 2.
SEMANTIC_EQUIVALENCE("countable", "countably infinite") := false, because finite sets are countable here.

8. PROVENANCE
PROVENANCE := {source_url: SOURCE_URL, origin: "domain-based draft", author_credit: AUTHORS, version: VERSION, assumptions: ["classical set theory", "standard natural numbers"]}.

9. FLOW_HASH
FLOW_HASH := SHA256(canonical_utf8(ontology_without_FLOW_HASH_value)).
Hash is computed by the consuming implementation; no hash value is asserted in this draft.

10. UPDATE_MODEL
UPDATE_MODEL(change) := validate_schema(change) -> check_proofs(change) -> preserve_provenance(change) -> increment_version(change) -> recompute_FLOW_HASH(change).
Never silently alter established mathematical definitions or proof assumptions.

11. AI_CONSUMPTION
AI_CONSUMPTION := {mode: "read-only mathematical knowledge", parse: "typed entities and relations", reasoning: "proof-grounded inference", ambiguity: "request definitions and assumptions", output: "claims with derivations and provenance", safety: "no unverified theorem assertion"}.

END FLOW ALGEBRA