Logical Language Ontology

# Logical Language Ontology — Flow Algebra

URL: https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/foundations-of-logic/logical-language-ontology.html

FLOW LogicalLanguageOntology {

  DOMAIN:
    AI Core
    -> Ontologies
    -> Mathematical Ontologies
    -> Mathematical Logic Ontologies
    -> Foundations of Logic
    -> Logical Language Ontology

  PURPOSE:
    Represent logical language as a machine-interpretable formal communication system composed of alphabets, symbols, vocabularies, signatures, terms, formulas, formation rules, variable-binding rules, syntactic categories, semantic interpretations and notation conventions. The ontology enables AI systems to recognise, parse, validate, translate and reason over expressions belonging to propositional, predicate, first-order, typed, many-sorted, modal, temporal, description and other formal logical languages. It preserves strict distinctions between symbols and their denotations, object language and metalanguage, syntax and semantics, terms and formulas, free and bound variables, logical and nonlogical vocabulary, notation variants and canonical identifiers, and language translation versus semantic equivalence.

  ENTITY LogicalLanguage {
    TYPE: FormalSymbolicLanguage

    PROPERTIES:
      has_alphabet
      has_vocabulary
      has_signature
      has_syntax
      has_formation_rules
      has_terms
      has_formulas
      has_binding_rules
      has_notation
      has_semantic_framework
      has_version
      supports_parsing
      supports_translation
      supports_machine_reasoning
  }

  ENTITY LogicalSymbol {
    TYPE: LanguagePrimitive

    POSSIBLE:
      variable
      constant
      function_symbol
      predicate_symbol
      connective
      quantifier
      equality_symbol
      modal_operator
      temporal_operator
      punctuation
  }

  ENTITY LogicalExpression {
    TYPE: StructuredLanguageObject

    POSSIBLE:
      term
      atomic_formula
      compound_formula
      quantified_formula
      sentence
      open_formula
  }

  ENTITY LanguageSignature {
    TYPE: NonlogicalVocabularySpecification

    COMPONENTS:
      constants
      functions
      predicates
      arities
      sorts_or_types
  }

  LANGUAGE_IDENTITY_MODEL {
    fields:
      language_identifier
      language_name
      logic_family
      version
      notation_profile

    RULE:
      language_identity MUST not_be inferred_fromglyphs_alone
  }

  ALPHABET_MODEL {
    alphabet:
      set_orcollection_ofprimitive_symbols

    RULE:
      alphabet != vocabulary
      alphabet != language
  }

  SYMBOL_MODEL {
    fields:
      symbol_identifier
      glyph
      category
      namespace

    RULE:
      glyph != semantic_identity
  }

  GLYPH_MODEL {
    examples:
      ¬
      ∧
      ∨
      →
      ↔
      ∀
      ∃
      =
      ⊢
      ⊨

    RULE:
      same_glyph MAY have_different_roles_indifferent_languages
  }

  LOGICAL_VOCABULARY_MODEL {
    possible:
      connectives
      quantifiers
      equality
      modal_operators
      punctuation

    RULE:
      logical_status MAY depend_onformal_system
  }

  NONLOGICAL_VOCABULARY_MODEL {
    possible:
      constants
      function_symbols
      predicate_symbols

    RULE:
      nonlogical_symbols_receive_interpretation
  }

  SIGNATURE_MODEL {
    declarations:
      constant_symbols
      function_symbols_witharity
      relation_symbols_witharity

    optional:
      sorts
      types

    RULE:
      signature MUST support_symbol_resolution
  }

  ARITY_MODEL {
    symbol:
      number_ofarguments

    RULE:
-
      expression_withwrong_arity_isnotwellformed_underdeclared_signature
  }

  SORT_MODEL {
    symbol_orvariable:
      belongs_toformal_sort

    RULE:
      sort != physical_dimension_orprogramming_type_necessarily
  }

  TYPE_MODEL {
    possible:
      proposition_type
      individual_type
      function_type
      domain_specific_type

    RULE:
      type_system_semantics MUST be declared
  }

  UNTYPED_LANGUAGE_MODEL {
    terms:
      noexplicit_type_discipline

    RULE:
      untyped != semantically_unconstrained
  }

  TYPED_LANGUAGE_MODEL {
    terms:
      carry_types

    RULE:
      application_andbinding MUST respecttypes
  }

  MANY_SORTED_LANGUAGE_MODEL {
    variables:
      range_overdeclared_sorts

    RULE:
      quantifier_sort MUST be preserved
  }

  SYNTAX_MODEL {
    components:
      lexical_rules
      grammar
      precedence
      associativity
      binding
      scope

    RULE:
      syntax != semantics
  }

  LEXICAL_MODEL {
    input:
      character_or token_stream

    output:
      classified_tokens

    RULE:
      tokenisation_precedes_structural_parsing
  }

  TOKEN_MODEL {
    fields:
      token_identifier
      token_class
      surface_form
      position

    RULE:
      token != logical_entity_untilresolved
  }

  TOKENISATION_MODEL {
    process:
      split_input_into_language_tokens

    RULE:
      multi_character_operators MUST remain_atomic_whenlanguage_defines_them
  }

  WHITESPACE_MODEL {
    role:
      separator_orinsignificant_formatting_underdeclared_language

    RULE:
      whitespace_semantics MAY vary
  }

  COMMENT_MODEL {
    syntax:
      language_specific_nonsemantic_annotation

    RULE:
      comment_text MUST not_be parsed_asformula_unlessembedded_language_declared
  }

  FORMATION_RULE_MODEL {
    defines:
      valid_terms
      valid_formulas

    RULE:
      formation_rules MUST be recursively_orotherwise_formally_defined
  }

  TERM_MODEL {
    possible:
      variable
      constant
      function_application

    RULE:
      term != formula
  }

  VARIABLE_MODEL {
    symbol:
      ranges_overdomain_or sort

    possible:
      free
      bound
  }

  CONSTANT_SYMBOL_MODEL {
    symbol:
      denotes_designated_entity_underinterpretation

    RULE:
      constant_symbol != constant_value_withoutinterpretation
  }

  FUNCTION_SYMBOL_MODEL {
    notation:
      f(t_1,...,t_n)

    RULE:
      arguments MUST matcharity_andtypes_whenapplicable
  }

  PREDICATE_SYMBOL_MODEL {
    notation:
      P(t_1,...,t_n)

    RULE:
      predicate_application_formsformula
  }

  ATOMIC_FORMULA_MODEL {
    possible:
      predicate_application
      equality
      propositional_atom

    RULE:
      atomicity_isrelative_tological_language
  }

  COMPOUND_FORMULA_MODEL {
    formed_by:
      applying_connectives_toformulas

    RULE:
      connective_arity MUST be respected
  }

  QUANTIFIED_FORMULA_MODEL {
    components:
      quantifier
      variable
      body

    RULE:
      binding_andbody_scope MUST be preserved
  }

  SENTENCE_MODEL {
    formula:
      no_free_variables

    RULE:
      sentence != natural_language_sentence_necessarily
  }

  OPEN_FORMULA_MODEL {
    formula:
      has_free_variables

    RULE:
      semantic_evaluation_requires_assignment
  }

  WELL_FORMEDNESS_MODEL {
    expression:
      valid_undergrammar_signature_andbinding_rules

    RULE:
      well_formedness != truth
      well_formedness != theoremhood
  }

  MALFORMED_EXPRESSION_MODEL {
    causes:
      invalid_token
      missing_operand
      wrong_arity
      unmatched_parenthesis
      invalid_binding
      type_or sort_mismatch

    RULE:
      error_location SHOULD be preserved
  }

  PARSER_MODEL {
    input:
      token_sequence

    output:
      syntax_tree

    RULE:
      parser MUST useexact_language_version
  }

  ABSTRACT_SYNTAX_TREE_MODEL {
    nodes:
      symbols
      operators
      binders
      terms

    RULE:
      AST != semantic_interpretation
  }

  CONCRETE_SYNTAX_MODEL {
    representation:
      exact_surface_notation

    RULE:
      concrete_syntax_andabstract_syntax MUST be distinguished
  }

  PRECEDENCE_MODEL {
    operators:
      ordered_binding_strength

    RULE:
      precedence_profile MUST be language_specific
  }

  ASSOCIATIVITY_MODEL {
    possible:
      left
      right
      none

    RULE:
      associativity_affects_parse_whenparentheses_absent
  }

  PARENTHESIS_MODEL {
    role:
      explicit_grouping

    RULE:
      explicit_grouping_overrides_default_precedence
  }

  CONNECTIVE_MODEL {
    possible:
      negation
      conjunction
      disjunction
      implication
      biconditional

    RULE:
      symbol_andsemantics MUST be resolved
  }

  NEGATION_SYMBOL_MODEL {
    variants:
      ¬
      ~
      !
      NOT

    RULE:
      variant_mapping_requires_notation_profile
  }

  CONJUNCTION_SYMBOL_MODEL {
    variants:
      ∧
      &
      AND

    RULE:
      ampersand_orword_may_haveother_meanings_outside_declared_language
  }

  DISJUNCTION_SYMBOL_MODEL {
    variants:
      ∨
      |
      OR

    RULE:
      inclusive_vs exclusive_semantics MUST be explicit
  }

  IMPLICATION_SYMBOL_MODEL {
    variants:
      →
      ->
      =>
      IMPLIES

    RULE:
      notation_mapping MUST distinguish_object_language_implication_frommetalanguage_arrow
  }

  BICONDITIONAL_SYMBOL_MODEL {
    variants:
      ↔
      <->
      IFF
  }

  QUANTIFIER_MODEL {
    possible:
      universal
      existential
      unique_existence
      logic_specific_binders

    RULE:
      quantifier_scope MUST be explicit
  }

  UNIVERSAL_SYMBOL_MODEL {
    variants:
      ∀
      forall
      FORALL
  }

  EXISTENTIAL_SYMBOL_MODEL {
    variants:
      ∃
      exists
      EXISTS
  }

  UNIQUE_EXISTENCE_SYMBOL_MODEL {
    variants:
      ∃!
      exists_unique

    RULE:
      may_be syntactic_sugar_for expanded_formula
  }

  BINDING_MODEL {
    binder:
      quantifier_orlogic_specific_operator

    RULE:
      bound_occurrences MUST be computable_fromsyntax_tree
  }

  FREE_VARIABLE_MODEL {
    occurrence:
      notbound_byenclosing_binder

    RULE:
      free_variable_set_isstructural_property
  }

  BOUND_VARIABLE_MODEL {
    occurrence:
      withinbinder_scope

    RULE:
      bound_variable_identity_islocal_toscope
  }

  VARIABLE_SHADOWING_MODEL {
    inner_binder:
      reuses_variable_name

    RULE:
      nearest_applicable_binder_controls_occurrence_understandard_lexical_binding
  }

  VARIABLE_CAPTURE_MODEL {
    risk:
      substitution_ortranslation_changes_binding

    RULE:
      capture MUST be prevented
  }

  ALPHA_EQUIVALENCE_MODEL {
    formulas:
      differ_only_inbound_variable_names

    RULE:
      alpha_equivalence != textual_identity
  }

  SUBSTITUTION_MODEL {
    operation:
      replace_free_occurrences_ofvariable_withterm

    RULE:
      substitution MUST be capture_avoiding
  }

  PROPOSITIONAL_LANGUAGE_MODEL {
    vocabulary:
      propositional_atoms
      connectives
      parentheses

    RULE:
      noindividual_quantification_inpure_propositional_language
  }

  PREDICATE_LANGUAGE_MODEL {
    adds:
      terms
      predicates
      quantifiers

    RULE:
      signature_anddomain_semantics MUST be available_forinterpretation
  }

  FIRST_ORDER_LANGUAGE_MODEL {
    quantification:
      overindividuals

    RULE:
      predicate_andfunction_symbols_arepart_ofsignature_notquantified_variables_understandard_FOL
  }

  HIGHER_ORDER_LANGUAGE_MODEL {
    quantification:
      may_include_functions_predicates_sets_orrelations

    RULE:
      type_andsemantic_regime MUST be explicit
  }

  MODAL_LANGUAGE_MODEL {
    adds:
      necessity
      possibility

    RULE:
      modal_operator_symbols MUST be distinguished_fromordinary_connectives
  }

  TEMPORAL_LANGUAGE_MODEL {
    adds:
      temporal_operators

    possible:
      G
      F
      X
      U

    RULE:
      operator_vocabulary_depends_onchosen_temporal_logic
  }

  DESCRIPTION_LOGIC_LANGUAGE_MODEL {
    entities:
      concepts
      roles
      individuals
      constructors

    RULE:
      DL_fragment MUST be identified
  }

  SET_THEORY_LANGUAGE_MODEL {
    signature:
      membership
      equality
      optional_additional_symbols

    RULE:
      set_theoretic_symbols MAY be nonlogical_vocabulary
  }

  ARITHMETIC_LANGUAGE_MODEL {
    possible:
      zero
      successor
      addition
      multiplication
      order

    RULE:
      exact_signature_depends_onformal arithmetic
  }

  EQUALITY_MODEL {
    symbol:
      =

    possible_status:
      logical
      nonlogical_relation

    RULE:
      equality_status MUST be declared
  }

  IDENTITY_SYMBOL_MODEL {
    semantic:
      object_identity_whenlanguage_interprets_equality_asidentity

    RULE:
      equality_symbol != assignment
  }

  META_SYMBOL_MODEL {
    possible:
      turnstile
      double_turnstile
      equivalence_marker

    RULE:
      meta_symbols SHOULD not_be inserted_intoobject_language_AST_unlesslanguage_defines_them
  }

  TURNSTILE_MODEL {
    symbol:
      ⊢

    meaning:
      syntactic_derivability_relation_inmetalanguage_orproof_judgment

    RULE:
      ⊢ != ⊨
  }

  DOUBLE_TURNSTILE_MODEL {
    symbol:
      ⊨

    meaning:
      semantic_satisfaction_orconsequence_relation

    RULE:
      semantic_relation != proof_relation
  }

  SEQUENT_LANGUAGE_MODEL {
    structure:
      antecedent
      turnstile
      succedent

    RULE:
      sequent != ordinary_formula_unlessencoded_asone
  }

  JUDGMENT_MODEL {
    formal:
      meta_orobject_level_assertion_underformal system

    examples:
      typing_judgment
      derivability_judgment

    RULE:
      judgment_type MUST be explicit
  }

  NATURAL_DEDUCTION_NOTATION_MODEL {
    representation:
      assumptions
      subproofs
      discharge
      conclusion

    RULE:
      layout MAY encode_scope_andmust_be preserved
  }

  PROOF_LANGUAGE_MODEL {
    symbols:
      formulas
      rule_names
      references
      assumption_markers

    RULE:
      proof_language != formula_language_necessarily
  }

  SEMANTIC_FRAMEWORK_MODEL {
    components:
      domain
      interpretation
      valuation
      satisfaction

    RULE:
      language_definition_andsemantic_framework_arelinked_butdistinct
  }

  INTERPRETATION_MODEL {
    assigns:
      nonlogical_symbols -> semantic_entities

    RULE:
      interpretation MUST respect_signature
  }

  DENOTATION_MODEL {
    term:
      denotes_entity_underinterpretation_andassignment

    RULE:
      denotation != surface_symbol
  }

  SATISFACTION_MODEL {
    formula:
      evaluated_inmodel_orstructure

    RULE:
      satisfaction != syntactic_well_formedness
  }

  LANGUAGE_SEMANTICS_LINK_MODEL {
    syntax_entity:
      mapped_to semantic_entity_ortruth_condition

    RULE:
      mapping MUST be explicit
  }

  NOTATION_MODEL {
    profile:
      glyph_choices
      operator_aliases
      precedence
      formatting

    RULE:
      notation != underlying_language_semantics
  }

  ASCII_NOTATION_MODEL {
    purpose:
      plain_text_serialisation

    RULE:
      ASCII_aliases MUST map_to canonical_identifiers
  }

  UNICODE_NOTATION_MODEL {
    purpose:
      mathematical_display

    RULE:
      Unicode_codepoint_normalisation MUST preserve_distinct_symbols
  }

  LATEX_NOTATION_MODEL {
    examples:
      \neg
      \land
      \lor
      \to
      \forall
      \exists

    RULE:
      LaTeX_source_requires_parsing_notliteral_symbol_matching
  }

  PREFIX_NOTATION_MODEL {
    operator:
      before_operands

    RULE:
      arity_required_forunambiguous_parse
  }

  INFIX_NOTATION_MODEL {
    operator:
      between_operands

    RULE:
      precedence_andassociativity_required
  }

  POSTFIX_NOTATION_MODEL {
    operator:
      after_operand

    RULE:
      notation_profile MUST defineoperator
  }

  POLISH_NOTATION_MODEL {
    form:
      prefix_withoutparentheses_underfixed_arity

    RULE:
      arity_enables_parse
  }

  REVERSE_POLISH_MODEL {
    form:
      postfix_stack_based

    RULE:
      operator_arity MUST be known
  }

  CANONICAL_SYMBOL_MODEL {
    language_entity:
      hascanonical_identifier

    display:
      may_have multiple_notation_variants

    RULE:
      machine_reasoning SHOULD useidentifier_notglyph
  }

  ALIAS_MODEL {
    source_label:
      maps_tocanonical_symbol

    RULE:
      alias_mapping MUST be language_andnotation_specific
  }

  HOMOGRAPH_MODEL {
    same_surface_form:
      multiple_symbols_orroles

    RULE:
      resolve_using_signature_syntax_andcontext
  }

  OVERLOADING_MODEL {
    symbol:
      multiple_operations_orrelations

    RULE:
      type_sort_arity_andcontext MUST resolve_overload
  }

  RESERVED_SYMBOL_MODEL {
    symbol:
      unavailable_foruser_defined_role

    RULE:
      reserved_set MUST be language_version_specific
  }

  ESCAPING_MODEL {
    purpose:
      represent_reserved_orambiguous_characters

    RULE:
      escape_processing MUST occur_beforesemantic_resolution_asdefined
  }

  NAMESPACE_MODEL {
    purpose:
      avoid_identifier_collision

    RULE:
      local_name_withoutnamespace MAY be ambiguous
  }

  LANGUAGE_FRAGMENT_MODEL {
    subset:
      restricted_grammar_orvocabulary

    RULE:
      fragment_identifier SHOULD be preserved
  }

  LANGUAGE_EXTENSION_MODEL {
    base:
      L

    extension:
      L_plusnew_symbols_orconstructors

    RULE:
      extension != same_language_version_withoutdeclared_policy
  }

  CONSERVATIVE_LANGUAGE_EXTENSION_MODEL {
    extension:
      adds_expressive_notation_or symbols_withoutchanging_old_expression_meanings

    RULE:
      semantic_conservativity_requires_formal_definition
  }

  SYNTACTIC_SUGAR_MODEL {
    surface_construct:
      expands_to core_language_expression

    RULE:
      expansion MUST preserve_binding_andsemantics
  }

  DESUGARING_MODEL {
    source:
      extended_syntax

    target:
      core_syntax

    RULE:
      source_expression SHOULD be preserved_forprovenance
  }

  MACRO_MODEL {
    construct:
      expands_toexpression_pattern

    RULE:
      macro_expansion MUST avoidcapture_whenbinders_involved
  }

  NORMAL_FORM_MODEL {
    language
_expression:
      transformed_to canonical_orrestricted_syntax

    RULE:
      normalisation_goal MUST be declared
  }

  CNF_LANGUAGE_MODEL {
    formulas:
      conjunction_ofclauses

    RULE:
      CNF_isrestricted_formula_shape_notseparate_logic
  }

  DNF_LANGUAGE_MODEL {
    formulas:
      disjunction_ofconjunctions_ofliterals
  }

  PRENEX_LANGUAGE_MODEL {
    formulas:
      quantifier_prefix_plusquantifier_free_matrix

    RULE:
      transformation_requires_variable_management
  }

  SERIALISATION_MODEL {
    possible:
      plain_text
      Unicode
      LaTeX
      JSON
      XML
      RDF
      AST_binary

    RULE:
      serialisation MUST preserve_canonical_identifiers_andbinding
  }

  ROUND_TRIP_MODEL {
    process:
      parse
      serialise
      parse_again

    expectation:
      same_abstract_syntax_andresolved_symbols

    RULE:
      display_formatting_differences MAY be acceptable
  }

  TRANSLATION_MODEL {
    source_language:
      L1

    target_language:
      L2

    mapping:
      symbols
      terms
      formulas
      binders

    RULE:
      translation MUST declare_preserved_semantic_relation
  }

  SYMBOL_TRANSLATION_MODEL {
    source_symbol:
      maps_to target_symbol_orconstruction

    RULE:
      lexical_translation != semantic_translation
  }

  STRUCTURAL_TRANSLATION_MODEL {
    source_AST:
      transformed_to target_AST

    RULE:
      binding_andoperator_structure MUST be preserved_orformallymapped
  }

  SEMANTIC_PRESERVATION_MODEL {
    translation:
      may_preserve
        truth
        satisfiability
        validity
        derivability
        equivalence

    RULE:
      preservation_property MUST be explicit
  }

  EMBEDDING_MODEL {
    source_language:
      represented_withintarget_language

    RULE:
      embedding MAY requireencoding
  }

  ENCODING_MODEL {
    source_entity:
      represented_by target_structure

    RULE:
      encoding != semantic_identity
  }

  DECODING_MODEL {
    target_representation:
      mapped_back_to source_entity

    RULE:
      losslessness SHOULD be declared
  }

  MULTILINGUAL_LABEL_MODEL {
    canonical_symbol:
      may_have natural_language_labels

    RULE:
      labels_do_notreplaceformal_identifier
  }

  NATURAL_LANGUAGE_INTERFACE_MODEL {
    input:
      natural_language_statement

    output:
      candidate_formal_expressions

    RULE:
      formalisation_isinterpretive_andmay_beambiguous
  }

  FORMALISATION_MODEL {
    source:
      informal_statement

    target:
      logical_expression

    metadata:
      assumptions
      candidate_parse
      confidence

    RULE:
      AI MUST preserve_source_andinterpretive_choices
  }

  DEFORMALISATION_MODEL {
    source:
      logical_expression

    target:
      natural_language_explanation

    RULE:
      explanation SHOULD preserve_quantifier_scope_andlogical_force
  }

  AMBIGUITY_MODEL {
    possible:
      lexical
      syntactic
      scope
      symbol
      signature
      notation
      semantic

    RULE:
      unresolved_ambiguity MUST remain_explicit
  }

  SCOPE_AMBIGUITY_MODEL {
    example:
      quantifier_ornegation_scope_uncertain

    RULE:
      preserve_candidate_ASTs
  }

  SYMBOL_AMBIGUITY_MODEL {
    glyph:
      maps_to multiple_possible_identifiers

    RULE:
      resolve_usinglanguage_signature_andcontext
  }

  PARSE_AMBIGUITY_MODEL {
    token_sequence:
      multiple_valid_parse_trees

    RULE:
      parser MUST preserve_candidates_oruseexplicit_disambiguation_rule
  }

  ERROR_RECOVERY_MODEL {
    malformed_input:
      parser_may propose_correction

    RULE:
      corrected_expression MUST be marked_inferred_notoriginal
  }

  DIAGNOSTIC_MODEL {
    output:
      error_type
      token_position
      expected_categories
      suggested_resolution

    RULE:
      diagnostics SHOULD not silentlymodify_source
  }

  SEMANTIC_CONFIDENCE_MODEL {
    confidence:
      support_forresolved_language_interpretation

    RULE:
      semantic_confidence != logical_truth
  }

  LANGUAGE_VALIDATION_MODEL {
    checks:
      identifier
      version
      alphabet
      signature
      tokenisation
      grammar
      arity
      types
      binding
      scope
      notation

    RULE:
      validation MUST use_declared_language_profile
  }

  GRAMMAR_VALIDATION_MODEL {
    expression:
      accepted_orrejected_bygrammar

    RULE:
      grammar_acceptance != semantic_validity
  }

  SIGNATURE_VALIDATION_MODEL {
    checks:
      declared_symbols
      arities
      sorts
      types

    RULE:
      undeclared_symbol MUST be flagged_orresolved_viaextension
  }

  BINDING_VALIDATION_MODEL {
    checks:
      binder
      bound_occurrences
      free_variables
      shadowing
      capture

    RULE:
      binding_errors_aresemantic_structure_errors_evenwhen_tokens_parse
  }

  INTEROPERABILITY_MODEL {
    requirements:
      canonical_identifiers
      AST
      signature
      binding
      notation_profile
      language_version

    RULE:
      plain_formula_string_isnotalways_lossless
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      language
      alphabet
      symbol
      signature
      term
      formula
      binder
      notation
      interpretation

    edges:
      CONTAINS
      DECLARES
      BINDS
      APPLIES_TO
      EXPRESSES
      TRANSLATES_TO
      DENOTES
      INTERPRETED_AS

    RULE:
      syntactic_andsemantic_relationships MUST be typed
  }

  PROVENANCE_MODEL {
    fields:
      language_source
      language_version
      notation_source
      parser
      translation
      formalisation_agent
      timestamp

    RULE:
      parsed_ortranslated_expression MUST retain_language_provenance
  }

  VERSION_MODEL {
    versioned:
      language
      signature
      grammar
      notation
      translation_mapping
      ontology

    RULE:
-
      expression_interpretation MUST preserve_version_context
  }

  RELATIONSHIPS {
    LogicalLanguage -> HAS -> Alphabet
    LogicalLanguage -> HAS -> Signature
    Alphabet -> CONTAINS -> LogicalSymbol
    Signature -> DECLARES -> NonlogicalSymbol
    FormationRule -> GENERATES -> TermOrFormula
    Formula -> HAS -> AbstractSyntaxTree
    Quantifier -> BINDS -> Variable
    LogicalSymbol -> MAY_HAVE -> NotationVariant
    Interpretation -> ASSIGNS_MEANING_TO -> NonlogicalSymbol
    Translation -> MAPS -> SourceExpressionToTargetExpression
  }

  SEMANTIC_EQUIVALENCE {
    "logical language" ~= formal_symbolic_language_forrepresentinglogical_expressions
    "formal signature" ~= declaration_ofnonlogical_symbols_arities_andoptional_types_or sorts
    "well formed formula" ~= formula_conforming_todeclared_language_formation_rules

    alphabet != language
    vocabulary != alphabet
    symbol != denotation
    glyph != canonical_symbol_identity
    token != logical_entity
    term != formula
    sentence != natural_language_sentence
    syntax != semantics
    AST != interpretation
    free_variable != bound_variable
    notation != underlying_language
    translation != semantic_equivalence_necessarily
    grammar_validity != logical_validity
    semantic_confidence != truth
  }

  CONSTRAINTS {
    language_identifier_andversion_must_be preserved = true
    alphabet_vocabulary_andsignature_must_be distinguished = true
    canonical_symbol_identifiers_must_be preferred_overglyph_onlyidentity = true
    symbol_arity_type_orsort_must_be preserved = true
    tokenisation_grammar_precedence_andassociativity_must_be language_specific = true
    terms_andformulas_must_be distinguished = true
    variable_binding_scope_shadowing_andcapture_must_be preserved = true
    notation_variants_must_map_tocanonical_identifiers = true
    object_language_andmeta_symbols_must_be distinguished = true
    syntax_andsemantics_must_be distinguished = true
    translation_must_declare_semantic_preservation_property = true
    corrected_orinferred_expression_must_not_replace_original_source = true
    unresolved_ambiguity_must_be preserved = true
    provenance_must_be preserved = true
  }

  LOGICAL_LANGUAGE_RECORD_MODEL {
    RECORD:
      language_identifier
      language_name
      logic_family
      language_version
      fragment_identifier
      notation_profile
      alphabet_identifier
      signature_identifier
      symbol_identifiers
      symbol_classes
      glyphs
      aliases
      arities
      sorts
      types
      reserved_symbols
      source_expression
      token_sequence
      concrete_syntax
      abstract_syntax_tree
      expression_type
      free_variables
      bound_variables
      binding_graph
      precedence_profile
      associativity_profile
      formation_rule_identifiers
      semantic_framework_identifier
      interpretation_identifier
      translation_identifier
      target_language_identifier
      ambiguity_status
      diagnostics
      semantic_confidence
      ontology_version
      provenance

    RULE:
      logical_language_record MUST support_reconstruction_ofsource_tokens_AST_signature_binding_notation_version_andprovenance
  }

  REASONING_RULES {
    IF logical_expression_received
      THEN identify_candidate_language_andnotation
      tokenise
      resolve_signature_symbols
      parse_AST
      validate_formation_rules

    IF symbol_glyph_has_multiple_meanings
      THEN use_language_signature_arity_type_sort_andlocal_context
      else_preserve_candidates

    IF parentheses_absent
      THEN apply_declared_precedence_andassociativity_only

    IF quantifier_orbinder_present
      THEN compute_scope_free_variables_bound_variables_andshadowing

    IF substitution_translation_ormacro_expansion
      THEN detect_andprevent_variable_capture

    IF source_expression_iswellformed
      THEN preserve_original_concrete_syntax_andcanonical_AST

    IF expression_ismalformed
      THEN generate_diagnostics
      andmark_anyproposed_correction_asinferred

    IF translation_requested
      THEN resolve_source_andtarget_languages
      map_symbols_andstructure
      preserve_binding
      declare_semantic_preservation_property

    IF natural_language_formalisation_requested
      THEN generate_candidate_formalisations
      preserve_assumptions_ambiguity_andconfidence

    IF language_signature_orgrammar_version_changes
      THEN preserve_historical_parse
      andreparse_current_expression_onlyunderdeclared_policy
  }

  VALIDATION {
    CHECK language_identifier
    CHECK logic_family
    CHECK language_version
    CHECK alphabet
    CHECK vocabulary
    CHECK signature
    CHECK symbol_identifiers
    CHECK symbol_classes
    CHECK arities
    CHECK sorts_andtypes
    CHECK tokenisation
    CHECK reserved_symbols
    CHECK formation_rules
    CHECK expression_type
    CHECK parse_tree
    CHECK precedence
    CHECK associativity
    CHECK parentheses
    CHECK term_formula_distinction
    CHECK free_bound_variables
    CHECK binder_scope
    CHECK shadowing
    CHECK variable_capture
    CHECK notation_profile
    CHECK meta_symbol_distinction
    CHECK semantic_framework
    CHECK translation_mapping
    CHECK ambiguity
    CHECK diagnostics
    CHECK semantic_confidence
    CHECK ontology_version
    CHECK provenance
  }

  CONFIDENCE {
    language_identity_confidence: 0.99
    tokenisation_confidence: 1.00
    signature_resolution_confidence: 0.99
    parsing_confidence: 1.00
    binding_scope_confidence: 1.00
    notation_mapping_confidence: 0.99
    translation_confidence: 0.98
    natural_language_formalisation_confidence: 0.96

    RULE:
      confidence decreases when language identity, version,
      signature, notation, arity, scope, type, translation mapping
      orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_language_definition:
      assign_language_identifier
      register_alphabet_signature_grammar_andnotation
      validate_internal_consistency
      preserve_provenance
      compute_FLOW_HASH

    ON new_expression:
      identify_language
      tokenise
      resolve_symbols
      parse
      validate
      store_concrete_andabstract_syntax
      preserve_provenance

    ON signature_orgrammar_revision:
      preserve_previous_language_version
      create_new_version
      identify_affected_expressions
      revalidate_underdeclared_policy

    ON translation_revision:
      preserve_previous_mapping
      register_new_mapping_version
      revalidate_target_semantic_preservation

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: LogicalLanguage
    canonical_role: FormalSymbolicLanguage

    interpretation_order:
      identify_language_andversion
      identify_logic_family_andfragment
      identify_notation_profile
      resolve_alphabet_vocabulary_andsignature
      tokenise_source_expression
      resolve_symbol_identifiers_classes_arities_types_andsorts
      apply_declared_grammar_precedence_andassociativity
      construct_abstract_syntax_tree
      classify_terms_atomic_compound_quantified_sentence_andopen_formula
      resolve_binders_scope_free_andbound_variables
      distinguish_object_language_frommeta_symbols
      resolve_semantic_framework_whenrequired
      validate_well_formedness
      detect_ambiguity_orlanguage_errors
      translate_orformalise_whenrequested
      preserve_original_concrete_syntax
      assign_semantic_confidence
      preserve_versions_andprovenance
      emit_machine_resolvable_logical_language_structure

    ambiguity_controls:
      distinguish_alphabet_fromlanguage
      distinguish_vocabulary_fromalphabet
      distinguish_symbol_fromdenotation
      distinguish_glyph_fromcanonical_symbol_identity
      distinguish_token_fromlogical_entity
      distinguish_term_fromformula
      distinguish_sentence_fromnatural_language_sentence
      distinguish_syntax_fromsemantics
      distinguish_AST_frominterpretation
      distinguish_free_variable_frombound_variable
      distinguish_notation_fromunderlying_language
      distinguish_translation_fromsemantic_equivalence_necessarily
      distinguish_grammar_validity_fromlogical_validity
      distinguish_semantic_confidence_fromtruth
      preserve_language_signature_notation_AST_binding_translation_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      logical_languages_symbols_signatures_syntax_binding_notation_translation_andmachine_interpretation

    parent_path:
      AI Core
      -> Ontologies
      -> Mathematical Ontologies
      -> Mathematical Logic Ontologies
      -> Foundations of Logic
      -> Logical Language Ontology

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      language_identity_model
      alphabet_model
      symbol_model
      glyph_model
      logical_vocabulary_model
      nonlogical_vocabulary_model
      signature_model
      arity_model
      sort_model
      type_model
      untyped_language_model
      typed_language_model
      many_sorted_language_model
      syntax_model
      lexical_model
      token_model
      tokenisation_model
      whitespace_model
      comment_model
      formation_rule_model
      term_model
      variable_model
      constant_symbol_model
      function_symbol_model
      predicate_symbol_model
      atomic_formula_model
      compound_formula_model
      quantified_formula_model
      sentence_model
      open_formula_model
      well_formedness_model
      malformed_expression_model
      parser_model
      abstract_syntax_tree_model
      concrete_syntax_model
      precedence_model
      associativity_model
      parenthesis_model
      connective_model
      negation_symbol_model
      conjunction_symbol_model
      disjunction_symbol_model
      implication_symbol_model
      biconditional_symbol_model
      quantifier_model
      universal_symbol_model
      existential_symbol_model
      unique_existence_symbol_model
      binding_model
      free_variable_model
      bound_variable_model
      variable_shadowing_model
      variable_capture_model
      alpha_equivalence_model
      substitution_model
      propositional_language_model
      predicate_language_model
      first_order_language_model
      higher_order_language_model
      modal_language_model
      temporal_language_model
      description_logic_language_model
      set_theory_language_model
      arithmetic_language_model
      equality_model
      identity_symbol_model
      meta_symbol_model
      turnstile_model
      double_turnstile_model
      sequent_language_model
      judgment_model
      natural_deduction_notation_model
      proof_language_model
      semantic_framework_model
      interpretation_model
      denotation_model
      satisfaction_model
      language_semantics_link_model
      notation_model
      ASCII_notation_model
      Unicode_notation_model
      LaTeX_notation_model
      prefix_notation_model
      infix_notation_model
      postfix_notation_model
      Polish_notation_model
      reverse_Polish_model
      canonical_symbol_model
      alias_model
      homograph_model
      overloading_model
      reserved_symbol_model
      escaping_model
      namespace_model
      language_fragment_model
      language_extension_model
      conservative_language_extension_model
      syntactic_sugar_model
      desugaring_model
      macro_model
      normal_form_model
      CNF_language_model
      DNF_language_model
      prenex_language_model
      serialisation_model
      round_trip_model
      translation_model
      symbol_translation_model
      structural_translation_model
      semantic_preservation_model
      embedding_model
      encoding_model
      decoding_model
      multilingual_label_model
      natural_language_interface_model
      formalisation_model
      deformalisation_model
      ambiguity_model
      scope_ambiguity_model
      symbol_ambiguity_model
      parse_ambiguity_model
      error_recovery_model
      diagnostic_model
      semantic_confidence_model
      language_validation_model
      grammar_validation_model
      signature_validation_model
      binding_validation_model
      interoperability_model
      knowledge_graph_model
      provenance_model
      version_model
      relationships
      semantic_equivalence
      constraints
      logical_language_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      language_identity_orversion_changes
      alphabet_vocabulary_signature_orarity_changes
      tokenisation_grammar_precedence_orassociativity_changes
      term_formula_orbinding_semantics_change
      notation_alias_overloading_ornamespace_changes
      language_fragment_extension_or syntactic_sugar_changes
      serialisation_translation_orsemantic_preservation_changes
      formalisation_ambiguity_orerror_recovery_changes
      semantic_framework_orinterpretation_changes
      logical_language_record_changes
      constraint_model_changes
      reasoning_rule_changes
      version_orprovenance_changes
  }

}

END FLOW