Logical Equivalence Ontology

# Logical Equivalence Ontology — Flow Algebra

URL: https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/propositional-logic/logical-equivalence-ontology.html

FLOW LogicalEquivalenceOntology {

  DOMAIN:
    AI Core
    -> Ontologies
    -> Mathematical Ontologies
    -> Mathematical Logic Ontologies
    -> Propositional Logic
    -> Logical Equivalence Ontology

  PURPOSE:
    Represent logical equivalence as a machine-interpretable semantic relation between formulas that have the same truth value under every valuation in an explicitly identified logical system. In classical propositional logic, formulas A and B are logically equivalent exactly when A ↔ B is valid, when A XOR B is unsatisfiable, or when their complete truth vectors are identical under the same atomic-variable mapping and valuation order. The ontology models equivalence identity, formula pairs and classes, truth-functional semantics, biconditional validity, mutual entailment, proof transformations, replacement, canonical forms, normalisation, SAT and BDD equivalence checking, Boolean-function identity, natural-language equivalence claims, non-classical variants, ambiguity, versioning and provenance. It prevents logical equivalence from being confused with syntactic identity, numerical equality, semantic similarity, approximate equality, equisatisfiability, one-way implication, same current truth value, causal equivalence or ontology identity.

  ENTITY LogicalEquivalence {
    TYPE: SemanticFormulaRelation

    PROPERTIES:
      has_identifier
      has_left_formula
      has_right_formula
      belongs_to_logic_system
      is_reflexive
      is_symmetric
      is_transitive
      may_be_verified_by_truth_table
      may_be_verified_by_biconditional
      may_be_verified_by_SAT
      may_be_verified_by_proof
      has_version
      has_provenance
  }

  ENTITY EquivalenceClass {
    TYPE: SetOfSemanticallyEquivalentFormulas

    COMPONENTS:
      representative_formula
      member_formulas
      semantic_signature
  }

  ENTITY EquivalenceWitness {
    TYPE: VerificationArtifact

    POSSIBLE:
      truth_table
      proof
      BDD
      canonical_form
      UNSAT_certificate_for_XOR
  }

  ENTITY EquivalenceCounterexample {
    TYPE: Valuation

    CONDITION:
      left_formula_value != right_formula_value
  }

  EQUIVALENCE_IDENTITY_MODEL {
    fields:
      equivalence_identifier
      left_formula_identifier
      right_formula_identifier
      logic_system_identifier
      version

    RULE:
      equivalence_claim MUST be logic_andversion_specific
  }

  FORMULA_PAIR_MODEL {
    left:
      well_formed_formula_A

    right:
      well_formed_formula_B

    RULE:
      formulas MUST be interpreted_undercompatible_language
  }

  COMMON_LANGUAGE_MODEL {
    formulas:
      may_use different_atom_subsets

    evaluation_space:
      union_ofatomic_variables

    RULE:
      atom_identity_mapping MUST be preserved
  }

  CLASSICAL_DEFINITION_MODEL {
    A equivalent B:
      forallvaluations_v:
        v(A)=v(B)

    RULE:
      equality_required_foreveryvaluation
  }

  TRUTH_FUNCTION_MODEL {
    formula:
      denotesBoolean_function

    equivalence:
      sameBoolean_function

    RULE:
      logical_equivalence_isextensional_underclassical_propositional_semantics
  }

  TRUTH_TABLE_MODEL {
    method:
      evaluateA_andB_overallvaluations

    equivalent_if:
      columns_identical

    RULE:
      table MUST be complete
  }

  TRUTH_VECTOR_MODEL {
    A:
      vector_A

    B:
      vector_B

    equivalent_if:
      vector_A = vector_B

    RULE:
      atom_mapping_andvaluation_order MUST match
  }

  SEMANTIC_SIGNATURE_MODEL {
    formula:
      canonical_truth_vector_orothercanonical_Boolean_function_representation

    RULE:
      same_signature impliesequivalence_underdeclared_method
  }

  BICONDITIONAL_TEST_MODEL {
    formula:
      A IFF B

    equivalent_if:
      A_IFF_B_valid
  }

  XOR_TEST_MODEL {
    formula:
      A XOR B

    equivalent_if:
      A_XOR_B_unsatisfiable
  }

  MUTUAL_ENTAILMENT_MODEL {
    A equivalent B:
      iff A entails B
      AND B entails A

    RULE:
      bothdirections_required
  }

  MUTUAL_IMPLICATION_MODEL {
    test:
      (A -> B) AND (B -> A)

    equivalent_if:
      valid
  }

  ONE_WAY_IMPLICATION_DISTINCTION_MODEL {
    A entails B:
      doesnotnecessarilyimply B entails A

    RULE:
      one_way_entailment != equivalence
  }

  SAME_VALUE_DISTINCTION_MODEL {
    valuation_v:
      v(A)=v(B)

    RULE:
      agreement_underonevaluation != logical_equivalence
  }

  SYNTACTIC_IDENTITY_MODEL {
    formulas:
      same_AST

    RULE:
      syntactic_identity impliesequivalence_butconverse_notrequired
  }

  SYNTACTIC_VARIATION_MODEL {
    examples:
      A AND B
      B AND A

    RULE:
      different_syntax MAY denote_sameBoolean_function
  }

  REFLEXIVITY_MODEL {
    A equivalent A:
      true
  }

  SYMMETRY_MODEL {
    if:
      A equivalent B

    then:
      B equivalent A
  }

  TRANSITIVITY_MODEL {
    if:
      A equivalent B
      AND B equivalent C

    then:
      A equivalent C
  }

  EQUIVALENCE_RELATION_MODEL {
    properties:
      reflexive
      symmetric
      transitive

    RULE:
      partitions_formulas_intoequivalence_classes
  }

  EQUIVALENCE_CLASS_MODEL {
    class:
      allformulas_denotingsameBoolean_function

    RULE:
      representative_choice_doesnotchangeclass
  }

  CLASS_REPRESENTATIVE_MODEL {
    possible:
      shortest_formula
      canonical_CNF
      canonical_DNF
      ROBDD
      selected_source_formula

    RULE:
      representative_selection_criterion MUST be explicit
  }

  CANONICAL_REPRESENTATIVE_MODEL {
    formula_orartifact:
      unique_underdeclared_canonicalisation_method

    RULE:
      canonicality_requiresmethod_andvariable_order_whenrelevant
  }

  DOUBLE_NEGATION_MODEL {
    NOT NOT A:
      equivalent_to A
      underclassical semantics
  }

  DE_MORGAN_MODEL {
    NOT(A AND B):
      equivalent_to
      NOT A OR NOT B

    NOT(A OR B):
      equivalent_to
      NOT A AND NOT B
  }

  COMMUTATIVITY_MODEL {
    A AND B equivalent B AND A
    A OR B equivalent B OR A
  }

  ASSOCIATIVITY_MODEL {
    (A AND B) AND C equivalent A AND (B AND C)
    (A OR B) OR C equivalent A OR (B OR C)
  }

  DISTRIBUTIVITY_MODEL {
    A AND (B OR C):
      equivalent_to
      (A AND B) OR (A AND C)

    A OR (B AND C):
      equivalent_to
      (A OR B) AND (A OR C)
  }

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

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

  IDENTITY_MODEL {
    A AND TRUE equivalent A
    A OR FALSE equivalent A
  }

  DOMINATION_MODEL {
    A AND FALSE equivalent FALSE
    A OR TRUE equivalent TRUE
  }

  COMPLEMENT_MODEL {
    A OR NOT A equivalent TRUE
    A AND NOT A equivalent FALSE
  }

  IMPLICATION_ELIMINATION_MODEL {
    A -> B:
      equivalent_to
      NOT A OR B
  }

  BICONDITIONAL_ELIMINATION_MODEL {
    A IFF B:
      equivalent_to
      (A -> B) AND (B -> A)
  }

  XOR_EXPANSION_MODEL {
    A XOR B:
      equivalent_to
      (A AND NOT B) OR (NOT A AND B)
  }

  CONTRAPOSITION_MODEL {
    A -> B:
      equivalent_to
      NOT B -> NOT A

    RULE:
      classical_context
  }

  EXPORTATION_MODEL {
    (A AND B) -> C:
      equivalent_to
      A -> (B -> C)

    RULE:
      classical_context
  }

  REPLACEMENT_MODEL {
    if:
      A equivalent B

    then:
      A_maybereplaced_byB_inside_truth_functional_formula_context

    RULE:
      replacement_context MUST be extensional
  }

  REPLACEMENT_THEOREM_MODEL {
    formula_context:
      C[_]

    if:
      A equivalent B

    then:
      C[A] equivalent C[B]

    RULE:
      holds_forclassical_truth_functional_contexts
  }

  SUBSTITUTION_OF_EQUIVALENTS_MODEL {
    process:
      replaceequivalent_subformula

    RULE:
      provenance_ofreplacement SHOULD be preserved
  }

  REWRITE_MODEL {
    source:
      formula_pattern

    target:
      equivalent_formula_pattern

    RULE:
      rewrite_rule MUST carryequivalence_basis
  }

  BIDIRECTIONAL_REWRITE_MODEL {
    equivalence:
      permitsrewrite_bothdirections

    RULE:
      orientation_fornormalisation_isoperational_choice
  }

  DIRECTED_SIMPLIFICATION_MODEL {
    equivalent_pair:
      choose_lowercomplexity_target

    RULE:
      simplification_direction != logical_asymmetry
  }

  NORMALISATION_MODEL {
    source_formula:
      transform_to canonical_orselected_normal_form

    RULE:
      eachstep MUST preserveequivalence_unlessmethoddeclaresotherwise
  }

  NNF_MODEL {
    target:
      negation_normal_form

    RULE:
      equivalent_underappropriate_logic
  }

  CNF_MODEL {
    target:
      conjunctive_normal_form

    RULE:
      directdistribution_method_preservesequivalence
  }

  DNF_MODEL {
    target:
      disjunctive_normal_form

    RULE:
      directdistribution_method_preservesequivalence
  }

  TSEITIN_DISTINCTION_MODEL {
    source:
      formula

    encoded_CNF:
      introducesauxiliary_variables

    property:
      equisatisfiable

    RULE:
      Tseitin_encoding_notnecessarilylogically_equivalent_overextendedvocabulary
  }

  EQUISATISFIABILITY_DISTINCTION_MODEL {
    formulas:
      bothsatisfiable_orbothunsatisfiable

    RULE:
      equisatisfiable != logically_equivalent
  }

  SAT_EQUIVALENCE_MODEL {
    test:
      solve_A_XOR_B

    if:
      UNSAT
      then equivalent

    if:
      SAT
      then assignment_is_counterexample
  }

  SAT_CERTIFICATE_MODEL {
    UNSAT_of_XOR:
      certificate_supportsequivalence

    RULE:
      certificate_checker_andversion SHOULD be preserved
  }

  COUNTEREXAMPLE_MODEL {
    valuation:
      v(A) != v(B)

    RULE:
      onecounterexample disproves_equivalence
  }

  COUNTEREXAMPLE_MINIMISATION_MODEL {
    witness:
      maybereduced_orpresented_aspartial_assignment_ifitguaranteesdifference

    RULE:
      partial_witness_semantics MUST be explicit
  }

  BDD_MODEL {
    formulas:
      compiletoROBDD_underfixed_variable_order

    equivalent_if:
      canonical_BDD_roots_identical

    RULE:
      variable_order MUST match
  }

  ROBDD_CANONICALITY_MODEL {
    fixed_order:
      reduced_ordered_BDD_iscanonical_forBoolean_function

    RULE:
      canonicality_depends_onvariable_order
  }

  BOOLEAN_ALGEBRA_MODEL {
    formulas:
      equivalent_ifrepresent_sameBoolean_algebra_element_orfunction

    RULE:
      algebraic_context MUST be explicit
  }

  BOOLEAN_POLYNOMIAL_MODEL {
    formulas:
      maytranslate_toalgebraic_normal_form

    equivalent_if:
      sameANF_underfixedvariable_mapping

    RULE:
      GF2_encoding MUST be declared
  }

  ALGEBRAIC_NORMAL_FORM_MODEL {
    abbreviation:
      ANF

    operators:
      XOR
      AND
      constants

    RULE:
      unique_forBoolean_function_underfixedvariables
  }

  CANONICAL_DNF_MODEL {
    formula:
      disjunction_ofminterms_forTRUE_rows

    RULE:
      uniqueuptoordering_underfixedatomset
  }

  CANONICAL_CNF_MODEL {
    formula:
      conjunction_ofmaxterms_forFALSE_rows

    RULE:
      uniqueuptoordering_underfixedatomset
  }

  MINIMISATION_MODEL {
    goal:
      findequivalent_formula_withlowercost

    cost:
      literals
      gates
      clauses
      depth
      other

    RULE:
      minimised != canonical_necessarily
  }

  QUINE_MCCLUSKEY_MODEL {
    method:
      Boolean_function_minimisation

    RULE:
      output_equivalence MUST be verified
  }

  KARNAUGH_MAP_MODEL {
    method:
      visualBoolean_simplification

    RULE:
      grouping_preservesequivalent_truth_function
  }

  CIRCUIT_EQUIVALENCE_MODEL {
    circuits:
      sameBoolean_outputs_forallinputs

    RULE:
      sharedinput_mapping MUST be explicit
  }

  COMBINATIONAL_EQUIVALENCE_MODEL {
    circuits:
      compareoutputs_underallinput_assignments

    RULE:
      statefulcircuits_requireseparate_sequential_equivalence
  }

  Miter_MODEL {
    construct:
      XOR_corresponding_outputs
      OR_differences

    equivalent_if:
      miter_UNSAT

    RULE:
      input_output_mapping MUST be preserved
  }

  MULTI_OUTPUT_EQUIVALENCE_MODEL {
    outputs:
      vectors_ofBoolean_functions

    equivalent_if:
      everycorresponding_output_equivalent
  }

  SEMANTIC_HASH_MODEL {
    possible_basis:
      canonical_truth_vector
      ROBDD
      ANF
      canonical_normal_form

    RULE:
      hash_method_atom_order_andlogic_version MUST be preserved
  }

  FORMULA_HASH_DISTINCTION_MODEL {
    syntactic_hash:
      hashesAST

    semantic_hash:
      hashescanonical_semantics

    RULE:
      syntactic_hash_difference_doesnotimplysemantic_nonequivalence
  }

  PROOF_MODEL {
    equivalence:
      maybederivedthroughsequence_ofequivalence_rules

    RULE:
      proof_steps MUST be traceable
  }

  EQUIVALENCE_PROOF_STEP_MODEL {
    fields:
      source_formula
      target_formula
      rule
      location
      side_conditions

    RULE:
      every_step MUST preserveequivalence
  }

  PROOF_BY_CHAIN_MODEL {
    A equivalent B
    B equivalent C
    therefore A equivalent C

    RULE:
      usestransitivity
  }

  PROOF_BY_MUTUAL_ENTAILMENT_MODEL {
    establish:
      A entails B
      B entails A

    conclude:
      A equivalent B
  }

  PROOF_BY_BICONDITIONAL_MODEL {
    establish:
      A IFF B_isvalid

    conclude:
      A equivalent B
  }

  PROOF_BY_TRUTH_TABLE_MODEL {
    establish:
      columns_equal_everyrow
  }

  PROOF_BY_NORMALISATION_MODEL {
    transform:
      A -> canonical_C
      B -> canonical_C

    conclude:
      equivalent

    RULE:
      canonicalisation_andtransformations MUST be valid
  }

  EQUIVALENCE_CHECKER_MODEL {
    input:
      formula_A
      formula_B

    methods:
      truth_table
      SAT
      BDD
      proof
      canonicalisation

    output:
      equivalent
      not_equivalent_withcounterexample
      unknown
  }

  UNKNOWN_STATUS_MODEL {
    possible:
      timeout
      resource_limit
      unsupported_logic
      unresolved_atom_mapping

    RULE:
      unknown != not_equivalent
  }

  APPROXIMATE_EQUIVALENCE_DISTINCTION_MODEL {
    approximate:
      formulas_agree_onmost_orselectedcases

    RULE:
      approximate_agreement != logical_equivalence
  }

  SAMPLED_EQUIVALENCE_DISTINCTION_MODEL {
    sampled:
      tested_onfinite_subset_ofvaluations

    RULE:
      sample_agreement_doesnotproveequivalence_unlesssampleisexhaustive
  }

  PROBABILISTIC_EQUIVALENCE_DISTINCTION_MODEL {
    formulas:
      sameprobability_underdistribution

    RULE:
      equalprobability != logical_equivalence
  }

  SYNTACTIC_SIMILARITY_DISTINCTION_MODEL {
    formulas:
      structurallysimilar

    RULE:
      similarity != equivalence
  }

  SEMANTIC_SIMILARITY_DISTINCTION_MODEL {
    formulas:
      meanings_related_ortruthvectors_close

    RULE:
      semantic_similarity != exactlogical_equivalence
  }

  NUMERICAL_EQUALITY_DISTINCTION_MODEL {
    values:
      x=y

    RULE:
      mathematical_equality != formula_equivalence_withoutmapping
  }

  SET_EQUALITY_MODEL {
    model_sets:
      Models(A)=Models(B)

    RULE:
      equivalent_toformula_equivalence_undercommonvaluationuniverse
  }

  MODEL_SET_MODEL {
    formula:
      set_ofsatisfyingvaluations

    equivalence:
      same_model_set
  }

  ONTOLOGY_EQUIVALENCE_DISTINCTION_MODEL {
    ontology_entities:
      equivalentClass
      sameAs
      mapping

    RULE:
      ontology_equivalence_relation != propositional_logical_equivalence_bydefault
  }

  DEFINITIONAL_EQUIVALENCE_DISTINCTION_MODEL {
    theories:
      maybedefinitionally_equivalent

    RULE:
      theory_level_definitional_equivalence != formula_equivalence
  }

  THEORY_EQUIVALENCE_DISTINCTION_MODEL {
    theories:
      sameconsequences_orintertranslatable

    RULE:
      theory_equivalence_requiresseparatecriteria
  }

  NATURAL_LANGUAGE_EQUIVALENCE_MODEL {
    cues:
      equivalent_to
      same_as
      exactly_when
      if_and_only_if
      means_the_same_as

    RULE:
      natural_language_equivalence MAY referidentity_similarity_definition_orlogicalequivalence
  }

  NATURAL_LANGUAGE_FORMALISATION_MODEL {
    source:
      equivalence_claim

    process:
      identifyleft_claim
      identifyright_claim
      classifyrelation_type
      constructIFF_iflogical

    RULE:
      relation_type MUST notbeassumedfromword_equivalent_alone
  }

  PARAPHRASE_DISTINCTION_MODEL {
    sentences:
      mayexpresssameproposition

    RULE:
      paraphrase_equivalence_islinguistic_semanticrelation_nottruth_functionalformula_equivalence_byidentity
  }

  DEFINITION
AL_LANGUAGE_DISTINCTION_MODEL {
    source:
      "X means Y"

    RULE:
      mayintroduce_definition_ratherthanassertbiconditional_theorem
  }

  CURRENT_TRUTH_DISTINCTION_MODEL {
    A_andB:
      bothTRUE_orbothFALSE_now

    RULE:
      currentagreement != equivalence_acrossallvaluations
  }

  CAUSAL_EQUIVALENCE_DISTINCTION_MODEL {
    systems:
      mayhaveequivalentcausal_effects

    RULE:
      causal_equivalence != logical_equivalence
  }

  BEHAVIOURAL_EQUIVALENCE_DISTINCTION_MODEL {
    systems:
      sameobservablebehaviour_undercriterion

    RULE:
      behavioural_equivalence != propositional_formula_equivalence_withoutencoding
  }

  INTUITIONISTIC_EQUIVALENCE_MODEL {
    common:
      A_andB_interderivable

    representation:
      (A -> B) AND (B -> A)

    RULE:
      implication_isintuitionistic
  }

  PARACONSISTENT_EQUIVALENCE_MODEL {
    semantics:
      logic_specific

    RULE:
      classical_truthvector_criterion MUST notbeassumed
  }

  MANY_VALUED_EQUIVALENCE_MODEL {
    formulas:
      same_truth_value_foreveryvaluation_underdeclaredmanyvaluedsemantics

    RULE:
      designatedness_equivalence MAY beweakerthanvalue_equality_andmustbedistinguished
  }

  FUZZY_EQUIVALENCE_MODEL {
    possible:
      equality_offuzzytruthfunctions
      graded_equivalence_operator

    RULE:
      exactrelation MUST be identified
  }

  MODAL_EQUIVALENCE_MODEL {
    formulas:
      equivalent_atallworlds_inallmodels_underdeclaredmodal logic

    RULE:
      worldrelative_agreement_inonemodel_isinsufficient
  }

  TEMPORAL_EQUIVALENCE_MODEL {
    formulas:
      equivalent_overalltraces_andtimes_underdeclaredtemporal logic

    RULE:
      temporal_semantics MUST be explicit
  }

  STRICT_EQUIVALENCE_MODEL {
    modal:
      necessarily(A IFF B)

    RULE:
      strict_equivalence != material_biconditional_truth_atoneworld
  }

  RELEVANCE_EQUIVALENCE_MODEL {
    logic:
      equivalence_basedonrelevance_implications

    RULE:
      system_specific
  }

  PROOF_THEORETIC_EQUIVALENCE_MODEL {
    formulas:
      mutuallyderivable_inproofsystem

    RULE:
      proof_theoretic_equivalence_andsemantic_equivalence_coincide_onlyunderappropriate_soundness_completeness_conditions
  }

  ALGEBRAIC_EQUIVALENCE_MODEL {
    formulas:
      sameelement_inLindenbaum_algebra_orquotient

    RULE:
      quotient_relation MUST be declared
  }

  LINDENBAUM_ALGEBRA_MODEL {
    elements:
      equivalence_classes_offormulas_underprovable_equivalence

    RULE:
      underlying_logic_andtheory MUST be identified
  }

  CONTEXTUAL_EQUIVALENCE_MODEL {
    relative_toGamma:
      Gamma entails A IFF B

    RULE:
      contextual_equivalence != unconditional_equivalence
  }

  THEORY_RELATIVE_EQUIVALENCE_MODEL {
    theory_T:
      T proves_orentails A IFF B

    RULE:
      background_theory MUST be preserved
  }

  ASSUMPTION_RELATIVE_MODEL {
    assumptions:
      maymakeotherwise_nonequivalentformulas_equivalent

    RULE:
      assumption_scope MUST be explicit
  }

  DOMAIN_RESTRICTION_MODEL {
    valuation_subset:
      formulas_agree_overrestricted_domain

    RULE:
      restricted_equivalence != global_equivalence
  }

  CARE_SET_EQUIVALENCE_MODEL {
    care_valuations:
      formulas_agree_onallcare_inputs

    RULE:
      don't-care valuations MUST be preserved
  }

  DONT_CARE_MODEL {
    valuations:
      excluded_fromequivalencecriterion

    RULE:
      equivalence_isrelative_tocare_set
  }

  REFINEMENT_MODEL {
    formula_A:
      stronger_thanB_ifA_entailsB

    RULE:
      refinement_orstrength_relation != equivalence_unlessmutual
  }

  STRONGER_WEAKER_MODEL {
    A_stronger_thanB:
      A entails B
      butnotnecessarilyB entails A

    RULE:
      strength != equivalence
  }

  REDUNDANCY_MODEL {
    subformula_orconstraint:
      redundant_ifremoval_preservesoverallformula_equivalence

    RULE:
      redundancy_requirescontextual_equivalence_test
  }

  CONSTRAINT_EQUIVALENCE_MODEL {
    constraint_sets:
      same_solution_set

    RULE:
      corresponds_toequivalence_ofconjoinedconstraints_undercommonvariables
  }

  SAT_PREPROCESSING_MODEL {
    transformations:
      variable_elimination
      subsumption
      clause_simplification

    RULE:
      somepreprocessing_preservessatisfiability_butnotfullmodelset
      andmustnotbemislabelled_equivalence
  }

  MODEL_PRESERVING_TRANSFORMATION_MODEL {
    transformation:
      preservesexact_satisfyingassignments_overoriginalvariables

    RULE:
      stronger_thanmereequisatisfiability
  }

  PROJECTION_EQUIVALENCE_MODEL {
    encodings:
      maypreserveprojected_models_overoriginalvariables

    RULE:
      projectioncriterion MUST be explicit
  }

  VARIABLE_RENAMING_MODEL {
    formula_A:
      equivalent_uptobijective_atomrenaming_toB

    RULE:
      renamed_equivalence != literal_same-variable_equivalence_withoutmapping
  }

  ALPHA_EQUIVALENCE_DISTINCTION_MODEL {
    bound_variable_formulas:
      differonlyinboundvariablenames

    RULE:
      alpha_equivalence_isprimarilypredicate_lambda_type_context_notbasicpropositional_equivalence
  }

  ATOM_PERMUTATION_MODEL {
    Boolean_functions:
      maymatchunderinputpermutation

    RULE:
      permutation_equivalence != equivalence_underfixedatomidentities
  }

  NEGATION_EQUIVALENCE_MODEL {
    functions:
      maymatchunderoutputnegation_orinputnegation

    RULE:
      NPN_equivalence != logical_equivalence
  }

  NPN_EQUIVALENCE_MODEL {
    Boolean_functions:
      equivalent_uptoinputNegation_Permutation_andoutputNegation

    RULE:
      NPN_classification_iscoarserthanlogical_equivalence
  }

  FORMULA_MINIMISATION_MODEL {
    input:
      formula

    output:
      lowercost_equivalent_formula

    RULE:
      equivalence MUST be verified_afterminimisation
  }

  OPTIMISATION_OBJECTIVE_MODEL {
    possible:
      literal_count
      connective_count
      depth
      gate_count
      clause_count

    RULE:
      optimisation_metric_doesnotchangeequivalencecriterion
  }

  EQUIVALENCE_DATABASE_MODEL {
    store:
      formula_identifier
      equivalence_class_identifier
      canonical_representative
      proof_orcertificate

    RULE:
      class_membership SHOULD be independentlyverifiable
  }

  EQUIVALENCE_CACHE_MODEL {
    key:
      semantic_hash_orcanonical_artifact

    RULE:
      cache_version MUST includelogic_andatom_mapping
  }

  DEPENDENCY_MODEL {
    equivalence_result:
      depends_on
        formula_versions
        logic_version
        atom_mapping
        proof_orcertificate
        checker

    RULE:
      dependency_revision SHOULD triggerrevalidation
  }

  VERSION_MODEL {
    versioned:
      formulas
      logic_system
      transformation_rules
      canonicalisation
      solver
      checker
      ontology

    RULE:
      equivalence_status_isversion_specific
  }

  REVISION_MODEL {
    formula_change:
      invalidates_orrequiresrechecking_equivalence_links

    RULE:
      historical_equivalence_records MUST be preserved
  }

  PROVENANCE_MODEL {
    fields:
      source_formulas
      atom_mapping
      method
      proof
      certificate
      solver
      checker
      version
      agent

    RULE:
      equivalence_record MUST remainprovenance_linked
  }

  EXPLAINABILITY_MODEL {
    output:
      formula_A
      formula_B
      atom_mapping
      equivalence_method
      proof_ortruthcomparison
      counterexample_ifnot_equivalent
      result

    RULE:
      explanation MUST distinguishglobal_equivalence_fromlocalagreement
  }

  AMBIGUITY_MODEL {
    possible:
      atom_mapping
      logic_system
      contextual_assumptions
      equivalence_type
      natural_language_relation
      equisatisfiable_vs_equivalent

    RULE:
      unresolved_ambiguity MUST be preserved
  }

  SEMANTIC_CONFIDENCE_MODEL {
    confidence:
      support_forformula_mapping_orinterpreted_equivalence_claim

    RULE:
      confidence != equivalence_status
  }

  ERROR_MODEL {
    possible:
      incomplete_truth_table
      mismatched_atom_mapping
      invalid_rewrite
      false_equivalence
      equisatisfiability_confusion
      unverified_canonicalisation

    RULE:
      error SHOULD identifyfailedcriterion
  }

  VALIDATION_MODEL {
    checks:
      formula_pair
      logic_system
      atom_mapping
      truth_function
      equivalence_method
      proof_orcertificate
      contextual_scope
      version
      provenance

    RULE:
      validation MUST useexact_semanticcriterion
  }

  INTEROPERABILITY_MODEL {
    exchange:
      equivalence_identifier
      left_formula_identifier
      right_formula_identifier
      atom_mapping
      logic_system
      equivalence_scope
      method
      witness_orcounterexample
      version

    RULE:
      relation_label_equivalent_withoutcriterion_isnotlossless
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      formula
      equivalence_relation
      equivalence_class
      proof
      truth_table
      BDD
      counterexample

    edges:
      EQUIVALENT_TO
      MEMBER_OF
      VERIFIED_BY
      COUNTEREXAMPLE_TO
      REWRITES_TO
      CANONICALISES_TO
      DEPENDS_ON

    RULE:
      exact_contextual_approximate_andother_equivalence_edges MUST be typed
  }

  RELATIONSHIPS {
    LogicalEquivalence -> RELATES -> FormulaA
    LogicalEquivalence -> RELATES -> FormulaB
    Formula -> MEMBER_OF -> EquivalenceClass
    EquivalenceClass -> HAS_REPRESENTATIVE -> FormulaOrCanonicalArtifact
    EquivalenceProof -> VERIFIES -> LogicalEquivalence
    Counterexample -> REFUTES -> LogicalEquivalenceClaim
    FormulaA -> MUTUALLY_ENTAILS -> FormulaB
    FormulaA -> MAY_REWRITE_TO -> FormulaB
  }

  SEMANTIC_EQUIVALENCE {
    "logical equivalence" ~= equality_oftruth_function_acrossallvaluations_underdeclaredlogic
    "equivalence class" ~= set_offormulas_related_bylogical_equivalence
    "equivalence counterexample" ~= valuation_wherecomparedformulas_receive_differenttruthvalues

    logical_equivalence != syntactic_identity
    logical_equivalence != one_way_implication
    logical_equivalence != same_truth_value_underonevaluation
    logical_equivalence != equisatisfiability
    logical_equivalence != semantic_similarity
    logical_equivalence != approximate_equivalence
    logical_equivalence != equal_probability
    logical_equivalence != ontology_identity
    logical_equivalence != causal_equivalence
    contextual_equivalence != unconditional_equivalence
    NPN_equivalence != logical_equivalence
    semantic_confidence != equivalence_status
  }

  CONSTRAINTS {
    equivalence_identifier_formula_versions_andlogic_system_must_be preserved = true
    atom_identity_mapping_must_be explicit = true
    classical_logical_equivalence_requires_same_truth_value_forallvaluations = true
    one_way_entailment_must_not_be interpreted_asequivalence = true
    singlevaluation_agreement_must_not_be interpreted_asequivalence = true
    equisatisfiability_andlogical_equivalence_must_be distinguished = true
    truth_table_equivalence_requirescompletevaluationcoverage = true
    SAT_equivalence_test_must_preservecounterexample_orUNSAT_certificate_whenavailable = true
    replacement_ofequivalents_must_useappropriate_extensional_context = true
    contextual_theory_relative_andcare_set_equivalence_must_preservescope = true
    approximate_similarity_NPN_andrenaming_relations_must_be separatelytyped = true
    nonclassical_equivalence_must_defineitscriterion = true
    provenance_must_be preserved = true
  }

  LOGICAL_EQUIVALENCE_RECORD_MODEL {
    RECORD:
      equivalence_identifier
      logic_system_identifier
      logic_version
      left_formula_identifier
      left_formula_version
      right_formula_identifier
      right_formula_version
      left_AST
      right_AST
      atom_mapping
      valuation_domain
      equivalence_scope
      background_theory
      assumptions
      truth_vector_left
      truth_vector_right
      biconditional_validity
      mutual_entailment_status
      XOR_SAT_status
      counterexample
      canonical_form_left
      canonical_form_right
      BDD_identifier_left
      BDD_identifier_right
      equivalence_method
      proof_identifier
      certificate_identifier
      checker_identifier
      verification_status
      ambiguity_status
      semantic_confidence
      version
      provenance

    RULE:
      logical_equivalence_record MUST support_independent_reconstruction_andverification_ofequivalence_orcounterexample
  }

  REASONING_RULES {
    IF equivalence_claim_received
      THEN identifylogic
      resolveformula_A_andformula_B
      resolveatom_mapping_andcontext

    IF classical_propositional_context
      THEN equivalence_maybeverified_bycomplete_truthvectors
      biconditional_validity
      mutual_entailment
      XOR_UNSAT
      canonical_BDD_orproof

    IF truth_table_method_used
      THEN requirecompletevaluationcoverage
      comparecolumns_foreveryrow

    IF SAT_method_used
      THEN constructA_XOR_B
      IF SAT
        THEN preserveassignment_ascounterexample
      IF UNSAT
        THEN preservecertificate_whenavailable

    IF rewrite_chain_used
      THEN validateeverystep_preservesequivalence

    IF contextual_assumptions_present
      THEN labelresult_contextual
      anddo_notpromote_to_unconditional_equivalence

    IF onlyequisatisfiability_established
      THEN preserveequisatisfiable_status
      anddo_notlabel_logically_equivalent

    IF sampled_orapproximateagreement_only
      THEN preserveapproximate_orunverified_status

    IF nonclassical_logic_selected
      THEN loadlogic_specific_equivalencecriterion

    IF formula_logic_solver_orchecker_version_changes
      THEN preservehistorical_record
      recursively_revalidate_current_equivalence_links
  }

  VALIDATION {
    CHECK equivalence_identifier
    CHECK logic_system
    CHECK logic_version
    CHECK left_formula
    CHECK right_formula
    CHECK formula_versions
    CHECK atom_mapping
    CHECK valuation_domain
    CHECK equivalence_scope
    CHECK background_theory
    CHECK assumptions
    CHECK truth_vectors
    CHECK biconditional_validity
    CHECK mutual_entailment
    CHECK XOR_SAT_status
    CHECK counterexample
    CHECK canonical_forms
    CHECK BDDs
    CHECK proof
    CHECK certificate
    CHECK checker
    CHECK equisatisfiability_distinction
    CHECK contextual_scope
    CHECK nonclassical_criterion
    CHECK ambiguity
    CHECK semantic_confidence
    CHECK version
    CHECK provenance
  }

  CONFIDENCE {
    formula_identity_confidence: 1.00
    atom_mapping_confidence: 1.00
    classical_equivalence_confidence: 1.00
    truth_table_verification_confidence: 1.00
    SAT_equivalence_confidence: 1.00
    proof_transformation_confidence: 1.00
    contextual_scope_confidence: 0.99
    natural_language_equivalence_confidence: 0.95
    nonclassical_equivalence_confidence: 0.98

    RULE:
      confidence decreases when logic, atom mapping, formula version,
      equivalence scope, proof/certificate, checker, natural-language relation,
      version orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_equivalence_claim:
      assign_equivalence_identifier
      attachformula_versions_logic_andatom_mapping
      selectverification_method
      preserveprovenance
      compute_FLOW_HASH

    ON verified_equivalence:
      attachproof_certificate_truthvector_orcanonicalartifact
      updateequivalence_class_membership
      preserveverification_status

    ON counterexample:
      preservevaluation
      markclaim_not_equivalent_underdeclaredscope
      retainmethod_andprovenance

    ON formula_orlogic_revision:
      preservehistorical_equivalence
      createcurrent_revalidation_record
      updateequivalence_classes_ifrequired

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: LogicalEquivalence
    canonical_role: SemanticFormulaRelation

    interpretation_order:
      identify_logic_system_andversion
      identify_left_andright_formulas
      resolveformula_versions_andASTs
      resolveatomic_variable_mapping
      determineglobal_contextual_theory_relative_orcare_set_scope
      chooseequivalence_verification_method
      comparetruthfunctions_orverifybiconditional
      evaluatebothdirections_ofentailment
      invokeXOR_SAT_test_whenappropriate
      preservecounterexample_orUNSAT_certificate
      resolvecanonical_forms_BDDs_orproofchain
      distinguishlogical_equivalence_fromequisatisfiability_andlocalagreement
      identifyequivalence_class_andcanonical_representative
      resolve_natural_language_equivalence_relation_type
      loadnonclassicalcriterion_whenrequired
      detectambiguity
      assignsemantic_confidence
      preserveversions_andprovenance
      emit_machine_resolvable_logical_equivalence_structure

    ambiguity_controls:
      distinguish_logical_equivalence_fromsyntactic_identity
      distinguish_logical_equivalence_fromone_way_implication
      distinguish_logical_equivalence_fromsame_truth_value_underonevaluation
      distinguish_logical_equivalence_fromequisatisfiability
      distinguish_logical_equivalence_fromsemantic_similarity
      distinguish_logical_equivalence_fromapproximate_equivalence
      distinguish_logical_equivalence_fromequal_probability
      distinguish_logical_equivalence_fromontology_identity
      distinguish_logical_equivalence_fromcausal_equivalence
      distinguish_contextual_equivalence_fromunconditional_equivalence
      distinguish_NPN_equivalence_fromlogical_equivalence
      distinguish_semantic_confidence_fromequivalence_status
      preserve_logic_formula_versions_atom_mapping_scope_method_certificate_counterexample_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      logical_equivalence_truth_function_identity_mutual
_entailment_rewriting_SAT_BDD_andAI_equivalence_reasoning

    parent_path:
      AI Core
      -> Ontologies
      -> Mathematical Ontologies
      -> Mathematical Logic Ontologies
      -> Propositional Logic
      -> Logical Equivalence Ontology

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      equivalence_identity_model
      formula_pair_model
      common_language_model
      classical_definition_model
      truth_function_model
      truth_table_model
      truth_vector_model
      semantic_signature_model
      biconditional_test_model
      XOR_test_model
      mutual_entailment_model
      mutual_implication_model
      one_way_implication_distinction_model
      same_value_distinction_model
      syntactic_identity_model
      syntactic_variation_model
      reflexivity_model
      symmetry_model
      transitivity_model
      equivalence_relation_model
      equivalence_class_model
      class_representative_model
      canonical_representative_model
      double_negation_model
      De_Morgan_model
      commutativity_model
      associativity_model
      distributivity_model
      idempotence_model
      absorption_model
      identity_model
      domination_model
      complement_model
      implication_elimination_model
      biconditional_elimination_model
      XOR_expansion_model
      contraposition_model
      exportation_model
      replacement_model
      replacement_theorem_model
      substitution_of_equivalents_model
      rewrite_model
      bidirectional_rewrite_model
      directed_simplification_model
      normalisation_model
      NNF_model
      CNF_model
      DNF_model
      Tseitin_distinction_model
      equisatisfiability_distinction_model
      SAT_equivalence_model
      SAT_certificate_model
      counterexample_model
      counterexample_minimisation_model
      BDD_model
      ROBDD_canonicality_model
      Boolean_algebra_model
      Boolean_polynomial_model
      algebraic_normal_form_model
      canonical_DNF_model
      canonical_CNF_model
      minimisation_model
      Quine_McCluskey_model
      Karnaugh_map_model
      circuit_equivalence_model
      combinational_equivalence_model
      miter_model
      multi_output_equivalence_model
      semantic_hash_model
      formula_hash_distinction_model
      proof_model
      equivalence_proof_step_model
      proof_by_chain_model
      proof_by_mutual_entailment_model
      proof_by_biconditional_model
      proof_by_truth_table_model
      proof_by_normalisation_model
      equivalence_checker_model
      unknown_status_model
      approximate_equivalence_distinction_model
      sampled_equivalence_distinction_model
      probabilistic_equivalence_distinction_model
      syntactic_similarity_distinction_model
      semantic_similarity_distinction_model
      numerical_equality_distinction_model
      set_equality_model
      model_set_model
      ontology_equivalence_distinction_model
      definitional_equivalence_distinction_model
      theory_equivalence_distinction_model
      natural_language_equivalence_model
      natural_language_formalisation_model
      paraphrase_distinction_model
      definitional_language_distinction_model
      current_truth_distinction_model
      causal_equivalence_distinction_model
      behavioural_equivalence_distinction_model
      intuitionistic_equivalence_model
      paraconsistent_equivalence_model
      many_valued_equivalence_model
      fuzzy_equivalence_model
      modal_equivalence_model
      temporal_equivalence_model
      strict_equivalence_model
      relevance_equivalence_model
      proof_theoretic_equivalence_model
      algebraic_equivalence_model
      Lindenbaum_algebra_model
      contextual_equivalence_model
      theory_relative_equivalence_model
      assumption_relative_model
      domain_restriction_model
      care_set_equivalence_model
      dont_care_model
      refinement_model
      stronger_weaker_model
      redundancy_model
      constraint_equivalence_model
      SAT_preprocessing_model
      model_preserving_transformation_model
      projection_equivalence_model
      variable_renaming_model
      alpha_equivalence_distinction_model
      atom_permutation_model
      negation_equivalence_model
      NPN_equivalence_model
      formula_minimisation_model
      optimisation_objective_model
      equivalence_database_model
      equivalence_cache_model
      dependency_model
      version_model
      revision_model
      provenance_model
      explainability_model
      ambiguity_model
      semantic_confidence_model
      error_model
      validation_model
      interoperability_model
      knowledge_graph_model
      relationships
      semantic_equivalence
      constraints
      logical_equivalence_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      equivalence_identity_formula_version_logic_oratom_mapping_changes
      truth_function_truth_vector_biconditional_orentailment_semantics_change
      rewrite_replacement_normalisation_orcanonical_form_changes
      SAT_XOR_certificate_BDD_ANF_orcircuit_equivalence_changes
      contextual_theory_relative_care_set_orassumption_scope_changes
      equisatisfiability_approximate_NPN_orrenaming_relation_semantics_change
      nonclassical_intuitionistic_paraconsistent_manyvalued_modal_ortemporal_equivalence_changes
      equivalence_checker_solver_orproof_version_changes
      logical_equivalence_record_changes
      constraint_model_changes
      reasoning_rule_changes
      version_orprovenance_changes
  }

}

END FLOW