Deductive System Ontology

# Deductive System Ontology — Flow Algebra

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

FLOW DeductiveSystemOntology {

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

  PURPOSE:
    Represent a deductive system as a machine-interpretable framework for deriving conclusions from axioms, premises and assumptions by explicitly defined inference rules. The ontology models formal languages, judgments, sequents, theories, proof contexts, derivations, theoremhood, rule schemata, structural rules, introduction and elimination rules, assumption discharge, substitution, proof trees, proof search, admissibility, derivability, soundness, completeness, consistency, conservative extension, automated deduction and provenance. It enables AI systems to determine whether a claimed conclusion is formally derivable within a specified deductive system while distinguishing derivability from semantic consequence, proof search from proof verification, admissible rules from primitive rules, local assumptions from axioms, and formal deduction from inductive, abductive or heuristic reasoning.

  ENTITY DeductiveSystem {
    TYPE: RuleGovernedDerivationFramework

    COMPONENTS:
      formal_language
      judgments
      axioms
      inference_rules
      derivation_definition
      proof_context
      theorem_definition

    PROPERTIES:
      derives_conclusions
      supports_formal_proofs
      has_rule_schemata
      has_structural_rules
      has_versions
      may_have_semantics
      may_be_sound
      may_be_complete
  }

  ENTITY DeductiveRule {
    TYPE: FormalInferenceRule

    COMPONENTS:
      rule_identifier
      premises
      conclusion
      metavariables
      side_conditions
  }

  ENTITY DeductiveDerivation {
    TYPE: FormalDependencyStructure

    COMPONENTS:
      initial_context
      proof_steps
      rule_instances
      assumptions
      conclusion
  }

  ENTITY DeductiveJudgment {
    TYPE: FormalAssertion

    POSSIBLE:
      formula_judgment
      sequent
      typing_judgment
      equality_judgment
      derivability_judgment
  }

  SYSTEM_IDENTITY_MODEL {
    fields:
      deductive_system_identifier
      logic_family
      proof_calculus
      version

    RULE:
      derivability_status MUST reference_exact_system_version
  }

  LANGUAGE_MODEL {
    fields:
      language_identifier
      signature
      formation_rules

    RULE:
      every_judgment MUST be well_formed_inlanguage
  }

  JUDGMENT_MODEL {
    judgment:
      object_manipulated_byinference_rules

    RULE:
      judgment != proposition_inall_deductive_systems
  }

  FORMULA_JUDGMENT_MODEL {
    form:
      phi

    interpretation:
      assertion_offormula_underproof_context
  }

  SEQUENT_MODEL {
    generic:
      Gamma |- Delta

    components:
      antecedent
      turnstile
      succedent

    RULE:
      exact_sequent_semantics depend_oncalculus
  }

  SINGLE_CONCLUSION_SEQUENT_MODEL {
    form:
      Gamma |- A

    RULE:
      succedent_contains_atmostoneformula
  }

  MULTIPLE_CONCLUSION_SEQUENT_MODEL {
    form:
      Gamma |- Delta

    RULE:
      calculus_semantics MUST be declared
  }

  CONTEXT_MODEL {
    Gamma:
      collection_orsequence_ofactive_assumptions

    possible_structure:
      set
      multiset
      sequence

    RULE:
      context_structure determines_structural_rule_validity
  }

  EMPTY_CONTEXT_MODEL {
    notation:
      |- A

    meaning:
      theoremhood_underdeclared_system
  }

  PREMISE_MODEL {
    statement:
      externally_supplied_starting_judgment

    RULE:
      premise != axiom
  }

  AXIOM_MODEL {
    judgment:
      accepted_asprimitive_derivable_statement

    RULE:
      axiom_status_isrelative_todeductive_system
  }

  AXIOM_SCHEMA_MODEL {
    pattern:
      generates_axiom_instances

    RULE:
      metavariables MUST be distinguished_fromobject_variables
  }

  INFERENCE_RULE_MODEL {
    form:
      premises
      ----
      conclusion

    RULE:
      all_rule_instances MUST satisfy_side_conditions
  }

  ZERO_PREMISE_RULE_MODEL {
    rule:
      derives_conclusion_withoutpremises

    RULE:
      may_function_asaxiom_rule
  }

  UNARY_RULE_MODEL {
    premises:
      one

    conclusion:
      one_judgment
  }

  BINARY_RULE_MODEL {
    premises:
      two

    conclusion:
      one_judgment
  }

  NARY_RULE_MODEL {
    premises:
      finite_orotherwise_declared_collection

    RULE:
      arity MUST be explicit
  }

  RULE_SCHEMA_MODEL {
    components:
      metavariables
      premise_patterns
      conclusion_pattern
      side_conditions

    RULE:
      rule_instance_requires_valid_metavariable_substitution
  }

  RULE_INSTANCE_MODEL {
    schema:
      instantiated_withconcrete_judgments

    RULE:
      instantiation_mapping MUST be preserved
  }

  SIDE_CONDITION_MODEL {
    possible:
      variable_freshness
      variable_not_free
      type_constraint
      term_admissibility
      context_condition

    RULE:
      side_condition_failure_invalidates_rule_instance
  }

  METAVARIABLE_MODEL {
    ranges_over:
      formulas
      terms
      contexts
      derivations

    RULE:
      metavariable != object_language_variable
  }

  SUBSTITUTION_MODEL {
    mapping:
      metavariables_orvariables -> admissible_expressions

    RULE:
      substitution MUST preserve_binding_andtypes
  }

  VARIABLE_CAPTURE_MODEL {
    risk:
      substitution_changes_binding_status

    RULE:
      capture_avoiding_substitution REQUIRED
  }

  STRUCTURAL_RULE_MODEL {
    possible:
      weakening
      contraction
      exchange
      cut

    RULE:
      availability_depends_oncalculus
  }

  WEAKENING_MODEL {
    generic:
      from Gamma |- A
      infer Gamma,B |- A

    RULE:
      notvalid_inallsubstructural_logics
  }

  CONTRACTION_MODEL {
    generic:
      from Gamma,A,A |- B
      infer Gamma,A |- B

    RULE:
      notavailable_inalllogics
  }

  EXCHANGE_MODEL {
    generic:
      reorder_context_elements

    RULE:
      notavailable_whencontext_order_semantically_material
  }

  CUT_MODEL {
    generic:
      Gamma |- A
      A,Delta |- B
      therefore Gamma,Delta |- B

    RULE:
      exact_form_depends_oncalculus
  }

  CUT_ELIMINATION_MODEL {
    property:
      derivations_usingcut_can_be transformed_tocut_free_derivations_when theorem_applies

    RULE:
      cut_elimination_iscalculus_specific
  }

  IDENTITY_RULE_MODEL {
    generic:
      A |- A

    RULE:
      identity_rule_form MAY vary
  }

  CONNECTIVE_RULE_MODEL {
    categories:
      introduction
      elimination
      left_rule
      right_rule

    RULE:
      rule_family depends_onproof_calculus
  }

  CONJUNCTION_INTRODUCTION_MODEL {
    premises:
      Gamma |- A
      Gamma |- B

    conclusion:
      Gamma |- A AND B

    RULE:
      context_handling_depends_oncalculus
  }

  CONJUNCTION_ELIMINATION_MODEL {
    premise:
      A AND B

    conclusions:
      A
      orB

    RULE:
      natural_deduction_context_assumed
  }

  DISJUNCTION_INTRODUCTION_MODEL {
    premise:
      A

    conclusion:
      A OR B
  }

  DISJUNCTION_ELIMINATION_MODEL {
    premises:
      A OR B
      derivation_ofC_fromA
      derivation_ofC_fromB

    conclusion:
      C

    RULE:
      case_assumptions MUST be discharged
  }

  IMPLICATION_INTRODUCTION_MODEL {
    process:
      assume_A
      derive_B
      discharge_A

    conclusion:
      A -> B

    RULE:
      assumption_scope MUST be preserved
  }

  IMPLICATION_ELIMINATION_MODEL {
    aliases:
      modus_ponens

    premises:
      A
      A -> B

    conclusion:
      B
  }

  NEGATION_RULE_MODEL {
    possible:
      negation_introduction
      negation_elimination

    RULE:
      exact_rules depend_onlogic
  }

  FALSITY_MODEL {
    symbol:
      bottom_orformal_falsehood

    RULE:
      falsity_elimination_notvalid_inallparaconsistent_systems
  }

  EXPLOSION_MODEL {
    premise:
      bottom

    conclusion:
      arbitrary_A

    RULE:
      classical_orintuitionistic_standard_systems_mayallow
      paraconsistent_systems_maynot
  }

  UNIVERSAL_INTRODUCTION_MODEL {
    process:
      derive_phi(x)
      generalise_x

    RULE:
      eigenvariable_orfree_variable_side_conditions MUST be checked
  }

  UNIVERSAL_ELIMINATION_MODEL {
    premise:
      forall x phi(x)

    conclusion:
      phi(t)

    RULE:
      t_must_be admissible
  }

  EXISTENTIAL_INTRODUCTION_MODEL {
    premise:
      phi(t)

    conclusion:
      exists x phi(x)
  }

  EXISTENTIAL_ELIMINATION_MODEL {
    premise:
      exists x phi(x)

    subderivation:
      assume_phi(c)
      derive_C

    conclusion:
      C

    RULE:
      freshness_conditions_onc MUST be checked
  }

  EQUALITY_RULE_MODEL {
    possible:
      reflexivity
      symmetry
      transitivity
      substitution
      congruence

    RULE:
      equality_treatment MUST be declared
  }

  REFLEXIVITY_MODEL {
    conclusion:
      t = t
  }

  SYMMETRY_MODEL {
    premise:
      s = t

    conclusion:
      t = s
  }

  TRANSITIVITY_MODEL {
    premises:
      r = s
      s = t

    conclusion:
      r = t
  }

  CONGRUENCE_MODEL {
    premise:
      corresponding_arguments_equal

    conclusion:
      function_applications_equal

    RULE:
      function_symbol_andarity MUST match
  }

  ASSUMPTION_MODEL {
    judgment:
      locally_added_tocontext

    RULE:
      assumption != theorem
  }

  ASSUMPTION_SCOPE_MODEL {
    assumption:
      active_withinsubderivation

    RULE:
      proof_structure MUST identify_scope_boundaries
  }

  ASSUMPTION_DISCHARGE_MODEL {
    rule:
      closes_assumption

    RULE:
      discharge MUST identify_which_occurrences_orassumptions_areclosed
  }

  DERIVATION_MODEL {
    structure:
      finite_tree_sequence_orDAG_underdeclared_calculus

    leaves:
      axioms
      premises
      assumptions

    internal_nodes:
      rule_instances

    root:
      conclusion

    RULE:
      every_internal_node MUST be justified
  }

  DERIVATION_HEIGHT_MODEL {
    height:
      longest_dependency_path

    RULE:
      height != number_ofsteps
  }

  DERIVATION_LENGTH_MODEL {
    length:
      count_ofrule_instances_orsteps_underdeclared_measure

    RULE:
      representation_affects_length
  }

  PROOF_MODEL {
    derivation:
      satisfies_proof_definition

    RULE:
      derivation_withopen_assumptions MAY proveconditional_judgment_butnotclosed_theorem
  }

  THEOREM_MODEL {
    judgment:
      derivable_fromaxioms_withno_unpermitted_open_assumptions

    RULE:
      theoremhood_isrelative_tosystem
  }

  DERIVABILITY_MODEL {
    notation:
      Gamma |- A

    meaning:
      derivation_exists_fromGamma_toA

    RULE:
      derivability_isformal_syntactic_relation
  }

  NONDERIVABILITY_MODEL {
    claim:
      no_derivation_exists

    RULE:
      failure_ofsearch != proof_ofnonderivability
  }

  ADMISSIBLE_RULE_MODEL {
    rule:
      whenever_premises_derivable_thenconclusion_derivable

    RULE:
      admissible_rule_neednotbeprimitive_rule
  }

  DERIVED_RULE_MODEL {
    rule:
      hasuniform_derivation_fromprimitive_rules

    RULE:
      derived_rule_isadmissible_butdistinction_maymatter
  }

  PRIMITIVE_RULE_MODEL {
    rule:
      explicitly_part_ofdeductive_system_definition

    RULE:
      primitive != logically_morefundamental_withoutmetatheoretic_claim
  }

  RULE_ADMISSIBILITY_PROOF_MODEL {
    proof:
      establishes_rule_preserves_derivability

    RULE:
      admissibility_isproperty_ofsystem
  }

  INVERTIBLE_RULE_MODEL {
    rule:
      derivability_ofconclusion_implies_derivability_ofpremises_underappropriate_conditions

    RULE:
      invertibility_definition MUST be calculus_specific
  }

  DERIVATION_TRANSFORMATION_MODEL {
    source:
      derivation_D

    target:
      derivation_D_prime

    preserves:
      conclusion
      anddeclared_context

    RULE:
      transformation_theorem MUST be identified
  }

  NORMALISATION_MODEL {
    process:
      remove_detours_orreduceproof

    RULE:
      normalisation_isproof_system specific
  }

  DETOUR_REDUCTION_MODEL {
    pattern:
      introduction_followed_bycorresponding_elimination

    RULE:
      reduction MUST preserveconclusion
  }

  SUBFORMULA_PROPERTY_MODEL {
    property:
      formulas_inproof_are_subformulas_ofendsequent_oraxioms_asdeclared

    RULE:
      property_depends_oncalculus_andnormal_form
  }

  NATURAL_DEDUCTION_MODEL {
    features:
      introduction_elimination_rules
      assumptions
      discharge

    RULE:
      derivation_context MUST be scoped
  }

  SEQUENT_CALCULUS_MODEL {
    features:
      sequents
      left_right_rules
      structural_rules

    RULE:
      sequent_variant MUST be identified
  }

  HILBERT_CALCULUS_MODEL {
    features:
      axiom_schemata
      small_rule_set

    RULE:
      theorem_derivation MAY be linear
  }

  TABLEAU_CALCULUS_MODEL {
    process:
      decompose_formulas
      branch
      close_oropen

    RULE:
      tableau_success_condition depends_onproof_goal
  }

  RESOLUTION_CALCULUS_MODEL {
    representation:
      clauses

    rule:
      resolution

    RULE:
      clausification_andunification MUST be provenance_linked
  }

  TYPE_THEORETIC_DEDUCTION_MODEL {
    judgments:
      Gamma |- t : T

    RULE:
      context_andtyping_rules define_derivability
  }

  EQUATIONAL_DEDUCTION_MODEL {
    judgments:
      s = t

    rules:
      equality_reasoning

    RULE:
      equational_theory MUST be identified
  }

  MODAL_DEDUCTIVE_MODEL {
    formulas:
      modal_operators

    RULE:
      modal_axioms_orrules determine_logic
  }

  TEMPORAL_DEDUCTIVE_MODEL {
    formulas:
      temporal_operators

    RULE:
      temporal_calculus MUST be explicit
  }

  INTUITIONISTIC_DEDUCTIVE_MODEL {
    constraints:
      constructive_rules

    RULE:
      classical_rules_such_asdouble_negation_elimination_maynotbeavailable
  }

  CLASSICAL_DEDUCTIVE_MODEL {
    may_support:
      excluded_middle
      classical_reductio
      double_negation_elimination

    RULE:
      classical_extensions MUST be explicit
  }

  PARACONSISTENT_DEDUCTIVE_MODEL {
    property:
      contradiction_withoutunrestricted_explosion

    RULE:
      explosion_rule MUST not_be assumed
  }

  SUBSTRUCTURAL_LOGIC_MODEL {
    possible:
      linear_logic
      relevance_logic
      ordered_logic

    RULE:
      weakening_contraction_exchange MAY be restricted
  }

  LINEAR_LOGIC_MODEL {
    resources:
      assumptions_treated_asconsumable_orcontrolled

    RULE:
      ordinary_structural_rules MUST not_be imported_withoutbasis
  }

  RELEVANCE_LOGIC_MODEL {
    principle:
      premise_relevance_constraints

    RULE:
      material_implication_rules MAY differ
  }

  SOUNDNESS_MODEL {
    proof_system:
      if Gamma |- A
      then Gamma entails A

    RULE:
      semantic_framework MUST be identified
  }

  COMPLETENESS_MODEL {
    proof_system:
      if Gamma entails A
      then Gamma |- A

    RULE:
      completeness != consistency
  }

  CONSISTENCY_MODEL {
    system:
      does_notderive_designated_contradiction

    RULE:
      consistency_definition depends_onlogic
  }

  SYNTACTIC_COMPLETENESS_MODEL {
    theory:
      forrelevant_sentence_A
      either A_orNOT_A_derivable

    RULE:
      syntactic_completeness != semantic_completeness_ofcalculus
  }

  CONSERVATIVITY_MODEL {
    extension:
      adds_no_new_theorems_inbase_language_beyondbase_system

    RULE:
      language_scope MUST be explicit
  }

  EXTENSION_MODEL {
    base_system:
      S

    extended_system:
      S_plusrules_axioms_orlanguage

    RULE:
      extension_relationship MUST be recorded
  }

  RULE_EXTENSION_MODEL {
    new_rule:
      primitive_inextended_system

    RULE:
      if_rule_wasalreadyadmissible_extension_may_be conservative
  }

  AXIOM_EXTENSION_MODEL {
    new_axiom:
      expands_theory

    RULE:
      may_change_theorem_set_andconsistency_status
  }

  EQUIVALENT_CALCULUS_MODEL {
    calculi:
      derive_same_judgments_underdeclared_translation

    RULE:
      proof_objects MAY differ
  }

  TRANSLATION_MODEL {
    source_calculus:
      C1

    target_calculus:
      C2

    mapping:
      judgments_andderivations

    RULE:
      preservation_ofderivability MUST be stated
  }

  PROOF_SEARCH_MODEL {
    input:
      context
      goal

    process:
      choose_rules
      generate_subgoals
      backtrack_orforward_chain

    RULE:
      proof_search_strategy != deductive_validity
  }

  BACKWARD_CHAINING_MODEL {
    goal:
      match_rule_conclusion
      generate_premise_subgoals

    RULE:
      candidate_rule_application MUST later_bevalidated
  }

  FORWARD_CHAINING_MODEL {
    facts:
      apply_rules_to derive_newjudgments

    RULE:
      termination_depends_onlanguage_andrules
  }

  BIDIRECTIONAL_SEARCH_MODEL {
    process:
      combine_forward_andbackward
reasoning

    RULE:
      search_completeness_depends_onstrategy_andspace
  }

  TACTIC_MODEL {
    tactic:
      automates_rule_selection_andproof_construction

    RULE:
      tactic_output MUST be verified_asderivation
  }

  AUTOMATED_DEDUCTION_MODEL {
    engine:
      proof_search_overdeductive_system

    outputs:
      derivation
      refutation
      unknown
      timeout

    RULE:
      automated_engine != deductive_system
  }

  THEOREM_PROVER_MODEL {
    input:
      system
      premises
      goal

    output:
      proof_orstatus

    RULE:
      proof_artifact SHOULD be independently_checkable
  }

  PROOF_CHECKER_MODEL {
    input:
      derivation

    process:
      validate_each_rule_instance

    RULE:
      checker_version_andrule_set MUST be preserved
  }

  PROOF_CERTIFICATE_MODEL {
    artifact:
      compact_orcomplete_evidence_ofderivability

    RULE:
      certificate_requires_checker_semantics
  }

  UNKNOWN_STATUS_MODEL {
    possible:
      unknown
      timeout
      resource_limit
      unsupported_rule

    RULE:
      unknown != nonderivable
  }

  FAILED_SEARCH_MODEL {
    result:
      no_proof_found_undersearch

    RULE:
      failed_search != formal_nonderivability
  }

  COUNTERMODEL_MODEL {
    semantic:
      refutes_entailment_orvalidity

    RULE:
      countermodel != failed_deductive_search
  }

  DEDUCTION_VS_ENTAILMENT_MODEL {
    syntactic:
      Gamma |- A

    semantic:
      Gamma entails A

    RULE:
      equality_betweenrelations_requires_soundness_andcompleteness_theorems
  }

  DEDUCTION_VS_INDUCTION_MODEL {
    deduction:
      rule_governed_necessity

    induction:
      ampliative_support

    RULE:
      inductive_strength != derivability
  }

  DEDUCTION_VS_ABDUCTION_MODEL {
    deduction:
      derive_fromrules

    abduction:
      infer_explanatory_hypothesis

    RULE:
      abductive_candidate != theorem
  }

  DEDUCTION_VS_HEURISTIC_MODEL {
    deduction:
      formally_valid_rule_application

    heuristic:
      search_guidance

    RULE:
      heuristic_choice MUST not_be encoded_asinference_rule
  }

  META_RULE_MODEL {
    rule:
      operates_onderivations_orrules

    RULE:
      meta_rule_level MUST be distinguished_fromobject_deduction
  }

  DERIVED_META_THEOREM_MODEL {
    possible:
      deduction_theorem
      cut_elimination
      admissibility
      normalisation

    RULE:
      theorem_conditions MUST be preserved
  }

  DEDUCTION_THEOREM_MODEL {
    generic_relation:
      Gamma,A |- B
      related_to
      Gamma |- A -> B

    RULE:
      exact_form_andvalidity depend_onsystem
  }

  PROOF_IRRELEVANCE_MODEL {
    possible:
      theorem_status_depends_onlyonexistence_ofderivation

    RULE:
      proof_identity MAY stillmatter_forprovenance_computation_orconstructive_content
  }

  CONSTRUCTIVE_CONTENT_MODEL {
    derivation:
      may_encode_witness_orprogram

    RULE:
      computational_content depends_onlogic_andproof_correspondence
  }

  CURRY_HOWARD_MODEL {
    correspondence:
      propositions_as_types
      proofs_asterms

    RULE:
      deductive_system_andtype_theory MUST be specified
  }

  RECURSIVE_DERIVATION_MODEL {
    derivability:
      least_relation_closed_underaxioms_andrules

    RULE:
      inductive_definition SHOULD be explicit
  }

  FIXED_POINT_MODEL {
    derivability_operator:
      F

    theorem_set:
      least_fixed_point_understandard_inductive_semantics

    RULE:
      alternative_coinductive_semantics MUST be declared
  }

  COINDUCTIVE_DEDUCTION_MODEL {
    derivations:
      potentially_infinite_orcyclic_underformal_rules

    RULE:
      productivity_guardedness_oracceptance_condition MUST be specified
  }

  CIRCULAR_DERIVATION_MODEL {
    cycle:
      conclusion_depends_onitself

    RULE:
      invalid_unlesssystem_explicitlypermits_andvalidates_cyclic_proofs
  }

  DEPENDENCY_GRAPH_MODEL {
    nodes:
      axioms
      assumptions
      judgments
      rule_instances
      lemmas
      theorems

    edges:
      USES
      DERIVES
      DEPENDS_ON
      DISCHARGES

    RULE:
      graph MUST support_recursive_validation
  }

  RULE_DEPENDENCY_MODEL {
    derived_rule:
      depends_onprimitive_rules

    RULE:
      rule_revision MAY invalidate_derived_rules
  }

  VERSION_MODEL {
    versioned:
      deductive_system
      language
      axiom_set
      rule_set
      proof_calculus
      checker

    RULE:
      derivability_isversion_specific
  }

  REVISION_MODEL {
    change:
      axiom
      rule
      side_condition
      language
      proof_definition

    RULE:
      previous_derivations MUST remainhistorically_linked_tooldversion
  }

  PROVENANCE_MODEL {
    fields:
      deductive_system
      version
      proof_calculus
      rule_instances
      source
      checker
      agent
      timestamp

    RULE:
      derivation MUST remain_provenance_linked
  }

  EXPLAINABILITY_MODEL {
    output:
      context
      goal
      selected_rules
      generated_subgoals
      discharged_assumptions
      final_derivation
      verification_status

    RULE:
      explanation MUST distinguish_search_process_fromverified_derivation
  }

  AMBIGUITY_MODEL {
    possible:
      rule_name_collision
      unspecified_calculus
      context_structure_unknown
      side_condition_missing
      logic_unspecified

    RULE:
      ambiguity MUST be resolved_orpreserved_beforederivability_claim
  }

  SEMANTIC_CONFIDENCE_MODEL {
    confidence:
      support_forresolved_system_rule_orcontext_interpretation

    RULE:
      semantic_confidence != derivability_status
  }

  VALIDATION_MODEL {
    checks:
      system_identity
      language
      judgment_well_formedness
      context
      axioms
      rule_schemata
      rule_instances
      side_conditions
      substitutions
      assumptions
      discharge
      dependencies
      conclusion
      versions

    RULE:
      validation MUST useexact_deductive_system
  }

  INTEROPERABILITY_MODEL {
    exchange:
      system_identifier
      judgments
      contexts
      rule_schemata
      derivations
      proof_certificates
      versions

    RULE:
      formula_sequence_withoutrule_andcontext_metadata_isnotlossless_derivation
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      deductive_system
      judgment
      context
      axiom
      rule
      rule_instance
      derivation
      theorem

    edges:
      HAS_RULE
      HAS_AXIOM
      USES
      DERIVES
      DISCHARGES
      DEPENDS_ON
      EXTENDS
      TRANSLATES_TO

    RULE:
      primitive_derived_admissible_andsemantic_relations MUST be typed
  }

  RELATIONSHIPS {
    DeductiveSystem -> HAS -> FormalLanguage
    DeductiveSystem -> HAS_AXIOM -> Axiom
    DeductiveSystem -> HAS_RULE -> DeductiveRule
    DeductiveDerivation -> STARTS_WITH -> ProofContext
    RuleInstance -> INSTANCE_OF -> DeductiveRule
    RuleInstance -> DERIVES -> DeductiveJudgment
    DeductiveDerivation -> CONTAINS -> RuleInstance
    AssumptionDischarge -> DISCHARGES -> Assumption
    DeductiveDerivation -> ESTABLISHES -> Conclusion
    ProofChecker -> VERIFIES -> DeductiveDerivation
  }

  SEMANTIC_EQUIVALENCE {
    "deductive system" ~= formal_framework_ofaxioms_judgments_andinference_rules_generatingderivations
    "derivability" ~= existence_ofvalid_derivation_fromcontext_underidentified_deductive_system
    "admissible rule" ~= rule_whosepremise_derivability_guaranteesconclusion_derivability_withoutnecessarilybeingprimitive

    deduction != semantic_entailment
    premise != axiom
    assumption != theorem
    primitive_rule != admissible_rule
    admissible_rule != derived_rule_necessarily
    proof_search != proof_verification
    failed_search != nonderivability
    countermodel != failed_search
    soundness != completeness
    syntactic_completeness != semantic_completeness
    heuristic_choice != inference_rule
    semantic_confidence != derivability
  }

  CONSTRAINTS {
    deductive_system_identifier_andversion_must_be preserved = true
    language_andjudgment_types_must_be identified = true
    proof_context_structure_must_be preserved = true
    premise_axiom_assumption_andtheorem_roles_must_be distinguished = true
    rule_schemata_instances_andmetavariables_must_be distinguished = true
    inference_rule_side_conditions_must_be checked = true
    substitutions_must_preserve_binding_andtypes = true
    assumption_scope_anddischarge_must_be tracked = true
    structural_rules_must_not_be assumed_whenlogic_restricts_them = true
    primitive_derived_andadmissible_rules_must_be distinguished = true
    derivability_andsemantic_entailment_must_be distinguished = true
    proof_search_failure_must_not_be interpreted_asnonderivability = true
    AI_heuristic_search_steps_must_not_be encoded_asformal_inference_withoutvalidation = true
    versions_andprovenance_must_be preserved = true
  }

  DEDUCTIVE_SYSTEM_RECORD_MODEL {
    RECORD:
      deductive_system_identifier
      system_version
      logic_family
      proof_calculus
      language_identifier
      judgment_type
      context_structure
      initial_context
      goal
      axiom_identifiers
      rule_schema_identifiers
      primitive_rule_identifiers
      derived_rule_identifiers
      admissible_rule_identifiers
      rule_instances
      metavariable_substitutions
      side_conditions
      active_assumptions
      discharged_assumptions
      derivation_identifier
      derivation_steps
      dependency_graph
      conclusion
      theorem_status
      derivability_status
      semantic_entailment_context
      soundness_status
      completeness_status
      consistency_status
      proof_search_strategy
      search_status
      checker_identifier
      checker_version
      verification_status
      ambiguity_status
      semantic_confidence
      provenance

    RULE:
      deductive_system_record MUST support_reconstruction_andindependent_verification_ofderivation
  }

  REASONING_RULES {
    IF derivation_requested
      THEN identify_deductive_system_version
      resolve_context_goal_axioms_rules_andcalculus

    IF candidate_rule_selected
      THEN match_conclusion_to current_goal_orpremises
      instantiate_metavariables
      check_side_conditions
      preserve_substitution

    IF assumption_introduced
      THEN add_toactive_context
      record_scope

    IF assumption_discharged
      THEN validate_discharge_rule
      update_context

    IF structural_rule_requested
      THEN verify_rule_isavailable_inselected_logic

    IF candidate_derivation_complete
      THEN validate_every_rule_instance_anddependency
      verify_final_conclusion_matchesgoal

    IF rule_notprimitive_butclaimed_admissible
      THEN require_admissibility_result_oruniform_derivation

    IF proof_search_fails_or timesout
      THEN preserve_search_status
      anddo_notinfer_nonderivability

    IF semantic_countermodel_found
      THEN record_entailment_refutation
      separately_fromdeductive_search_status

    IF axiom_rule_side_condition_orcalculus_changes
      THEN recursively_revalidate_affected_derivations_andderived_rules
  }

  VALIDATION {
    CHECK deductive_system_identifier
    CHECK system_version
    CHECK logic_family
    CHECK proof_calculus
    CHECK language
    CHECK judgment_well_formedness
    CHECK context_structure
    CHECK premises_andaxioms
    CHECK rule_schemata
    CHECK primitive_derived_admissible_rule_status
    CHECK metavariable_instantiation
    CHECK substitutions
    CHECK variable_capture
    CHECK side_conditions
    CHECK structural_rule_availability
    CHECK assumption_scope
    CHECK assumption_discharge
    CHECK derivation_steps
    CHECK dependency_graph
    CHECK unsupported_cycles
    CHECK conclusion_goal_match
    CHECK theorem_status
    CHECK derivability
    CHECK semantic_entailment_distinction
    CHECK soundness
    CHECK completeness
    CHECK consistency
    CHECK search_status
    CHECK checker_status
    CHECK ambiguity
    CHECK semantic_confidence
    CHECK provenance
  }

  CONFIDENCE {
    system_resolution_confidence: 1.00
    rule_schema_confidence: 1.00
    rule_instantiation_confidence: 1.00
    context_assumption_confidence: 1.00
    derivation_validation_confidence: 1.00
    structural_rule_confidence: 0.99
    automated_deduction_confidence: 0.99
    metatheoretic_mapping_confidence: 0.99

    RULE:
      confidence decreases when system version, calculus, context,
      rule identity, side condition, substitution, assumption scope,
      checker status orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_deductive_system:
      assign_system_identifier
      register_language_judgments_axioms_rules_andcalculus
      validate_rule_definitions
      preserve_provenance
      compute_FLOW_HASH

    ON new_derivation:
      assign_derivation_identifier
      resolve_exact_system_version
      validate_steps_context_anddependencies
      attach_verification_status
      preserve_provenance

    ON rule_oraxiom_revision:
      preserve_previous_system
      create_new_version
      update_dependency_graph
      recursively_revalidate_affected_derivations

    ON checker_revision:
      preserve_previous_check
      register_checker_version
      optionally_reverify_current_derivations

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: DeductiveSystem
    canonical_role: RuleGovernedDerivationFramework

    interpretation_order:
      identify_deductive_system_andversion
      identify_logic_family_andproof_calculus
      resolve_formal_language_andjudgment_type
      resolve_initial_context_andgoal
      identify_axioms_rule_schemata_andprimitive_rules
      identify_metavariables_side_conditions_andstructural_rules
      reconstruct_rule_instances_andsubstitutions
      track_assumptions_scope_anddischarge
      reconstruct_derivation_dependency_graph
      distinguish_primitive_derived_andadmissible_rules
      validate_every_rule_application
      determine_derivability_andtheorem_status
      distinguish_derivability_fromsemantic_entailment
      identify_soundness_completeness_andconsistency_context
      identify_search_strategy_checker_andstatus
      preserve_unknown_timeout_orfailed_search
      detect_ambiguity_orunsupported_cycles
      assign_semantic_confidence
      preserve_versions_andprovenance
      emit_machine_resolvable_deductive_system_structure

    ambiguity_controls:
      distinguish_deduction_fromsemantic_entailment
      distinguish_premise_fromaxiom
      distinguish_assumption_fromtheorem
      distinguish_primitive_rule_fromadmissible_rule
      distinguish_admissible_rule_fromderived_rule_necessarily
      distinguish_proof_search_fromproof_verification
      distinguish_failed_search_fromnonderivability
      distinguish_countermodel_fromfailed_search
      distinguish_soundness_fromcompleteness
      distinguish_syntactic_completeness_fromsemantic_completeness
      distinguish_heuristic_choice_frominference_rule
      distinguish_semantic_confidence_fromderivability
      preserve_system_calculus_context_rules_assumptions_derivation_checker_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      deductive_systems_judgments_rules_derivations_proof_calculi_andautomated_deduction

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

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      system_identity_model
      language_model
      judgment_model
      formula_judgment_model
      sequent_model
      single_conclusion_sequent_model
      multiple_conclusion_sequent_model
      context_model
      empty_context_model
      premise_model
      axiom_model
      axiom_schema_model
      inference_rule_model
      zero_premise_rule_model
      unary_rule_model
      binary_rule_model
      nary_rule_model
      rule_schema_model
      rule_instance_model
      side_condition_model
      metavariable_model
      substitution_model
      variable_capture_model
      structural_rule_model
      weakening_model
      contraction_model
      exchange_model
      cut_model
      cut_elimination_model
      identity_rule_model
      connective_rule_model
      conjunction_introduction_model
      conjunction_elimination_model
      disjunction_introduction_model
      disjunction_elimination_model
      implication_introduction_model
      implication_elimination_model
      negation_rule_model
      falsity_model
      explosion_model
      universal_introduction_model
      universal_elimination_model
      existential_introduction_model
      existential_elimination_model
      equality_rule_model
      reflexivity_model
      symmetry_model
      transitivity_model
      congruence_model
      assumption_model
      assumption_scope_model
      assumption_discharge_model
      derivation_model
      derivation_height_model
      derivation_length_model
      proof_model
      theorem_model
      derivability_model
      nonderivability_model
      admissible_rule_model
      derived_rule_model
      primitive_rule_model
      rule_admissibility_proof_model
      invertible_rule_model
      derivation_transformation_model
      normalisation_model
      detour_reduction_model
      subformula_property_model
      natural_deduction_model
      sequent_calculus_model
      Hilbert_calculus_model
      tableau_calculus_model
      resolution_calculus_model
      type_theoretic_deduction_model
      equational_deduction_model
      modal_deductive_model
      temporal_deductive_model
      intuitionistic_deductive_model
      classical_deductive_model
      paraconsistent_deductive_model
      substructural_logic_model
      linear_logic_model
      relevance_logic_model
      soundness_model
      completeness_model
      consistency_model
      syntactic_completeness_model
      conservativity_model
      extension_model
      rule_extension_model
      axiom_extension_model
      equivalent_calculus_model
      translation_model
      proof_search_model
      backward_chaining_model
      forward_chaining_model
      bidirectional_search_model
      tactic_model
      automated_deduction_model
      theorem_prover_model
      proof_checker_model
      proof_certificate_model
      unknown_status_model
      failed_search_model
      countermodel_model
      deduction_vs_entailment_model
      deduction_vs_induction_model
      deduction_vs_abduction_model
      deduction_vs_heuristic_model
      meta_rule_model
      derived_meta_theorem_model
      deduction_theorem_model
      proof_irrelevance_model
      constructive_content_model
      Curry_Howard_model
      recursive_derivation_model
      fixed_point_model
      coinductive_deduction_model
      circular_derivation_model
      dependency_graph_model
      rule_dependency_model
      version_model
      revision_model
      provenance_model
      explainability_model
      ambiguity_model
      semantic_confidence_model
      validation_model
      interoperability_model
      knowledge_graph_model
      relationships
      semantic_equivalence
      constraints
      deductive_system_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      deductive_system_identity_orversion_changes
      language_judgment_orcontext_semantics_change
      axiom_rule_schema_side_condition_orstructural_rule_changes
      substitution_binding_orassumption_discharge_changes
      derivation_proof_theorem_oradmissibility_semantics_change
      proof_calculus_normalisation_orcut_elimination_changes
      classical_intuitionistic_paraconsistent_orsubstructural_changes
      soundness_completeness_consistency_orconservativity_changes
      automated_deduction_search_checker_orcertificate_changes
      dependency_graph_revision_orprovenance_changes
      deductive_system_record_changes
      constraint_model_changes
      reasoning_rule_changes
  }

}

END FLOW