Foundations of Logic

# Foundations of Logic — Flow Algebra

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

FLOW FoundationsOfLogicOntology {

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

  PURPOSE:
    Represent the foundational concepts required for formal logical reasoning, including propositions, truth values, logical connectives, formulas, terms, variables, predicates, quantifiers, interpretations, models, axioms, inference rules, arguments, proofs, validity, satisfiability, consistency, soundness and completeness. The ontology establishes a machine-interpretable boundary between syntax and semantics, object language and metalanguage, truth and provability, validity and factual truth, implication and causation, contradiction and inconsistency, and formal deduction versus heuristic inference. It provides the base semantic layer from which more specialised propositional, predicate, first-order, modal, temporal, proof-theoretic and computational logic ontologies can inherit.

  ENTITY FoundationsOfLogic {
    TYPE: FoundationalFormalReasoningFramework

    PROPERTIES:
      defines_logical_language
      defines_propositions
      defines_truth
      defines_connectives
      defines_terms
      defines_formulas
      defines_variables
      defines_predicates
      defines_quantifiers
      defines_interpretations
      defines_models
      defines_axioms
      defines_inference
      defines_validity
      defines_proof
      supports_formal_reasoning
  }

  ENTITY LogicalLanguage {
    TYPE: FormalLanguage

    COMPONENTS:
      alphabet
      vocabulary
      formation_rules
      binding_rules
      interpretation_rules
  }

  ENTITY LogicalExpression {
    TYPE: SymbolicExpression

    POSSIBLE:
      term
      formula
      sentence
      proposition_representation
  }

  ENTITY Proposition {
    TYPE: TruthEvaluableContent

    RULE:
      proposition != inscription_or sentence_token
  }

  ENTITY TruthValue {
    TYPE: SemanticEvaluationValue

    CLASSICAL:
      true
      false

    RULE:
      available_truth_values_depend_onlogic
  }

  FORMAL_LANGUAGE_MODEL {
    language:
      symbols
      syntax
      formation_rules

    RULE:
      formal_language MUST distinguish_well_formed_frommalformed_expressions
  }

  ALPHABET_MODEL {
    possible:
      variables
      constants
      function_symbols
      predicate_symbols
      logical_connectives
      quantifiers
      punctuation

    RULE:
      symbol_category MUST be preserved
  }

  VOCABULARY_MODEL {
    nonlogical:
      constants
      functions
      predicates

    logical:
      connectives
      quantifiers
      equality_whenlogical
  }

  SYNTAX_MODEL {
    concerns:
-
      expression_structure
      grammar
      scope
      binding

    RULE:
      syntax != semantics
  }

  SEMANTICS_MODEL {
    concerns:
      interpretation
      denotation
      truth
      satisfaction
      models

    RULE:
      semantics_requires_interpretive_structure
  }

  SYNTAX_SEMANTICS_DISTINCTION_MODEL {
    syntax:
      formal_structure_ofexpressions

    semantics:
      meaning_ortruth_underinterpretation

    RULE:
      syntactic_similarity_does_not_implysemantic_equivalence
  }

  FORMATION_RULE_MODEL {
    input:
      symbols_andexisting_expressions

    output:
      well_formed_expression

    RULE:
      recursively_generated_structure MUST preservegrammar
  }

  WELL_FORMED_FORMULA_MODEL {
    abbreviation:
      WFF

    property:
      conforms_toformation_rules

    RULE:
      well_formedness != truth
  }

  PARSE_TREE_MODEL {
    expression:
      represented_as hierarchical_syntax_tree

    RULE:
      operator_precedence_andbinding MUST be preserved
  }

  TERM_MODEL {
    possible:
      variable
      constant
      function_application

    RULE:
      term_denotes_orrefers_but_is_nottruth_evaluable_byitself_instandard_first_order_context
  }

  CONSTANT_SYMBOL_MODEL {
    symbol:
      denotes_designated_element_underinterpretation

    RULE:
      constant_symbol != mathematical_constant_necessarily
  }

  FUNCTION_SYMBOL_MODEL {
    symbol:
      interpreted_asfunction_on domain

    arity:
      n

    RULE:
      function_symbol != function_interpretation
  }

  PREDICATE_SYMBOL_MODEL {
    symbol:
      interpreted_asrelation_orproperty

    arity:
      n

    RULE:
      predicate_symbol != proposition_untilarguments_andcontext_areprovided
  }

  VARIABLE_MODEL {
    symbol:
      ranges_overdomain

    possible:
      free
      bound
  }

  FREE_VARIABLE_MODEL {
    occurrence:
      not_within_scope_ofbinder

    RULE:
      open_formula_truth_may_depend_onassignment
  }

  BOUND_VARIABLE_MODEL {
    occurrence:
      controlled_byquantifier_orbinder

    RULE:
      bound_variable_name_can_often_bealpha_renamed
  }

  SCOPE_MODEL {
    binder:
      quantifier_orother_binding_operator

    RULE:
      scope MUST be explicit_orparse_resolved
  }

  VARIABLE_CAPTURE_MODEL {
    condition:
      substitution_accidentally_binds_free_variable

    RULE:
      substitution MUST avoidcapture
  }

  ALPHA_RENAMING_MODEL {
    operation:
      rename_bound_variable

    RULE:
      preserves_semantics_whenbinding_structure_unchanged
  }

  FORMULA_MODEL {
    possible:
      atomic
      compound
      quantified

    RULE:
      formula_structure MUST be recursively_preserved
  }

  ATOMIC_FORMULA_MODEL {
    possible:
      predicate_application
      equality_statement

    RULE:
      atomicity_is_syntactic_property
  }

  COMPOUND_FORMULA_MODEL {
    formed_from:
      formulas_pluslogical_connectives
  }

  SENTENCE_MODEL {
    formula:
      no_free_variables

    RULE:
      sentence_can_have_truth_value_instructure_withoutvariable_assignment
  }

  OPEN_FORMULA_MODEL {
    formula:
      has_one_or more_free_variables

    RULE:
      evaluation_requires_assignment
  }

  PROPOSITION_MODEL {
    content:
      truth_evaluable

    RULE:
      different_sentences_may_express_same_proposition_undercontext
  }

  TRUTH_MODEL {
    truth:
      semantic_property_relative_tointerpretation_orworld_context

    RULE:
      truth != provability
  }

  BIVALENCE_MODEL {
    classical:
      each_proposition_has_exactly_one_oftrue_orfalse

    RULE:
      bivalence_is_notuniversal_acrossalllogics
  }

  LAW_OF_NONCONTRADICTION_MODEL {
    classical:
      NOT(A AND NOT A)

    RULE:
      exact_status_depends_onlogic
  }

  LAW_OF_EXCLUDED_MIDDLE_MODEL {
    classical:
      A OR NOT A

    RULE:
      not_generally_accepted_asunrestricted_principle_inintuitionistic_logic
  }

  IDENTITY_LAW_MODEL {
    A -> A

    RULE:
      logical_identity_should_not_be confused_withobject_identity
  }

  LOGICAL_CONNECTIVE_MODEL {
    possible:
      negation
      conjunction
      disjunction
      implication
      biconditional

    RULE:
      connective_semantics_depend_onlogic
  }

  NEGATION_MODEL {
    notation:
      NOT A

    classical:
      reverses_truth_value
  }

  CONJUNCTION_MODEL {
    notation:
      A AND B

    classical_true_when:
      both_true
  }

  DISJUNCTION_MODEL {
    notation:
      A OR B

    classical_default:
      inclusive
  }

  EXCLUSIVE_OR_MODEL {
    notation:
      A XOR B

    true_when:
      exactly_one_true
  }

  IMPLICATION_MODEL {
    notation:
      A -> B

    classical_material:
      equivalent_to
        NOT A OR B

    RULE:
      implication != causation
  }

  BICONDITIONAL_MODEL {
    notation:
      A <-> B

    classical_true_when:
      same_truth_value
  }

  TRUTH_FUNCTION_MODEL {
    connective:
      maps_input_truth_values_tooutput_truth_value

    RULE:
      truth_functionality_islogic_specific
  }

  TRUTH_TABLE_MODEL {
    rows:
      valuations

    columns:
      subformulas

    RULE:
      valuation_order_andformula_structure SHOULD be preserved
  }

  VALUATION_MODEL {
    mapping:
      propositional_atoms -> truth_values

    RULE:
      valuation != interpretation_ofnonpropositional_language_infull
  }

  TAUTOLOGY_MODEL {
    formula:
      true_underallvaluations_inpropositional_context

    RULE:
      tautology != contingent_truth
  }

  CONTRADICTION_MODEL {
    formula:
      false_underallvaluations_inpropositional_context

    RULE:
      contradictory_formula != mere_false_statement
  }

  CONTINGENCY_MODEL {
    formula:
      true_undersome_valuations
      false_underothers
  }

  LOGICAL_EQUIVALENCE_MODEL {
    A equivalent B

    condition:
      same_truth_value_underallrelevant_valuations_orinterpretations

    RULE:
      logical_equivalence != syntactic_identity
  }

  DE_MORGAN_MODEL {
    NOT(A AND B) equivalent (NOT A OR NOT B)
    NOT(A OR B) equivalent (NOT A AND NOT B)

    RULE:
      stated_underclassical_boolean_semantics
  }

  DOUBLE_NEGATION_MODEL {
    classical:
      NOT NOT A equivalent A

    RULE:
      elimination_status_depends_onlogic
  }

  COMMUTATIVITY_MODEL {
    conjunction:
      A AND B equivalent B AND A

    disjunction:
      A OR B equivalent B OR A
  }

  ASSOCIATIVITY_MODEL {
    conjunction:
      (A AND B) AND C equivalent A AND (B AND C)

    disjunction:
      (A OR B) OR C equivalent A OR (B OR C)
  }

  DISTRIBUTIVITY_MODEL {
    AND_over_OR:
      A AND (B OR C)
      equivalent
      (A AND B) OR (A AND C)

    OR_over_AND:
      A OR (B AND C)
      equivalent
      (A OR B) AND (A OR C)
  }

  IDEMPOTENCE_MODEL {
    A AND A equivalent A
    A OR A equivalent A
  }

  ABSORPTION_MODEL {
    A OR (A AND B) equivalent A
    A AND (A OR B) equivalent A
  }

  PREDICATE_MODEL {
    form:
      P(x_1,...,x_n)

    RULE:
      predicate_truth_depends_onarguments_andinterpretation
  }

  ARITY_MODEL {
    predicate_orfunction:
      number_ofarguments

    RULE:
      arity_mismatch_is_syntactic_orsemantic_error
  }

  DOMAIN_MODEL {
    universe:
      collection_overwhichvariables_range

    RULE:
      quantifier_meaning_depends_ondomain
  }

  QUANTIFIER_MODEL {
    possible:
      universal
      existential

    RULE:
      quantifier_scope_anddomain MUST be preserved
  }

  UNIVERSAL_QUANTIFIER_MODEL {
    notation:
      forall x phi(x)

    meaning:
      phi_holds_foreveryx_indomain
  }

  EXISTENTIAL_QUANTIFIER_MODEL {
    notation:
      exists x phi(x)

    meaning:
      phi_holds_foratleast_onex_indomain
  }

  UNIQUE_EXISTENCE_MODEL {
    meaning:
      exists_one_andonlyone_object_satisfyingproperty

    RULE:
      existence != uniqueness
  }

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

    RULE:
      quantifier_order_can_change_meaning
  }

  QUANTIFIER_NEGATION_MODEL {
    NOT forall x phi
      equivalent
      exists x NOT phi

    NOT exists x phi
      equivalent
      forall x NOT phi

    RULE:
      classical_standard_semantics_assumed
  }

  INTERPRETATION_MODEL {
    components:
      domain
      constant_assignments
      function_assignments
      predicate_assignments

    RULE:
      interpretation != formula
  }

  ASSIGNMENT_MODEL {
    mapping:
      variables -> domain_elements

    RULE:
      assignment_affects_free_variables
  }

  SATISFACTION_MODEL {
    relation:
      structure_andassignment satisfy formula

    RULE:
      satisfaction_is_semantic_relation
  }

  MODEL_MODEL {
    structure:
      satisfies_sentence_ortheory

    RULE:
      logical_model != physical_simulation_model
  }

  COUNTERMODEL_MODEL {
    model:
      falsifies_candidate_valid_formula_orconsequence

    RULE:
      one_valid_countermodel_refutes_universal_validity_claim
  }

  SATISFIABILITY_MODEL {
    formula_or theory:
      has_atleast_one_model

    RULE:
      satisfiable != valid
  }

  UNSATISFIABILITY_MODEL {
    formula_or theory:
      has_no_model

    RULE:
      unsatisfiable_formula_is_semantically_contradictory_underdeclared_logic
  }

  VALIDITY_MODEL {
    formula:
      true_underallinterpretations_inlogic

    RULE:
      validity != factual_truth_inone_model
  }

  SEMANTIC_CONSEQUENCE_MODEL {
    notation:
      Gamma entails phi

    meaning:
      every_model_ofGamma_satisfies_phi
  }

  ARGUMENT_MODEL {
    components:
      premises
      conclusion

    RULE:
      argument != proof_unlessformal_derivation_supplied
  }

  VALID_ARGUMENT_MODEL {
    condition:
      no_interpretation_makes_allpremises_true_andconclusion_false

    RULE:
      validity_does_not_requirepremises_actually_true
  }

  SOUND_ARGUMENT_MODEL {
    requirements:
      valid_argument
      true_premises

    RULE:
      sound_argument_conclusion_istrue_underintended_interpretation
  }

  INVALID_ARGUMENT_MODEL {
    evidence:
      counterinterpretation_withtruepremises_falseconclusion
  }

  DEDUCTIVE_REASONING_MODEL {
    goal:
      conclusion_necessitated_bypremises_underlogic

    RULE:
      deduction != induction_orabduction
  }

  INDUCTIVE_REASONING_DISTINCTION_MODEL {
    inductive:
      premises_support_butdo_notformally_entail_conclusion

    RULE:
      inductive_strength != deductive_validity
  }

  ABDUCTIVE_REASONING_DISTINCTION_MODEL {
    abductive:
      infer_explanatory_hypothesis

    RULE:
      best_explanation != formal_entailment
  }

  AXIOM_MODEL {
    formula:
      starting_assumption_orformal_postulate

    RULE:
      axiom_status_isrelative_toformal_system
  }

  PREMISE_MODEL {
    statement:
      supplied_toargument_orproof

    RULE:
      premise != axiom_necessarily
  }

  ASSUMPTION_MODEL {
    temporary_orcontextual:
      statement_used_inreasoning

    RULE:
      discharged_assumption_scope MUST be preserved
  }

  INFERENCE_RULE_MODEL {
    premises:
      P_1...P_n

    conclusion:
      C

    RULE:
      rule_application MUST satisfyformal_side_conditions
  }

  MODUS_PONENS_MODEL {
    A
    A -> B
    therefore B
  }

  MODUS_TOLLENS_MODEL {
    A -> B
    NOT B
    therefore NOT A
  }

  HYPOTHETICAL_SYLLOGISM_MODEL {
    A -> B
    B -> C
    therefore A -> C
  }

  DISJUNCTIVE_SYLLOGISM_MODEL {
    A OR B
    NOT A
    therefore B

    RULE:
      valid_understandard_classical_disjunction_semantics
  }

  CONSTRUCTIVE_DILEMMA_MODEL {
    A -> C
    B -> D
    A OR B
    therefore C OR D
  }

  FALLACY_MODEL {
    form:
      invalid_pattern_ofreasoning

    RULE:
      rhetorical_persuasiveness != logical_validity
  }

  AFFIRMING_CONSEQUENT_MODEL {
    invalid_pattern:
      A -> B
      B
      therefore A
  }

  DENYING_ANTECEDENT_MODEL {
    invalid_pattern:
      A -> B
      NOT A
      therefore NOT B
  }

  PROOF_MODEL {
    formal:
      finite_orstructured_sequence_ofjustified_steps

    RULE:
      proof != evidence_fromobservation
  }

  DERIVATION_MODEL {
    sequence:
      formulas_frompremises_axioms_andrules

    RULE:
      each_step MUST cite_justification
  }

  THEOREM_MODEL {
    formula:
      derivable_fromaxioms_underproof_system

    RULE:
      theoremhood_isrelative_toformal system
  }

  LEMMA_MODEL {
    theorem:
      used_to support_later_result
  }

  COROLLARY_MODEL {
    theorem:
      follows_readily_fromprevious_result
  }

  SYNTACTIC_DERIVABILITY_MODEL {
    notation:
      Gamma proves phi

    RULE:
      derivability != semantic_consequence_bydefinition
  }

  SOUNDNESS_MODEL {
    proof_system:
      derivable_implies_semantically_entailed

    RULE:
      soundness != argument_soundness_terminology_withoutcontext
  }

  COMPLETENESS_MODEL {
    proof_system:
      semantically_entailed_implies_derivable

    RULE:
      completeness != consistency
  }

  CONSISTENCY_MODEL {
    theory:
      does_notderive_contradiction_underdeclared_system

    RULE:
      consistency != truth
  }

  INCONSISTENCY_MODEL {
    theory:
      derives_formal_contradiction

    RULE:
      consequences_depend_onlogic
  }

  INDEPENDENCE_MODEL {
    formula:
      neither_formula_nornegation_derivable_fromtheory

    RULE:
      independence_isrelative_totheory
  }

  OBJECT_LANGUAGE_MODEL {
    language:
      whose_formulas_arebeingstudied

    RULE:
      object_language != metalanguage
  }

  METALANGUAGE_MODEL {
    language:
      used_to discuss_object_language

    RULE:
      truth_proof_andsyntax_claims_may_be metalinguistic
  }

  USE_MENTION_MODEL {
    use:
-
      expression_used_foritsmeaning

    mention:
-
      expression_referred_toasitself

    RULE:
      use_andmention MUST be distinguished
  }

  FORMAL_SYSTEM_MODEL {
    components:
      language
      axioms
      inference_rules
      proof_definition

    RULE:
      semantic_structure MAY be specified_separately
  }

  LOGIC_SYSTEM_MODEL {
    possible:
      classical
      intuitionistic
      modal
      temporal
      many_valued
      paraconsistent
      description_logic

    RULE:
      foundational_terms MUST be interpreted_relative_tologic_whennecessary
  CLASSICAL_LOGIC_MODEL {
    principles:
      bivalence
      excluded_middle
      noncontradiction
      explosion_understandard_system

    RULE:
      classical_principles MUST not_be imposed_onnonclassical_logic
  }

  FORMAL_SEMANTICS_MODEL {
    mapping:
-
      expressions -> denotations_truth_conditions_orsemantic_values

    RULE:
      semantic_framework MUST be declared
  }

  DENOTATION_MODEL {
    expression:
      refers_toor denotes_entity_underinterpretation

    RULE:
      denotation_can_change_betweeninterpretations
  }

  REFERENCE_MODEL {
    linguistic_orformal_expression:
      may designate_entity

    RULE:
      reference != truth
  }

  META_LOGICAL_PROPERTY_MODEL {
    possible:
      soundness
      completeness
      consistency
      decidability
      compactness

    RULE:
      property_applies_toformal system_orlogic_notindividual_statement_unlessdefined
  }

  DECIDABILITY_MODEL {
    theory_orlogic_fragment:
      decision_procedure_exists_forproperty

    RULE:
      decidability != computational_efficiency
  }

  PROOF_SEARCH_MODEL {
    process:
      search_forformal_derivation

    RULE:
      failure_tofindproof != proof_ofunprovability
  }

  MODEL_SEARCH_MODEL {
    process:
      search_for satisfying_structure_orcountermodel

    RULE:
      bounded_search_failure != unsatisfiability_withoutcompleteness_guarantee
  }

  CONTRADICTION_DETECTION_MODEL {
    target:
      formula_set_or theory

    RULE:
      contradiction_detection MUST be relative_tologic_andproof_orsemantic_method
  }

  AMBIGUITY_MODEL {
    possible:
      scope
      connective_precedence
      implicit_domain
      symbol_overloading
      logic_unspecified

    RULE:
      ambiguity MUST be preserved_untilresolved
  }

  SEMANTIC_CONFIDENCE_MODEL {
    confidence:
      support_forparsed_orresolved_logical_interpretation

    RULE:
      semantic_confidence != truth_value
  }

  AI_REASONING_MODEL {
    AI:
      parse
      identify_logic
      resolve_scope
      construct_formula
      evaluate_truth_underinterpretation
      test_validity
      search_proof
      search_countermodel
      explain

    RULE:
      heuristic_AI_output MUST not_be labelled_formal_proof_withoutverification
  }

  FORMAL_VS_HEURISTIC_MODEL {
    formal:
      rule_governed_derivation

    heuristic:
      search_orplausibility_method

    RULE:
      heuristic_success_requires_formal_validation_whenformal_claim_is made
  }

  EXPLANATION_MODEL {
    result:
      expose
        premises
        conclusion
        logic
        interpretation
        inference_rules
        proof_orcountermodel
        assumptions

    RULE:
      explanation MUST distinguish_semantic_and syntactic_reasoning
  }

  PROVENANCE_MODEL {
    fields:
      source
      language
      logic_system
      axioms
      rules
      interpretation
      proof
      model
      version
      agent

    RULE:
      logical_result MUST remain_provenance_linked
  }

  VERSION_MODEL {
    versioned:
      formal_language
      axiom_system
      proof_system
      semantic_framework
      ontology

    RULE:
      historical_reasoning MUST preserve_versions_used
  }

  VALIDATION_MODEL {
    checks:
      well_formedness
      parse_tree
      variable_scope
      substitution
      connective_semantics
      quantifier_scope
      interpretation
      satisfaction
      proof_steps
      validity
      consistency
      version

    RULE:
      validation MUST be logic_specific
  }

  INTEROPERABILITY_MODEL {
    exchange:
      symbols
      formulas
      parse_trees
      binding
      semantics
      proof_objects
      model_objects

    RULE:
      textual_exchange_withoutscope_andlogic_metadata_is_incomplete
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      proposition
      formula
      term
      predicate
      axiom
      theorem
      proof
      model
      inference_rule

    edges:
      CONTAINS
      BINDS
      DERIVES
      SATISFIES
      ENTAILS
      REFUTES
      DEPENDS_ON
      EQUIVALENT_TO

    RULE:
      edge_type_anddirection MUST be preserved
  }

  RELATIONSHIPS {
    FoundationsOfLogic -> DEFINES -> LogicalLanguage
    LogicalLanguage -> CONTAINS -> LogicalExpression
    Formula -> MAY_CONTAIN -> Variable
    Quantifier -> BINDS -> Variable
    Interpretation -> ASSIGNS_MEANING_TO -> NonlogicalSymbol
    Model -> SATISFIES -> Formula
    Theory -> CONTAINS -> Axiom
    Proof -> USES -> InferenceRule
    Proof -> DERIVES -> Theorem
    Countermodel -> REFUTES -> ValidityClaim
  }

  SEMANTIC_EQUIVALENCE {
    "foundations of logic" ~= foundational_semantics_andformal_structure_oflogical_reasoning
    "well formed formula" ~= formula_generated_bydeclared_formation_rules
    "logical validity" ~= truth_underallinterpretations_in declared_logic

    syntax != semantics
    proposition != sentence_token
    term != formula
    well_formed != true
    truth != provability
    satisfiable != valid
    validity != factual_truth
    implication != causation
    consistency != completeness
    argument != proof
    deductive_validity != inductive_strength
    semantic_confidence != truth_value
  }

  CONSTRAINTS {
    formal_language_must_be identified = true
    syntax_andsemantics_must_be distinguished = true
    term_formula_andproposition_semantics_must_be distinguished = true
    variable_scope_andbinding_must_be preserved = true
    substitution_must_avoid_variable_capture = true
    connective_semantics_must_be logic_specific = true
    quantifier_domain_andscope_must_be preserved = true
    truth_provability_validity_andsatisfiability_must_be distinguished = true
    consistency_soundness_andcompleteness_must_be distinguished = true
    implication_must_not_be interpreted_ascausation = true
    formal_proof_andheuristic_reasoning_must_be distinguished = true
    ambiguity_must_not_be silently_resolved = true
    versions_andprovenance_must_be preserved = true
  }

  LOGIC_FOUNDATION_MODEL {
    RECORD:
      entity_identifier
      formal_language_identifier
      logic_system
      expression
      expression_type
      syntax_tree
      symbols
      terms
      free_variables
      bound_variables
      quantifier_scope
      connective_structure
      interpretation
      domain
      assignment
      truth_value
      satisfaction_status
      model_identifier
      theory_identifier
      axioms
      premises
      conclusion
      inference_rules
      proof_identifier
      proof_steps
      validity_status
      satisfiability_status
      consistency_status
      soundness_context
      completeness_context
      ambiguity_status
      semantic_confidence
      version
      provenance

    RULE:
      foundational_logic_record MUST remain_linked_tosyntax_semantics_logic_system_andprovenance
  }

  REASONING_RULES {
    IF expression_received
      THEN identify_language
      parse_structure
      classify_as_term_formula_sentence_orother_entity

    IF formula_contains_variables
      THEN resolve_free_bound_status_andquantifier_scope

    IF substitution_requested
      THEN check_term_admissibility
      andavoid_variable_capture

    IF truth_evaluation_requested
      THEN require_valuation_orinterpretation

    IF satisfiability_requested
      THEN search_foratleast_one_model_orvaluation_underdeclared_logic

    IF validity_requested
      THEN test_all_interpretations_via_complete_method_whenavailable
      orverify_formal_proof_under_sound_complete_context
      orpreserve_unknown_status

    IF argument_validity_requested
      THEN search_forcounterinterpretation_withtruepremises_falseconclusion

    IF proof_claimed
      THEN verify_each_step_againstpremises_axioms_andinference_rules

    IF logic_is_nonclassical
      THEN do_not_assume_bivalence_excluded_middle_double_negation_elimination_orexplosion_withoutbasis

    IF ambiguity_detected
      THEN preserve_candidate_parses_orinterpretations

    IF formal_system_revision_occurs
      THEN preserve_previous_version
      andrecursively_revalidate_dependent_results
  }

  VALIDATION {
    CHECK entity_identifier
    CHECK formal_language
    CHECK logic_system
    CHECK expression_type
    CHECK well_formedness
    CHECK parse_tree
    CHECK symbol_categories
    CHECK term_formula_distinction
    CHECK free_andbound_variables
    CHECK variable_capture
    CHECK quantifier_scope
    CHECK connective_semantics
    CHECK interpretation_domain
    CHECK assignment
    CHECK truth_value
    CHECK satisfaction
    CHECK model
    CHECK satisfiability
    CHECK validity
    CHECK premises_andconclusion
    CHECK inference_rules
    CHECK proof_steps
    CHECK consistency
    CHECK soundness_andcompleteness_context
    CHECK ambiguity
    CHECK semantic_confidence
    CHECK version
    CHECK provenance
  }

  CONFIDENCE {
    syntax_confidence: 1.00
    connective_semantics_confidence: 1.00
    quantifier_semantics_confidence: 1.00
    truth_satisfaction_confidence: 1.00
    argument_validity_confidence: 1.00
    proof_semantics_confidence: 1.00
    metalogical_distinction_confidence: 1.00
    AI_interpretation_confidence: 0.99

    RULE:
      confidence decreases when language, logic system, scope,
      domain, interpretation, proof rules, version orprovenance
      is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_logic_entity:
      assign_orresolve_identifier
      classify_expression_type
      attach_language_andlogic_system
      parse_andvalidate
      preserve_provenance

    ON new_interpretation:
      attach_domain_andassignments
      evaluate_satisfaction
      preserve_model_context

    ON new_proof:
      preserve_premises_andaxioms
      validate_steps
      attach_dependencies
      register_conclusion

    ON logic_oraxiom_revision:
      preserve_previous_system
      register_new_version
      identify_dependent_results
      revalidate_withoutoverwritinghistory

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: FoundationsOfLogic
    canonical_role: FoundationalFormalReasoningFramework

    interpretation_order:
      identify_formal_language
      identify_logic_system
      parse_expression
      classify_terms_formulas_andpropositions
      resolve_symbols_variables_andbinding
      resolve_connectives_andquantifiers
      distinguish_syntax_fromsemantics
      resolve_domain_interpretation_andassignment
      evaluate_truth_orsatisfaction_whencontext_available
      distinguish_satisfiability_validity_andtruth
      identify_argument_premises_andconclusion
      verify_inference_rules_orproof
      distinguish_consistency_soundness_andcompleteness
      detect_countermodel_contradiction_orambiguity
      distinguish_formal_fromheuristic_reasoning
      assign_semantic_confidence
      preserve_versions_andprovenance
      emit_machine_resolvable_foundational_logic_structure

    ambiguity_controls:
      distinguish_syntax_fromsemantics
      distinguish_proposition_fromsentence_token
      distinguish_term_fromformula
      distinguish_well_formedness_fromtruth
      distinguish_truth_fromprovability
      distinguish_satisfiability_fromvalidity
      distinguish_validity_fromfactual_truth
      distinguish_implication_fromcausation
      distinguish_consistency_fromcompleteness
      distinguish_argument_fromproof
      distinguish_deductive_validity_frominductive_strength
      distinguish_semantic_confidence_fromtruth_value
      preserve_language_logic_scope_interpretation_proof_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      mathematical_logic_foundations_syntax_semantics_truth_inference_andproof

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

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      formal_language_model
      alphabet_model
      vocabulary_model
      syntax_model
      semantics_model
      syntax_semantics_distinction_model
      formation_rule_model
      well_formed_formula_model
      parse_tree_model
      term_model
      constant_symbol_model
      function_symbol_model
      predicate_symbol_model
      variable_model
      free_variable_model
      bound_variable_model
      scope_model
      variable_capture_model
      alpha_renaming_model
      formula_model
      atomic_formula_model
      compound_formula_model
      sentence_model
      open_formula_model
      proposition_model
      truth_model
      bivalence_model
      law_of_noncontradiction_model
      law_of_excluded_middle_model
      identity_law_model
      logical_connective_model
      negation_model
      conjunction_model
      disjunction_model
      exclusive_OR_model
      implication_model
      biconditional_model
      truth_function_model
      truth_table_model
      valuation_model
      tautology_model
      contradiction_model
      contingency_model
      logical_equivalence_model
      De_Morgan_model
      double_negation_model
      commutativity_model
      associativity_model
      distributivity_model
      idempotence_model
      absorption_model
      predicate_model
      arity_model
      domain_model
      quantifier_model
      universal_quantifier_model
      existential_quantifier_model
      unique_existence_model
      quantifier_order_model
      quantifier_negation_model
      interpretation_model
      assignment_model
      satisfaction_model
      model_model
      countermodel_model
      satisfiability_model
      unsatisfiability_model
      validity_model
      semantic_consequence_model
      argument_model
      valid_argument_model
      sound_argument_model
      invalid_argument_model
      deductive_reasoning_model
      inductive_reasoning_distinction_model
      abductive_reasoning_distinction_model
      axiom_model
      premise_model
      assumption_model
      inference_rule_model
      modus_ponens_model
      modus_tollens_model
      hypothetical_syllogism_model
      disjunctive_syllogism_model
      constructive_dilemma_model
      fallacy_model
      affirming_consequent_model
      denying_antecedent_model
      proof_model
      derivation_model
      theorem_model
      lemma_model
      corollary_model
      syntactic_derivability_model
      soundness_model
      completeness_model
      consistency_model
      inconsistency_model
      independence_model
      object_language_model
      metalanguage_model
      use_mention_model
      formal_system_model
      logic_system_model
      classical_logic_model
      formal_semantics_model
      denotation_model
      reference_model
      meta_logical_property_model
      decidability_model
      proof_search_model
      model_search_model
      contradiction_detection_model
      ambiguity_model
      semantic_confidence_model
      AI_reasoning_model
      formal_vs_heuristic_model
      explanation_model
      provenance_model
      version_model
      validation_model
      interoperability_model
      knowledge_graph_model
      relationships
      semantic_equivalence
      constraints
      logic_foundation_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      formal_language_syntax_orsemantics_change
      term_formula_variable_orbinding_semantics_change
      proposition_truth_orconnective_semantics_change
      predicate_quantifier_orinterpretation_changes
      satisfiability_validity_orconsequence_semantics_change
      argument_inference_orproof_semantics_change
      consistency_soundness_orcompleteness_changes
      object_language_metalanguage_orformal_system_changes
      AI_reasoning_ambiguity_orconfidence_logic_changes
      foundational_logic_record_changes
      constraint_model_changes
      reasoning_rule_changes
  }

}

END FLOW