Formal Proof Ontology

# Formal Proof Ontology — Flow Algebra

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

FLOW FormalProofOntology {

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

  PURPOSE:
    Represent formal proof as a machine-verifiable derivation in an explicitly identified formal system. The ontology models proof goals, premises, axioms, assumptions, definitions, lemmas, theorems, inference rules, substitutions, side conditions, proof steps, proof trees, dependency graphs, assumption discharge, proof strategies, certificates, proof checking, automated theorem proving, countermodels, soundness context, versioning and provenance. It enables AI systems to distinguish a valid formal proof from an informal argument, heuristic search, empirical evidence, semantic model or unverified generated derivation, while preserving every dependency required to reconstruct and independently check the result.

  ENTITY FormalProof {
    TYPE: MachineVerifiableDerivation

    PROPERTIES:
      has_formal_system
      has_goal
      has_premises
      has_axioms
      has_assumptions
      has_definitions
      has_inference_rules
      has_steps
      has_dependencies
      has_conclusion
      has_verification_status
      has_version
      has_provenance
  }

  ENTITY ProofStep {
    TYPE: JustifiedDerivationStep

    COMPONENTS:
      step_identifier
      statement
      rule
      premises_or_dependencies
      substitution
      side_conditions
      active_assumptions
  }

  ENTITY ProofGoal {
    TYPE: TargetFormulaOrJudgment

    COMPONENTS:
      target_expression
      formal_system
      context
  }

  ENTITY ProofCertificate {
    TYPE: MachineCheckableProofEvidence

    COMPONENTS:
      certificate_format
      proof_content
      checker_requirements
      system_version
  }

  PROOF_IDENTITY_MODEL {
    fields:
      proof_identifier
      formal_system_identifier
      proof_system_identifier
      version
      conclusion_identifier

    RULE:
      proof_identity MUST remain_stable_across_representations
  }

  FORMAL_SYSTEM_CONTEXT_MODEL {
    requires:
      language
      signature
      axioms
      inference_rules
      proof_definition

    RULE:
      formal_proof_validity_isrelative_toformal_system
  }

  GOAL_MODEL {
    target:
      formula_judgment_orsequent

    RULE:
      goal MUST be well_formed_underdeclared_language
  }

  PREMISE_MODEL {
    statement:
      externally_supplied_starting_point

    RULE:
      premise != axiom
  }

  AXIOM_MODEL {
    statement:
      designated_starting_formula_ofsystem

    RULE:
      axiom_status_isrelative_tosystem_version
  }

  DEFINITION_MODEL {
    role:
      introduces_orfixes_semantics_ofsymbol_orconstruction

    RULE:
      definitional_rewrite MUST preserve_declared_definition_scope
  }

  ASSUMPTION_MODEL {
    statement:
      locally_adopted_forproof_substructure

    RULE:
      active_assumption_scope MUST be tracked
  }

  ASSUMPTION_DISCHARGE_MODEL {
    operation:
      closes_local_assumption_underdeclared_rule

    RULE:
      discharged_assumption MUST not_remain_active_outside_scope
  }

  CONTEXT_MODEL {
    contains:
      premises
      assumptions
      variable_declarations
      local_definitions

    RULE:
      proof_step_validity MAY depend_oncontext
  }

  PROOF_STEP_MODEL {
    each_step:
      statement
      justification
      dependencies

    RULE:
      every_nonprimitive_step MUST havevalid_justification
  }

  STEP_ORDER_MODEL {
    proof:
      ordered_orpartially_ordered_dependencies

    RULE:
      dependency_order MUST prevent_use_beforeavailability_unlessproof_system_supports_otherstructure
  }

  DEPENDENCY_MODEL {
    step:
      depends_on_prior_steps_axioms_definitions_orassumptions

    RULE:
      dependencies MUST be explicit_andtraversable
  }

  DEPENDENCY_GRAPH_MODEL {
    nodes:
      proof_steps
      axioms
      definitions
      lemmas
      assumptions

    edges:
      DEPENDS_ON
      USES
      DERIVED_FROM

    RULE:
      unsupported_cycles MUST be detected
  }

  CIRCULARITY_MODEL {
    invalid_cycle:
      conclusion_used_tojustify_itself_withoutaccepted_recursive_orcoinductive_rule

    RULE:
      circular_dependency MUST be flagged
  }

  INFERENCE_RULE_MODEL {
    schema:
      premises
      conclusion
      side_conditions

    RULE:
      proof_step MUST instantiate_valid_rule_schema
  }

  RULE_INSTANCE_MODEL {
    inference_rule:
      instantiated_withspecific_formulas_or terms

    RULE:
      metavariable_mapping MUST be preserved
  }

  SIDE_CONDITION_MODEL {
    possible:
      freshness
      variable_not_free
      type_constraint
      admissible_term
      scope_condition

    RULE:
      side_conditions_arepart_ofproof_validity
  }

  SUBSTITUTION_MODEL {
    mapping:
      variables_or metavariables -> terms_or formulas

    RULE:
      substitution MUST be capture_avoiding
  }

  VARIABLE_CAPTURE_MODEL {
    risk:
      substitution_changes_binding

    RULE:
      captured_substitution_invalid_unlessformallyintended
  }

  ALPHA_RENAMING_MODEL {
    bound_variables:
      may_be renamed

    RULE:
      renaming MUST preserve_binding_structure
  }

  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)
  }

  EQUALITY_SUBSTITUTION_MODEL {
    premises:
      a = b
      phi(a)

    conclusion:
      phi(b)

    RULE:
      substitutivity_conditions depend_onlogic_andtypes
  }

  DIRECT_PROOF_MODEL {
    process:
      derive_goal_frompremises_axioms_andrules

    RULE:
      final_step MUST matchgoal_oraccepted_equivalent
  }

  CONDITIONAL_PROOF_MODEL {
    goal:
      A -> B

    process:
      assume_A
      derive_B
      discharge_A

    RULE:
      discharge_rule MUST be supported_byproof_system
  }

  PROOF_BY_CONTRADICTION_MODEL {
    goal:
      phi

    process:
      assume_NOT_phi
      derive_contradiction
      discharge_assumption

    RULE:
      classical_orappropriate_logic_required
  }

  PROOF_BY_CONTRAPOSITION_MODEL {
    goal:
      A -> B

    process:
      prove_NOT_B -> NOT_A

    RULE:
      equivalence_islogic_specific
  }

  PROOF_BY_CASES_MODEL {
    cases:
      C_1...C_n

    REQUIRE:
      cases_exhaustive_undercontext

    RULE:
      goal MUST be derived_ineach_case
  }

  MATHEMATICAL_INDUCTION_MODEL {
    base_case:
      P(n_0)

    inductive_hypothesis:
      P(k)

    inductive_step:
      P(k) -> P(k+1)

    RULE:
      induction_principle_anddomain MUST be identified
  }

  STRONG_INDUCTION_MODEL {
    hypothesis:
      all_values_beforek_satisfyP

    step:
      derive_P(k)

    RULE:
      well_ordering_context MUST be appropriate
  }

  STRUCTURAL_INDUCTION_MODEL {
    objects:
      recursively_generated

    proof:
      base_constructors
      inductive_constructors

    RULE:
      proof_structure MUST followgeneration_rules
  }

  EXISTENCE_PROOF_MODEL {
    goal:
      exists x P(x)

    possible:
      construct_witness
      derive_nonconstructively

    RULE:
      constructive_status MUST be preserved
  }

  UNIQUENESS_PROOF_MODEL {
    goal:
      exists_unique x P(x)

    components:
      existence
      uniqueness

    RULE:
      both_components_required
  }

  COUNTEREXAMPLE_MODEL {
    purpose:
      refute_universal_claim

    witness:
      satisfies_domain
      violates_claim

    RULE:
      counterexample_isnotproof_ofalternative_general_claim
  }

  PROOF_TREE_MODEL {
    root:
      conclusion

    children:
      premises_forrule_application

    RULE:
      tree_nodes MUST identify_rule_instances
  }

  PROOF_DAG_MODEL {
    structure:
      shared_subproof_dependencies

    RULE:
      DAG_representation MAY reduce_duplicate_steps_withoutchangingproof_semantics
  }

  LINEAR_PROOF_MODEL {
    structure:
      sequence_ofsteps

    RULE:
      references MUST resolve_toavailable_dependencies
  }

  NATURAL_DEDUCTION_MODEL {
    rules:
      introduction
      elimination

    features:
      scoped_assumptions
      discharge

    RULE:
      proof_layout_andcontext MUST preserve_scope
  }

  SEQUENT_CALCULUS_MODEL {
    judgment:
      Gamma |- Delta

    rules:
      structural
      logical

    RULE:
      exact_calculus_variant MUST be identified
  }

  HILBERT_PROOF_MODEL {
    basis:
      axiom_schemata
      limited_inference_rules

    RULE:
      proof_steps MUST instantiate_axioms_orfollowrules
  }

  TABLEAU_PROOF_MODEL {
    process:
      decompose_formulas_into branches

    success:
      closure_forrefutation_orotherdeclaredcriterion

    RULE:
      tableau_variant_andclosure_conditions MUST be explicit
  }

  RESOLUTION_PROOF_MODEL {
    representation:
      clauses

    process:
      resolution_steps

    terminal_forrefutation:
      empty_clause

    RULE:
      clause_conversion_andunification_lineage MUST be preserved
  }

  EQUATIONAL_PROOF_MODEL {
    steps:
      reflexivity
      symmetry
      transitivity
      congruence
      substitution
      rewrite

    RULE:
      equality_theory MUST be identified
  }

  REWRITE_PROOF_MODEL {
    source:
-
      expression

    target:
-
      expression

    RULE:
      rewrite_rule_orientation_andsemantic_status MUST be explicit
  }

  NORMALISATION_PROOF_MODEL {
    process:
      reduce_expression_toprescribed_normal_form

    RULE:
      termination_andconfluence MAY be required_foruniqueness_claim
  }

  LEMMA_MODEL {
    theorem:
      established_forreuse

    RULE:
      lemma_dependencies MUST be included_transitively
  }

  THEOREM_MODEL {
    conclusion:
      derivable_underformal system

    RULE:
      theorem_status MUST identify_system_andassumptions
  }

  COROLLARY_MODEL {
    theorem:
      follows_fromprior_theorem

    RULE:
      formal_dependency MUST be recorded
  }

  PROOF_REUSE_MODEL {
    prior_theorem:
      used_asproof_step

    RULE:
      theorem_version_andformal_system_compatibility MUST be checked
  }

  IMPORTED_PROOF_MODEL {
    proof:
      sourced_fromexternal_library

    RULE:
      imported_artifact MUST be verified_ortrusted_underexplicit_policy
  }

  TRUSTED_AXIOM_MODEL {
    statement:
      accepted_withoutproof_withinsystem

    RULE:
      trust_boundary MUST be explicit
  }

  TRUSTED_KERNEL_MODEL {
    checker:
      small_core_validatingproof_objects

    RULE:
      verified_status_depends_onkernel_andformalisation
  }

  PROOF_CHECKING_MODEL {
    input:
      proof_artifact
      formal_system

    output:
      verified
      rejected
      incomplete

    RULE:
      checker_version_andresult MUST be preserved
  }

  LOCAL_CHECKABILITY_MODEL {
    property:
      each_step_checkable_fromdeclared_dependencies

    RULE:
      local_validity_plusvalid_dependency_graph_supportswholeproof_validation
  }

  PROOF_CERTIFICATE_MODEL {
    artifact:
      machine_checkable_evidence

    possible:
      derivation_trace
      resolution_certificate
      SAT_unsat_certificate
      proof_term

    RULE:
      certificate_format MUST be identified
  }

  PROOF_TERM_MODEL {
    term:
      encodes_proof_underCurry_Howard_orotherformal correspondence

    RULE:
      type_system_andcorrespondence MUST be declared
  }

  CURRY_HOWARD_MODEL {
    relation:
      propositions_as_types
      proofs_asterms

    RULE:
      correspondence_isformal_system_specific
  }

  TYPING_DERIVATION_MODEL {
    judgment:
      Gamma |- t : T

    RULE:
      context_andtyping_rules MUST be preserved
  }

  SOUNDNESS_CONTEXT_MODEL {
    claim:
      verified_proof_implies_semantic_consequence

    RULE:
      requires_sound_proof_system_relative_tosemantics
  }

  SEMANTIC_CONSEQUENCE_MODEL {
    Gamma entails phi:
      every_model_ofGamma_satisfies_phi

    RULE:
      semantic_consequence != proof_bydefinition
  }

  SYNTACTIC_DERIVABILITY_MODEL {
    Gamma proves phi:
      formal_derivation_exists

    RULE:
      derivability != semantic_consequence_bydefinition
  }

  PROOF_VALIDITY_MODEL {
    valid_if:
      well_formed
      all_steps_justified
      side_conditions_satisfied
      dependencies_valid
      conclusion_matchesgoal

    RULE:
      proof_validity != truth_ofpremises
  }

  ARGUMENT_SOUNDNESS_DISTINCTION_MODEL {
    formal_proof:
      conditional_onaxioms_andpremises

    sound_argument:
      valid_plustruepremises

    RULE:
      proof_checker_does_notgenerally_establish_empirical_truth_ofpremises
  }

  PROOF_COMPLETENESS_MODEL {
    proof_artifact:
      contains_allrequired_steps_orreferences

    RULE:
      artifact_completeness != logical_completeness_ofproof_system
  }

  PROOF_SYSTEM_COMPLETENESS_MODEL {
    metatheoretic:
      semantic_consequence_implies_derivability

    RULE:
      distinct_fromproof_artifact_completeness
  }

  CONSISTENCY_CONTEXT_MODEL {
    formal_system:
      consistency_status

    RULE:
      a_valid_derivation_inaninconsistent_classical_system_maynotprovideuseful_discrimination
  }

  PROOF_MINIMALITY_MODEL {
    possible:
      no_redundant_steps
      minimal_axiom_dependencies
      shortest_known_proof

    RULE:
      minimality_criterion MUST be explicit
  }

  REDUNDANT_STEP_MODEL {
    step:
      notrequired_forconclusion_dependency

    RULE:
      redundancy_does_notinvalidateproof
  }

  PROOF_COMPRESSION_MODEL {
    process:
      replace_subderivations_withlemmas_orcertificates

    RULE:
      compressed_proof MUST remain_checkable
  }

  PROOF_EXPANSION_MODEL {
    process:
      inline_lemmas_definitions_orabbreviations

    RULE:
      expansion MUST preserveproof_semantics
  }

  PROOF_NORMALISATION_MODEL {
    transformation:
      proof_to canonical_orreduced_form

    RULE:
      normalisation_theorem_andproof_system MUST be identified
  }

  CUT_MODEL {
    sequent_rule:
      introduces_intermediate_formula

    RULE:
      exact_rule_variant MUST be preserved
  }

  CUT_ELIMINATION_MODEL {
    property:
      transform_proof_to cut_free_form_when theorem_applies

    RULE:
      cut_elimination_isproof_system_specific
  }

  DETOUR_REDUCTION_MODEL {
    natural_deduction:
      eliminate_introduction_followed_byelimination_patterns

    RULE:
      reduction_preserves_conclusion_underdeclared_system
  }

  PROOF_EQUIVALENCE_MODEL {
    proofs:
      may_be equivalent_underdeclared_proof_identity_ornormalisation_relation

    RULE:
      same_conclusion != same_proof
  }

  PROOF_IRRELEVANCE_MODEL {
    principle:
      proof_identity_may_be ignored_forcertain propositions_or type_theories

    RULE:
      proof_irrelevance_isnotuniversal
  }

  CONSTRUCTIVE_PROOF_MODEL {
    proof:
      supplies_computational_orwitness_content_underconstructive_framework

    RULE:
      constructive_status MUST be logic_specific
  }

  NONCONSTRUCTIVE_PROOF_MODEL {
    proof:
      establishes_result_withoutconstructive_witness_asrequired_byconstructive_standard

    RULE:
      nonconstructive != invalid_inclassical_logic
  }

  CLASSICAL_PROOF_MODEL {
    may_use:
      excluded_middle
      double_negation_elimination
      contradiction_methods

    RULE:
      classical_rules MUST not_be imported_intuitionistically_withoutbasis
  }

  INTUITIONISTIC_PROOF_MODEL {
    constraints:
      constructive_inference_rules

    RULE:
      classical_proof MAY fail_intuitionistic_verification
  }

  MODAL_PROOF_MODEL {
    formulas:
      modal_operators

    RULE:
      modal_proof_system_andframe_conditions MUST be identified
  }

  TEMPORAL_PROOF_MODEL {
    formulas:
      temporal_operators

    RULE:
      temporal_logic_andproof_system MUST be explicit
  }

  INDUCTIVE_PROOF_OBJECT_MODEL {
    proof:
      finite_structure_generated_byinference_rules

    RULE:
      least_closed_set_semantics MAY apply
  }

  COINDUCTIVE_PROOF_MODEL {
    proof:
      potentially_cyclic_orinfinite_evidence_undercoinductive_rules

    RULE:
      guardedness_orproductivity_conditions MUST be checked
  }

  CIRCULAR_PROOF_MODEL {
    cycle:
      proof_dependency_returns_toancestor

    RULE:
      invalid_unlessformal_cyclic_orcoinductive_system_justifies_cycle
  }

  PROOF_SEARCH_MODEL {
    process:
      generate_candidate_derivations

    statuses:
      found
      not_found
      timeout
      resource_limit

    RULE:
      not_found != unprovable_withoutcomplete_search
  }

  FORWARD_REASONING_MODEL {
    process:
      apply_rules_fromknown_statements

    RULE:
      search_strategy != proof_validity
  }

  BACKWARD_REASONING_MODEL {
    process:
      reduce_goal_tosubgoals

    RULE:
      generated_subgoals MUST correspond_toinvertible_orotherwisejustified_rule_application
  }

  TACTIC_MODEL {
    tactic:
      proof_search_program_orstrategy

    RULE:
      tactic_execution_result MUST be checked_bykernel_whenpossible
  }

  TACTICAL_MODEL {
    combinator:
      composes_tactics

    RULE:
      tactic_language != object_logic
  }

  AUTOMATED_THEOREM_PROVER_MODEL {
    input:
      formal_system
      premises
      conjecture

    output:
      proof
      refutation
      unknown

    RULE:
      proof_output_requires_verification_orcertificate_forformal_status
  }

  INTERACTIVE_THEOREM_PROVER_MODEL {
    process:
      human_orAI_guided_proof_construction_withkernel_checking

    RULE:
      interaction_history MAY be preserved_butverified_proof_isprimary_artifact
  }

  SAT_CERTIFICATE_MODEL {
    possible:
      satisfying_assignment
      unsatisfiability_certificate

    RULE:
      certificate_semantics depend_onsolver_andchecker_format
  }

  SMT_PROOF_MODEL {
    proof:
      combines_logical_andbackground_theory_reasoning

    RULE:
      theory_lemmas_andsolver_version MUST be preserved
  }

  MODEL_CHECKING_PROOF_MODEL {
    property:
      verified_againsttransition_system

    possible_evidence:
      invariant
      certificate
      counterexample

    RULE:
      model_andabstraction_scope MUST be explicit
  }

  FORMAL_VERIFICATION_MODEL {
    proof:
      establishes_formalised_property_ofmodel_orimplementation

    RULE:
      verified_property_islimited_tospecification_andassumptions
  }

  PROOF_FAILURE_MODEL {
    possible:
      malformed_goal
      missing_axiom
      invalid_step
      unmet_side_condition
      circular_dependency
      checker_rejection
      unsupported_logic
      timeout

    RULE:
      failure_type MUST be explicit
  }

  UNKNOWN_STATUS_MODEL {
    possible:
      unverified
      incomplete
      unknown
      timeout
      resource_limit

    RULE:
      unknown != false
      unknown != unprovable
  }

  COUNTERMODEL_DISTINCTION_MODEL {
    countermodel:
      semantic_refutation_ofvalidity_orconsequence

    failed_proof:
      absence_ofverified_derivation

    RULE:
      failed_proof != countermodel
  }

  INFORMAL_PROOF_MODEL {
    artifact:
      human_explanatory_reasoning_notfullyformalised

    RULE:
      informal_proof MAY guideformalisation_butnotreceive_machine_verified_status_withouttranslation_andchecking
  }

  SKETCH_MODEL {
    proof_sketch:
      omits_someformal_steps

    RULE:
      omitted_steps MUST be reconstructed_andverified_forformal_proof_status
  }

  AI_GENERATED_PROOF_MODEL {
    source:
      AI_system

    RULE:
      authorship_or generation_method_does_notdetermine_validity
      formal_checker_status SHOULD determine_machine_verified_label
  }

  AI_HEURISTIC_MODEL {
    process:
      predicts_promising_lemmas_rules_orsteps

    RULE:
      heuristic_score != proof_validity
  }

  PROOF_EXPLANATION_MODEL {
    output:
      theorem
      assumptions
      key_lemmas
      inference_chain
      formal_system
      verification_status

    RULE:
      explanation MAY simplifypresentation_butmustnotmisstateformal_dependencies
  }

  PROOF_PROVENANCE_MODEL {
    fields:
      proof_identifier
      author_oragent
      source
      formal_system
      system_version
      checker
      checker_version
      timestamp
      imported_dependencies

    RULE:
      provenance MUST remain_attached_toverified_artifact
  }

  VERSION_MODEL {
    versioned:
      proof
      formal_system
      axioms
      rules
      definitions
      checker
      theorem_library

    RULE:
      proof_verification_status_isversion_specific
  }

  REVISION_MODEL {
    changed_dependency:
      axiom
      definition
      rule
      lemma
      checker

    RULE:
      dependent_proofs SHOULD be recursively_revalidated
  }

  DEPRECATION_MODEL {
    proof:
      superseded_bynew_proof_orinvalidated_dependency

    RULE:
      deprecated_proof MUST remain_historically_auditable
  }

  REPRODUCIBILITY_MODEL {
    requires:
      proof_artifact
      formal_system_version
      dependency_versions
      checker
      configuration

    RULE:
      independent_rechecking SHOULD reproduce_verification_status
  }

  INTEROPERABILITY_MODEL {
    exchange:
      proof_identifier
      goal
      formal_system
      proof_steps
      dependencies
      substitutions
      certificates
      versions

    RULE:
      plain_natural_language_proof_isnotlossless_formal_exchange
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      theorem
      proof
      proof_step
      axiom
      assumption
      definition
      lemma
      inference_rule
      checker

    edges:
      PROVES
      USES
      DEPENDS_ON
      DISCHARGES
      DERIVED_FROM
      VERIFIED_BY
      REFUTES
      SUPERSEDES

    RULE:
      proof_dependency_andverification_edges MUST be typed
  }

  RELATIONSHIPS {
    FormalProof -> PROVES -> ProofGoal
    FormalProof -> USES -> Premise
    FormalProof -> USES -> Axiom
    FormalProof -> USES -> Definition
    FormalProof -> CONTAINS -> ProofStep
    ProofStep -> USES -> InferenceRule
    ProofStep -> DEPENDS_ON -> PriorProofStep
    AssumptionDischarge -> CLOSES -> Assumption
    ProofCertificate -> CERTIFIES -> FormalProof
    ProofChecker -> VERIFIES -> ProofCertificateOrProof
    Countermodel -> REFUTES -> SemanticValidityClaim
  }

  SEMANTIC_EQUIVALENCE {
    "formal proof" ~= rule_governed_derivation_verifiable_inidentified_formal_system
    "proof step" ~= formally_justified_transition_orjudgment_withinderviation
    "proof certificate" ~= machine_checkable_evidence_supportingformal_result

    proof != informal_argument
    proof != empirical_evidence
    proof != semantic_model
    proof_search != proof_verification
    theoremhood != truth_bydefinition
    syntactic_derivability != semantic_consequence
    proof_validity != truth_ofpremises
    proof_artifact_completeness != proof_system_completeness
    same_conclusion != same_proof
    failed_proof != countermodel
    heuristic_score != proof_validity
    unknown != unprovable
  }

  CONSTRAINTS {
    formal_system_identifier_andversion_must_be preserved = true
    proof_goal_must_be well_formed = true
    premises_axioms_assumptions_anddefinitions_must_be distinguished = true
    every_proof_step_must_haveformal_justification = true
    inference_rule_side_conditions_must_be checked = true
    substitutions_must_be capture_avoiding = true
    active_assumptions_anddischarge_must_be tracked = true
    proof_dependencies_must_be traversable = true
    unsupported_circularity_must_be rejected = true
    proof_search_failure_must_not_be interpreted_asunprovability = true
    semantic_consequence_andsyntactic_derivability_must_be distinguished = true
    proof_validity_andpremise_truth_must_be distinguished = true
    AI_generated_candidate_proof_must_not_be labelled_machine_verified_withoutchecking = true
    proof_checker_anddependency_versions_must_be preserved = true
    provenance_must_be preserved = true
  }

  FORMAL_PROOF_RECORD_MODEL {
    RECORD:
      proof_identifier
      proof_version
      formal_system_identifier
      formal_system_version
      proof_system_identifier
      goal_identifier
      goal_expression
      premise_identifiers
      axiom_identifiers
      definition_identifiers
      initial_assumptions
      proof_step_identifiers
      proof_steps
      rule_identifiers
      substitutions
      side_conditions
      active_assumption_states
      discharged_assumptions
      lemma_identifiers
      dependency_graph
      conclusion
      theorem_identifier
      derivability_status
      semantic_consequence_context
      proof_certificate_identifier
      checker_identifier
      checker_version
      verification_status
      countermodel_identifier
      search_status
      proof_strategy
      constructive_status
      ambiguity_status
      semantic_confidence
      provenance

    RULE:
      formal_proof_record MUST support_independent_reconstruction_andverification
  }

  REASONING_RULES {
    IF proof_artifact_received
      THEN identify_formal_system_andexact_version
      identify_goal_premises_axioms_definitions_andassumptions
      construct_dependency_graph

    IF proof_step_encountered
      THEN resolve_rule_instance
      verify_dependencies
      verify_substitution
      verify_side_conditions
      update_active_assumption_context

    IF assumption_discharged
      THEN verify_discharge_rule
      remove_assumption_fromsubsequent_active_context_asappropriate

    IF all_steps_valid
      AND dependency_graph_valid
      AND conclusion_matches_goal
      THEN mark_proof_verified_underdeclared_system_andchecker

    IF proof_hasunverified_imported_lemma
      THEN overall_machine_verified_status_requires_trusted_orverified_dependency_policy

    IF proof_search_returns_no_result
      THEN preserve_not_found_timeout_orunknown
      anddo_notinfer_unprovability

    IF semantic_countermodel_found
      THEN record_refutation_ofvalidity_claim
      anddistinguish_fromfailed_proof_search

    IF AI_generates_candidate_steps
      THEN treat_asunverified_untilformal_checker_accepts

    IF axiom_definition_rule_orlemma_version_changes
      THEN traverse_dependency_graph
      recursively_revalidate_affected_proofs

    IF historical_proof_checked_undernew_system
      THEN preserve_original_verification
      create_new_verification_record
  }

  VALIDATION {
    CHECK proof_identifier
    CHECK proof_version
    CHECK formal_system_identifier
    CHECK formal_system_version
    CHECK goal_well_formedness
    CHECK premise_roles
    CHECK axiom_roles
    CHECK definition_roles
    CHECK assumption_scope
    CHECK proof_steps
    CHECK rule_instances
    CHECK substitutions
    CHECK variable_capture
    CHECK side_conditions
    CHECK dependency_order
    CHECK circularity
    CHECK assumption_discharge
    CHECK lemma_dependencies
    CHECK conclusion_goal_match
    CHECK derivability_status
    CHECK semantic_consequence_distinction
    CHECK proof_certificate
    CHECK checker_identifier_andversion
    CHECK verification_status
    CHECK countermodel_distinction
    CHECK search_status
    CHECK constructive_orclassical_context
    CHECK ambiguity
    CHECK semantic_confidence
    CHECK provenance
  }

  CONFIDENCE {
    formal_system_resolution_confidence: 1.00
    proof_step_validation_confidence: 1.00
    inference_rule_confidence: 1.00
    assumption_scope_confidence: 1.00
    dependency_graph_confidence: 1.00
    certificate_checking_confidence: 1.00
    automated_proof_search_confidence: 0.99
    informal_toformal_mapping_confidence: 0.97

    RULE:
      confidence decreases when formal system, dependency version,
      rule identity, side condition, assumption scope, certificate,
      checker status orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_proof:
      assign_proof_identifier
      resolve_formal_system
      parse_proof_structure
      validate_dependencies_andsteps
      attach_verification_status
      preserve_provenance
      compute_FLOW_HASH

    ON proof_revision:
      preserve_previous_proof
      create_new_proof_version
      identify_changed_steps
      revalidate_changed_anddependent_steps

    ON dependency_revision:
      preserve_historical_dependency
      update_dependency_graph
      identify_affected_proofs
      recursively_revalidate_undernew_version

    ON checker_revision:
      preserve_previous_verification_record
      register_new_checker_version
      optionally_recheck_proofs
      never_overwrite_historical_status

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: FormalProof
    canonical_role: MachineVerifiableDerivation

    interpretation_order:
      identify_proof_artifact
      identify_formal_system_andversion
      identify_proof_goal
      classify_premises_axioms_definitions_andassumptions
      identify_proof_system_andrule_set
      reconstruct_proof_steps_anddependency_graph
      resolve_substitutions_andvariable_binding
      validate_rule_instances_andside_conditions
      track_active_anddischarged_assumptions
      validate_imported_lemmas_andtheorem_dependencies
      detect_unsupported_cycles
      compare_final_conclusion_withgoal
      distinguish_derivability_fromsemantic_consequence
      identify_certificate_checker_andverification_status
      distinguish_failed_search_fromcountermodel_orunprovability
      distinguish_AI_heuristic_steps_fromverified_steps
      assign_semantic_confidence
      preserve_versions_andprovenance
      emit_machine_resolvable_formal_proof_structure

    ambiguity_controls:
      distinguish_proof_frominformal_argument
      distinguish_proof_fromempirical_evidence
      distinguish_proof_fromsemantic_model
      distinguish_proof_search_fromproof_verification
      distinguish_theoremhood_fromtruth_bydefinition
      distinguish_syntactic_derivability_fromsemantic_consequence
      distinguish_proof_validity_fromtruth_ofpremises
      distinguish_proof_artifact_completeness_fromproof_system_completeness
      distinguish_same_conclusion_fromsame_proof
      distinguish_failed_proof_fromcountermodel
      distinguish_heuristic_score_fromproof_validity
      distinguish_unknown_fromunprovable
      preserve_system_goal_context_steps_dependencies_certificate_checker_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      formal_proofs_derivations_inference_rules_certificates_checking_andAI_proof_reasoning

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

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      proof_identity_model
      formal_system_context_model
      goal_model
      premise_model
      axiom_model
      definition_model
      assumption_model
      assumption_discharge_model
      context_model
      proof_step_model
      step_order_model
      dependency_model
      dependency_graph_model
      circularity_model
      inference_rule_model
      rule_instance_model
      side_condition_model
      substitution_model
      variable_capture_model
      alpha_renaming_model
      modus_ponens_model
      universal_instantiation_model
      existential_generalisation_model
      equality_substitution_model
      direct_proof_model
      conditional_proof_model
      proof_by_contradiction_model
      proof_by_contraposition_model
      proof_by_cases_model
      mathematical_induction_model
      strong_induction_model
      structural_induction_model
      existence_proof_model
      uniqueness_proof_model
      counterexample_model
      proof_tree_model
      proof_DAG_model
      linear_proof_model
      natural_deduction_model
      sequent_calculus_model
      Hilbert_proof_model
      tableau_proof_model
      resolution_proof_model
      equational_proof_model
      rewrite_proof_model
      normalisation_proof_model
      lemma_model
      theorem_model
      corollary_model
      proof_reuse_model
      imported_proof_model
      trusted_axiom_model
      trusted_kernel_model
      proof_checking_model
      local_checkability_model
      proof_certificate_model
      proof_term_model
      Curry_Howard_model
      typing_derivation_model
      soundness_context_model
      semantic_consequence_model
      syntactic_derivability_model
      proof_validity_model
      argument_soundness_distinction_model
      proof_completeness_model
      proof_system_completeness_model
      consistency_context_model
      proof_minimality_model
      redundant_step_model
      proof_compression_model
      proof_expansion_model
      proof_normalisation_model
      cut_model
      cut_elimination_model
      detour_reduction_model
      proof_equivalence_model
      proof_irrelevance_model
      constructive_proof_model
      nonconstructive_proof_model
      classical_proof_model
      intuitionistic_proof_model
      modal_proof_model
      temporal_proof_model
      inductive_proof_object_model
      coinductive_proof_model
      circular_proof_model
      proof_search_model
      forward_reasoning_model
      backward_reasoning_model
      tactic_model
      tactical_model
      automated_theorem_prover_model
      interactive_theorem_prover_model
      SAT_certificate_model
      SMT_proof_model
      model_checking_proof_model
      formal_verification_model
      proof_failure_model
      unknown_status_model
      countermodel_distinction_model
      informal_proof_model
      sketch_model
      AI_generated_proof_model
      AI_heuristic_model
      proof_explanation_model
      proof_provenance_model
      version_model
      revision_model
      deprecation_model
      reproducibility_model
      interoperability_model
      knowledge_graph_model
      relationships
      semantic_equivalence
      constraints
      formal_proof_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      formal_system_orproof_system_changes
      goal_premise_axiom_definition_orassumption_semantics_change
      inference_rule_side_condition_orsubstitution_changes
      proof_step_dependency_orassumption_discharge_changes
      proof_strategy_induction_resolution_orrewriting_changes
      certificate_checker_ortrusted_kernel_changes
      soundness_derivability_orsemantic_consequence_context_changes
      constructive_classical_modal_ortemporal_proof_changes
      automated_theorem_proving_orAI_proof_reasoning_changes
      proof_version_dependency_orprovenance_changes
      formal_proof_record_changes
      constraint_model_changes
      reasoning_rule_changes
  }

}

END FLOW