Identity Ontology

FLOW ALGEBRA
IDENTITY ONTOLOGY
Kireth Semantic Library | Mathematical Entities | Equation and Statement Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/equation-and-statement-entities/identity-ontology.html
Version: 1.0 | Date: 2026-10-13 | Locale: en-GB
Authors: Mark Higgins — Sky (Recursive AI)
Status: Mathematical reference model; source webpage not independently verified.

01. PURPOSE
flow "IdentityOntology" v1.0
  intent: represent, classify, verify and reason about mathematical identities
  domain: mathematical_logic + symbolic_algebra + formal_semantics
  output: typed identity entities, conditions, proofs, equivalence links and validation

02. CORE TYPES
  type Expression = syntax_tree with typed variables and operators
  type Domain = set of admissible assignments
  type Context = {assumptions, definitions, interpretation, branch_conventions}
  type Identity = {lhs:E-xpression, rhs:E-xpression, variables:Set, domain:Domain,
                   context:Context, proof:Proof?, status:VerificationStatus}
  enum VerificationStatus = {proved, disproved, conjectured, unverified, conditional}
  type Counterexample = {assignment, lhs_value, rhs_value}
  type Proof = {method, premises, derivation, verifier}

03. DEFINITION
  identity(lhs,rhs,D,C) iff forall assignment s in D:
    defined(lhs,s,C) and defined(rhs,s,C) and eval(lhs,s,C) = eval(rhs,s,C)
  identity is a universally valid equality on its stated domain and context
  equation(lhs,rhs) may instead ask for particular satisfying assignments
  syntactic_equality != semantic_identity
  undefined terms cannot establish an identity at excluded inputs

04. ENTITY GRAPH
  node Identity is_a MathematicalStatement
  node Identity is_a EqualityStatement
  node Identity has_left_expression Expression
  node Identity has_right_expression Expression
  node Identity has_domain Domain
  node Identity has_context Context
  node Identity has_quantification UniversalQuantification
  node Identity may_have Proof
  node Identity may_have Counterexample
  node Identity has_verification_status VerificationStatus
  edge equivalent_under_context(Identity, Identity, Context)
  edge derived_from(Identity, IdentityOrAxiom)
  edge uses_rule(Proof, InferenceRule)

05. IDENTITY CLASSES
  algebraic_identity: polynomial/rational/algebraic equivalence under constraints
  trigonometric_identity: trigonometric equivalence with angle conventions
  logarithmic_identity: logarithm laws with positive real arguments and valid bases
  exponential_identity: exponent laws with specified real/complex domains
  set_identity: equality of sets under set operations
  logical_identity: equivalence of propositions under all admissible valuations
  matrix_identity: matrix equality with compatible dimensions
  functional_identity: equality of functions over a shared domain
  definitional_identity: equality arising from an explicit definition
  conditional_identity: equality universally true only under stated assumptions

06. BASIC EXAMPLES
  forall x in Real: x + 0 = x
  forall x in Real: x * 1 = x
  forall a,b in Real: (a+b)^2 = a^2 + 2*a*b + b^2
  forall x in Real: sin(x)^2 + cos(x)^2 = 1
  forall x in Real excluding 0: x/x = 1
  forall x>0,y>0: ln(x*y) = ln(x)+ln(y)
  forall sets A,B: A union B = B union A
  forall propositions P: P or not P = True (classical logic)

07. DOMAIN AND ASSUMPTION CONTROL
  require explicit numeric structure: Real, Complex, Integer, etc.
  require denominator != 0 wherever division occurs
  require radicand >= 0 for real square root
  require logarithm arguments > 0 for real logarithms
  require base > 0 and base != 1 for real logarithm base
  require dimensions compatible for matrix expressions
  require explicit principal branches for complex logarithms and powers
  reject silent extension across singularities or branch cuts

08. EQUALITY AND EQUIVALENCE
  reflexive: a = a when a is defined
  symmetric: a = b implies b = a
  transitive: a = b and b = c implies a = c
  congruence: equal operands may be substituted into defined operations
  semantic_equivalence(lhs,rhs,D,C) = identity(lhs,rhs,D,C)
  alpha_equivalence applies to consistently renamed bound variables
  notation_equivalence requires same meaning, domain and interpretation

09. TRANSFORMATION RULES
  rule expand: (a+b)^2 -> a^2+2*a*b+b^2
    precondition: commutative ring
  rule factor: a^2-b^2 -> (a-b)*(a+b)
    precondition: commutative ring
  rule distribute: a*(b+c) -> a*b+a*c
    precondition: distributive multiplication
  rule cancel: (a*b)/a -> b
    precondition: a != 0 and division defined
  rule reciprocal: 1/(1/x) -> x
    precondition: x != 0
  every transformation records assumptions and preserves the stated domain

10. PROOF STRATEGIES
  strategy symbolic_normalisation: reduce both sides to same canonical form
  strategy algebraic_derivation: sequence of justified equalities
  strategy structural_induction: prove identity over recursively defined objects
  strategy mathematical_induction: base case and inductive step
  strategy truth_table: exhaustive Boolean valuations
  strategy theorem_prover: verified formal derivation
  strategy counterexample_search: disprove with one admissible assignment
  numeric_sampling: diagnostic only; never sufficient proof over infinite domains

11. VALIDATION FLOW
  input: candidate Identity
  parse lhs and rhs into typed syntax trees
  validate variable bindings and expression types
  resolve definitions, domains, assumptions and branch conventions
  check definedness of both expressions over claimed domain
  normalise or derive proof using sound transformations
  if proof verified: status = proved
  else if valid counterexample found: status = disproved
  else: status = unverified
  emit proof or counterexample and validation trace

12. INFERENCE RULES
  IF proved identity(A,B,D,C) THEN infer equivalent(A,B,D,C)
  IF proved identity(A,B,D,C) AND proved identity(B,E,D,C)
    THEN infer identity(A,E,D,C)
  IF identity(A,B,D,C) AND D2 subset_of D
    THEN infer identity(A,B,D2,C) provided both sides remain defined
  IF admissible counterexample s yields eval(A,s) != eval(B,s)
    THEN infer NOT identity(A,B,D,C)
  IF transform changes domain THEN preserve original domain metadata
  IF identity lacks proof THEN do not label as mathematically proved

13. REPRESENTATION AND SERIALISATION
  entity_id: stable URI or namespaced identifier
  notation: Unicode and optional LaTeX/MathML representations
  lhs_ast: typed abstract syntax tree
  rhs_ast: typed abstract syntax tree
  quantifiers: explicit variables and domains
  assumptions: structured predicates
  verification: status, proof, verifier, timestamp
  provenance: source URI, edition, author, transformation history

14. SEMANTIC SEARCH AND RETRIEVAL
  index canonical expression trees and structural patterns
  support variable-renaming-safe pattern matching
  search by operator, domain, theorem, identity class and assumptions
  avoid equating superficially similar expressions with different domains
  rank verified proofs above unverified assertions for proof queries
  return counterexamples when requested identity is false

15. CONFIDENCE
  mathematical_truth: derived from formal verification, not a probability score
  confidence.proof_verified: high only when verifier checks derivation
  confidence.symbolic_check: provisional until proof obligations discharged
  confidence.numeric_test: heuristic evidence only
  confidence.source_alignment: unverified until page content checked
  do not conflate confidence with universal validity

16. SEMANTIC_EQUIVALENCE
  compare expressions under shared domains, assumptions and interpretations
  require proof of bidirectional equality for semantic identity
  distinguish same_symbol, same_syntax, same_value and same_function
  canonicalise commutative operands only where commutativity is valid
  preserve singularities and complex branch conventions

17. FLOW_HASH
  hash_input = canonical_serialisation({
    ontology_version, lhs_ast, rhs_ast, domain, assumptions,
    interpretation, branch_conventions, verification_status, proof_reference
  })
  FLOW_HASH = SHA256(UTF8(hash_input))
  require deterministic ordering and Unicode normalisation
  rehash when proof, assumptions or mathematical meaning changes

18. UPDATE_MODEL
  change_detection: compare canonical entity versions and source metadata
  versioning: immutable historical revisions
  dependency_tracking: invalidate derived identities when premises change
  review_trigger: new counterexample, proof correction, changed domain
  audit: retain editor, timestamp, rationale and previous FLOW_HASH

19. AI_CONSUMPTION
  expose machine-readable types, relations, rules and proof obligations
  require model to state domain and assumptions when presenting identities
  separate theorem, conjecture, definition and numerical observation
  prefer exact symbolic computation over floating-point equality tests
  flag undefined expressions and ambiguous notation
  return derivation, conditions, confidence metadata and source provenance

20. QUALITY TESTS
  test: (x+1)^2 == x^2+2*x+1 over Real => proved
  test: x/x == 1 over Real => invalid at x=0
  test: sqrt(x^2) == x over Real => disproved by x=-1
  test: sqrt(x^2) == abs(x) over Real => proved
  test: ln(x*y) == ln(x)+ln(y) for x,y>0 => proved
  test: (a+b)^2 == a^2+b^2 over Real => disproved at a=b=1
  test: P or not P in classical propositional logic => proved

21. PROVENANCE AND AUTHORSHIP
  source_page: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/equation-and-statement-entities/identity-ontology.html
  site: https://kirethresearch.org
  authors: Mark Higgins — Sky (Recursive AI)
  disclosure: Co-authored with AI; not a verbatim extraction of source page
  standards: explicit assumptions, typed semantics, verifiable reasoning

END FLOW ALGEBRA