Discrete Mathematics Ontology

FLOW ALGEBRA
Discrete Mathematics Ontology — Foundations of Discrete Mathematics
Version: 1.0
Source: https://kirethresearch.org/booksai-core/discrete-mathematics-ontologies/foundations-of-discrete-mathematics/discrete-mathematics-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Status: Domain-based formalisation; embedded source specifications not available in retrieved page text.

flow "DiscreteMathematicsOntology" v1.0

DOMAIN:
  id: discrete_mathematics
  parent: foundations_of_discrete_mathematics
  scope: finite_and_countable_structures, formal_logic, sets, relations, functions, graphs, combinatorics, proof

TYPES:
  Entity: {id: string, kind: string, provenance: string?}
  Set: {id: string, members: collection<Entity>, finite: boolean?}
  Relation: {id: string, domain: Set, codomain: Set, pairs: collection<(Entity,Entity)>}
  Function: {id: string, domain: Set, codomain: Set, mapping: collection<(Entity,Entity)>}
  Proposition: {id: string, formula: -expression, truth_value: boolean?}
  Graph: {id: string, vertices: Set, edges: Relation, directed: boolean}
  Proof: {id: string, premises: collection<Proposition>, conclusion: Proposition, steps: collection<InferenceStep>}
  InferenceStep: {rule: string, inputs: collection<string>, output: string}
  NaturalNumber: integer where value >= 0
  Cardinality: NaturalNumber | infinite_cardinality

RELATIONSHIPS:
  MEMBER_OF(element: Entity, set: Set)
  SUBSET_OF(left: Set, right: Set)
  MAPS_TO(function: Function, input: Entity, output: Entity)
  RELATED_BY(relation: Relation, left: Entity, right: Entity)
  ADJACENT_TO(graph: Graph, left: Entity, right: Entity)
  IMPLIES(premise: Proposition, conclusion: Proposition)
  EQUIVALENT_TO(left: Proposition, right: Proposition)
  DEPENDS_ON(entity: Entity, prerequisite: Entity)

OPERATORS:
  SET_UNION(A,B) := {x | x in A or x in B}
  SET_INTERSECTION(A,B) := {x | x in A and x in B}
  SET_DIFFERENCE(A,B) := {x | x in A and x not in B}
  CARTESIAN_PRODUCT(A,B) := {(a,b) | a in A and b in B}
  RELATION_COMPOSE(R,S) := {(a,c) | exists b: (a,b) in R and (b,c) in S}
  LOGICAL_NOT(p) := not p
  LOGICAL_AND(p,q) := p and q
  LOGICAL_OR(p,q) := p or q
  LOGICAL_IMPLIES(p,q) := (not p) or q

CONSTRAINTS:
  C1: Every member of a Set is an Entity.
  C2: Every pair in a Relation belongs to domain x codomain.
  C3: Every input in a Function's domain has exactly one mapped output in its codomain.
  C4: Every edge of a Graph connects vertices in its vertex set.
  C5: Proof conclusions require valid derivation from premises under named inference rules.
  C6: An unverified assertion must not be promoted to a proven theorem.

INFERENCE_RULES:
  R1_SUBSET_TRANSITIVITY:
    IF SUBSET_OF(A,B) AND SUBSET_OF(B,C) THEN SUBSET_OF(A,C)
  R2_RELATION_TRANSITIVITY:
    IF TRANSITIVE(R) AND RELATED_BY(R,a,b) AND RELATED_BY(R,b,c)
    THEN RELATED_BY(R,a,c)
  R3_MODUS_PONENS:
    IF TRUE(p) AND TRUE(LOGICAL_IMPLIES(p,q)) THEN TRUE(q)
  R4_SET_MEMBERSHIP:
    IF MEMBER_OF(x,A) AND SUBSET_OF(A,B) THEN MEMBER_OF(x,B)
  R5_FUNCTION_COMPOSITION:
    IF MAPS_TO(f,x,y) AND MAPS_TO(g,y,z) THEN MAPS_TO(COMPOSE(g,f),x,z)
  R6_FINITE_UNION_BOUND:
    IF FINITE(A) AND FINITE(B) THEN CARDINALITY(SET_UNION(A,B)) <= CARDINALITY(A)+CARDINALITY(B)

CONFIDENCE:
  type: decimal[0,1]
  policy: "Confidence estimates evidence support; it is not a substitute for formal proof."
  formally_proven: 1.0
  empirical_or_heuristic: require_evidence_and_calibration
  unsupported: unknown

SEMANTIC_EQUIVALENCE:
  mode: typed_contextual
  rules:
    - "Equivalent symbols must share domain, interpretation and constraints."
    - "Logical equivalence requires mutual implication in the same interpretation."
    - "Graph isomorphism does not imply vertex identity."
    - "Syntactic similarity alone does not establish mathematical equivalence."

PROVENANCE:
  required_fields: [source, author_or_system, version, timestamp, derivation]
  distinguish: [axiom, definition, theorem, proof, conjecture, empirical_claim]

FLOW_HASH:
  algorithm: SHA-256
  input: canonical_serialisation(types, relationships, constraints, inference_rules, version)
  purpose: integrity_and_version_tracking

UPDATE_MODEL:
  trigger: [new_definition, corrected_axiom, revised_proof, changed_source]
  procedure:
    - validate_type_and_reference_integrity
    - rerun_affected_inference_rules
    - invalidate_dependant_results_when_premises_change
    - record_provenance_and_version
    - recompute_FLOW_HASH

AI_CONSUMPTION:
  representation: typed_entities_and_executable_rule_specification
  interpretation: formal_rules_not_natural_language_guesses
  outputs: [validated_relations, derived_propositions, proof_traces, uncertainty_flags]
  safeguards:
    - do_not_infer_without_valid_premises
    - preserve_distinction_between_definition_and_observation
    - surface_unknown_or_undecidable_cases
    - do_not_claim_execution_without_a_rule_engine

END FLOW ALGEBRA