Semantic Translation Ontology

FLOW ALGEBRA
TITLE: Semantic Translation Ontology
DOMAIN: Kireth Semantic Library / Relationship Ontologies / Semantic Relationships
SOURCE: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/semantic-relationships/semantic-translation-ontology.html
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source page not independently verified.
VERSION: 1.0

ONTOLOGY SemanticTranslation {
  ENTITY Concept { id: URI; label: String; language: LanguageTag; context: ContextID? }
  ENTITY Expression { id: URI; text: String; language: LanguageTag; denotes: ConceptID? }
  ENTITY Translation { id: URI; source: -ExpressionID; target: -ExpressionID; strategy: Strategy; confidence: Decimal[0,1]; provenance: EvidenceID? }
  ENTITY Context { id: ContextID; domain: String?; audience: String?; register: String? }
  ENTITY Evidence { id: EvidenceID; source_uri: URI?; method: String; reviewed_at: DateTime? }

  ENUM Strategy = { literal, idiomatic, terminological, contextual, paraphrase, transliteration }
  RELATION translates_to(Expression -> Expression)
  RELATION denotes(Expression -> Concept)
  RELATION context_of(Translation -> Context)
  RELATION supported_by(Translation -> Evidence)
  RELATION semantic_equivalent(Expression <-> Expression, Context)
  RELATION narrower_meaning(Expression -> Expression, Context)
  RELATION broader_meaning(Expression -> Expression, Context)

  RULE R1: translation.source != translation.target OR translation.strategy == paraphrase;
  RULE R2: translation.confidence >= 0 AND translation.confidence <= 1;
  RULE R3: semantic_equivalent(a,b,c) IF denotes(a,x) AND denotes(b,x) AND compatible_context(a,b,c);
  RULE R4: translates_to(a,b) DOES_NOT_IMPLY semantic_equivalent(a,b,c);
  RULE R5: translates_to(a,b) AND translates_to(b,d) DOES_NOT_IMPLY translates_to(a,d) WITHOUT context_validation;
  RULE R6: semantic_equivalent(a,b,c) IMPLIES semantic_equivalent(b,a,c);
  RULE R7: contradictory_meaning(a,b,c) IMPLIES NOT semantic_equivalent(a,b,c);

  FUNCTION translate(expression, target_language, context) -> Ranked<Translation> {
    candidates := retrieve_crosslingual_candidates(expression, target_language);
    candidates := filter_by_context(candidates, context);
    candidates := rank(candidates, meaning_preservation, terminology_fit, fluency, evidence_quality);
    RETURN candidates;
  }

  FUNCTION validate(translation, context) -> ValidationResult {
    REQUIRE valid_language_tags(translation);
    REQUIRE exists(translation.source) AND exists(translation.target);
    CHECK semantic_fidelity(translation.source, translation.target, context);
    CHECK ambiguity_and_polysemy(translation, context);
    CHECK terminology_and_register(translation, context);
    CHECK provenance_integrity(translation.provenance);
    RETURN findings_with_confidence_and_explanations;
  }

  SEMANTIC_EQUIVALENCE {
    scope: context_sensitive;
    exact_equivalence: same_denotation_and_relevant_implications;
    approximate_equivalence: high_overlap_with_recorded_differences;
    non_equivalence: material_meaning_change;
    caution: similarity_is_not_identity;
  }

  CONFIDENCE {
    range: [0,1];
    factors: [semantic_fidelity, context_match, terminology_consistency, evidence_quality, human_review];
    calibration: required_when_empirically_available;
    low_confidence_action: flag_for_review;
  }

  PROVENANCE {
    capture: [source_expression, target_expression, language_pair, context, strategy, evidence, timestamp, version];
    preserve_original: true;
  }

  FLOW_HASH {
    algorithm: SHA-256;
    input: canonical_serialisation(ontology_id, version, entities, relations, rules, mappings);
    purpose: integrity_and_change_detection;
  }

  UPDATE_MODEL {
    trigger: [new_evidence, terminology_change, context_change, corrected_translation, ontology_revision];
    steps: [validate_input, compare_versions, revise_mapping, rerun_constraints, regenerate_flow_hash, record_provenance];
    preserve_history: true;
  }

  AI_CONSUMPTION {
    input: [expression, source_language, target_language, context];
    output: [ranked_translations, semantic_alignment, confidence, provenance, warnings];
    constraints: [no_unverified_equivalence, retain_ambiguity, distinguish_translation_from_transliteration];
    interoperability: [RDF, OWL, SKOS, JSON-LD];
  }
}

END FLOW ALGEBRA