Formal Logic Ontology

# Formal Logic Ontology — Flow Algebra

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

FLOW FormalLogicOntology {

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

  PURPOSE:
    Represent formal logic as a machine-interpretable system in which reasoning is expressed through precisely defined languages, symbols, syntax, semantics, axioms, assumptions, inference rules, derivations, proofs, interpretations and models. The ontology enables AI systems to parse formal expressions, identify their logical type, resolve variable binding and quantifier scope, distinguish object language from metalanguage, test satisfiability and validity, verify proof steps, construct countermodels, reason over theories and preserve formal dependencies. It explicitly distinguishes syntactic derivability from semantic consequence, truth from provability, consistency from completeness, implication from causation, formal proof from heuristic argument, and solver failure from logical refutation.

  ENTITY FormalLogic {
    TYPE: FormalDeductiveReasoningFramework

    PROPERTIES:
      has_formal_language
      has_signature
      has_syntax
      has_semantics
      has_terms
      has_formulas
      has_axioms
      has_assumptions
      has_inference_rules
      has_derivations
      has_proofs
      has_theories
      has_interpretations
      has_models
      supports_satisfiability
      supports_validity
      supports_proof_verification
  }

  ENTITY FormalSystem {
    TYPE: LogicSystem

    COMPONENTS:
      formal_language
      axioms
      inference_rules
      proof_definition
      semantic_framework
  }

  ENTITY FormalExpression {
    TYPE: SyntacticObject

    POSSIBLE:
      symbol
      term
      atomic_formula
      compound_formula
      quantified_formula
      sentence
  }

  ENTITY FormalProof {
    TYPE: RuleGovernedDerivation

    COMPONENTS:
      premises
      assumptions
      axioms
      proof_steps
      inference_rules
      conclusion
  }

  FORMAL_LANGUAGE_MODEL {
    components:
      alphabet
      signature
      terms
      formulas
      formation_rules
      binding_rules

    RULE:
      formal_language MUST be versioned_orotherwise_identifiable
  }

  SIGNATURE_MODEL {
    possible:
      constant_symbols
      function_symbols_witharity
      relation_symbols_witharity

    RULE:
      symbol_arity MUST be preserved
  }

  ALPHABET_MODEL {
    categories:
      variables
      logical_symbols
      nonlogical_symbols
      punctuation

    RULE:
      lexical_symbol_class != interpreted_meaning
  }

  LOGICAL_SYMBOL_MODEL {
    possible:
      negation
      conjunction
      disjunction
      implication
      biconditional
      universal_quantifier
      existential_quantifier
      equality

    RULE:
      exact_semantics depend_onformal_logic
  }

  NONLOGICAL_SYMBOL_MODEL {
    possible:
      constant
      function
      predicate_orrelation

    RULE:
      interpretation supplies_semantic_value
  }

  SYNTAX_MODEL {
    defines:
      legal_expressions
      parse_structure
      binding
      derivation_form

    RULE:
      syntax != semantics
  }

  SEMANTICS_MODEL {
    defines:
      interpretations
      denotations
      valuations
      satisfaction
      truth_conditions

    RULE:
      semantic_claim MUST identify_logic_orinterpretation_context
  }

  FORMATION_RULE_MODEL {
    input:
      valid_symbols_andexpressions

    output:
      well_formed_expression

    RULE:
      formation_is_recursive_underdeclared_grammar
  }

  WELL_FORMED_FORMULA_MODEL {
    abbreviation:
      WFF

    condition:
      generated_byformation_rules

    RULE:
      well_formedness != validity_ortruth
  }

  PARSE_TREE_MODEL {
    expression:
      abstract_syntax_tree

    RULE:
      precedence_scope_andbinding MUST be recoverable
  }

  TERM_MODEL {
    recursive:
      variable
      constant
      function_applied_to_terms

    RULE:
      term != formula
  }

  VARIABLE_MODEL {
    possible:
      free
      bound

    RULE:
      variable_occurrence_status MUST be context_specific
  }

  CONSTANT_SYMBOL_MODEL {
    interpretation:
      designated_domain_element

    RULE:
      constant_symbol != fixed_mathematical_constant_necessarily
  }

  FUNCTION_SYMBOL_MODEL {
    arity:
      n

    interpretation:
      function_on_domain

    RULE:
      argument_count MUST matcharity
  }

  RELATION_SYMBOL_MODEL {
    arity:
      n

    interpretation:
      n_ary_relation_on domain

    RULE:
      relation_symbol != relation_extension_untilinterpreted
  }

  ATOMIC_FORMULA_MODEL {
    possible:
      R(t_1,...,t_n)
      t_1=t_2

    RULE:
      term_andarity_constraints MUST hold
  }

  COMPOUND_FORMULA_MODEL {
    formed_from:
      formulas
      logical_connectives

    RULE:
      connective_scope MUST be explicit
  }

  FREE_VARIABLE_MODEL {
    occurrence:
      outside_scope_ofbinder

    RULE:
      open_formula_evaluation_requires_assignment
  }

  BOUND_VARIABLE_MODEL {
    occurrence:
      within_scope_ofbinder

    RULE:
      bound_variable_can_bealpha_renamed_when capture_avoided
  }

  BINDER_MODEL {
    possible:
      quantifier
      lambda_orotherlogic_specific_binder

    RULE:
      binder_scope MUST be preserved
  }

  VARIABLE_CAPTURE_MODEL {
    risk:
      free_variable_becomes_bound_during substitution

    RULE:
      substitutions MUST be capture_avoiding
  }

  SUBSTITUTION_MODEL {
    expression:
      phi[x:=t]

    REQUIRE:
      term_t_admissible_forx

    RULE:
      substitution MUST preserve_binding_semantics
  }

  ALPHA_EQUIVALENCE_MODEL {
    formulas:
      differ_only_bybound_variable_names

    RULE:
      binding_structure_must_match
  }

  PROPOSITIONAL_FRAGMENT_MODEL {
    atoms:
      p_1...p_n

    connectives:
      NOT
      AND
      OR
      IMPLIES
      IFF

    RULE:
      truth_functional_semantics_apply_underdeclared_classical_fragment
  }

  NEGATION_MODEL {
    form:
      NOT A
  }

  CONJUNCTION_MODEL {
    form:
      A AND B
  }

  DISJUNCTION_MODEL {
    form:
      A OR B
  }

  IMPLICATION_MODEL {
    form:
      A -> B

    RULE:
      formal_implication != causation
  }

  BICONDITIONAL_MODEL {
    form:
      A <-> B
  }

  TRUTH_VALUE_MODEL {
    classical:
      true
      false

    RULE:
      formal_logic MAY useother_semantic_values
  }

  VALUATION_MODEL {
    mapping:
      propositional_atoms -> truth_values

    RULE:
      valuation MUST be associated_withformula_language
  }

  TRUTH_TABLE_MODEL {
    purpose:
      exhaustive_propositional_semantic_evaluation

    RULE:
      truth_table_isfinite_only_forfinite_atom_set
  }

  TAUTOLOGY_MODEL {
    formula:
      true_underallvaluations
  }

  CONTRADICTION_MODEL {
    formula:
      false_underallvaluations
  }

  CONTINGENCY_MODEL {
    formula:
      true_undersome_andfalse_underother_valuations
  }

  LOGICAL_EQUIVALENCE_MODEL {
    formulas:
      same_truth_value_underallrelevant_interpretations

    RULE:
      equivalence != syntactic_identity
  }

  NORMAL_FORM_MODEL {
    possible:
      CNF
      DNF
      prenex_normal_form_whenapplicable

    RULE:
      transformation MUST declarewhether_equivalence_orsatisfiability_is preserved
  }

  CNF_MODEL {
    structure:
      conjunction_ofclauses
  }

  DNF_MODEL {
    structure:
      disjunction_ofconjunctions
  }

  LITERAL_MODEL {
    possible:
      atom
      negated_atom
  }

  CLAUSE_MODEL {
    structure:
      disjunction_ofliterals
  }

  PREDICATE_LOGIC_MODEL {
    extends:
      propositional_structure_withterms_predicates_andquantifiers

    RULE:
      domain MUST be identified
  }

  QUANTIFIER_MODEL {
    possible:
      universal
      existential

    RULE:
      scope_andbinding MUST be explicit
  }

  UNIVERSAL_QUANTIFIER_MODEL {
    form:
      forall x phi(x)

    semantics:
      phi_satisfied_forevery_domain_element
  }

  EXISTENTIAL_QUANTIFIER_MODEL {
    form:
      exists x phi(x)

    semantics:
      phi_satisfied_foratleast_one_domain_element
  }

  UNIQUE_EXISTENCE_MODEL {
    form:
      exists_unique x phi(x)

    RULE:
      requires_existence_plusuniqueness
  }

  QUANTIFIER_SCOPE_MODEL {
    quantifier:
      binds_variable_occurrences_withinscope

    RULE:
      scope_changes MAY altertruth_conditions
  }

  QUANTIFIER_ORDER_MODEL {
    example_A:
      forall x exists y R(x,y)

    example_B:
      exists y forall x R(x,y)

    RULE:
      order_is_semantically_material
  }

  QUANTIFIER_NEGATION_MODEL {
    classical:
      NOT forall x phi
        equivalent
        exists x NOT phi

      NOT exists x phi
        equivalent
        forall x NOT phi
  }

  FIRST_ORDER_MODEL {
    quantification:
      overindividual_domain_elements

    RULE:
      standard_first_order_logic_does_notquantify_overpredicates_orfunctions
  }

  STRUCTURE_MODEL {
    M:
      domain
      interpretations_ofconstants
      interpretations_offunctions
      interpretations_ofrelations

    RULE:
      structure != syntax
  }

  INTERPRETATION_MODEL {
    mapping:
      signature_symbols -> semantic_entities

    RULE:
      interpretation MUST respect_symbol_arity_andtype
  }

  ASSIGNMENT_MODEL {
    mapping:
      variables -> domain_elements

    RULE:
      assignment_affects_free_variables
  }

  DENOTATION_MODEL {
    term:
      denotes_domain_element_understructure_andassignment

    RULE:
      denotation MAY vary_byinterpretation
  }

  SATISFACTION_MODEL {
    notation:
      M,s satisfies phi

    RULE:
      satisfaction_issemantic_relation
  }

  SENTENCE_MODEL {
    formula:
      no_free_variables

    RULE:
      truth_instructure_does_notdepend_onassignment
  }

  MODEL_MODEL {
    structure:
      model_ofTheory_ifallsentences_satisfied

    RULE:
      model != formal_proof
  }

  COUNTERMODEL_MODEL {
    structure:
      satisfies_premises_butfalsifies_conclusion_orclaim

    RULE:
      countermodel_refutes_semantic_validity_withinscope
  }

  THEORY_MODEL {
    T:
      set_ofsentences_oraxioms

    RULE:
      theory MAY havezero_one_ormanymodels
  }

  SATISFIABILITY_MODEL {
    formula_orTheory:
      satisfiable_ifhasmodel

    RULE:
      satisfiable != valid
  }

  UNSATISFIABILITY_MODEL {
    formula_orTheory:
      has_no_model
  }

  VALIDITY_MODEL {
    formula:
      true_underallmodels_ofdeclared_logic

    RULE:
      validity != truth_inparticular_model
  }

  SEMANTIC_CONSEQUENCE_MODEL {
    notation:
      Gamma entails phi

    condition:
      every_model_ofGamma_is_model_ofphi
  }

  SYNTACTIC_DERIVABILITY_MODEL {
    notation:
      Gamma proves phi

    condition:
      formal_derivation_exists

    RULE:
      derivability != semantic_consequence_bydefinition
  }

  AXIOM_MODEL {
    formula:
      designated_starting_formula

    RULE:
      axiom_status_relative_toformal_system
  }

  AXIOM_SCHEMA_MODEL {
    pattern:
      generates_axiom_instances

    RULE:
      schema != individual_formula
  }

  PREMISE_MODEL {
    formula:
      provided_asderivation_assumption

    RULE:
      premise != theorem_oraxiom_necessarily
  }

  ASSUMPTION_MODEL {
    formula:
      temporarily_adopted_withscope

    RULE:
      assumption_discharge MUST be tracked
  }

  INFERENCE_RULE_MODEL {
    premises:
      P_1...P_n

    conclusion:
      C

    side_conditions:
      optional

    RULE:
      rule_application_valid_only_whenconditions_hold
  }

  MODUS_PONENS_MODEL {
    premises:
      A
      A -> B

    conclusion:
      B
  }

  UNIVERSAL_INSTANTIATION_MODEL {
    premise:
      forall x phi(x)

    conclusion:
      phi(t)

    RULE:
      t_must_be free_forx
  }

  EXISTENTIAL_GENERALISATION_MODEL {
    premise:
      phi(t)

    conclusion:
      exists x phi(x)
  }

  DERIVATION_MODEL {
    sequence:
      formulas

    each_step:
      premise
      axiom
      orresult_ofinference_rule

    RULE:
      dependency_graph MUST be preserved
  }

  PROOF_MODEL {
    derivation:
      establishes_target_formula_underformal system

    RULE:
      proof != informal_argument
  }

  PROOF_STEP_MODEL {
    fields:
      step_identifier
      formula
      rule_identifier
      dependencies
      assumptions
  }

  THEOREM_MODEL {
    formula:
      derivable_fromaxioms

    RULE:
      theoremhood_relative_toformal system
  }

  LEMMA_MODEL {
    theorem:
      intermediate_proof_result
  }

  COROLLARY_MODEL {
    theorem:
      derived_fromprevious_theorem_orlemma
  }

  DIRECT_PROOF_MODEL {
    process:
      derive_conclusion_frompremises
  }

  PROOF_BY_CONTRADICTION_MODEL {
    process:
      assume_negation
      derive_contradiction
      infer_target_underappropriate_logic

    RULE:
      inference_depends_onlogic
  }

  PROOF_BY_CASES_MODEL {
    premises:
      exhaustive_cases

    RULE:
      case_exhaustiveness MUST be justified
  }

  NATURAL_DEDUCTION_MODEL {
    rules:
      introduction
      elimination

    RULE:
      assumption_scope_anddischarge MUST be preserved
  }

  SEQUENT_CALCULUS_MODEL {
    sequent:
      Gamma |- Delta

    RULE:
      structural_andlogical_rules MUST be identified
  }

  HILBERT_SYSTEM_MODEL {
    components:
      axiom_schemata
      small_set_ofinference_rules

    RULE:
      proof_system_identity MUST be preserved
  }

  RESOLUTION_MODEL {
    clauses:
      resolve_complementary_literals

    RULE:
      first_order_resolution_requires_unification
  }

  UNIFICATION_MODEL {
    objective:
      substitution_makingterms_oratoms_identical

    RULE:
      occurs_check_andterm_theory MAY matter
  }

  SOUNDNESS_MODEL {
    proof_system:
      if Gamma proves phi
      then Gamma entails phi

    RULE:
      soundness != completeness
  }

  COMPLETENESS_MODEL {
    proof_system:
      if Gamma entails phi
      then Gamma proves phi

    RULE:
      completeness_claim_islogic_andproof_system_specific
  }

  CONSISTENCY_MODEL {
    theory:
      does_notderive_contradiction

    RULE:
      consistency != completeness
  }

  INCONSISTENCY_MODEL {
    theory:
      derives_contradiction

    RULE:
      consequences_depend_onlogic
  }

  EXPLOSION_MODEL {
    classical:
      fromcontradiction_arbitrary_formula_can_bederived

    RULE:
      notuniversal_inparaconsistent_logic
  }

  INDEPENDENCE_MODEL {
    phi:
      neither_phi_norNOT_phi_derivable_fromT

    RULE:
      independence_relative_toT
  }

  DECIDABILITY_MODEL {
    theory_orproblem:
      total_decision_procedure_exists

    RULE:
      decidability != computational_efficiency
  }

  SEMIDECIDABILITY_MODEL {
    positive_cases:
      recognisable_byhalting_acceptance

    RULE:
      semidecidability != decidability
  }

  PROOF_THEORY_MODEL {
    studies:
      formal_proof_systems_andderivations

    RULE:
      proof_theoretic_property != semantic_property_withouttheorem
  }

  MODEL_THEORY_MODEL {
    studies:
      structures_models_satisfaction_anddefinability

    RULE:
      model_theory_operates_onsemantic_side
  }

  OBJECT_LANGUAGE_MODEL {
    language:
      whose_formulas_areobject_ofreasoning

    RULE:
      object_language != metalanguage
  }

  METALANGUAGE_MODEL {
    language:
      used_to discuss_syntax_semantics_andproof

    RULE:
      logical_level MUST be preserved
  }

  USE_MENTION_MODEL {
    use:
-
      expression_used_withmeaning

    mention:
-
      expression_referred_toassyntactic_object

    RULE:
      use != mention
  }

  TRUTH_MODEL {
    semantic:
      formula_true_ininterpretation

    RULE:
      truth != provability
  }

  PROVABILITY_MODEL {
    syntactic:
      formal_proof_exists

    RULE:
      provability != truth_bydefinition
  }

  SATISFIABILITY_VALIDITY_MODEL {
    satisfiable:
      true_insome_model

    valid:
      true_inallmodels

    RULE:
      concepts MUST remain_distinct
  }

  CONSISTENCY_COMPLETENESS_MODEL {
    consistency:
      absence_ofderivable_contradiction

    completeness:
      semantic_consequences_derivable_underdeclared_metatheory

    RULE:
      concepts MUST remain_distinct
  }

  CLASSICAL_FORMAL_LOGIC_MODEL {
    typical:
      bivalence
      excluded_middle
      material_implication
      explosion

    RULE:
      classical_principles MUST not_be exported_tootherlogics_withoutbasis
  }

  NONCLASSICAL_EXTENSION_MODEL {
    possible:
      intuitionistic
      paraconsistent
      many_valued
      modal
      temporal

    RULE:
      extension_semantics MUST be explicitly_selected
  }

  TYPE_DISCIPLINE_MODEL {
    possible:
      untyped
      many_sorted
      typed

    RULE:
      term_andpredicate_compatibility MUST respecttype_system_whenpresent
  }

  MANY_SORTED_LOGIC_MODEL {
    domains:
      multiple_sorts

    RULE:
      variable_andfunction_sort_constraints MUST be preserved
  }

  EQUALITY_MODEL {
    possible:
      logical_identity_relation
      theory_specific_equivalence

    RULE:
      equality_semantics MUST be specified
  }

  IDENTITY_MODEL {
    relation:
      same_domain_entity

    RULE:
      object_identity != logical
_equivalence
  }

  FORMAL_EQUIVALENCE_MODEL {
    formulas:
      equivalent_underdeclared_semantics

    RULE:
      equivalence != syntactic_identity
  }

  CONTRADICTION_DETECTION_MODEL {
    target:
      formula_orTheory

    methods:
      proof_search
      SAT_orSMT
      semantic_analysis

    RULE:
      no_contradiction_found != proof_ofconsistency_unlessmethod_complete
  }

  PROOF_SEARCH_MODEL {
    input:
      premises
      target

    output:
      proof
      failure
      unknown
      timeout

    RULE:
      failure_or timeout != unprovability
  }

  MODEL_SEARCH_MODEL {
    input:
      formula_orTheory

    output:
      model
      no_model_undercomplete_method
      unknown

    RULE:
      bounded_model_search_isnotcomplete_ingeneral
  }

  SAT_SOLVER_MODEL {
    domain:
      propositional_satisfiability

    RULE:
      satisfying_assignment_orunsatisfiability_certificate SHOULD be preserved
  }

  SMT_SOLVER_MODEL {
    domain:
      satisfiability_modulo_theories

    RULE:
      background_theories_andfragments MUST be preserved
  }

  THEOREM_PROVER_MODEL {
    input:
      theory
      conjecture

    output:
      proof
      refutation
      unknown

    RULE:
      solver_result MUST include_status
  }

  PROOF_CHECKER_MODEL {
    input:
      proof_artifact

    output:
      verified
      rejected

    RULE:
      checker_kernel_andversion MUST be preserved
  }

  MODEL_CHECKING_MODEL {
    input:
      formal_transition_system
      formal_property

    output:
      holds
      counterexample
      unknown

    RULE:
      abstraction_boundedness_andlogic MUST be explicit
  }

  FORMAL_VERIFICATION_MODEL {
    target:
      system_orartifact

    specification:
      formal_property

    RULE:
      verified_claim_islimited_tospecification_model_andassumptions
  }

  PROOF_CERTIFICATE_MODEL {
    artifact:
      machine_checkable_evidence

    RULE:
      certificate_semantics depend_onchecker
  }

  COUNTEREXAMPLE_MODEL {
    witness:
      violates_universal_orvalidity_claim

    RULE:
      witness MUST satisfydeclared_domain_conditions
  }

  FORMALISATION_MODEL {
    source:
      natural_language_orinformal_mathematics

    target:
      formal_expression

    RULE:
      formalisation_isinterpretive_andmust_preserve_source_andassumptions
  }

  AMBIGUITY_MODEL {
    causes:
      missing_scope
      overloaded_symbol
      implicit_domain
      unspecified_logic
      ambiguous_formalisation

    RULE:
      unresolved_ambiguity MUST be preserved
  }

  SEMANTIC_CONFIDENCE_MODEL {
    confidence:
      support_forformalisation_orinterpretation

    RULE:
      semantic_confidence != formal_truth_orvalidity
  }

  AI_FORMAL_REASONING_MODEL {
    AI:
      parse
      formalise
      type
      validate
      search_proof
      search_model
      check_proof
      explain

    RULE:
      AI_generated_candidate_derivation MUST be verified_beforeformal_proof_status
  }

  HEURISTIC_SEARCH_MODEL {
    role:
      prioritise_candidate_proof_or model_steps

    RULE:
      heuristic_choice != inference_rule
  }

  UNKNOWN_STATUS_MODEL {
    possible:
      unknown
      timeout
      resource_limit
      unsupported_fragment

    RULE:
      unknown != false
      unknown != unprovable
      unknown != unsatisfiable
  }

  DEPENDENCY_GRAPH_MODEL {
    nodes:
      definitions
      axioms
      assumptions
      lemmas
      theorems
      proofs
      models

    edges:
      DEPENDS_ON
      DERIVED_FROM
      ENTAILS
      SATISFIES
      REFUTES

    RULE:
      dependency_type MUST be explicit
  }

  RECURSIVE_VALIDATION_MODEL {
    process:
      validate_language
      validate_formula
      validate_dependencies
      validate_proof
      validate_conclusion

    RULE:
      changed_dependency SHOULD trigger_revalidation
  }

  EXPLAINABILITY_MODEL {
    formal_result:
      expose
        formal_language
        theory
        assumptions
        rules
        proof_steps
        model_orcountermodel
        solver_status

    RULE:
      explanation MUST distinguish_verified_steps_fromheuristic_search
  }

  VERSION_MODEL {
    versioned:
      language
      signature
      theory
      axioms
      inference_rules
      proof_system
      solver
      ontology

    RULE:
      historical_result MUST preserveversions_used
  }

  PROVENANCE_MODEL {
    fields:
      source
      formalisation
      language
      signature
      theory
      axioms
      rules
      solver
      proof
      model
      version
      agent

    RULE:
      formal_result MUST remain_provenance_linked
  }

  INTEROPERABILITY_MODEL {
    exchange:
      signatures
      terms
      formulas
      parse_trees
      proof_objects
      model_objects
      solver_certificates

    RULE:
      exchange MUST preserve_binding_scope_logic_andversion
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      formal_language
      formula
      term
      theory
      axiom
      inference_rule
      proof
      theorem
      model

    edges:
      CONTAINS
      BINDS
      USES
      DERIVES
      PROVES
      ENTAILS
      SATISFIES
      REFUTES
      DEPENDS_ON

    RULE:
      syntactic_andsemantic_edges MUST be distinguished
  }

  RELATIONSHIPS {
    FormalLogic -> DEFINES -> FormalSystem
    FormalSystem -> HAS -> FormalLanguage
    FormalLanguage -> HAS -> Signature
    FormalLanguage -> CONTAINS -> FormalExpression
    Quantifier -> BINDS -> Variable
    Theory -> CONTAINS -> Axiom
    Proof -> USES -> InferenceRule
    Proof -> DERIVES -> Theorem
    Structure -> SATISFIES -> Formula
    Countermodel -> REFUTES -> ValidityClaim
    Solver -> MAY_PRODUCE -> ProofCertificateOrModel
  }

  SEMANTIC_EQUIVALENCE {
    "formal logic" ~= logic_using_explicit_formal_languages_semantics_andrules_ofinference
    "formal proof" ~= rule_governed_derivation_inidentified_formal_system
    "semantic consequence" ~= truth_preservation_acrossallmodels_ofpremises

    syntax != semantics
    term != formula
    well_formedness != truth
    truth != provability
    satisfiable != valid
    validity != truth_inone_model
    semantic_consequence != syntactic_derivability
    consistency != completeness
    implication != causation
    proof != model
    heuristic_search != formal_inference
    unknown != false
    semantic_confidence != formal_validity
  }

  CONSTRAINTS {
    formal_language_andlogic_system_must_be identified = true
    signature_symbol_arities_must_be preserved = true
    syntax_andsemantics_must_be distinguished = true
    terms_andformulas_must_be distinguished = true
    variable_binding_andquantifier_scope_must_be preserved = true
    substitution_must_avoid_capture = true
    interpretations_must_respect_signature = true
    satisfiability_validity_truth_andprovability_must_be distinguished = true
    semantic_consequence_andderivability_must_be distinguished = true
    proof_steps_must_haveformal_justification = true
    consistency_soundness_andcompleteness_must_be distinguished = true
    solver_unknown_timeout_orresource_limit_must_not_be interpreted_aslogical_refutation = true
    AI_heuristic_reasoning_must_not_be represented_asformal_proof_withoutverification = true
    versions_andprovenance_must_be preserved = true
  }

  FORMAL_LOGIC_RECORD_MODEL {
    RECORD:
      formal_logic_identifier
      formal_system_identifier
      language_identifier
      signature_identifier
      logic_system
      theory_identifier
      expression
      expression_type
      syntax_tree
      terms
      free_variables
      bound_variables
      quantifier_scope
      symbol_arities
      interpretation_identifier
      domain
      assignment
      denotation
      satisfaction_status
      model_identifier
      axioms
      premises
      assumptions
      conclusion
      inference_rules
      derivation_identifier
      proof_identifier
      proof_steps
      theorem_identifier
      entailment_status
      derivability_status
      satisfiability_status
      validity_status
      consistency_status
      soundness_context
      completeness_context
      solver_identifier
      solver_status
      proof_certificate
      countermodel
      ambiguity_status
      semantic_confidence
      version
      provenance

    RULE:
      formal_logic_record MUST remain_linked_tosystem_language_signature_semantics_proof_model_version_andprovenance
  }

  REASONING_RULES {
    IF formal_expression_received
      THEN identify_language_signature_andlogic
      parse_expression
      validate_well_formedness

    IF variables_andquantifiers_present
      THEN resolve_binding_scope_andadmissible_substitutions

    IF semantic_evaluation_requested
      THEN resolve_structure_interpretation_assignment_anddenotation

    IF satisfiability_requested
      THEN search_for_model
      andpreserve_unknown_whenmethod_notcomplete

    IF validity_requested
      THEN search_forcountermodel
      orverify_proof_underappropriate_metatheoretic_context

    IF proof_claimed
      THEN verify_every_step_againstaxioms_premises_assumptions_rules_andside_conditions

    IF solver_returns_unknown_timeout_orresource_limit
      THEN preserve_status
      anddo_not inferfalse_unsatisfiable_orunprovable

    IF formalisation_fromnatural_language
      THEN preserve_source_candidate_formalisations_assumptions_andconfidence

    IF AI_generates_candidate_proof
      THEN pass_toformal_checker_whenavailable
      beforeassigning_verified_status

    IF axiom_rule_orlanguage_revision_occurs
      THEN recursively_revalidate_dependent_proofs_andtheorems
  }

  VALIDATION {
    CHECK formal_logic_identifier
    CHECK formal_system
    CHECK formal_language
    CHECK signature
    CHECK symbol_arities
    CHECK expression_type
    CHECK syntax_tree
    CHECK well_formedness
    CHECK term_formula_distinction
    CHECK free_bound_variables
    CHECK quantifier_scope
    CHECK substitution
    CHECK interpretation
    CHECK domain
    CHECK assignment
    CHECK denotation
    CHECK satisfaction
    CHECK model
    CHECK satisfiability
    CHECK validity
    CHECK semantic_consequence
    CHECK syntactic_derivability
    CHECK axioms
    CHECK premises_andassumptions
    CHECK inference_rules
    CHECK proof_steps
    CHECK theorem_dependencies
    CHECK consistency
    CHECK soundness
    CHECK completeness
    CHECK solver_status
    CHECK proof_certificate_orcountermodel
    CHECK ambiguity
    CHECK semantic_confidence
    CHECK version
    CHECK provenance
  }

  CONFIDENCE {
    formal_language_confidence: 1.00
    syntax_binding_confidence: 1.00
    semantic_interpretation_confidence: 1.00
    satisfiability_validity_confidence: 1.00
    proof_verification_confidence: 1.00
    model_reasoning_confidence: 1.00
    automated_solver_semantics_confidence: 0.99
    natural_language_formalisation_confidence: 0.97

    RULE:
      confidence decreases when language, signature, logic,
      scope, interpretation, proof system, solver status,
      version orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_formal_expression:
      resolve_language_signature_andlogic
      parse
      type
      validate
      preserve_provenance
      compute_FLOW_HASH

    ON new_proof:
      assign_proof_identifier
      preserve_dependencies
      validate_steps
      attach_conclusion_andstatus

    ON new_model:
      assign_model_identifier
      attach_domain_andinterpretation
      evaluate_satisfaction
      preserve_witness_orcountermodel

    ON formal_system_revision:
      preserve_previous_system
      register_new_version
      identify_dependent_results
      recursively_revalidate_withoutoverwritinghistory

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: FormalLogic
    canonical_role: FormalDeductiveReasoningFramework

    interpretation_order:
      identify_formal_system
      identify_formal_language_andsignature
      identify_logic_system
      parse_expression
      resolve_terms_symbols_arities_andtypes
      resolve_variables_binders_quantifiers_andscope
      distinguish_syntax_fromsemantics
      resolve_structure_interpretation_assignment_anddenotation
      evaluate_satisfaction_whencontext_available
      distinguish_satisfiability_validity_entailment_andderivability
      identify_theory_axioms_premises_assumptions_andrules
      validate_orconstruct_formal_derivation
      search_forcountermodel_orproof_whenappropriate
      distinguish_consistency_soundness_andcompleteness
      identify_solver_status_andcertificate
      preserve_unknown_timeout_andresource_limit
      detect_ambiguity_orcontradiction
      distinguish_heuristic_AI_search_fromformal_inference
      assign_semantic_confidence
      preserve_versions_andprovenance
      emit_machine_resolvable_formal_logic_structure

    ambiguity_controls:
      distinguish_syntax_fromsemantics
      distinguish_term_fromformula
      distinguish_well_formedness_fromtruth
      distinguish_truth_fromprovability
      distinguish_satisfiable_fromvalid
      distinguish_validity_fromtruth_inone_model
      distinguish_semantic_consequence_fromsyntactic_derivability
      distinguish_consistency_fromcompleteness
      distinguish_implication_fromcausation
      distinguish_proof_frommodel
      distinguish_heuristic_search_fromformal_inference
      distinguish_unknown_fromfalse
      distinguish_semantic_confidence_fromformal_validity
      preserve_system_language_signature_scope_semantics_proof_model_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      formal_logic_languages_syntax_semantics_deduction_proof_models_andautomated_reasoning

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

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      formal_language_model
      signature_model
      alphabet_model
      logical_symbol_model
      nonlogical_symbol_model
      syntax_model
      semantics_model
      formation_rule_model
      well_formed_formula_model
      parse_tree_model
      term_model
      variable_model
      constant_symbol_model
      function_symbol_model
      relation_symbol_model
      atomic_formula_model
      compound_formula_model
      free_variable_model
      bound_variable_model
      binder_model
      variable_capture_model
      substitution_model
      alpha_equivalence_model
      propositional_fragment_model
      negation_model
      conjunction_model
      disjunction_model
      implication_model
      biconditional_model
      truth_value_model
      valuation_model
      truth_table_model
      tautology_model
      contradiction_model
      contingency_model
      logical_equivalence_model
      normal_form_model
      CNF_model
      DNF_model
      literal_model
      clause_model
      predicate_logic_model
      quantifier_model
      universal_quantifier_model
      existential_quantifier_model
      unique_existence_model
      quantifier_scope_model
      quantifier_order_model
      quantifier_negation_model
      first_order_model
      structure_model
      interpretation_model
      assignment_model
      denotation_model
      satisfaction_model
      sentence_model
      model_model
      countermodel_model
      theory_model
      satisfiability_model
      unsatisfiability_model
      validity_model
      semantic_consequence_model
      syntactic_derivability_model
      axiom_model
      axiom_schema_model
      premise_model
      assumption_model
      inference_rule_model
      modus_ponens_model
      universal_instantiation_model
      existential_generalisation_model
      derivation_model
      proof_model
      proof_step_model
      theorem_model
      lemma_model
      corollary_model
      direct_proof_model
      proof_by_contradiction_model
      proof_by_cases_model
      natural_deduction_model
      sequent_calculus_model
      Hilbert_system_model
      resolution_model
      unification_model
      soundness_model
      completeness_model
      consistency_model
      inconsistency_model
      explosion_model
      independence_model
      decidability_model
      semidecidability_model
      proof_theory_model
      model_theory_model
      object_language_model
      metalanguage_model
      use_mention_model
      truth_model
      provability_model
      satisfiability_validity_model
      consistency_completeness_model
      classical_formal_logic_model
      nonclassical_extension_model
      type_discipline_model
      many_sorted_logic_model
      equality_model
      identity_model
      formal_equivalence_model
      contradiction_detection_model
      proof_search_model
      model_search_model
      SAT_solver_model
      SMT_solver_model
      theorem_prover_model
      proof_checker_model
      model_checking_model
      formal_verification_model
      proof_certificate_model
      counterexample_model
      formalisation_model
      ambiguity_model
      semantic_confidence_model
      AI_formal_reasoning_model
      heuristic_search_model
      unknown_status_model
      dependency_graph_model
      recursive_validation_model
      explainability_model
      version_model
      provenance_model
      interoperability_model
      knowledge_graph_model
      relationships
      semantic_equivalence
      constraints
      formal_logic_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      formal_language_signature_orformation_rules_change
      syntax_binding_substitution_orformula_semantics_change
      propositional_predicate_orquantifier_semantics_change
      structure_interpretation_satisfaction_ormodel_changes
      satisfiability_validity_entailment_orderivability_changes
      axiom_inference_derivation_orproof_system_changes
      consistency_soundness_completeness_ordecidability_changes
      automated_reasoning_solver_orverification_changes
      formalisation_ambiguity_orconfidence_changes
      formal_logic_record_changes
      constraint_model_changes
      reasoning_rule_changes
      version_orprovenance_changes
  }

}

END FLOW