Mathematical Property Ontology

FLOW ALGEBRA
MATHEMATICAL PROPERTY ONTOLOGY
Kireth Semantic Library | Entity Graph | Mathematical Entities | Foundations
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/foundations-of-mathematical-entities/mathematical-property-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | Date: 2026-10-12 | Locale: en-GB
Status: Subject-based formalisation; source page content not independently verified.

01. PURPOSE
flow MathematicalPropertyOntology v1.0:
  goal: Represent, evaluate, infer and validate mathematical properties of typed objects.
  scope: Algebraic, order-theoretic, topological, analytic, combinatorial and logical properties.
  principle: A property claim is distinct from its proof, its evidence and its truth status.

02. TYPES
  type Entity = {id: URI, kind: MathematicalKind, domain: DomainRef}
  type Property = {id: URI, name: String, signature: TypeSignature, definition: Formula}
  type Claim = {subject: Entity, predicate: Property, context: Context, status: TruthStatus}
  type Context = {axioms: Set[Axiom], assumptions: Set[Formula], interpretation: Optional[Model]}
  type Proof = {premises: Set[Formula], conclusion: Formula, steps: List[InferenceStep]}
  type Counterexample = {model: Model, witness: Entity, refuted: Formula}
  type TruthStatus = PROVED | REFUTED | UNDECIDED | INCONSISTENT | UNKNOWN
  type Confidence = {value: Real[0,1], basis: EvidenceType}
  type Provenance = {source: URI, version: String, method: String, timestamp: ISO8601}

03. ENTITY CLASSES
  MathematicalKind := Number | Set | Function | Relation | Operation | Structure |
                      Space | Graph | Sequence | Matrix | Proposition | Model
  PropertyFamily := Algebraic | Order | Topological | Metric | Analytic |
                    Geometric | Combinatorial | Logical | Computational

04. PROPERTY SIGNATURES
  predicate holds: Entity x Property x Context -> TruthStatus
  predicate satisfies: Model x Formula -> Boolean
  predicate entails: Set[Formula] x Formula -> Boolean
  predicate is_invariant_under: Property x Transformation -> Boolean
  predicate implies_property: Property x Property x Context -> Boolean
  predicate equivalent_property: Property x Property x Context -> Boolean
  predicate contradicts_property: Property x Property x Context -> Boolean
  predicate inherited_by: Property x Morphism x Context -> Boolean

05. RELATIONSHIPS
  HAS_PROPERTY(Entity, Property)
  DEFINED_ON(Property, Domain)
  REQUIRES_AXIOM(Property, Axiom)
  IMPLIED_BY(Property, Property)
  EQUIVALENT_UNDER(Property, Property, Context)
  INCOMPATIBLE_WITH(Property, Property, Context)
  PRESERVED_BY(Property, Transformation)
  VERIFIED_BY(Claim, Proof)
  REFUTED_BY(Claim, Counterexample)
  DEPENDS_ON(Claim, Assumption)
  DERIVED_FROM(Claim, Claim)

06. ALGEBRAIC PROPERTIES
  associative(op): forall a,b,c, op(op(a,b),c) = op(a,op(b,c))
  commutative(op): forall a,b, op(a,b) = op(b,a)
  idempotent(op): forall a, op(a,a) = a
  identity_element(op,e): forall a, op(e,a)=a and op(a,e)=a
  inverse_element(op,a,b,e): op(a,b)=e and op(b,a)=e
  distributive(op1,op2): forall a,b,c, op1(a,op2(b,c)) = op2(op1(a,b),op1(a,c))
  closure(op,S): forall a,b in S, op(a,b) in S
  note: All quantifiers are scoped to a declared carrier and well-typed operations.

07. ORDER AND SET PROPERTIES
  reflexive(R): forall x, R(x,x)
  symmetric(R): forall x,y, R(x,y) -> R(y,x)
  antisymmetric(R): forall x,y, (R(x,y) and R(y,x)) -> x=y
  transitive(R): forall x,y,z, (R(x,y) and R(y,z)) -> R(x,z)
  total(R): forall x,y, R(x,y) or R(y,x)
  finite(S): exists n in Natural, cardinality(S)=n
  countable(S): S is finite or admits an injection into Natural

08. TOPOLOGICAL AND METRIC PROPERTIES
  compact(X): every open cover of X has a finite subcover
  connected(X): X cannot be separated into two nonempty disjoint open subsets
  complete(X,d): every Cauchy sequence converges in X
  continuous(f): inverse image of every open set is open
  bounded(A,d): exists M finite and x0, forall x in A, d(x,x0)<=M
  caveat: Completeness requires a specified metric or uniform structure.

09. ANALYTIC AND COMPUTATIONAL PROPERTIES
  differentiable(f,x): derivative exists at x within the stated domain
  integrable(f,measure): integral is defined under the chosen integration theory
  monotone(f,order): x<=y implies f(x)<=f(y)
  decidable(P,representation): exists terminating algorithm deciding P for all valid inputs
  computable(f,representation): exists algorithm computing f to specified semantics
  caveat: Computability claims require a representation and computation model.

10. CLAIM CONSTRUCTION
  input: entity E, property P, context C
  require typecheck(E,P.signature)
  require context_is_explicit(C)
  claim := Claim(E,P,C,UNKNOWN)
  emit claim with provenance and stable identifier

11. PROOF FLOW
  input: Claim(E,P,C), candidate Proof pi
  verify each proof step against accepted inference rules
  verify all premises follow from C.axioms or C.assumptions
  if derivation proves P(E): status := PROVED
  else: status := UNKNOWN
  output: status, proof trace, dependencies

12. COUNTEREXAMPLE FLOW
  input: universal property claim and candidate model M
  check model satisfies declared axioms and typing
  check witness violates the claimed property
  if both checks pass: status := REFUTED
  else: status := UNKNOWN
  output: validated witness and model provenance

13. PROPERTY INFERENCE
  rule R1: associative(op) and identity_element(op,e) and
           all_elements_have_inverses(op,e) -> group_axioms_hold(op)
  rule R2: reflexive(R) and antisymmetric(R) and transitive(R) -> partial_order(R)
  rule R3: partial_order(R) and total(R) -> total_order(R)
  rule R4: continuous(f) and compact(domain(f)) -> compact(image(f))
           [topological spaces; f maps domain into codomain]
  rule R5: differentiable(f,x) -> continuous_at(f,x)
           [real or normed-space differentiability under standard assumptions]
  require: Rule preconditions, types and contexts are checked before inference.

14. SEMANTIC EQUIVALENCE
  SEMANTIC_EQUIVALENCE(P,Q,C):
    require compatible signatures and domains
    prove forall x in domain(C), P(x) <-> Q(x)
    return PROVED only if both directions are formally established
    return UNKNOWN otherwise; similarity alone does not establish equivalence

15. CONSTRAINTS AND CONSISTENCY
  prohibit conflation of property name with its formal definition
  prohibit inference across incompatible domains without a mapping theorem
  detect conflicting claims within the same context
  distinguish undecidable, unproved, false and inconsistent
  preserve assumptions when propagating claims

16. CONFIDENCE
  CONFIDENCE(claim):
    if machine_checked_proof(claim): value := 1.0; basis := FORMAL_PROOF
    else if validated_counterexample(claim): value := 1.0; basis := FORMAL_REFUTATION
    else: value := calibrated_estimate(evidence); basis := EVIDENTIAL
  note: Confidence in evidence is not a substitute for mathematical truth.

17. FLOW_HASH
  FLOW_HASH(claim):
    payload := canonicalise(entity_id, property_definition, domain,
                            axioms, assumptions, proof_dependencies, version)
    return SHA256(UTF8(payload))
  require deterministic canonicalisation and versioned serialization

18. UPDATE_MODEL
  UPDATE_MODEL(new_axiom_or_proof):
    validate incoming artefact
    update dependency graph
    invalidate claims dependent on changed assumptions
    recompute affected truth statuses and hashes
    preserve previous versions and provenance

19. AI_CONSUMPTION
  AI_CONSUMPTION:
    emit typed JSON-compatible entities, properties and claims
    emit machine-readable formula ASTs and proof dependencies
    expose truth status, assumptions, domain, confidence and provenance
    provide human-readable explanation without overstating certainty
    reject unsupported automatic theorem assertions

20. EXAMPLE: PARTIAL ORDER
  carrier := {a,b,c}
  R := {(a,a),(b,b),(c,c),(a,b),(b,c),(a,c)}
  derive reflexive(R) = true
  derive antisymmetric(R) = true
  derive transitive(R) = true
  infer partial_order(R) = true
  proof_status := PROVED under explicitly enumerated finite relation

21. EXAMPLE: COMMUTATIVITY COUNTEREXAMPLE
  domain := 2x2 real matrices
  op := matrix_multiplication
  A := [[1,1],[0,1]]
  B := [[1,0],[1,1]]
  A*B := [[2,1],[1,1]]
  B*A := [[1,1],[1,2]]
  infer not commutative(op)
  witness := (A,B)

22. VALIDATION CHECKLIST
  [ ] Entity and property signatures are type-safe
  [ ] Domains and quantifier scopes are explicit
  [ ] Axioms and assumptions are versioned
  [ ] Proofs are independently checkable
  [ ] Counterexamples satisfy context constraints
  [ ] Inference rules preserve logical validity
  [ ] Provenance and dependency graphs are retained
  [ ] FLOW_HASH is reproducible
  [ ] AI output distinguishes proof from prediction

23. INTEGRATION
  parent: Foundations of Mathematical Entities
  siblings: Mathematical Entity, Mathematical Object, Abstract Object,
            Mathematical Structure, Mathematical System, Mathematical Domain
  links: Mathematical Relation Ontology; Mathematical Operation Ontology;
         Mathematical Logic; Proof Theory; Set Theory; Algebra; Topology

24. LIMITATIONS
  This is an executable-style conceptual Flow Algebra specification, not a
  parser-validated program for a particular runtime. Mathematical statements
  require explicit interpretations, axioms and proof checks before deployment.

END FLOW ALGEBRA