Theorem Ontology

# Theorem Ontology — Flow Algebra

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

FLOW TheoremOntology {

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

  PURPOSE:
    Represent a theorem as a formally derivable statement, formula or judgment within an explicitly identified mathematical or logical system. The ontology models theorem identity, formal language, theory, axioms, assumptions, definitions, lemmas, inference rules, proof objects, derivations, dependencies, hypotheses, conclusions, equivalence, generalisation, specialisation, corollaries, independence, decidability, constructive status, machine verification, theorem libraries, versioning and provenance. It enables AI systems to distinguish theoremhood from truth, conjecture, axiom status, empirical evidence and informal plausibility while supporting recursive proof validation, dependency tracking, automated theorem proving and explainable machine reasoning.

  ENTITY Theorem {
    TYPE: FormallyDerivableStatement

    PROPERTIES:
      has_identifier
      belongs_to_formal_system
      belongs_to_theory
      has_statement
      has_hypotheses
      has_conclusion
      has_proof
      depends_on_axioms
      depends_on_definitions
      depends_on_lemmas
      has_derivability_status
      may_have_semantic_status
      has_version
      has_provenance
  }

  ENTITY TheoremStatement {
    TYPE: FormulaOrJudgment

    COMPONENTS:
      formal_expression
      language
      free_variables
      bound_variables
      assumptions
  }

  ENTITY TheoremProof {
    TYPE: FormalDerivation

    COMPONENTS:
      proof_identifier
      proof_system
      proof_steps
      dependencies
      verification_status
  }

  ENTITY TheoremDependency {
    TYPE: TypedProofDependency

    POSSIBLE:
      axiom
      definition
      lemma
      prior_theorem
      inference_rule
      assumption
  }

  THEOREM_IDENTITY_MODEL {
    fields:
      theorem_identifier
      canonical_name
      formal_system_identifier
      theory_identifier
      version

    RULE:
      theorem_identity MUST be distinguished_fromstatement_text
  }

  THEOREM_STATUS_MODEL {
    theorem:
      derivable_underidentified_formal_system

    RULE:
      theoremhood_isrelative_tosystem_andproof_rules
  }

  STATEMENT_MODEL {
    theorem:
      well_formed_formula_orjudgment

    RULE:
      theorem_statement MUST be valid_syntax_inlanguage
  }

  LANGUAGE_MODEL {
    fields:
      language_identifier
      signature
      syntax
      semantics

    RULE:
      theorem_expression MUST preserve_language_context
  }

  THEORY_MODEL {
    theorem:
      consequence_ofidentified_theory_underproof_system

    RULE:
      same_statement MAY have_different_status_indifferent_theories
  }

  FORMAL_SYSTEM_MODEL {
    components:
      language
      axioms
      inference_rules
      proof_definition

    RULE:
      theorem_status MUST reference_formal_system_version
  }

  THEOREM_VS_AXIOM_MODEL {
    theorem:
      derived

    axiom:
      designated_starting_statement

    RULE:
      theorem != axiom_withinsame_formal_role
  }

  THEOREM_VS_CONJECTURE_MODEL {
    theorem:
      formally_proven_orverified

    conjecture:
      proposed_statement_withoutaccepted_proof

    RULE:
      conjecture MUST not_be labelled_theorem_withoutproof_status
  }

  THEOREM_VS_LEMMA_MODEL {
    lemma:
      theorem_used_asintermediate_result

    RULE:
      distinction_isprimarily_role_orpresentation
  }

  THEOREM_VS_COROLLARY_MODEL {
    corollary:
      theorem_following_readily_fromprior_result

    RULE:
      corollary_isstill_theorem_informal sense
  }

  THEOREM_VS_PROPOSITION_MODEL {
    proposition:
      may_mean_theorem_oflesser_prominence_orlogical_statement

    RULE:
      terminology_context MUST be preserved
  }

  THEOREM_VS_EMPIRICAL_MODEL {
    theorem:
      formal_derivation

    empirical_law_orfinding:
      observation_supported_claim

    RULE:
      theoremhood_does_notderive_fromexperimental_confirmation
  }

  HYPOTHESIS_MODEL {
    theorem:
      may_beconditional_onhypotheses

    RULE:
      hypotheses MUST not_be omitted_frommachine_interpretation
  }

  CONCLUSION_MODEL {
    theorem:
      target_statement_underhypotheses

    RULE:
      conclusion_withoutconditions MAY misrepresent_theorem
  }

  CONDITIONAL_THEOREM_MODEL {
    structure:
      hypotheses -> conclusion

    RULE:
      logical_form MUST preserve_condition_direction
  }

  UNIVERSAL_THEOREM_MODEL {
    statement:
      quantified_overdeclared_domain

    RULE:
      quantifier_domain MUST be preserved
  }

  EXISTENCE_THEOREM_MODEL {
    conclusion:
      exists_entity_satisfyingconditions

    RULE:
      existence != construction
  }

  UNIQUENESS_THEOREM_MODEL {
    conclusion:
      exactly_one_entity_satisfiesconditions

    RULE:
      uniqueness_requires_existence_plusatmostone
  }

  NONEXISTENCE_THEOREM_MODEL {
    conclusion:
      no_entity_satisfiesconditions

    RULE:
      domain_andconditions MUST be explicit
  }

  EQUIVALENCE_THEOREM_MODEL {
    conclusion:
      A_iff_B
      orstructures_equivalent_underdeclared_relation

    RULE:
      equivalence_type MUST be explicit
  }

  CHARACTERISATION_THEOREM_MODEL {
    result:
      gives_necessary_andsufficient_conditions

    RULE:
      both_directions MUST be represented
  }

  REPRESENTATION_THEOREM_MODEL {
    result:
      abstract_entity_representable_byconcrete_oralternative_structure

    RULE:
      representation_mapping_andconditions MUST be preserved
  }

  CLASSIFICATION_THEOREM_MODEL {
    result:
      partitions_orcharacterises_entities_byinvariants_orproperties

    RULE:
      completeness_ofclassification MUST be justified
  }

  FIXED_POINT_THEOREM_MODEL {
    result:
      existence_oruniqueness_offixed_point_underconditions

    RULE:
      operator_space_andconditions MUST be explicit
  }

  IMPOSSIBILITY_THEOREM_MODEL {
    result:
      proves_noobject_algorithm_orconfiguration_canmeetdeclared_conditions

    RULE:
      scope_andassumptions MUST be preserved
  }

  LIMITATION_THEOREM_MODEL {
    result:
      establishes_bound_orformal_limit

    RULE:
      limitation_context MUST not_be generalised_beyondhypotheses
  }

  META_THEOREM_MODEL {
    theorem:
      statement_aboutformal_system_language_proofs_ormodels

    RULE:
      object_language_andmetalanguage MUST be distinguished
  }

  SOUNDNESS_THEOREM_MODEL {
    generic:
      derivability_implies_semantic_consequence

    RULE:
      proof_system_andsemantics MUST be identified
  }

  COMPLETENESS_THEOREM_MODEL {
    generic:
      semantic_consequence_implies_derivability

    RULE:
      theorem_scope MUST be explicit
  }

  COMPACTNESS_THEOREM_MODEL {
    generic_first_order_context:
      finite_satisfiability_ofallfinite_subsets_implies_satisfiability

    RULE:
      logic_specific_conditions MUST be preserved
  }

  INCOMPLETENESS_THEOREM_MODEL {
    context:
      sufficiently_expressive_effectively_axiomatised_formal_system

    RULE:
      theorem_conditions MUST not_be omitted
  }

  DECIDABILITY_THEOREM_MODEL {
    result:
      establishes_decision_procedure_exists

    RULE:
      algorithm_andinput_class SHOULD be identified
  }

  UNDECIDABILITY_THEOREM_MODEL {
    result:
      establishes_no_total_decision_procedure_underformal model

    RULE:
      reduction_orformal_metaproof SHOULD be linked
  }

  AXIOM_DEPENDENCY_MODEL {
    theorem:
      depends_onaxioms

    RULE:
      direct_andtransitive_dependencies SHOULD be distinguished
  }

  DEFINITION_DEPENDENCY_MODEL {
    theorem:
      depends_ondefinitions

    RULE:
      definition_version MUST be preserved
  }

  LEMMA_DEPENDENCY_MODEL {
    theorem:
      usesprior_lemma_or theorem

    RULE:
      dependency_version_andproof_status MUST be checked
  }

  RULE_DEPENDENCY_MODEL {
    proof:
      usesinference_rules

    RULE:
      proof_system_rule_version MUST be preserved
  }

  ASSUMPTION_DEPENDENCY_MODEL {
    theorem:
      may_depend_ondeclared_hypotheses_orbackground_assumptions

    RULE:
      open_assumptions MUST not_be hidden
  }

  DEPENDENCY_GRAPH_MODEL {
    nodes:
      theorem
      proof
      axiom
      definition
      lemma
      inference_rule

    edges:
      DEPENDS_ON
      USES
      DERIVED_FROM
      PROVES

    RULE:
      graph MUST be acyclic_unlessformal_recursive_orcoinductive_structure_permitsotherwise
  }

  MINIMAL_DEPENDENCY_MODEL {
    theorem:
      minimal_axiom_orlemma_basis_underdeclared criterion

    RULE:
      proof_dependency_set != globally_minimal_dependency_set_unlessproven
  }

  PROOF_MODEL {
    theorem:
      supported_byformal_proof

    RULE:
      proof MUST identify_formal_system
  }

  PROOF_STEP_MODEL {
    fields:
      statement
      rule
      dependencies
      assumptions
      substitution

    RULE:
      each_step MUST be formally_justified
  }

  PROOF_VERIFICATION_MODEL {
    status:
      verified
      rejected
      incomplete
      unverified

    RULE:
      verification_status MUST be explicit
  }

  MACHINE_VERIFIED_THEOREM_MODEL {
    theorem:
      proof_checked_byformal_kernel_orchecker

    RULE:
      checker_identifier_version_andformalisation MUST be preserved
  }

  HUMAN_PROVED_THEOREM_MODEL {
    theorem:
      accepted_viahuman_mathematical_proof

    RULE:
      human_acceptance != machine_verification
  }

  INFORMAL_PROOF_MODEL {
    proof:
      explanatory_argument_withomitted_formal_steps

    RULE:
      theorem MAY be mathematicallyaccepted_butmachine_formal_status_requiresformalisation
  }

  PROOF_SKETCH_MODEL {
    artifact:
      outlines_key_steps

    RULE:
      sketch != complete_formal_proof
  }

  ALTERNATIVE_PROOF_MODEL {
    theorem:
      hasmultiple_proofs

    RULE:
      same_theorem_does_not implyproof_identity
  }

  PROOF_EQUIVALENCE_MODEL {
    proofs:
      may_be equivalent_underdeclared_proof_relation

    RULE:
      equivalence_criterion MUST be explicit
  }

  SHORTEST_PROOF_MODEL {
    proof:
      minimal_length_underdeclared proof_system_andmeasure

    RULE:
      shortest_known != globally_shortest_unlessproven
  }

  CONSTRUCTIVE_THEOREM_MODEL {
    theorem:
      proof_provides_constructive_evidence_orwitness_underconstructive_framework

    RULE:
      constructive_status depends_onlogic_andproof
  }

  NONCONSTRUCTIVE_THEOREM_MODEL {
    theorem:
      proof_establishes_existence_withoutconstructive_witness

    RULE:
      nonconstructive != invalid_inclassical_mathematics
  }

  CLASSICAL_THEOREM_MODEL {
    proof:
      may_useclassical_principles

    RULE:
      classical_theorem_proof MAY nottransfer_tointuitionistic_system
  }

  INTUITIONISTIC_THEOREM_MODEL {
    proof:
      derivable_inintuitionistic_system

    RULE:
      formal_system MUST be identified
  }

  THEOREM_GENERALISATION_MODEL {
    theorem_B:
      extends_theorem_A_to broader_domain_orweaker_conditions

    RULE:
      generalisation_relation MUST be justified
  }

  THEOREM_SPECIALISATION_MODEL {
    theorem_B:
      instance_orrestricted_case_oftheorem_A

    RULE:
      substitution_orrestriction_mapping MUST be explicit
  }

  STRONGER_THEOREM_MODEL {
    theorem_A:
      implies_theorem_B_underbackground_theory

    RULE:
      strength_isdirectional_andcontextual
  }

  WEAKER_THEOREM_MODEL {
    theorem_B:
      follows_fromtheorem_A

    RULE:
      weaker != lessimportant
  }

  EQUIVALENT_THEOREM_MODEL {
    theorem_A:
      equivalent_totheorem_B_underdeclared assumptions

    RULE:
      equivalence_context MUST be preserved
  }

  COROLLARY_MODEL {
    theorem:
      follows_fromprevious_theorem_withshort_orimmediate_derivation

    RULE:
      dependency MUST be recorded
  }

  LEMMA_MODEL {
    theorem:
      used_toestablish_later_result

    RULE:
      role MAY change_acrosspresentations
  }

  PROPOSITION_MODEL {
    formal_result:
      theorem_like_statement

    RULE:
      naming_convention_doesnotdetermineformal_strength
  }

  CLAIM_MODEL {
    statement:
      asserted_butformal_status_unknown

    RULE:
      claim != theorem
  }

  CONJECTURE_MODEL {
    statement:
      proposed_astrue_withoutaccepted_proof

    RULE:
      conjecture_status MUST be preserved_untilproof
  }

  OPEN_PROBLEM_MODEL {
    question:
      theorem_orcounterexample_notcurrently_established_underdeclared knowledge_state

    RULE:
      open_status_isversion_andknowledge_time_dependent
  }

  DISPROVED_CONJECTURE_MODEL {
    statement:
      refuted_bycounterexample_orproof_ofnegation

    RULE:
      disproved_conjecture MUST notretain_theorem_candidate_status_withoutqualification
  }

  COUNTEREXAMPLE_MODEL {
    witness:
      refutes_universal_claim

    RULE:
      valid_counterexample_must_satisfydomain_andhypotheses
  }

  INDEPENDENCE_MODEL {
    statement:
      neither_statement_nornegation_derivable_fromtheory

    RULE:
      independent_statement != theorem_ofthat_theory
  }

  INDEPENDENCE_THEOREM_MODEL {
    metatheorem:
      establishes_independence_relative_toformal system

    RULE:
      relative_context MUST be explicit
  }

  THEOREM_SCHEMA_MODEL {
    pattern:
      family_oftheorems

    RULE:
      theorem_schema != single_theorem
  }

  PARAMETRIC_THEOREM_MODEL {
    theorem:
      parameterised_byobjects_values_orstructures

    RULE:
      parameter_domain_andconstraints MUST be explicit
  }

  DOMAIN_MODEL {
    theorem:
      applies_toidentified_mathematical_domain

    RULE:
      domain_extension_requiresproof
  }

  CONDITION_MODEL {
    theorem:
      hasnecessary_hypotheses

    RULE:
      dropping_condition MAY invalidate_result
  }

  NECESSARY_CONDITION_MODEL {
    condition:
      required_forconclusion_orproperty

    RULE:
      necessary != sufficient
  }

  SUFFICIENT_CONDITION_MODEL {
    condition:
      guaranteesconclusion_undercontext

    RULE:
      sufficient != necessary
  }

  NECESSARY_SUFFICIENT_MODEL {
    condition:
      iff_characterisation

    RULE:
      bothdirections MUST be proven
  }

  EDGE_CASE_MODEL {
    theorem:
      mayexclude_orrequire_special_treatment_forboundary_cases

    RULE:
      exclusions MUST be preserved
  }

  EXCEPTION_MODEL {
    theorem:
      exceptions_underparticular_conditions

    RULE:
      exception MUST not_be hidden_bygeneral_statement
  }

  PROOF_BY_INDUCTION_MODEL {
    theorem:
      established_usinginduction

    components:
      base_case
      inductive_step

    RULE:
      induction_domain MUST be identified
  }

  PROOF_BY_CONTRADICTION_MODEL {
    theorem:
      established_byassumingnegation_andderivingcontradiction

    RULE:
      logic_context MUST supportmethod
  }

  DIRECT_PROOF_MODEL {
    theorem:
      conclusion_derived_directly_fromhypotheses_andknown_results
  }

  EXISTENCE_PROOF_MODEL {
    theorem:
      existence_result

    possible:
      constructive
      nonconstructive

    RULE:
      witness_status MUST be preserved
  }

  COMPUTER_ASSISTED_PROOF_MODEL {
    theorem:
      proof_depends_oncomputer_calculation_orformal verification

    RULE:
      software_algorithm_inputs_andverification_context SHOULD be preserved
  }

  EXHAUSTIVE_COMPUTATION_MODEL {
    proof:
      checksfinite_cases_computationally

    RULE:
      completeness_ofcase_enumeration MUST be established
  }

  NUMERICAL_EVIDENCE_DISTINCTION_MODEL {
    computation:
      may_support_conjecture

    RULE:
      finite_numerical_testing != proof_ofuniversal_theorem_withoutformal_exhaustiveness_argument
  }

  PROBABILISTIC_PROOF_DISTINCTION_MODEL {
    randomized_algorithm:
      mayestablish_result_withprobabilistic_guarantee

    RULE:
      probabilistic_evidence_andformal_deterministic_theorem_proof MUST be distinguished
  }

  THEOREM_LIBRARY_MODEL {
    repository:
      collection_offormal_orinformal_theorems

    fields:
      identifiers
      dependencies
      proof_status
      versions

    RULE:
      library_entry_status MUST be explicit
  }

  IMPORTED_THEOREM_MODEL {
    theorem:
      sourced_fromexternal_library

    RULE:
      trust_orverification_policy MUST be explicit
  }

  TRUSTED_THEOREM_MODEL {
    theorem:
      accepted_asdependency_withoutlocal_rechecking

    RULE:
      trust_boundary MUST be recorded
  }

  THEOREM_REUSE_MODEL {
    theorem:
      used_aslemma_ordependency_innewproof

    RULE:
      compatibility_ofsystem_language_andversion MUST be checked
  }

  TRANSLATED_THEOREM_MODEL {
    theorem:
      mapped_betweenformal languages_or systems

    RULE:
      translation MUST preserve_declared_proof_orsemantic_relation
  }

  THEOREM_TRANSPORT_MODEL {
    theorem:
      transferred_alongisomorphism_equivalence_orstructure_preserving_map

    RULE:
      transport_conditions MUST be explicit
  }

  DUALITY_THEOREM_MODEL {
    theorem:
      paired_withdual_statement_underdeclared_duality

    RULE:
      duality_mapping MUST be formalised
  }

  INVARIANCE_THEOREM_MODEL {
    theorem:
      property_preserved_undertransformations

    RULE:
      transformation_class MUST be specified
  }

  MONOTONICITY_THEOREM_MODEL {
    theorem:
      establishes_order_preservation_or monotonic_relation

    RULE:
      order_structure MUST be identified
  }

  BOUND_THEOREM_MODEL {
    theorem:
      establishes_upper_lower_orasymptotic_bound

    RULE:
      bound_domain_constants
_andconditions MUST be preserved
  }

  EXISTENCE_UNIQUENESS_MODEL {
    theorem:
      establishes_both_existence_anduniqueness

    RULE:
      two_components SHOULD be separately machine_resolvable
  }

  LOCAL_THEOREM_MODEL {
    theorem:
      holds_inneighbourhood_orrestricted_context

    RULE:
      local_result != global_result
  }

  GLOBAL_THEOREM_MODEL {
    theorem:
      holds_overentiredeclared_domain

    RULE:
      globality_requires_proof_underfull_domain
  }

  FINITE_CASE_THEOREM_MODEL {
    domain:
      finite

    RULE:
      exhaustive_proof MAY be computationally_checkable
  }

  INFINITE_DOMAIN_THEOREM_MODEL {
    domain:
      infinite

    RULE:
      finite_testing_alone_cannotestablish_universal_result
  }

  EXACT_THEOREM_MODEL {
    statement:
      formal_exact_relation

    RULE:
      exact_theorem != numerical_approximation
  }

  APPROXIMATION_THEOREM_MODEL {
    result:
      establishes_error_bound_orconvergence_ofapproximation

    RULE:
      approximation_metric_andbound MUST be explicit
  }

  ASYMPTOTIC_THEOREM_MODEL {
    result:
      behaviour_underlimit_regime

    RULE:
      asymptotic_statement != finite_exact_equality
  }

  CONVERGENCE_THEOREM_MODEL {
    result:
      sequence_iteration_orapproximation_converges

    RULE:
      convergence_mode_andconditions MUST be explicit
  }

  STABILITY_THEOREM_MODEL {
    result:
      establishes_stability_underdeclared_perturbation_or dynamics

    RULE:
      stability_definition MUST be identified
  }

  COMPLEXITY_THEOREM_MODEL {
    result:
      establishes_resource_bound_orcomplexity_class_relation

    RULE:
      computational_model_andinput_measure MUST be preserved
  }

  CORRECTNESS_THEOREM_MODEL {
    algorithm:
      satisfies_formal_specification

    components:
      partial_correctness
      termination_whenrequired

    RULE:
      total_correctness != partial_correctness
  }

  TERMINATION_THEOREM_MODEL {
    result:
      algorithm_orrewrite_system_terminates

    RULE:
      termination != correctness
  }

  SOUNDNESS_OF_ALGORITHM_MODEL {
    algorithm:
      outputs_onlyvalid_results

    RULE:
      algorithmic_soundness != proof_system_soundness_withoutcontext
  }

  COMPLETENESS_OF_ALGORITHM_MODEL {
    algorithm:
      findsallsolutions_orrecognisesallpositive_cases_underdeclared scope

    RULE:
      algorithmic_completeness != logical_completeness_withoutcontext
  }

  FORMALISATION_MODEL {
    source:
      informal_theorem_statement

    target:
      formal_formula_orjudgment

    RULE:
      formalisation_choices_andassumptions MUST be preserved
  }

  NATURAL_LANGUAGE_THEOREM_MODEL {
    text:
      human_readable_statement

    RULE:
      natural_language_statement SHOULD link_tocanonical_formal_statement_whenavailable
  }

  SYMBOLIC_THEOREM_MODEL {
    expression:
      formal_symbolic_statement

    RULE:
      symbol_resolution_language_andbinding MUST be preserved
  }

  THEOREM_NORMALISATION_MODEL {
    statement:
      transformed_to canonical_form

    RULE:
      canonicalisation MUST preserve_semantics
  }

  THEOREM_EQUIVALENCE_MODEL {
    statements:
      equivalent_underdeclared theory_orsemantics

    RULE:
      textual_similarity != theorem_equivalence
  }

  THEOREM_MATCHING_MODEL {
    query_statement:
      compare_withlibrary_theorems

    evidence:
      formal_equivalence
      specialisation
      generalisation
      semantic_similarity

    RULE:
      semantic_similarity_alone MUST notestablish_identity
  }

  THEOREM_SEARCH_MODEL {
    input:
      goal_orconcept

    output:
      candidate_theorems

    RULE:
      retrieval_relevance != applicability
  }

  APPLICABILITY_MODEL {
    candidate_theorem:
      applicable_ifhypotheses_andtypes_match

    RULE:
      theorem_name_match_isinsufficient
  }

  HYPOTHESIS_MATCHING_MODEL {
    theorem_conditions:
      mapped_to current_context

    RULE:
      allrequired_hypotheses MUST be satisfied_orproven
  }

  TYPE_COMPATIBILITY_MODEL {
    theorem:
      expects_entities_ofdeclared_types_orstructures

    RULE:
      substitution MUST preservetypes
  }

  DOMAIN_COMPATIBILITY_MODEL {
    theorem:
      applies_overdeclared_domain

    RULE:
      domain_coercion_orrestriction MUST be justified
  }

  SUBSTITUTION_MODEL {
    theorem_schema_orparameterised_statement:
      instantiate_variables

    RULE:
      substitution MUST preserve_binding_andconstraints
  }

  THEOREM_INSTANTIATION_MODEL {
    general_theorem:
      instantiated_toparticular_objects

    RULE:
      resulting_statement_isderived_instance_notnewindependent_theorem_identity_unlesscatalogued
  }

  PROOF_OBLIGATION_MODEL {
    generated:
      condition_required_toapply_theorem_orcompleteproof

    RULE:
      unresolved_obligation MUST remain_open
  }

  AUTOMATED_THEOREM_PROVING_MODEL {
    input:
      theory
      goal

    output:
      proof
      countermodel_orrefutation_whenapplicable
      unknown
      timeout

    RULE:
      proof_search_status MUST not_be conflated_withtheorem_status
  }

  THEOREM_PROVER_MODEL {
    engine:
      searches_derivations

    RULE:
      theorem_prover_output SHOULD be verified_orcertificate_backed
  }

  PROOF_CHECKER_MODEL {
    engine:
      validates_proof_artifact

    RULE:
      checker_version_andformal_system MUST be preserved
  }

  PROOF_CERTIFICATE_MODEL {
    artifact:
      machine_checkable_support_for theorem_status

    RULE:
      certificate_format MUST be identified
  }

  COUNTERMODEL_SEARCH_MODEL {
    process:
      search_forsemantic_model_refuting_candidate

    RULE:
      countermodel_refutes_validity_orconsequence_withinscope
  }

  UNKNOWN_STATUS_MODEL {
    possible:
      unverified
      open
      unknown
      timeout
      resource_limit

    RULE:
      unknown != false
      unknown != disproven
  }

  THEOREM_VERIFICATION_STATE_MODEL {
    possible:
      machine_verified
      formally_proved_unchecked
      human_accepted
      proof_sketch_only
      conjectured
      refuted
      independent
      unknown

    RULE:
      state MUST be explicit
  }

  TRUST_MODEL {
    dependency:
      may_be trusted_withoutlocal_check

    RULE:
      trust_policy MUST be explicit
  }

  REPRODUCIBILITY_MODEL {
    machine_verified_theorem:
      requires
        formal_statement
        proof
        dependencies
        system_versions
        checker

    RULE:
      independent_rechecking SHOULD reproduce_status
  }

  REVISION_MODEL {
    changed:
      theorem_statement
      proof
      dependency
      definition
      axiom
      formal_system

    RULE:
      revision MUST create_newversion_orverification_record
  }

  DEPENDENCY_REVISION_MODEL {
    changed_dependency:
      identify_affected_theorems

    RULE:
      recursively_revalidate_machine_verified_results
  }

  DEPRECATION_MODEL {
    theorem_version:
      superseded_orinvalidated

    RULE:
      historical_version MUST remain_auditable
  }

  RETRACTION_MODEL {
    theorem:
      previous_status_withdrawn_due_toinvalid_proof_orchanged_system

    RULE:
      retraction_reason MUST be preserved
  }

  CONFLICT_MODEL {
    sources:
      disagree_onstatement_proof_orstatus

    RULE:
      AI MUST preserve_conflict_untilresolved
  }

  SOURCE_AUTHORITY_MODEL {
    source:
      authority_forparticular_formalisation_orproof

    RULE:
      source_authority_doesnotreplace_formal_verification
  }

  AMBIGUITY_MODEL {
    possible:
      theorem_name_collision
      statement_variant
      missing_hypothesis
      formal_system_unspecified
      proof_status_unclear

    RULE:
      ambiguity MUST be resolved_orpreserved
  }

  SEMANTIC_CONFIDENCE_MODEL {
    confidence:
      support_forresolved_theorem_identity_formalisation_orstatus

    RULE:
      semantic_confidence != proof_validity
  }

  EXPLAINABILITY_MODEL {
    theorem_output:
      statement
      hypotheses
      conclusion
      dependencies
      proof
      formal_system
      verification_status

    RULE:
      explanation MUST notomit_material_hypotheses
  }

  INTEROPERABILITY_MODEL {
    exchange:
      theorem_identifier
      formal_statement
      hypotheses
      proof_identifier
      dependencies
      verification_status
      versions
      provenance

    RULE:
      theorem_name_andprose_alone_areinsufficient_forlossless_machine_exchange
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      theorem
      statement
      hypothesis
      proof
      axiom
      definition
      lemma
      corollary
      conjecture
      checker

    edges:
      PROVED_BY
      DEPENDS_ON
      GENERALISES
      SPECIALISES
      EQUIVALENT_TO
      IMPLIES
      REFUTES
      VERIFIED_BY
      SUPERSEDES

    RULE:
      theorem_relations MUST be typed_andversioned
  }

  RELATIONSHIPS {
    Theorem -> HAS_STATEMENT -> TheoremStatement
    Theorem -> MAY_REQUIRE -> Hypothesis
    Theorem -> HAS_CONCLUSION -> Conclusion
    Theorem -> PROVED_BY -> TheoremProof
    TheoremProof -> USES -> Axiom
    TheoremProof -> USES -> Definition
    TheoremProof -> USES -> Lemma
    Corollary -> DEPENDS_ON -> Theorem
    GeneralisedTheorem -> GENERALISES -> Theorem
    SpecialisedTheorem -> SPECIALISES -> Theorem
    ProofChecker -> VERIFIES -> TheoremProof
  }

  SEMANTIC_EQUIVALENCE {
    "theorem" ~= formally_derivable_statement_withinidentified_mathematical_orlogical_system
    "theorem proof" ~= formal_derivation_supportingtheorem_status
    "theorem dependency" ~= axiom_definition_lemma_rule_orassumption_required_byproof

    theorem != axiom
    theorem != conjecture
    theorem != empirical_finding
    theoremhood != truth_bydefinition
    proof != theorem_statement
    proof_sketch != formal_proof
    human_acceptance != machine_verification
    existence != construction
    necessary != sufficient
    theorem_retrieval != theorem_applicability
    proof_search_failure != theorem_falsehood
    semantic_confidence != proof_validity
  }

  CONSTRAINTS {
    theorem_identifier_formal_system_theory_andversion_must_be preserved = true
    theorem_statement_must_be well_formed = true
    hypotheses_anddomain_conditions_must_not_be omitted = true
    theorem_axiom_conjecture_lemma_corollary_andempirical_claim_roles_must_be distinguished = true
    proof_dependencies_must_be explicit_andtraversable = true
    theorem_status_must_referenceproof_oraccepted_formal_basis = true
    machine_verified_status_requires_checker_ortrusted_kernel_evidence = true
    theorem_applicability_requires_hypothesis_type_anddomain_compatibility = true
    theoremhood_must_not_be interpreted_asempirical_truth = true
    proof_search_unknown_timeout_orfailure_must_not_be interpreted_asdisproof = true
    theorem_revisions_anddependency_changes_must_be versioned = true
    conflicts_andretractions_must_remain_auditable = true
    provenance_must_be preserved = true
  }

  THEOREM_RECORD_MODEL {
    RECORD:
      theorem_identifier
      canonical_name
      theorem_type
      formal_system_identifier
      formal_system_version
      theory_identifier
      theory_version
      language_identifier
      formal_statement
      natural_language_statement
      hypotheses
      domain
      conclusion
      theorem_schema_status
      parameterisation
      axiom_dependencies
      definition_dependencies
      lemma_dependencies
      rule_dependencies
      proof_identifier
      proof_version
      proof_method
      constructive_status
      machine_verification_status
      checker_identifier
      checker_version
      semantic_consequence_context
      generalisation_relations
      specialisation_relations
      equivalence_relations
      corollary_relations
      conjecture_history
      independence_status
      proof_obligations
      search_status
      conflict_status
      deprecation_orretraction_status
      ambiguity_status
      semantic_confidence
      version
      provenance

    RULE:
      theorem_record MUST support_reconstruction_ofstatement_conditions_proof_dependencies_verification_versions_andprovenance
  }

  REASONING_RULES {
    IF statement_claimed_as_theorem
      THEN identify_formal_system_theory_language_andversion
      resolve_formal_statement_andhypotheses

    IF proof_available
      THEN reconstruct_dependencies
      validate_proof_underexact_system
      attach_verification_status

    IF theorem_applied_to_new_context
      THEN match_domain_types_parameters_andallhypotheses
      generate_proof_obligations_forunresolved_conditions

    IF candidate_statement_hasnoaccepted_proof
      THEN preserve_conjecture_claim_orunknown_status
      anddo_notlabel_theorem

    IF counterexample_found
      THEN refute_universal_candidate_withinscope
      preserve_witness_andprovenance

    IF theorem_generalisation_claimed
      THEN verify_broader_domain_orweaker_conditions_andformal_implication_relation

    IF theorem_equivalence_claimed
      THEN verify_bothdirections_underdeclared_background_theory

    IF proof_search_returns_unknown_timeout_orfailure
      THEN preserve_search_status
      anddo_notinferfalsehood

    IF dependency_axiom_definition_lemma_orchecker_changes
      THEN traverse_dependency_graph
      recursively_revalidate_affected_theorems

    IF theorem_status_retracted
      THEN preserve_prior_status
      record_reason
      propagate_warning_todependent_results
  }

  VALIDATION {
    CHECK theorem_identifier
    CHECK theorem_type
    CHECK formal_system
    CHECK formal_system_version
    CHECK theory
    CHECK theory_version
    CHECK language
    CHECK statement_well_formedness
    CHECK hypotheses
    CHECK domain
    CHECK conclusion
    CHECK theorem_schema_orparameterisation
    CHECK axiom_dependencies
    CHECK definition_dependencies
    CHECK lemma_dependencies
    CHECK rule_dependencies
    CHECK proof_identifier
    CHECK proof_steps_orcertificate
    CHECK proof_method
    CHECK constructive_status
    CHECK checker_andverification_status
    CHECK theorem_applicability
    CHECK generalisation_specialisation_equivalence_relations
    CHECK corollaries
    CHECK conjecture_orindependence_history
    CHECK proof_obligations
    CHECK search_status
    CHECK conflicts
    CHECK deprecation_orretraction
    CHECK ambiguity
    CHECK semantic_confidence
    CHECK version
    CHECK provenance
  }

  CONFIDENCE {
    theorem_identity_confidence: 1.00
    statement_formalisation_confidence: 0.99
    hypothesis_resolution_confidence: 1.00
    dependency_confidence: 1.00
    proof_validation_confidence: 1.00
    applicability_confidence: 0.99
    theorem_relation_confidence: 0.99
    provenance_confidence: 1.00

    RULE:
      confidence decreases when formal system, theory, statement,
      hypotheses, proof, dependencies, checker, version
      orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_theorem:
      assign_orresolve_theorem_identifier
      attach_system_theory_language_andstatement
      resolve_hypotheses_anddependencies
      attach_proof_andverification_status
      preserve_provenance
      compute_FLOW_HASH

    ON theorem_revision:
      preserve_previous_theorem_version
      create_newversion
      identify_statement_proof_orcondition_changes
      update_dependencies
      recursively_revalidate_dependents

    ON proof_revision:
      preserve_previous_proof
      attach_newproof_version
      revalidate_theorem_status
      preserve_historical_verification

    ON dependency_revision:
      identify_affected_theorems
      preserve_previous_status
      recursively_recheck_current_versions

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: Theorem
    canonical_role: FormallyDerivableStatement

    interpretation_order:
      identify_theorem_candidate
      identify_formal_system_theory_andversions
      resolve_formal_language
      resolve_theorem_statement
      identify_hypotheses_domain_andconclusion
      classify_theorem_type
      distinguish_theorem_fromaxiom_conjecture_lemma_corollary_andempirical_claim
      reconstruct_axiom_definition_lemma_rule_andassumption_dependencies
      resolve_proof_identifier_method_andstatus
      verify_machine_checking_ortrust_boundary
      determine_constructive_orclassical_context
      resolve_generalisation_specialisation_equivalence_andcorollary_relations
      evaluate_applicability_toquery_context
      generate_unresolved_proof_obligations
      preserve_search_unknown_orcounterexample_status
      detect_conflicts_retractions_orversion_changes
      assign_semantic_confidence
      preserve_provenance
      emit_machine_resolvable_theorem_structure

    ambiguity_controls:
      distinguish_theorem_fromaxiom
      distinguish_theorem_fromconjecture
      distinguish_theorem_fromempirical_finding
      distinguish_theoremhood_fromtruth_bydefinition
      distinguish_proof_fromtheorem_statement
      distinguish_proof_sketch_fromformal_proof
      distinguish_human_acceptance_frommachine_verification
      distinguish_existence_fromconstruction
      distinguish_necessary_fromsufficient
      distinguish_theorem_retrieval_fromtheorem_applicability
      distinguish_proof_search_failure_fromtheorem_falsehood
      distinguish_semantic_confidence_fromproof_validity
      preserve_system_theory_statement_hypotheses_dependencies_proof_verification_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      theorems_formal_statements_proofs_dependencies_applicability_verification_andAI_theorem_reasoning

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

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      theorem_identity_model
      theorem_status_model
      statement_model
      language_model
      theory_model
      formal_system_model
      theorem_vs_axiom_model
      theorem_vs_conjecture_model
      theorem_vs_lemma_model
      theorem_vs_corollary_model
      theorem_vs_proposition_model
      theorem_vs_empirical_model
      hypothesis_model
      conclusion_model
      conditional_theorem_model
      universal_theorem_model
      existence_theorem_model
      uniqueness_theorem_model
      nonexistence_theorem_model
      equivalence_theorem_model
      characterisation_theorem_model
      representation_theorem_model
      classification_theorem_model
      fixed_point_theorem_model
      impossibility_theorem_model
      limitation_theorem_model
      meta_theorem_model
      soundness_theorem_model
      completeness_theorem_model
      compactness_theorem_model
      incompleteness_theorem_model
      decidability_theorem_model
      undecidability_theorem_model
      axiom_dependency_model
      definition_dependency_model
      lemma_dependency_model
      rule_dependency_model
      assumption_dependency_model
      dependency_graph_model
      minimal_dependency_model
      proof_model
      proof_step_model
      proof_verification_model
      machine_verified_theorem_model
      human_proved_theorem_model
      informal_proof_model
      proof_sketch_model
      alternative_proof_model
      proof_equivalence_model
      shortest_proof_model
      constructive_theorem_model
      nonconstructive_theorem_model
      classical_theorem_model
      intuitionistic_theorem_model
      theorem_generalisation_model
      theorem_specialisation_model
      stronger_theorem_model
      weaker_theorem_model
      equivalent_theorem_model
      corollary_model
      lemma_model
      proposition_model
      claim_model
      conjecture_model
      open_problem_model
      disproved_conjecture_model
      counterexample_model
      independence_model
      independence_theorem_model
      theorem_schema_model
      parametric_theorem_model
      domain_model
      condition_model
      necessary_condition_model
      sufficient_condition_model
      necessary_sufficient_model
      edge_case_model
      exception_model
      proof_by_induction_model
      proof_by_contradiction_model
      direct_proof_model
      existence_proof_model
      computer_assisted_proof_model
      exhaustive_computation_model
      numerical_evidence_distinction_model
      probabilistic_proof_distinction_model
      theorem_library_model
      imported_theorem_model
      trusted_theorem_model
      theorem_reuse_model
      translated_theorem_model
      theorem_transport_model
      duality_theorem_model
      invariance_theorem_model
      monotonicity_theorem_model
      bound_theorem_model
      existence_uniqueness_model
      local_theorem_model
      global_theorem_model
      finite_case_theorem_model
      infinite_domain_theorem_model
      exact_theorem_model
      approximation_theorem_model
      asymptotic_theorem_model
      convergence_theorem_model
      stability_theorem_model
      complexity_theorem_model
      correctness_theorem_model
      termination_theorem_model
      soundness_of_algorithm_model
      completeness_of_algorithm_model
      formalisation_model
      natural_language_theorem_model
      symbolic_theorem_model
      theorem_normalisation_model
      theorem_equivalence_model
      theorem_matching_model
      theorem_search_model
      applicability_model
      hypothesis_matching_model
      type_compatibility_model
      domain_compatibility_model
      substitution_model
      theorem_instantiation_model
      proof_obligation_model
      automated_theorem_proving_model
      theorem_prover_model
      proof_checker_model
      proof_certificate_model
      countermodel_search_model
      unknown_status_model
      theorem_verification_state_model
      trust_model
      reproducibility_model
      revision_model
      dependency_revision_model
      deprecation_model
      retraction_model
      conflict_model
      source_authority_model
      ambiguity_model
      semantic_confidence_model
      explainability_model
      interoperability_model
      knowledge_graph_model
      relationships
      semantic_equivalence
      constraints
      theorem_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      theorem_identity_statement_system_theory_orversion_changes
      hypotheses_domain_conditions_orconclusion_changes
      axiom_definition_lemma_rule_orassumption_dependencies_change
      proof_method_certificate_checker_orverification_status_changes
      theorem_generalisation_specialisation_equivalence_orcorollary_relations_change
      conjecture_independence_counterexample_oropen_problem_status_changes
      applicability_type_domain_orproof_obligation_logic_changes
      automated_theorem_proving_search_ortrust_policy_changes
      revision_retraction_conflict_orprovenance_changes
      theorem_record_changes
      constraint_model_changes
      reasoning_rule_changes
  }

}

END FLOW