Cross-Domain Mathematical Entity Ontology

FLOW ALGEBRA
Cross-Domain Mathematical Entity Ontology
Version: 1.0
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/ai-semantic-library-mathematical-entities/cross-domain-mathematical-entity-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Scope: AI Semantic Library / Mathematical Entities / Cross-Domain Integration

AI INTERPRETATION NOTE
Interpret the following as a declarative, typed rule specification. Evaluation requires a host implementation of the predicates, canonicalisation functions and proof checkers. Do not treat unverified mappings as established mathematical identities.

FLOW "CrossDomainMathematicalEntityOntology" v1.0 {

  ENTITY MathematicalEntity {
    id: Identifier;
    canonical_form: -Expression;
    entity_type: MathematicalType;
    native_domain: Domain;
    assumptions: Set[Proposition];
    definition: Proposition?;
    provenance: Set[SourceRecord];
    version: Version;
  }

  ENTITY Domain {
    id: Identifier;
    name: String;
    formal_language: Language;
    axioms: Set[Proposition];
    interpretation: Interpretation;
  }

  ENTITY CrossDomainMapping {
    id: Identifier;
    source_entity: MathematicalEntity;
    target_entity: MathematicalEntity;
    source_domain: Domain;
    target_domain: Domain;
    mapping_kind: MappingKind;
    transformation: TypedMorphism;
    assumptions: Set[Proposition];
    preserved_properties: Set[Property];
    proof: ProofCertificate?;
    confidence: ConfidenceRecord;
    provenance: Set[SourceRecord];
    status: MappingStatus;
  }

  ENUM MappingKind {
    DEFINITIONAL_EQUIVALENCE,
    ISOMORPHISM,
    EMBEDDING,
    HOMOMORPHISM,
    INTERPRETATION,
    ANALOGY,
    APPROXIMATION,
    APPLICATION
  }

  ENUM MappingStatus { PROPOSED, TYPE_CHECKED, VERIFIED, REJECTED, SUPERSEDED }

  TYPE ConfidenceRecord {
    score: Real[0,1];
    basis: String;
    calibration_reference: Identifier?;
    assessed_at: Timestamp;
  }

  RELATION BELONGS_TO(e: MathematicalEntity, d: Domain)
    := e.native_domain.id = d.id;

  RELATION MAPS_TO(a: MathematicalEntity, b: MathematicalEntity, m: CrossDomainMapping)
    := m.source_entity.id = a.id AND m.target_entity.id = b.id;

  RELATION PRESERVES(m: CrossDomainMapping, p: Property)
    := p IN m.preserved_properties AND VERIFIED_PROPERTY_PRESERVATION(m, p);

  RELATION CROSS_DOMAIN_EQUIVALENT(a: MathematicalEntity, b: MathematicalEntity)
    := EXISTS m: CrossDomainMapping (
      MAPS_TO(a,b,m)
      AND m.status = VERIFIED
      AND m.mapping_kind IN {DEFINITIONAL_EQUIVALENCE, ISOMORPHISM}
      AND PROOF_VALID(m.proof, m.assumptions)
    );

  RULE R01_DOMAIN_IDENTITY:
    REQUIRE unique(Domain.id);
    REQUIRE unique(MathematicalEntity.id);
    REQUIRE canonical_form is interpreted relative to native_domain;

  RULE R02_TYPED_MAPPING:
    FOR EACH m: CrossDomainMapping:
      REQUIRE TYPE_CHECK(m.transformation,
        m.source_entity.entity_type,
        m.target_entity.entity_type,
        m.source_domain.formal_language,
        m.target_domain.formal_language);
      OTHERWISE SET m.status = REJECTED;

  RULE R03_ASSUMPTION_DISCLOSURE:
    FOR EACH m: CrossDomainMapping:
      REQUIRE m.assumptions explicitly states all required hypotheses;
      REQUIRE CONSISTENT(m.assumptions UNION m.source_domain.axioms);
      REQUIRE CONSISTENT(m.assumptions UNION m.target_domain.axioms);

  RULE R04_PROOF_GATED_VERIFICATION:
    IF m.status = TYPE_CHECKED
       AND PROOF_VALID(m.proof, m.assumptions)
       AND VALID_INTERPRETATION(m.transformation)
    THEN SET m.status = VERIFIED;
    ELSE KEEP m.status != VERIFIED;

  RULE R05_PROPERTY_TRANSFER:
    IF m.status = VERIFIED
       AND PRESERVES(m, property)
       AND HOLDS(m.source_entity, property, m.assumptions)
    THEN DERIVE HOLDS(m.target_entity, property, m.assumptions)
      WITH provenance = {m.id, m.proof};
    ELSE DO_NOT_TRANSFER(property);

  RULE R06_NON_EQUIVALENCE_SAFEGUARD:
    IF m.mapping_kind IN {ANALOGY, APPROXIMATION, APPLICATION,
                          EMBEDDING, HOMOMORPHISM, INTERPRETATION}
    THEN DO_NOT_DERIVE CROSS_DOMAIN_EQUIVALENT(
      m.source_entity, m.target_entity)
    WITHOUT independent equivalence proof;

  RULE R07_DIRECTIONALITY:
    DO_NOT_INFER MAPS_TO(b,a,m) FROM MAPS_TO(a,b,m)
    UNLESS inverse(m.transformation) exists and is type-checked;

  RULE R08_COMPOSITION:
    IF VERIFIED(m1: A -> B) AND VERIFIED(m2: B -> C)
       AND COMPATIBLE(m1.target_domain, m2.source_domain)
       AND COMPATIBLE_ASSUMPTIONS(m1.assumptions, m2.assumptions)
    THEN PROPOSE m3: A -> C
      WITH transformation = compose(m2.transformation, m1.transformation),
           assumptions = m1.assumptions UNION m2.assumptions,
           preserved_properties = INTERSECTION(
             m1.preserved_properties, m2.preserved_properties),
           status = PROPOSED;
    VERIFY m3 independently before publishing as VERIFIED;

  RULE R09_AMBIGUITY_RESOLUTION:
    IF MULTIPLE_CANDIDATE_MAPPINGS(source_entity)
    THEN RANK by {type_compatibility, explicit_assumptions,
                  proof_quality, property_preservation, provenance};
    NEVER merge distinct candidate mappings solely on lexical similarity;

  RULE R10_CONFLICT_DETECTION:
    IF mappings assert incompatible conclusions under equivalent assumptions
    THEN FLAG CONFLICT;
    RETAIN competing records and their provenance;
    REQUIRE formal adjudication before selecting a verified conclusion;

  RULE R11_CONFIDENCE:
    REQUIRE 0 <= m.confidence.score <= 1;
    RECORD confidence.basis and calibration_reference when available;
    NEVER SUBSTITUTE confidence for proof validity;
    IF m.status != VERIFIED THEN LABEL inference as unverified;

  RULE R12_PROVENANCE:
    FOR EACH m: CrossDomainMapping:
      REQUIRE source and target entity identifiers;
      REQUIRE mapping author/source, timestamp, and version;
      LINK proof certificates and source assumptions where applicable;

  RULE R13_SEMANTIC_EQUIVALENCE:
    SEMANTIC_EQUIVALENCE(a,b) := CROSS_DOMAIN_EQUIVALENT(a,b);
    SEMANTIC_SIMILARITY(a,b) MAY hold without equivalence;
    DO_NOT_COLLAPSE distinct entities merely because labels match;

  RULE R14_FLOW_HASH:
    FLOW_HASH(m) := HASH_CANONICAL({
      m.source_entity.id, m.target_entity.id,
      m.mapping_kind, m.transformation,
      SORT(m.assumptions), SORT(m.preserved_properties),
      m.proof, m.status, m.version
    });
    REQUIRE deterministic serialisation and declared hash algorithm;

  RULE R15_UPDATE_MODEL:
    ON change of entity definition, domain axiom, mapping or proof:
      CREATE new version;
      INVALIDATE dependent verification results pending recheck;
      RECOMPUTE affected FLOW_HASH values;
      RETAIN historical provenance and supersession links;

  RULE R16_AI_CONSUMPTION:
    OUTPUT {
      source_entity, target_entity, source_domain, target_domain,
      mapping_kind, typed_transformation, assumptions,
      preserved_properties, verification_status, proof_reference,
      confidence, provenance, version, flow_hash
    };
    EXPOSE verification_status and assumptions to downstream reasoning;
    BLOCK unqualified equivalence claims for unverified mappings;

  EXAMPLE E01_LINEAR_ALGEBRA_TO_GEOMETRY:
    source = linear transformation between vector spaces;
    target = geometric transformation under chosen coordinates;
    mapping_kind = INTERPRETATION;
    assumptions = {specified bases, compatible dimensions};
    note = coordinate representations depend on basis choices;

  EXAMPLE E02_PROBABILITY_TO_MEASURE_THEORY:
    source = probability space (Omega, F, P);
    target = measure space (Omega, F, mu);
    mapping_kind = EMBEDDING;
    assumptions = {mu(Omega) = 1, mu = P};
    note = not every measure space is a probability space;

  EXAMPLE E03_GRAPH_TO_MATRIX:
    source = finite labelled graph;
    target = adjacency matrix relative to an ordered vertex set;
    mapping_kind = INTERPRETATION;
    assumptions = {finite vertex set, specified vertex ordering,
                   specified graph conventions};
    note = relabelling can change matrix entries without changing graph isomorphism class;

  VALIDATION_TESTS {
    PASS typed and proved mapping with explicit assumptions;
    FAIL equivalence inferred from shared terminology alone;
    FAIL unproved property transfer;
    FAIL inverse inferred from noninvertible morphism;
    FAIL outdated proof retained after a relevant axiom change;
    PASS provenance-preserving rejection of conflicting claims;
  }
}

IMPLEMENTATION NOTE
This Flow Algebra defines machine-readable semantics and verification obligations; it does not itself supply an executable theorem prover, parser, or hash implementation. The hosting system must bind these operations to its chosen formal tools.

Kireth Research — https://kirethresearch.org