Propositional Logic Ontology

# Propositional Logic Ontology — Flow Algebra

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

FLOW PropositionalLogicOntology {

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

  PURPOSE:
    Represent propositional logic as a machine-interpretable ontology of atomic propositions, propositional variables, truth values, logical connectives, compound formulas, valuations, truth tables, satisfiability, validity, logical equivalence, semantic entailment, formal derivability and automated Boolean reasoning. The ontology provides AI systems with an explicit semantic structure for parsing, evaluating, transforming and comparing truth-functional formulas while preserving distinctions between formula syntax and semantic truth, atomic propositions and their natural-language meanings, implication and causation, satisfiability and validity, semantic equivalence and syntactic identity, entailment and derivability, and proof search versus verified logical consequence.

  ENTITY PropositionalLogic {
    TYPE: ClassicalTruthFunctionalLogic

    COMPONENTS:
      propositional_variables
      truth_values
      logical_connectives
      formulas
      valuations
      semantic_relations
      proof_relations

    PROPERTIES:
      supports_truth_evaluation
      supports_truth_tables
      supports_satisfiability
      supports_validity
      supports_equivalence
      supports_entailment
      supports_formal_derivation
      supports_SAT_reasoning
  }

  ENTITY Proposition {
    TYPE: TruthEvaluableContent

    RULE:
      proposition != sentence_token
  }

  ENTITY PropositionalVariable {
    TYPE: AtomicPropositionalSymbol

    FIELDS:
      identifier
      symbol
      optional_interpretation
  }

  ENTITY PropositionalFormula {
    TYPE: WellFormedTruthFunctionalExpression

    POSSIBLE:
      atomic
      negated
      conjunction
      disjunction
      implication
      biconditional
      compound
  }

  ENTITY Valuation {
    TYPE: TruthAssignment

    MAPPING:
      PropositionalVariable -> TruthValue
  }

  LOGIC_IDENTITY_MODEL {
    canonical_logic:
      classical_propositional_logic

    default_truth_domain:
      {TRUE,FALSE}

    RULE:
      nonclassical_extensions MUST be separatelydeclared
  }

  LANGUAGE_MODEL {
    vocabulary:
      propositional_variables
      truth_constants
      connectives
      parentheses

    RULE:
      formula MUST be parsed_underdeclared_language
  }

  ATOMIC_PROPOSITION_MODEL {
    atom:
      formula_withoutinternal_propositional_structure

    RULE:
      atomicity_isrelative_topropositional_abstraction
  }

  PROPOSITIONAL_VARIABLE_MODEL {
    examples:
      p
      q
      r
      p_1
      p_2

    RULE:
      symbol_identity SHOULD be separated_fromhuman_readable_label
  }

  ATOM_INTERPRETATION_MODEL {
    atom:
      may_correspond_tonatural_language_claim_orformal condition

    RULE:
      propositional_semantics treats_atom_asindivisible_truth_bearer
  }

  TRUTH_VALUE_MODEL {
    TRUE:
      1

    FALSE:
      0

    RULE:
      numeric_encoding_isrepresentation_nottruth_definition
  }

  TRUTH_CONSTANT_MODEL {
    top:
      TRUE

    bottom:
      FALSE

    RULE:
      truth_constant != ordinary_propositional_variable
  }

  FORMULA_MODEL {
    recursive_definition:
      atom_isformula
      NOT_formula_isformula
      binary_connective_of_formulas_isformula

    RULE:
      recursive_structure MUST be preserved
  }

  WELL_FORMED_FORMULA_MODEL {
    abbreviation:
      WFF

    requirement:
      conforms_togrammar

    RULE:
      WFF_status != truth_status
  }

  TOKEN_MODEL {
    possible:
      atom
      connective
      truth_constant
      left_parenthesis
      right_parenthesis
  }

  TOKENISATION_MODEL {
    source:
-
      expression_string

    output:
      ordered_tokens

    RULE:
      operator_aliases MUST be resolved_beforesemantic_reasoning
  }

  PARSER_MODEL {
    input:
      token_sequence

    output:
      abstract_syntax_tree

    RULE:
      parser MUST respectparentheses_precedence_andassociativity
  }

  ABSTRACT_SYNTAX_TREE_MODEL {
    leaves:
      atoms_ortruth_constants

    internal_nodes:
      logical_connectives

    RULE:
      AST != valuation
  }

  PRECEDENCE_MODEL {
    representative_order:
      NOT
      AND
      OR
      IMPLIES
      IFF

    RULE:
      declared_notation_profile_overrides_default
  }

  PARENTHESIS_MODEL {
    role:
      explicit_grouping

    RULE:
      explicit_parentheses determine_scope
  }

  CONNECTIVE_MODEL {
    possible:
      NOT
      AND
      OR
      XOR
      IMPLIES
      IFF
      NAND
      NOR

    RULE:
      each_connective MUST havearity_andtruth_function
  }

  NEGATION_MODEL {
    arity:
      1

    formula:
      NOT A

    table:
      NOT TRUE = FALSE
      NOT FALSE = TRUE
  }

  CONJUNCTION_MODEL {
    arity:
      2

    formula:
      A AND B

    table:
      TRUE AND TRUE = TRUE
      otherwise = FALSE
  }

  DISJUNCTION_MODEL {
    arity:
      2

    formula:
      A OR B

    classical:
      inclusive_OR

    table:
      FALSE OR FALSE = FALSE
      otherwise = TRUE
  }

  XOR_MODEL {
    arity:
      2

    formula:
      A XOR B

    true_when:
      operands_have_different_truth_values
  }

  IMPLICATION_MODEL {
    arity:
      2

    formula:
      A -> B

    false_when:
      A=TRUE
      B=FALSE

    equivalence:
      NOT A OR B

    RULE:
      material_implication != causation
  }

  BICONDITIONAL_MODEL {
    arity:
      2

    formula:
      A <-> B

    true_when:
      operands_have_same_truth_value
  }

  NAND_MODEL {
    definition:
      NOT(A AND B)

    RULE:
      functionally_complete_connective
  }

  NOR_MODEL {
    definition:
      NOT(A OR B)

    RULE:
      functionally_complete_connective
  }

  CONNECTIVE_TRUTH_FUNCTION_MODEL {
    connective:
      maps_truth_tuple_to_truth_value

    RULE:
      truth_function MUST be deterministic_underclassical_semantics
  }

  VALUATION_MODEL {
    v:
      atoms -> {TRUE,FALSE}

    RULE:
      valuation_onatoms_uniquely_extends_toallformulas_undertruth_functional_semantics
  }

  COMPLETE_VALUATION_MODEL {
    valuation:
      assigns_every_atom_informula

    RULE:
      supports_determinate_formula_evaluation
  }

  PARTIAL_VALUATION_MODEL {
    valuation:
      assigns_subset_ofatoms

    RULE:
      formula_value MAY remainundetermined
  }

  EVALUATION_MODEL {
    input:
      formula_AST
      valuation

    process:
      recursively_evaluate_subformulas

    output:
      TRUE_orFALSE
  }

  SUBFORMULA_MODEL {
    formula:
      contains_recursive_constituent_formulas

    RULE:
      subformula_relation SHOULD be derived_fromAST
  }

  TRUTH_TABLE_MODEL {
    formula_with_n_atoms:
      rows = 2^n

    output:
      formula_value_foreachvaluation

    RULE:
      valuation_order MUST be stable_forcomparison
  }

  TRUTH_VECTOR_MODEL {
    formula:
      ordered_truth_values_overcanonical_valuation_order

    RULE:
      same_truth_vector_under_same_atom_mapping implies_semantic_equivalence
  }

  MODEL_MODEL {
    valuation:
      model_ofA_ifv(A)=TRUE

    RULE:
      propositional_model != first_order_structure
  }

  COUNTERMODEL_MODEL {
    valuation:
      v(A)=FALSE

    role:
      refutes_validity_ofA

    RULE:
      countermodel SHOULD be retained_aswitness
  }

  SATISFIABILITY_MODEL {
    A:
      satisfiable_ifexists_v:
        v(A)=TRUE

    RULE:
      satisfiable != valid
  }

  UNSATISFIABILITY_MODEL {
    A:
      unsatisfiable_ifforall_v:
        v(A)=FALSE

    RULE:
      unsatisfiable == contradiction_underclassical_propositional_semantics
  }

  VALIDITY_MODEL {
    A:
      valid_ifforall_v:
        v(A)=TRUE

    RULE:
      validity == tautology_underclassical_propositional_semantics
  }

  FALSIFIABILITY_MODEL {
    A:
      falsifiable_ifexists_v:
        v(A)=FALSE

    RULE:
      falsifiable != unsatisfiable
  }

  TAUTOLOGY_MODEL {
    formula:
      TRUE_underallvaluations
  }

  CONTRADICTION_MODEL {
    formula:
      FALSE_underallvaluations
  }

  CONTINGENCY_MODEL {
    formula:
      TRUE_undersomevaluations
      FALSE_underothers
  }

  SEMANTIC_EQUIVALENCE_MODEL {
    A equivalent B:
      forall_v:
        v(A)=v(B)

    RULE:
      semantic_equivalence != syntactic_identity
  }

  SYNTACTIC_IDENTITY_MODEL {
    A:
      same_resolved_AST_asB

    RULE:
      syntactic_identity_isrepresentation_relation
  }

  EQUIVALENCE_CLASS_MODEL {
    formulas:
      partitioned_bytruth_function

    RULE:
      formulas_indifferent_syntactic_forms MAY belong_sameclass
  }

  DOUBLE_NEGATION_MODEL {
    NOT NOT A
      equivalent_to
      A
  }

  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_to B AND A
    A OR B equivalent_to B OR A
  }

  ASSOCIATIVITY_MODEL {
    (A AND B) AND C equivalent_to A AND (B AND C)
    (A OR B) OR C equivalent_to 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_to A
    A OR A equivalent_to A
  }

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

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

  IDENTITY_LAW_MODEL {
    A AND TRUE equivalent_to A
    A OR FALSE equivalent_to A
  }

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

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

  BICONDITIONAL_ELIMINATION_MODEL {
    A <-> B
      equivalent_to
      (A -> B) AND (B -> A)
  }

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

  NORMAL_FORM_MODEL {
    possible:
      NNF
      CNF
      DNF

    RULE:
      target_normal_form MUST be identified
  }

  NNF_MODEL {
    full_name:
      Negation_Normal_Form

    condition:
      negation_occurs_onlyonatoms
  }

  CNF_MODEL {
    full_name:
      Conjunctive_Normal_Form

    structure:
      conjunction_ofclauses
  }

  DNF_MODEL {
    full_name:
      Disjunctive_Normal_Form

    structure:
      disjunction_ofconjunctions_ofliterals
  }

  LITERAL_MODEL {
    possible:
      atom
      negated_atom
  }

  CLAUSE_MODEL {
    structure:
      disjunction_ofliterals
  }

  MINTERM_MODEL {
    conjunction:
      each_atom_occurs_once_positive_ornegative

    role:
      represents_singlevaluation
  }

  MAXTERM_MODEL {
    disjunction:
      each_atom_occurs_once_positive_ornegative

    role:
      represents_singlefalse_row_undercanonical_convention
  }

  CANONICAL_DNF_MODEL {
    construction:
      disjoin_minterms_forTRUE_rows
  }

  CANONICAL_CNF_MODEL {
    construction:
      conjoin_maxterms_forFALSE_rows
  }

  NORMALISATION_MODEL {
    source:
      arbitrary_formula

    target:
      selected_normal_form

    RULE:
      transformation_steps MUST be provenance_linked
  }

  TSEITIN_MODEL {
    source:
      formula

    target:
      CNF_withfresh_auxiliary_atoms

    property:
      equisatisfiable

    RULE:
      equisatisfiable != fully_semantically_equivalent_overextended_atom_set
  }

  BOOLEAN_FUNCTION_MODEL {
    formula:
      denotes_function
        {TRUE,FALSE}^n -> {TRUE,FALSE}

    RULE:
      formula_syntax != Boolean_function_identity
  }

  FUNCTIONAL_COMPLETENESS_MODEL {
    connective_set:
      expresses_allBoolean_functions

    examples:
      {NOT,AND}
      {NOT,OR}
      {NAND}
      {NOR}

    RULE:
      functional_completeness != proof_system_completeness
  }

  SEMANTIC_ENTAILMENT_MODEL {
    Gamma entails A:
      everyvaluation_satisfying_Gamma_satisfiesA

    RULE:
      entailment_isrelation_betweenpremise_set_andconclusion
  }

  FINITE_ENTAILMENT_REDUCTION_MODEL {
    Gamma:
      A_1...A_n

    test:
      (A_1 AND ... AND A_n) -> B

    RULE:
      entailment_holds_ifconditional_isvalid
  }

  COUNTEREXAMPLE_MODEL {
    valuation:
      allpremises_TRUE
      conclusion_FALSE

    RULE:
      counterexample_refutes_entailment
  }

  ARGUMENT_MODEL {
    premises:
      Gamma

    conclusion:
      A

    valid:
      iff Gamma entails A
  }

  DERIVABILITY_MODEL {
    Gamma proves A:
      proof_exists_inidentified_proof_system

    RULE:
      derivability != entailment_bydefinition
  }

  PROOF_SYSTEM_MODEL {
    components:
      axioms_orassumptions
      inference_rules

    RULE:
      proof_system MUST be identified_for_derivability_claim
  }

  MODUS_PONENS_MODEL {
    premises:
      A
      A -> B

    conclusion:
      B
  }

  MODUS_TOLLENS_MODEL {
    premises:
      A -> B
      NOT B

    conclusion:
      NOT A
  }

  HYPOTHETICAL_SYLLOGISM_MODEL {
    premises:
      A -> B
      B -> C

    conclusion:
      A -> C
  }

  DISJUNCTIVE_SYLLOGISM_MODEL {
    premises:
      A OR B
      NOT A

    conclusion:
      B
  }

  CONJUNCTION_INFERENCE_MODEL {
    premises:
      A
      B

    conclusion:
      A AND B
  }

  SIMPLIFICATION_INFERENCE_MODEL {
    premise:
      A AND B

    conclusion:
      A
  }

  ADDITION_INFERENCE_MODEL {
    premise:
      A

    conclusion:
      A OR B
  }

  RESOLUTION_INFERENCE_MODEL {
    premises:
      A OR C
      NOT A OR D

    conclusion:
      C OR D
  }

  SOUNDNESS_MODEL {
    proof_system:
      derivability_implies_entailment
  }

  COMPLETENESS_MODEL {
    proof_system:
      entailment_implies_derivability

    RULE:
      exact_proof_system MUST be identified
  }

  CONSISTENCY_MODEL {
    premise_set:
      semantically_consistent_ifjointly_satisfiable

    RULE:
      syntactic_consistency_requiresproof_system_context
  }

  FALLACY_MODEL {
    possible:
      affirming_consequent
      denying_antecedent

    RULE:
      fallacy_isinvalid_argument_form
  }

  AFFIRMING_CONSEQUENT_MODEL {
    A -> B
    B
    therefore A

    status:
      invalid
  }

  DENYING_ANTECEDENT_MODEL {
    A -> B
    NOT A
    therefore NOT B

    status:
      invalid
  }

  SAT_MODEL {
    problem:
      determine_whetherformula_hassatisfyingvaluation

    RULE:
      satisfying_assignment SHOULD be retained
  }

  UNSAT_MODEL {
    problem:
      establish_no_satisfyingvaluation_exists

    RULE:
      certificate SHOULD be retained_whenavailable
  }

  CNF_SAT_MODEL {
    formula:
      conjunction_ofclauses

    RULE:
      clause_andliteral_structure MUST be preserved
  }

  UNIT_CLAUSE_MODEL {
    clause:
      exactly_one_literal
  }

  UNIT_PROPAGATION_MODEL {
    unit_clause:
      forces_literal_TRUE

    RULE:
      propagate_untilfixedpoint_orconflict
  }

  PURE_LITERAL_MODEL {
    atom:
      occurs_onlypositive_oronlynegative

    RULE:
      pure_literal_assignment_preserves_satisfiability
  }

  DPLL_MODEL {
    process:
      simplify
      unit_propagate
      choose_atom
      branch
      backtrack

    RULE:
      algorithmic_search != semantic_definition_ofSAT
  }

  CDCL_MODEL {
    process:
      decisions
      propagation
      conflict_analysis
      clause_learning
      backjumping

    RULE:
      learned_clause MUST be justified_asconsequence
  }

  RESOLUTION_MODEL {
    clauses:
      C OR p
      D OR NOT p

    resolvent:
      C OR D
  }

  EMPTY_CLAUSE_MODEL {
    representation:
      contradiction_inCNF

    RULE:
      resolution_derivation_ofempty_clause establishes_UNSAT_undercomplete_resolution_context
  }

  SAT_SOLVER_MODEL {
    input:
      propositional_formula

    output:
      SAT
      UNSAT
      UNKNOWN_whenapplicable

    metadata:
      solver
      version
      configuration

    RULE:
      UNKNOWN != UNSAT
  }

  SAT_CERTIFICATE_MODEL {
    SAT:
      satisfying_valuation

    UNSAT:
      proof
_orcertificate_whenavailable

    RULE:
      certificate_format_andchecker MUST be identified
  }

  MODEL_COUNTING_MODEL {
    problem:
      count_satisfying_valuations

    RULE:
      model_count != probability_withoutdistribution
  }

  TWO_SAT_MODEL {
    restriction:
      each_CNF_clause_hasatmosttwo_literals

    RULE:
      fragment_hasdifferent_algorithmic_complexity_fromgeneral_SAT
  }

  HORN_SAT_MODEL {
    restriction:
      each_clause_hasatmostone_positive_literal

    RULE:
      Horn_structure MUST be validated_beforeusingHorn_algorithm
  }

  MAX_SAT_MODEL {
    objective:
      maximise_satisfied_clauses_orweight

    RULE:
      optimisation_problem != SAT_decision_problem
  }

  BOOLEAN_ALGEBRA_MODEL {
    correspondence:
      TRUE -> 1
      FALSE -> 0
      AND -> Boolean_product_or meet
      OR -> Boolean_sum_or join
      NOT -> complement

    RULE:
      encoding_convention MUST be explicit
  }

  DIGITAL_LOGIC_MODEL {
    formula:
      may_be implemented_aslogic_circuit

    RULE:
      abstract_truth_value != physical_signal
  }

  CIRCUIT_MODEL {
    gates:
      Boolean_connectives

    RULE:
      circuit_representation MAY share_subexpressions_unlikeformula_tree
  }

  BDD_MODEL {
    full_name:
      Binary_Decision_Diagram

    role:
      graph_representation_ofBoolean_function

    RULE:
      variable_order MUST be preserved
  }

  ROBDD_MODEL {
    full_name:
      Reduced_Ordered_Binary_Decision_Diagram

    property:
      canonical_forfixed_variable_order

    RULE:
      canonicality_depends_onorder
  }

  PROBABILITY_DISTINCTION_MODEL {
    proposition:
      hastruth_value_under valuation

    probability:
      measure_overvaluations_or events

    RULE:
      probability != truth_value
  }

  FUZZY_LOGIC_DISTINCTION_MODEL {
    fuzzy:
      graded_truth_semantics

    classical_propositional:
      binary_truth

    RULE:
      fuzzy_degree MUST not_be silentlymapped_toBoolean_truth
  }

  INTUITIONISTIC_DISTINCTION_MODEL {
    intuitionistic_propositional_logic:
      proof_constructive_semantics

    RULE:
      classical_equivalences MAY notallhold
  }

  PARACONSISTENT_DISTINCTION_MODEL {
    paraconsistent_logic:
      mayreject_explosion

    RULE:
      classical_two_valued_rules MUST not_be assumed
  }

  NATURAL_LANGUAGE_FORMALISATION_MODEL {
    source:
      natural_language

    target:
      propositional_formula

    stages:
      identify_atomic_claims
      identify_negation
      identify_conjunction
      identify_disjunction
      identify_conditionals
      identify_biconditionals

    RULE:
      formalisation_isinterpretive
  }

  CONDITIONAL_LANGUAGE_MODEL {
    patterns:
      "if A then B" -> A -> B
      "A only if B" -> A -> B
      "A if B" -> B -> A
      "A iff B" -> A <-> B

    RULE:
      context_can_override_simple_pattern_mapping
  }

  NECESSARY_SUFFICIENT_MODEL {
    B_necessary_for_A:
      A -> B

    A_sufficient_for_B:
      A -> B

    RULE:
      necessary_and sufficient_direction MUST be preserved
  }

  OR_AMBIGUITY_MODEL {
    natural_language_OR:
      inclusive_or exclusive

    RULE:
      preserve_ambiguity_ifcontext_doesnotresolve
  }

  SCOPE_AMBIGUITY_MODEL {
    possible:
      NOT_scope
      connective_grouping

    RULE:
      preserve_candidate_ASTs
  }

  ATOMISATION_AMBIGUITY_MODEL {
    source_statement:
      may_be decomposed_intodifferent_atomic_claims

    RULE:
      candidate_atomisations SHOULD retainconfidence
  }

  FORMALISATION_CONFIDENCE_MODEL {
    confidence:
      support_forselected_propositional_structure

    RULE:
      confidence != truth_orvalidity
  }

  SIMPLIFICATION_MODEL {
    formula:
      transformed_toequivalent_smaller_orcanonical_formula

    RULE:
      every_rewrite MUST be justified
  }

  CONSTANT_PROPAGATION_MODEL {
    rules:
      A AND TRUE -> A
      A OR FALSE -> A
      A AND FALSE -> FALSE
      A OR TRUE -> TRUE
  }

  CLAUSE_SUBSUMPTION_MODEL {
    if:
      literals(C) subset literals(D)

    then:
      D_redundant_inCNF_containingC

    RULE:
      set_semantics_forclauses assumed
  }

  TAUTOLOGICAL_CLAUSE_MODEL {
    clause:
      contains_p_andNOT_p

    RULE:
      clause_alwaysTRUE_andmayberemoved_fromCNF
  }

  DUPLICATE_LITERAL_MODEL {
    clause:
      repeated_literal

    RULE:
      duplicates_canberemoved
  }

  SEMANTIC_HASH_MODEL {
    possible_basis:
      canonical_truth_vector
      ROBDD
      canonical_normal_form

    RULE:
      atom_order_andmethod MUST be preserved
  }

  FORMULA_COMPARISON_MODEL {
    compare:
      syntax
      truth_function
      satisfiability
      implication
      equivalence

    RULE:
      comparison_dimension MUST be explicit
  }

  FORMULA_COMPLEXITY_MODEL {
    possible:
      number_ofatoms
      connective_count
      depth
      clause_count

    RULE:
      complexity_measure MUST be identified
  }

  PROOF_MODEL {
    artifact:
      derivation_ofpropositional_formula

    RULE:
      proof_system_anddependencies MUST be preserved
  }

  PROOF_CERTIFICATE_MODEL {
    possible:
      truth_table
      derivation
      resolution_refutation
      SAT_certificate
      BDD_equivalence_certificate

    RULE:
      certificate_semantics MUST be explicit
  }

  PROOF_CHECKER_MODEL {
    input:
      formula_orclaim
      certificate

    output:
      verified
      rejected

    RULE:
      checker_version SHOULD be preserved
  }

  AUTOMATED_REASONING_MODEL {
    AI:
      parse
      evaluate
      classify
      simplify
      test_SAT
      test_validity
      test_entailment
      test_equivalence
      generateproof
      explain

    RULE:
      AI_generated_reasoning MUST distinguish_verified_result_fromheuristic_search
  }

  HEURISTIC_MODEL {
    role:
      choose_branching_atom_ortransformation

    RULE:
      heuristic_choice != inference_rule
  }

  UNKNOWN_STATUS_MODEL {
    possible:
      unknown
      timeout
      resource_limit
      ambiguous_parse

    RULE:
      unknown != FALSE
      unknown != invalid
      unknown != UNSAT
  }

  EXPLAINABILITY_MODEL {
    output:
      formula
      atoms
      AST
      valuation_ortruth_table
      countermodel_orSAT_assignment
      transformations
      proof_orcertificate
      result

    RULE:
      explanation MUST expose_reasoning_mode
  }

  VERSION_MODEL {
    versioned:
      ontology
      language
      notation
      proof_system
      solver
      transformation_rules

    RULE:
      result MUST preserveversions_used
  }

  PROVENANCE_MODEL {
    fields:
      source
      formalisation
      parser
      solver
      proof
      certificate
      version
      agent

    RULE:
      result MUST remain_provenance_linked
  }

  INTEROPERABILITY_MODEL {
    exchange:
      formula_identifier
      atom_identifiers
      AST
      truth_function
      valuation
      normal_form
      proof
      certificate
      status

    RULE:
      plain_text_formula_withoutnotation_andatom_mapping MAY beambiguous
  }

  KNOWLEDGE_GRAPH_MODEL {
    nodes:
      proposition
      atom
      formula
      connective
      valuation
      truth_table
      clause
      proof
      SAT_result

    edges:
      CONTAINS
      NEGATES
      EQUIVALENT_TO
      ENTAILS
      SATISFIED_BY
      REFUTED_BY
      DERIVED_FROM
      TRANSFORMS_TO
      VERIFIED_BY

    RULE:
      syntactic_semantic_andproof_edges MUST be distinguished
  }

  RELATIONSHIPS {
    PropositionalLogic -> HAS -> PropositionalVariable
    PropositionalLogic -> HAS -> Connective
    PropositionalFormula -> CONTAINS -> PropositionalVariable
    PropositionalFormula -> USES -> Connective
    Valuation -> ASSIGNS -> TruthValue
    Valuation -> SATISFIES -> PropositionalFormula
    Countermodel -> REFUTES -> ValidityClaim
    PropositionalFormula -> MAY_BE_EQUIVALENT_TO -> PropositionalFormula
    Proof -> DERIVES -> PropositionalFormula
    SATCertificate -> SUPPORTS -> SATResult
  }

  SEMANTIC_EQUIVALENCE {
    "propositional logic ontology" ~= machine_interpretable_model_ofclassical_truth_functional_propositional_logic
    "propositional variable" ~= atomic_symbol_assignedBoolean_truth_value
    "valuation" ~= mapping_frompropositional_atoms_toBoolean_truth_values

    proposition != sentence_token
    atom != internal_predicate_structure
    WFF_status != truth_status
    AST != valuation
    satisfiable != valid
    falsifiable != unsatisfiable
    semantic_equivalence != syntactic_identity
    material_implication != causation
    entailment != derivability_bydefinition
    functional_completeness != proof_system_completeness
    equisatisfiable != semantically_equivalent
    probability != truth_value
    heuristic_choice != inference_rule
  }

  CONSTRAINTS {
    classical_truth_domain_must_be explicit = true
    atom_identifiers_must_be stable = true
    formula_grammar_andAST_must_be preserved = true
    connective_arity_andtruth_functions_must_be explicit = true
    valuation_must_assignallrequired_atoms_forcomplete_evaluation = true
    satisfiability_validity_falsifiability_andunsatisfiability_must_be distinguished = true
    semantic_equivalence_and syntactic_identity_must_be distinguished = true
    implication_must_not_be interpreted_ascausation = true
    semantic_entailment_and syntactic_derivability_must_be distinguished = true
    normalisation_must_record_equivalence_orequisatisfiability = true
    SAT_assignments_countermodels_andcertificates_should_be preserved = true
    nonclassical_extensions_must_not_be silentlytreated_asclassical = true
    natural_language_formalisation_ambiguity_must_be preserved = true
    unknown_timeout_orresource_limit_must_not_be interpreted_asfalse_orUNSAT = true
    provenance_must_be preserved = true
  }

  PROPOSITIONAL_LOGIC_RECORD_MODEL {
    RECORD:
      propositional_logic_identifier
      formula_identifier
      language_identifier
      notation_profile
      source_expression
      formal_expression
      atom_identifiers
      atom_interpretations
      token_sequence
      syntax_tree
      connective_structure
      valuation
      truth_value
      truth_vector
      truth_table
      satisfiability_status
      validity_status
      falsifiability_status
      model
      countermodel
      semantic_equivalence_relations
      normal_form
      CNF
      DNF
      clauses
      premises
      conclusion
      entailment_status
      derivability_status
      proof_identifier
      proof_system
      proof_certificate
      SAT_solver
      SAT_status
      SAT_assignment
      formalisation_confidence
      ambiguity_status
      version
      provenance

    RULE:
      record MUST support_reconstruction_ofsyntax_truth_function_semantics_proof_andautomated_reasoning
  }

  REASONING_RULES {
    IF formula_received
      THEN identify_language_andnotation
      tokenise
      parse_AST
      identify_atoms_andconnectives
      validate_WFF

    IF valuation_received
      THEN ensure_required_atoms_assigned
      recursively_evaluate_formula

    IF satisfiability_requested
      THEN search_forTRUE_valuation
      preserve_witness_if_found
      preserve_UNSAT_certificate_whenavailable

    IF validity_requested
      THEN search_forFALSE_countermodel
      orprove_NOT_formula_UNSAT
      preserve_witness_orcertificate

    IF equivalence_requested
      THEN compare_truth_functions
      orprove_XOR_unsatisfiable
      underconsistent_atom_mapping

    IF entailment_requested
      THEN test_Gamma_AND_NOT_conclusion_forUNSAT
      preserve_counterexample_ifSAT

    IF normal_form_requested
      THEN transform_withvalidated_rules
      record_semantic_preservation_type

    IF natural_language_input_received
      THEN identify_candidate_atoms_andconnectives
      preserve_scope_OR_andconditional_ambiguity
      assign_formalisation_confidence

    IF solver_returns_unknown_timeout_orresource_limit
      THEN preserve_status
      anddo_notinferfalse_invalid_orUNSAT

    IF nonclassical_semantics_requested
      THEN route_toappropriate_logic_ontology
      rather_thanreuseclassical_truth_tables_withoutbasis
  }

  VALIDATION {
    CHECK propositional_logic_identifier
    CHECK formula_identifier
    CHECK language
    CHECK notation
    CHECK atom_identifiers
    CHECK tokenisation
    CHECK syntax_tree
    CHECK WFF_status
    CHECK connective_arity
    CHECK truth_functions
    CHECK valuation
    CHECK truth_value
    CHECK truth_vector
    CHECK truth_table
    CHECK satisfiability
    CHECK validity
    CHECK falsifiability
    CHECK model
    CHECK countermodel
    CHECK semantic_equivalence
    CHECK normal_form
    CHECK CNF_DNF
    CHECK clauses
    CHECK entailment
    CHECK derivability
    CHECK proof
    CHECK SAT_status
    CHECK SAT_assignment_orcertificate
    CHECK nonclassical_distinction
    CHECK formalisation_confidence
    CHECK ambiguity
    CHECK version
    CHECK provenance
  }

  CONFIDENCE {
    formula_parsing_confidence: 1.00
    truth_function_confidence: 1.00
    valuation_confidence: 1.00
    satisfiability_confidence: 1.00
    validity_confidence: 1.00
    equivalence_confidence: 1.00
    entailment_confidence: 1.00
    automated_SAT_confidence: 0.99
    natural_language_formalisation_confidence: 0.96

    RULE:
      confidence decreases when atom mapping, notation, parse,
      valuation, proof system, solver status, formalisation context,
      version orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_formula:
      assign_formula_identifier
      parse_andvalidate
      register_atoms_AST_andconnectives
      preserve_source
      compute_FLOW_HASH

    ON new_semantic_result:
      attach_valuation_truth_table_model_orcountermodel
      validate_result
      preserve_provenance

    ON new_transformation:
      preserve_source_formula
      record_rules
      validate_target
      record_equivalence_orequisatisfiability

    ON new_proof_orSAT_result:
      attach_proof_solver_assignment_orcertificate
      validate_status
      preserve_versions_andprovenance

    ON semantic_revision:
      preserve_previous_definition
      record_revision
      recompute_FLOW_HASH
  }

  AI_CONSUMPTION {
    canonical_entity: PropositionalLogic
    canonical_role: ClassicalTruthFunctionalLogic

    interpretation_order:
      identify_classical_propositional_context
      identify_language_andnotation
      identify_atomic_propositions
      construct_formula_AST
      resolve_connective_arity_andtruth_functions
      validate_well_formedness
      evaluate_underprovided_valuation
      construct_truth_table_whenrequired
      classify_tautology_contradiction_orcontingency
      determine_satisfiability_validity_orfalsifiability
      preserve_model_orcountermodel
      compare_semantic_equivalence
      transform_toNNF_CNF_orDNF_whenrequired
      distinguish_equivalence_fromequisatisfiability
      evaluate_semantic_entailment
      distinguish_entailment_fromderivability
      validate_proof_orinvokeSAT_reasoning
      preserve_assignment_certificate_orunknown_status
      detect_natural_language_formalisation_ambiguity
      assign_semantic_confidence
      preserve_versions_andprovenance
      emit_machine_resolvable_propositional_logic_structure

    ambiguity_controls:
      distinguish_proposition_fromsentence_token
      distinguish_atom_frominternal_predicate_structure
      distinguish_WFF_status_fromtruth_status
      distinguish_AST_fromvaluation
      distinguish_satisfiable_fromvalid
      distinguish_falsifiable_fromunsatisfiable
      distinguish_semantic_equivalence_fromsyntactic_identity
      distinguish_material_implication_fromcausation
      distinguish_entailment_fromderivability_bydefinition
      distinguish_functional_completeness_fromproof_system_completeness
      distinguish_equisatisfiable_fromsemantically_equivalent
      distinguish_probability_fromtruth_value
      distinguish_heuristic_choice_frominference_rule
      preserve_formula_atoms_AST_valuation_truth_table_proof_solver_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      propositional_logic_atoms_truth_functions_valuations_validity_equivalence_entailment_andSAT_reasoning

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

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      logic_identity_model
      language_model
      atomic_proposition_model
      propositional_variable_model
      atom_interpretation_model
      truth_value_model
      truth_constant_model
      formula_model
      well_formed_formula_model
      token_model
      tokenisation_model
      parser_model
      abstract_syntax_tree_model
      precedence_model
      parenthesis_model
      connective_model
      negation_model
      conjunction_model
      disjunction_model
      XOR_model
      implication_model
      biconditional_model
      NAND_model
      NOR_model
      connective_truth_function_model
      valuation_model
      complete_valuation_model
      partial_valuation_model
      evaluation_model
      subformula_model
      truth_table_model
      truth_vector_model
      model_model
      countermodel_model
      satisfiability_model
      unsatisfiability_model
      validity_model
      falsifiability_model
      tautology_model
      contradiction_model
      contingency_model
      semantic_equivalence_model
      syntactic_identity_model
      equivalence_class_model
      double_negation_model
      De_Morgan_model
      commutativity_model
      associativity_model
      distributivity_model
      idempotence_model
      absorption_model
      complement_model
      identity_law_model
      domination_model
      implication_elimination_model
      biconditional_elimination_model
      contraposition_model
      normal_form_model
      NNF_model
      CNF_model
      DNF_model
      literal_model
      clause_model
      minterm_model
      maxterm_model
      canonical_DNF_model
      canonical_CNF_model
      normalisation_model
      Tseitin_model
      Boolean_function_model
      functional_completeness_model
      semantic_entailment_model
      finite_entailment_reduction_model
      counterexample_model
      argument_model
      derivability_model
      proof_system_model
      modus_ponens_model
      modus_tollens_model
      hypothetical_syllogism_model
      disjunctive_syllogism_model
      conjunction_inference_model
      simplification_inference_model
      addition_inference_model
      resolution_inference_model
      soundness_model
      completeness_model
      consistency_model
      fallacy_model
      affirming_consequent_model
      denying_antecedent_model
      SAT_model
      UNSAT_model
      CNF_SAT_model
      unit_clause_model
      unit_propagation_model
      pure_literal_model
      DPLL_model
      CDCL_model
      resolution_model
      empty_clause_model
      SAT_solver_model
      SAT_certificate_model
      model_counting_model
      two_SAT_model
      Horn_SAT_model
      MAX_SAT_model
      Boolean_algebra_model
      digital_logic_model
      circuit_model
      BDD_model
      ROBDD_model
      probability_distinction_model
      fuzzy_logic_distinction_model
      intuitionistic_distinction_model
      paraconsistent_distinction_model
      natural_language_formalisation_model
      conditional_language_model
      necessary_sufficient_model
      OR_ambiguity_model
      scope_ambiguity_model
      atomisation_ambiguity_model
      formalisation_confidence_model
      simplification_model
      constant_propagation_model
      clause_subsumption_model
      tautological_clause_model
      duplicate_literal_model
      semantic_hash_model
      formula_comparison_model
      formula_complexity_model
      proof_model
      proof_certificate_model
      proof_checker_model
      automated_reasoning_model
      heuristic_model
      unknown_status_model
      explainability_model
      version_model
      provenance_model
      interoperability_model
      knowledge_graph_model
      relationships
      semantic_equivalence
      constraints
      propositional_logic_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      classical_propositional_logic_identity_changes
      language_atom_formula_orconnective_semantics_change
      valuation_truth_table_model_orcountermodel_changes
      satisfiability_validity_falsifiability_orequivalence_changes
      normal_form_Boolean_function_orTseitin_semantics_change
      entailment_derivability_proof_system_orinference_rule_changes
      SAT_DPLL_CDCL_resolution_orcertificate_changes
      Boolean_algebra_circuit_BDD_orfragment_semantics_change
      natural_language_formalisation_orambiguity_logic_changes
      proof_checker_automated_reasoning_orconfidence_changes
      propositional_logic_record_changes
      constraint_model_changes
      reasoning_rule_changes
      version_orprovenance_changes
  }

}

END FLOW