Logical Connective Ontology

# Logical Connective Ontology — Flow Algebra

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

FLOW LogicalConnectiveOntology {

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

  PURPOSE:
    Represent logical connectives as machine-interpretable operators that combine or transform propositions and formulas according to explicitly declared truth-functional or logic-specific semantics. In classical propositional logic the principal connectives are negation, conjunction, disjunction, implication and biconditional, with XOR, NAND and NOR as common derived or alternative operators. The ontology models connective identity, notation, arity, precedence, associativity, syntax-tree role, truth functions, truth tables, equivalence transformations, functional completeness, normal forms, proof rules, Boolean algebra mappings, circuit mappings, natural-language formalisation, non-classical variants, ambiguity, versioning and provenance. It prevents connective symbols from being confused with causal, probabilistic, temporal, programming or natural-language relations unless an explicit semantic mapping is declared.

  ENTITY LogicalConnective {
    TYPE: FormulaFormingLogicalOperator

    PROPERTIES:
      has_identifier
      has_name
      has_symbol
      has_arity
      has_truth_function
      has_precedence
      has_associativity
      belongs_to_logic_system
      may_have_aliases
      may_have_inference_rules
      may_have_equivalent_forms
      has_version
      has_provenance
  }

  ENTITY UnaryConnective {
    TYPE: LogicalConnective
    ARITY: 1
  }

  ENTITY BinaryConnective {
    TYPE: LogicalConnective
    ARITY: 2
  }

  ENTITY TruthFunction {
    TYPE: SemanticOperation

    MAPPING:
      TruthValueTuple -> TruthValue
  }

  CONNECTIVE_IDENTITY_MODEL {
    fields:
      connective_identifier
      canonical_name
      logic_system
      arity
      version

    RULE:
      connective_identity MUST notdepend_onglyphalone
  }

  LOGIC_CONTEXT_MODEL {
    default:
      classical_propositional_logic

    truth_domain:
      TRUE
      FALSE

    RULE:
      connective_semantics MUST be logic_specific
  }

  SYMBOL_MODEL {
    possible:
      ¬
      ∧
      ∨
      →
      ↔
      ⊕
      ↑
      ↓

    RULE:
      symbol != semantic_operator_withoutcontext
  }

  ALIAS_MODEL {
    examples:
      NOT
      AND
      OR
      XOR
      IMPLIES
      IFF
      NAND
      NOR

    RULE:
      alias_mapping MUST resolve_tocanonical_connective_identifier
  }

  ASCII_NOTATION_MODEL {
    examples:
      !A
      A && B
      A || B
      A -> B
      A <-> B

    RULE:
      ASCII_notation_islanguage_specific
  }

  UNICODE_NOTATION_MODEL {
    examples:
      ¬A
      A ∧ B
      A ∨ B
      A → B
      A ↔ B

    RULE:
      rendered_symbol MUST preservecanonical_identity
  }

  ARITY_MODEL {
    unary:
      negation

    binary:
      conjunction
      disjunction
      implication
      biconditional
      XOR
      NAND
      NOR

    RULE:
      wrong_operand_count MUST be rejected
  }

  OPERAND_MODEL {
    operand:
      well_formed_formula

    RULE:
      connective_application_requiresformula_operands
  }

  CONNECTIVE_APPLICATION_MODEL {
    unary:
      op(A)

    binary:
      op(A,B)

    output:
      formula
  }

  SYNTAX_TREE_MODEL {
    connective:
      internal_AST_node

    children:
      operands

    RULE:
      child_count MUST matcharity
  }

  PRECEDENCE_MODEL {
    common_classical_order:
      NOT
      AND
      OR
      IMPLIES
      IFF

    RULE:
      actual_precedence MUST followdeclared_notation_profile
  }

  ASSOCIATIVITY_MODEL {
    possible:
      left
      right
      associative
      nonassociative

    RULE:
      parse_ofoperator_chain MUST use declared_associativity
  }

  PARENTHESIS_MODEL {
    role:
      explicit_scope

    RULE:
      parentheses_override_precedence
  }

  SCOPE_MODEL {
    connective:
      applies_toidentified_operand_subtrees

    RULE:
      scope_ambiguity MUST be resolved_beforeevaluation
  }

  NEGATION_MODEL {
    identifier:
      NOT

    arity:
      1

    notation:
      ¬A

    truth_function:
      TRUE -> FALSE
      FALSE -> TRUE

    RULE:
      negation != absence_orunknown
  }

  CONJUNCTION_MODEL {
    identifier:
      AND

    arity:
      2

    notation:
      A ∧ B

    truth_function:
      TT -> TRUE
      TF -> FALSE
      FT -> FALSE
      FF -> FALSE
  }

  DISJUNCTION_MODEL {
    identifier:
      OR

    arity:
      2

    notation:
      A ∨ B

    classical_default:
      inclusive

    truth_function:
      TT -> TRUE
      TF -> TRUE
      FT -> TRUE
      FF -> FALSE
  }

  XOR_MODEL {
    identifier:
      XOR

    arity:
      2

    truth_function:
      TT -> FALSE
      TF -> TRUE
      FT -> TRUE
      FF -> FALSE

    RULE:
      XOR != inclusive_OR
  }

  IMPLICATION_MODEL {
    identifier:
      IMPLIES

    arity:
      2

    notation:
      A → B

    antecedent:
      A

    consequent:
      B

    truth_function:
      TT -> TRUE
      TF -> FALSE
      FT -> TRUE
      FF -> TRUE

    RULE:
      material_implication != causation
  }

  BICONDITIONAL_MODEL {
    identifier:
      IFF

    arity:
      2

    notation:
      A ↔ B

    truth_function:
      TT -> TRUE
      TF -> FALSE
      FT -> FALSE
      FF -> TRUE
  }

  NAND_MODEL {
    identifier:
      NAND

    definition:
      ¬(A ∧ B)

    truth_function:
      TT -> FALSE
      TF -> TRUE
      FT -> TRUE
      FF -> TRUE
  }

  NOR_MODEL {
    identifier:
      NOR

    definition:
      ¬(A ∨ B)

    truth_function:
      TT -> FALSE
      TF -> FALSE
      FT -> FALSE
      FF -> TRUE
  }

  TRUTH_FUNCTION_MODEL {
    connective:
      maps_input_truth_values_tooutput_truth_value

    RULE:
      classical_truth_function MUST be total_anddeterministic
  }

  TRUTH_TABLE_MODEL {
    unary_connective:
      2_rows

    binary_connective:
      4_rows

    RULE:
      table_size = 2^arity_underclassical_semantics
  }

  CONNECTIVE_TRUTH_VECTOR_MODEL {
    connective:
      ordered_output_values_overcanonical_input_order

    RULE:
      input_order_convention MUST be preserved
  }

  BOOLEAN_FUNCTION_MODEL {
    n_ary_connective:
      Boolean_function_from{0,1}^n_to{0,1}

    RULE:
      numeric_mapping_requiresBoolean_encoding
  }

  COMMUTATIVE_MODEL {
    possible:
      AND
      OR
      XOR
      IFF
      NAND
      NOR

    condition:
      op(A,B) equivalent op(B,A)

    RULE:
      commutativity MUST be verified_underdeclared semantics
  }

  NONCOMMUTATIVE_MODEL {
    example:
      IMPLIES

    RULE:
      operand_order_issemantically_material
  }

  ASSOCIATIVE_CONNECTIVE_MODEL {
    classical:
      AND
      OR
      XOR
      IFF

    RULE:
      associativity_claim MUST be logic_specific
  }

  IDEMPOTENT_MODEL {
    AND:
      A AND A equivalent A

    OR:
      A OR A equivalent A
  }

  NONIDEMPOTENT_MODEL {
    XOR:
      A XOR A equivalent FALSE
  }

  MONOTONE_CONNECTIVE_MODEL {
    classical_truth_order:
      FALSE <= TRUE

    examples:
      AND
      OR

    RULE:
      monotonicity_requiresdeclared_order
  }

  ANTITONE_MODEL {
    negation:
      reverses_classical_truth_order
  }

  FUNCTIONAL_COMPLETENESS_MODEL {
    connective_set:
      canexpress_everyBoolean_function

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

    RULE:
      functional_completeness != proof_system_completeness
  }

  SHEFFER_STROKE_MODEL {
    notation:
      A | B_or A ↑ B

    semantics:
      NAND

    RULE:
      symbol "|" isambiguous_acrosslanguages
  }

  PEIRCE_ARROW_MODEL {
    notation:
      A ↓ B

    semantics:
      NOR
  }

  DERIVED_CONNECTIVE_MODEL {
    connective:
      definable_usingotherconnectives

    RULE:
      primitive_vsderived_status depends_onlanguage_basis
  }

  PRIMITIVE_CONNECTIVE_MODEL {
    connective:
      included_informal_language_vocabulary

    RULE:
      primitive_status != semantic_indefinability
  }

  CONNECTIVE_BASIS_MODEL {
    basis:
      selected_primitive_connectives

    RULE:
      same_logic MAY use differentfunctionallycomplete_bases
  }

  NEGATION_ELIMINATION_EQUIVALENCE_MODEL {
    double_negation:
      ¬¬A equivalent A

    RULE:
      classical_context_assumed
  }

  DE_MORGAN_MODEL {
    ¬(A ∧ B)
      equivalent
      ¬A ∨ ¬B

    ¬(A ∨ B)
      equivalent
      ¬A ∧ ¬B
  }

  IMPLICATION_ELIMINATION_MODEL {
    A → B
      equivalent
      ¬A ∨ B
  }

  BICONDITIONAL_ELIMINATION_MODEL {
    A ↔ B
      equivalent
      (A → B) ∧ (B → A)
  }

  XOR_EXPANSION_MODEL {
    A XOR B
      equivalent
      (A ∨ B) ∧ ¬(A ∧ B)

    alternative:
      (A ∧ ¬B) ∨ (¬A ∧ B)
  }

  NAND_EXPANSION_MODEL {
    A NAND B
      equivalent
      ¬(A ∧ B)
  }

  NOR_EXPANSION_MODEL {
    A NOR B
      equivalent
      ¬(A ∨ B)
  }

  CONTRAPOSITION_MODEL {
    A → B
      equivalent
      ¬B → ¬A

    RULE:
      classical_equivalence
  }

  DISTRIBUTIVITY_MODEL {
    A ∧ (B ∨ C)
      equivalent
      (A ∧ B) ∨ (A ∧ C)

    A ∨ (B ∧ C)
      equivalent
      (A ∨ B) ∧ (A ∨ C)
  }

  ABSORPTION_MODEL {
    A ∨ (A ∧ B) equivalent A
    A ∧ (A ∨ B) equivalent A
  }

  COMPLEMENT_MODEL {
    A ∨ ¬A equivalent TRUE
    A ∧ ¬A equivalent FALSE
  }

  IDENTITY_MODEL {
    A ∧ TRUE equivalent A
    A ∨ FALSE equivalent A
  }

  DOMINATION_MODEL {
    A ∧ FALSE equivalent FALSE
    A ∨ TRUE equivalent TRUE
  }

  NORMAL_FORM_MODEL {
    connectives:
      transformed_to restricted_basis

    possible:
      NNF
      CNF
      DNF

    RULE:
      transformation_steps MUST preservedeclared semantics
  }

  NNF_CONNECTIVE_MODEL {
    allowed:
      AND
      OR
      NOT_onlyonatoms
  }

  CNF_CONNECTIVE_MODEL {
    top_level:
      AND

    clauses:
      OR_ofliterals
  }

  DNF_CONNECTIVE_MODEL {
    top_level:
      OR

    terms:
      AND_ofliterals
  }

  CONNECTIVE_ELIMINATION_MODEL {
    purpose:
      replaceconnective_withdefinition_usingbasis

    RULE:
      source_connective_semantics MUST be equivalent_toexpansion
  }

  REWRITE_RULE_MODEL {
    source_pattern:
      formula_usingconnective

    target_pattern:
      equivalent_formula

    RULE:
      rewrite_provenance MUST identifyrule
  }

  SEMANTIC_EQUIVALENCE_MODEL {
    connective_expressions:
      equivalent_ifsame_truth_function

    RULE:
      same_symbol != same_semantics_acrosslogics
  }

  CONNECTIVE_EQUIVALENCE_CLASS_MODEL {
    members:
      syntacticallydifferent_operators_orformula_patterns

    criterion:
      identical_truth_function
  }

  DUALITY_MODEL {
    AND_dual:
      OR

    TRUE_dual:
      FALSE

    RULE:
      duality_mapping MUST be explicit
  }

  BOOLEAN_ALGEBRA_MODEL {
    AND:
      meet

    OR:
      join

    NOT:
      complement

    RULE:
      Boolean_algebra_mapping assumesclassical semantics
  }

  SET_THEORETIC_MODEL {
    undercharacteristic_mapping:
      AND -> intersection
      OR -> union
      NOT -> complement

    RULE:
      universe_ofdiscourse REQUIRED
  }

  CIRCUIT_GATE_MODEL {
    mapping:
      NOT -> inverter
      AND -> AND_gate
      OR -> OR_gate
      XOR -> XOR_gate
      NAND -> NAND_gate
      NOR -> NOR_gate

    RULE:
      physical_gate != logical_connective_entity
  }

  MULTI_INPUT_CONNECTIVE_MODEL {
    extension:
      AND_n
      OR_n
      XOR_n

    RULE:
      n_ary_semantics MUST be explicitlydefined
  }

  FOLD_MODEL {
    associative_connective:
      mayfold_sequence_ofoperands

    RULE:
      identity_element_required_forzero_operand_fold
  }

  ZERO_ARITY_CONNECTIVE_MODEL {
    possible:
      truth_constants

    RULE:
      truth_constants MAY be treated_asnullaryconnectives_underdeclared formalism
  }

  PROOF_RULE_LINK_MODEL {
    connective:
      mayhaveintroduction_andelimination_rules

    RULE:
      proof_rules != truth_function_definition
  }

  NEGATION_INTRODUCTION_MODEL {
    natural_deduction:
      derivecontradiction_fromA
      inferNOT_A

    RULE:
      exact_rule depends_onlogic
  }

  NEGATION_ELIMINATION_MODEL {
    possible:
      A
      NOT_A
      deriveFALSE

    RULE:
      double_negation_elimination_isseparate_rule
  }

  CONJUNCTION_INTRODUCTION_MODEL {
    A
    B
    therefore A AND B
  }

  CONJUNCTION_ELIMINATION_MODEL {
    A AND B
    therefore A

    or:
      therefore B
  }

  DISJUNCTION_INTRODUCTION_MODEL {
    A
    therefore A OR B
  }

  DISJUNCTION_ELIMINATION_MODEL {
    A OR B
    A -> C
    B -> C
    therefore C

    RULE:
      formal natural_deduction_rule_tracks_assumptions
  }

  IMPLICATION_INTRODUCTION_MODEL {
    assume_A
    derive_B
    discharge_A
    infer_A -> B
  }

  IMPLICATION_ELIMINATION_MODEL {
    A
    A -> B
    therefore B
  }

  BICONDITIONAL_INTRODUCTION_MODEL {
    A -> B
    B -> A
    therefore A <-> B
  }

  BICONDITIONAL_ELIMINATION_MODEL {
    A <-> B
    therefore A -> B
    and B -> A
  }

  SEQUENT_RULE_MODEL {
    connective:
      mayhaveleft_andright_rules

    RULE:
      exact_calculus MUST be identified
  }

  CLASSICAL_CONNECTIVE_MODEL {
    semantics:
      two_valued_truth_functional

    RULE:
      classical_rules MUST not_be assumed_innonclassical_logic
  }

  INTUITIONISTIC_CONNECTIVE_MODEL {
    semantics:
      proof_theoretic_orKripke

    RULE:
      implication_andnegation_notreducible_toclassical_truth_functions_inthesameway
  }

  PARACONSISTENT_CONNECTIVE_MODEL {
    semantics:
      contradiction_tolerant

    RULE:
      explosion_related_inferences MAY fail
  }

  MANY_VALUED_CONNECTIVE_MODEL {
    truth_domain:
      more_than_two_values

    RULE:
      connective_table_oroperation MUST be separatelydefined
  }

  FUZZY_CONNECTIVE_MODEL {
    operators:
      t_norm
      t_conorm
      negator
      implication_operator

    RULE:
      fuzzy_AND_OR_NOT MAY differ_fromBoolean_functions
  }

  MODAL_OPERATOR_DISTINCTION_MODEL {
    operators:
      necessity
      possibility

    RULE:
      modal_operators_arelogical_operators_butnotordinary_truth_functional_connectives
  }

  TEMPORAL_OPERATOR_DISTINCTION_MODEL {
    operators:
      always
      eventually
      next
      until

    RULE:
      temporal_operators_depend_ontrace_orstate_semantics
  }

  QUANTIFIER_DISTINCTION_MODEL {
    quantifiers:
      forall
      exists

    RULE:
      quantifier != propositional_connective
  }

  EQUALITY_DISTINCTION_MODEL {
    equality:
      relation_orlogical_symbol

    RULE:
      equality != connective
  }

  PROGRAMMING_OPERATOR_DISTINCTION_MODEL {
    examples:
      &&
      ||
      !
      bitwise_operators

    RULE:
      programming_operator_semantics MAY differ_due_toevaluation_order_types_orshort_circuiting
  }

  SHORT_CIRCUIT_MODEL {
    programming:
      second_operand_maynotbeevaluated

    RULE:
      short_circuit_evaluation_strategy != classical_truth_function
  }

  BITWISE_OPERATOR_DISTINCTION_MODEL {
    bitwise_AND_OR_XOR:
      operate_onbit_vectors

    RULE:
      bitwise_operation != propositional_connective_withoutBoolean_mapping
  }

  PROBABILISTIC_CONNECTIVE_DISTINCTION_MODEL {
    probability_combination:
      requiresdependence_model

    RULE:
      P(A AND B) != logical_AND_truth_function
  }

  CAUSAL_CONNECTIVE_DISTINCTION_MODEL {
    causal_relation:
      intervention_orcausal_dependency

    RULE:
      implication_symbol MUST not_be interpreted
ascausal_relation_withoutmodel
  }

  NATURAL_LANGUAGE_CONNECTIVE_MODEL {
    source:
      natural_language

    possible_mappings:
      not -> NOT
      and -> AND
      or -> OR_orXOR
      if_then -> IMPLIES
      iff -> IFF

    RULE:
      mapping_isinterpretive
  }

  NATURAL_LANGUAGE_NEGATION_MODEL {
    cues:
      not
      no
      never
      it_is_not_the_case

    RULE:
      scope MUST be resolved
  }

  NATURAL_LANGUAGE_AND_MODEL {
    cues:
      and
      both
      as_well_as

    RULE:
      discourse_use MAY notalwaysencodeBoolean_conjunction
  }

  NATURAL_LANGUAGE_OR_MODEL {
    cues:
      or
      either

    ambiguity:
      inclusive
      exclusive

    RULE:
      preserveambiguity_whencontext_insufficient
  }

  NATURAL_LANGUAGE_CONDITIONAL_MODEL {
    patterns:
      if_A_then_B
      A_only_if_B
      A_if_B
      A_unless_B

    RULE:
      direction_andpragmatic_force MUST be resolved
  }

  ONLY_IF_MODEL {
    phrase:
      A_only_if_B

    formal:
      A -> B
  }

  IF_MODEL {
    phrase:
      A_if_B

    formal:
      B -> A
  }

  NECESSARY_CONDITION_MODEL {
    B_necessary_for_A:
      A -> B
  }

  SUFFICIENT_CONDITION_MODEL {
    A_sufficient_for_B:
      A -> B
  }

  UNLESS_MODEL {
    common_classical_reading:
      NOT_B -> A
      equivalent_to
      B OR A

    RULE:
      linguistic_context MAY alterformalisation
  }

  BICONDITIONAL_LANGUAGE_MODEL {
    cues:
      if_and_only_if
      exactly_when
      necessary_and_sufficient

    RULE:
      verifybothdirections
  }

  CONNECTIVE_SCOPE_AMBIGUITY_MODEL {
    source:
      A AND B OR C

    candidates:
      (A AND B) OR C
      A AND (B OR C)

    RULE:
      useparentheses_orprecedence_profile
  }

  NEGATION_SCOPE_AMBIGUITY_MODEL {
    source:
      NOT A AND B

    RULE:
      parse_usingdeclaredsyntax_notintuition
  }

  IMPLICATION_SCOPE_AMBIGUITY_MODEL {
    source:
      A -> B -> C

    RULE:
      associativity MUST be explicit
  }

  SYMBOL_OVERLOAD_MODEL {
    examples:
      |
      &
      +
      *

    RULE:
      resolveusinglanguage_andoperator_declaration
  }

  CONNECTIVE_FORMALISATION_CONFIDENCE_MODEL {
    confidence:
      support_forchosen_connective_mapping

    RULE:
      confidence != truth
  }

  SAT_MODEL {
    connectives:
      formulas_oftenreduced_toNOT_AND_OR_orCNF

    RULE:
      transformation_semantics MUST be preserved
  }

  CLAUSIFICATION_MODEL {
    process:
      eliminate_IFF
      eliminate_IMPLICATION
      push_NEGATION
      distribute_orTseitin_encode

    RULE:
      distinguish_equivalent_fromequisatisfiable_transformations
  }

  RESOLUTION_LINK_MODEL {
    clauses:
      useOR_betweenliterals
      conjunction_betweenclauses

    RULE:
      resolution_operates_onclausal_structure
  }

  TSEITIN_MODEL {
    auxiliary_variable:
      represents_subformula_withconnective

    RULE:
      encoding_preserves_satisfiability
  }

  BDD_MODEL {
    Boolean_function:
      compiled_fromconnective_formula

    RULE:
      BDD_representation_semantics independent_ofsurface_connective_notation
  }

  CONNECTIVE_SIMPLIFICATION_MODEL {
    examples:
      A AND TRUE -> A
      A OR FALSE -> A
      A AND FALSE -> FALSE
      A OR TRUE -> TRUE
      A XOR FALSE -> A

    RULE:
      simplification MUST preserveclassical_semantics
  }

  CONSTANT_FOLDING_MODEL {
    operands:
      truth_constants

    output:
      computed_truth_constant

    RULE:
      fold_usesdeclared_truth_function
  }

  CONNECTIVE_COUNT_MODEL {
    formula:
      number_ofconnective_occurrences

    RULE:
      occurrence_count != semantic_complexity_necessarily
  }

  CONNECTIVE_DEPTH_MODEL {
    formula_AST:
      maximum_nested_connective_depth

    RULE:
      depth_measure MUST be defined
  }

  CONNECTIVE_PROFILE_MODEL {
    formula:
      multiset_orcounts_byconnective_type

    RULE:
      profile_isstructural_metadata
  }

  CONNECTIVE_DEPENDENCY_MODEL {
    derived_connective:
      defined_usingprimitive_connectives

    RULE:
      dependency_graph SHOULD be acyclic_orformallyrecursive
  }

  CONNECTIVE_KNOWLEDGE_GRAPH_MODEL {
    nodes:
      connective
      truth_function
      symbol
      formula
      proof_rule
      circuit_gate

    edges:
      HAS_SYMBOL
      HAS_TRUTH_FUNCTION
      APPLIES_TO
      EQUIVALENT_TO
      DEFINED_BY
      IMPLEMENTED_BY
      HAS_RULE

    RULE:
      semantic_syntactic_andimplementation_edges MUST be typed
  }

  VALIDATION_MODEL {
    checks:
      identifier
      logic_system
      symbol
      aliases
      arity
      precedence
      associativity
      truth_function
      equivalence_rules
      proof_rules
      nonclassical_context

    RULE:
      validation MUST be logic_specific
  }

  ERROR_MODEL {
    possible:
      unknown_connective
      arity_mismatch
      ambiguous_symbol
      missing_operand
      invalid_truth_table
      incorrect_equivalence
      precedence_conflict

    RULE:
      error SHOULD identifysource_position_andexpected_semantics
  }

  UNKNOWN_STATUS_MODEL {
    possible:
      unresolved_symbol
      unresolved_scope
      unspecified_logic

    RULE:
      unknown != FALSE
  }

  EXPLAINABILITY_MODEL {
    output:
      connective_name
      symbol
      arity
      operand_structure
      truth_function
      equivalent_forms
      proof_rules
      interpretation

    RULE:
      explanation SHOULD distinguishsyntax_semantics_andnatural_language_mapping
  }

  VERSION_MODEL {
    versioned:
      connective_definition
      logic_system
      notation
      precedence
      proof_rules
      ontology

    RULE:
      historical_formula_parse MUST preserveversions
  }

  PROVENANCE_MODEL {
    fields:
      source
      language
      logic_system
      connective_definition
      transformation
      parser
      version
      agent

    RULE:
      connective_record MUST remainprovenance_linked
  }

  INTEROPERABILITY_MODEL {
    exchange:
      canonical_connective_identifier
      symbol
      aliases
      arity
      truth_function
      precedence
      associativity
      logic_system
      version

    RULE:
      glyph_alone_isnotlossless
  }

  RELATIONSHIPS {
    LogicalConnective -> BELONGS_TO -> LogicSystem
    LogicalConnective -> HAS -> TruthFunction
    LogicalConnective -> HAS_SYMBOL -> Symbol
    LogicalConnective -> APPLIES_TO -> Formula
    DerivedConnective -> DEFINED_BY -> PrimitiveConnectiveExpression
    LogicalConnective -> MAY_HAVE -> IntroductionRule
    LogicalConnective -> MAY_HAVE -> EliminationRule
    LogicalConnective -> MAY_MAP_TO -> CircuitGate
  }

  SEMANTIC_EQUIVALENCE {
    "logical connective" ~= formula_forming_operator_withdeclared_logical_semantics
    "truth-functional connective" ~= operator_whoseoutput_truth_value_isdetermined_byoperand_truth_values
    "material implication" ~= classical_truth_function_false_onlywhentrue_antecedent_andfalse_consequent

    connective_symbol != connective_semantics
    alias != canonical_identity
    connective != quantifier
    connective != equality
    implication != causation
    logical_AND != probabilistic_intersection_value
    logical_OR != natural_language_exclusive_OR_necessarily
    programming_operator != logical_connective_bydefault
    bitwise_operator != propositional_connective
    derived_connective != primitive_connective_bydefinition
    functional_completeness != proof_system_completeness
    semantic_confidence != truth_value
  }

  CONSTRAINTS {
    canonical_connective_identifier_must_be preserved = true
    logic_system_andversion_must_be identified = true
    connective_arity_must_be explicit = true
    operands_must_be well_formed_formulas = true
    precedence_associativity_andscope_must_be preserved = true
    truth_function_must_be explicit_forclassical_truth_functional_connectives = true
    symbols_andaliases_must_map_tocanonical_identifiers = true
    implication_must_not_be interpreted_ascausation = true
    inclusive_OR_andXOR_must_be distinguished = true
    primitive_andderived_connective_status_must_be context_specific = true
    proof_rules_andtruth_function_semantics_must_be distinguished = true
    nonclassical_connectives_must_notinherit_classical_truth_tables_withoutbasis = true
    natural_language_connective_mapping_must_preserveambiguity_andconfidence = true
    provenance_must_be preserved = true
  }

  LOGICAL_CONNECTIVE_RECORD_MODEL {
    RECORD:
      connective_identifier
      canonical_name
      logic_system_identifier
      logic_version
      connective_type
      arity
      canonical_symbol
      aliases
      notation_profile
      precedence
      associativity
      truth_domain
      truth_function
      truth_vector
      commutative_status
      associative_status
      idempotent_status
      monotonicity_status
      primitive_or_derived_status
      definition_expression
      equivalent_forms
      introduction_rules
      elimination_rules
      circuit_mapping
      natural_language_mappings
      ambiguity_status
      formalisation_confidence
      version
      provenance

    RULE:
      logical_connective_record MUST support_reconstruction_ofsyntax_truth_function_proof_rules_mappings_andprovenance
  }

  REASONING_RULES {
    IF connective_symbol_received
      THEN identifylogic_language_andnotation
      resolve_canonical_connective_identifier

    IF connective_application_received
      THEN verifyarity
      parseoperands
      constructAST_node

    IF valuation_available
      THEN evaluateoperands
      applydeclared_truth_function

    IF equivalence_transformation_requested
      THEN resolveconnective_definition
      transformformula
      validateequivalence_orotherpreservation_status

    IF natural_language_connective_received
      THEN identifycandidate_mapping
      resolveinclusive_exclusive_direction_scope_andpragmaticambiguity
      assignformalisation_confidence

    IF nonclassical_logic_selected
      THEN loadlogic_specific_connective_semantics
      anddo_notreuseclassical_truth_tables_withoutbasis

    IF programming_orbitwise_operator_encountered
      THEN resolveoperator_semantics_beforemapping_tological_connective

    IF connective_definition_orprecedence_changes
      THEN preservehistorical_version
      reparseandrevalidate_current_formulas_undernewversion
  }

  VALIDATION {
    CHECK connective_identifier
    CHECK canonical_name
    CHECK logic_system
    CHECK logic_version
    CHECK arity
    CHECK symbol
    CHECK aliases
    CHECK notation
    CHECK precedence
    CHECK associativity
    CHECK operands
    CHECK truth_domain
    CHECK truth_function
    CHECK truth_vector
    CHECK commutativity
    CHECK associativity_property
    CHECK idempotence
    CHECK monotonicity
    CHECK primitive_derived_status
    CHECK equivalent_forms
    CHECK proof_rules
    CHECK circuit_mapping
    CHECK natural_language_mapping
    CHECK nonclassical_context
    CHECK ambiguity
    CHECK formalisation_confidence
    CHECK version
    CHECK provenance
  }

  CONFIDENCE {
    connective_identity_confidence: 1.00
    arity_confidence: 1.00
    truth_function_confidence: 1.00
    parse_scope_confidence: 1.00
    equivalence_confidence: 1.00
    proof_rule_mapping_confidence: 0.99
    natural_language_mapping_confidence: 0.96
    nonclassical_semantics_confidence: 0.98

    RULE:
      confidence decreases when logic, notation, symbol identity,
      arity, precedence, truth domain, natural-language context,
      version orprovenance is missing or ambiguous
  }

  UPDATE_MODEL {
    ON new_connective:
      assigncanonical_identifier
      registerlogic_arity_symbols_andtruth_function
      validateproperties
      preserveprovenance
      compute_FLOW_HASH

    ON new_alias:
      attachalias_tocanonical_identifier
      verifylanguage_andnotation_scope

    ON semantic_revision:
      preserveprevious_connective_definition
      create_newversion
      revalidateequivalences_anddependentformulas
      recompute_FLOW_HASH

    ON proof_rule_revision:
      preservepreviousrules
      attachnewrule_version
      updateproof_dependencies

    ON notation_revision:
      preservehistorical_symbol_mapping
      updatecurrent_parser_profile
  }

  AI_CONSUMPTION {
    canonical_entity: LogicalConnective
    canonical_role: FormulaFormingLogicalOperator

    interpretation_order:
      identify_logic_system
      identify_connective_symbol_orname
      resolve_canonical_identifier
      resolvearity
      resolveprecedence_associativity_andscope
      identifyoperand_formulas
      resolveclassical_orlogic_specific_truth_function
      evaluateundertruth_assignment_whenrequested
      identifyprimitive_or derived_status
      resolveequivalent_forms_andnormal_form_expansions
      distinguishtruth_function_fromproof_rules
      maptoBoolean_algebra_orcircuit_whenrequested
      resolve_natural_language_connective_whenapplicable
      detectinclusive_exclusive_causal_programming_orbitwiseambiguity
      assignsemantic_confidence
      preserveversions_andprovenance
      emit_machine_resolvable_logical_connective_structure

    ambiguity_controls:
      distinguish_connective_symbol_fromconnective_semantics
      distinguish_alias_fromcanonical_identity
      distinguish_connective_fromquantifier
      distinguish_connective_fromequality
      distinguish_implication_fromcausation
      distinguish_logical_AND_fromprobabilistic_combination
      distinguish_logical_OR_fromexclusive_OR
      distinguish_programming_operator_fromlogical_connective
      distinguish_bitwise_operator_frompropositional_connective
      distinguish_derived_connective_fromprimitive_connective_bycontext
      distinguish_functional_completeness_fromproof_system_completeness
      distinguish_semantic_confidence_fromtruth_value
      preserve_logic_identifier_symbol_arity_scope_truth_function_rules_version_andprovenance
  }

  PROVENANCE {
    ontology_scope:
      logical_connectives_truth_functions_notation_equivalence_proof_rules_andAI_interpretation

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

    authorship:
      Mark Higgins
      Sky (Recursive AI)

    site:
      https://kirethresearch.org
  }

  FLOW_HASH {
    INPUTS:
      canonical_entity
      ontology_path
      connective_identity_model
      logic_context_model
      symbol_model
      alias_model
      ASCII_notation_model
      Unicode_notation_model
      arity_model
      operand_model
      connective_application_model
      syntax_tree_model
      precedence_model
      associativity_model
      parenthesis_model
      scope_model
      negation_model
      conjunction_model
      disjunction_model
      XOR_model
      implication_model
      biconditional_model
      NAND_model
      NOR_model
      truth_function_model
      truth_table_model
      connective_truth_vector_model
      Boolean_function_model
      commutative_model
      noncommutative_model
      associative_connective_model
      idempotent_model
      nonidempotent_model
      monotone_connective_model
      antitone_model
      functional_completeness_model
      Sheffer_stroke_model
      Peirce_arrow_model
      derived_connective_model
      primitive_connective_model
      connective_basis_model
      negation_elimination_equivalence_model
      De_Morgan_model
      implication_elimination_model
      biconditional_elimination_model
      XOR_expansion_model
      NAND_expansion_model
      NOR_expansion_model
      contraposition_model
      distributivity_model
      absorption_model
      complement_model
      identity_model
      domination_model
      normal_form_model
      NNF_connective_model
      CNF_connective_model
      DNF_connective_model
      connective_elimination_model
      rewrite_rule_model
      semantic_equivalence_model
      connective_equivalence_class_model
      duality_model
      Boolean_algebra_model
      set_theoretic_model
      circuit_gate_model
      multi_input_connective_model
      fold_model
      zero_arity_connective_model
      proof_rule_link_model
      negation_introduction_model
      negation_elimination_model
      conjunction_introduction_model
      conjunction_elimination_model
      disjunction_introduction_model
      disjunction_elimination_model
      implication_introduction_model
      implication_elimination_model
      biconditional_introduction_model
      biconditional_elimination_model
      sequent_rule_model
      classical_connective_model
      intuitionistic_connective_model
      paraconsistent_connective_model
      many_valued_connective_model
      fuzzy_connective_model
      modal_operator_distinction_model
      temporal_operator_distinction_model
      quantifier_distinction_model
      equality_distinction_model
      programming_operator_distinction_model
      short_circuit_model
      bitwise_operator_distinction_model
      probabilistic_connective_distinction_model
      causal_connective_distinction_model
      natural_language_connective_model
      natural_language_negation_model
      natural_language_AND_model
      natural_language_OR_model
      natural_language_conditional_model
      only_if_model
      if_model
      necessary_condition_model
      sufficient_condition_model
      unless_model
      biconditional_language_model
      connective_scope_ambiguity_model
      negation_scope_ambiguity_model
      implication_scope_ambiguity_model
      symbol_overload_model
      connective_formalisation_confidence_model
      SAT_model
      clausification_model
      resolution_link_model
      Tseitin_model
      BDD_model
      connective_simplification_model
      constant_folding_model
      connective_count_model
      connective_depth_model
      connective_profile_model
      connective_dependency_model
      connective_knowledge_graph_model
      validation_model
      error_model
      unknown_status_model
      explainability_model
      version_model
      provenance_model
      interoperability_model
      relationships
      semantic_equivalence
      constraints
      logical_connective_record_model
      reasoning_rules
      validation
      confidence_model
      update_model
      AI_consumption_model

    PURPOSE:
      deterministic_semantic_integrity_identifier

    RECOMPUTE_WHEN:
      ontology_definition_changes
      connective_identity_logic_system_orsymbol_mapping_changes
      arity_precedence_associativity_orscope_changes
      classical_or nonclassical_truth_function_changes
      primitive_derived_basis_orfunctional_completeness_changes
      equivalence_normal_form_orrewrite_semantics_change
      proof_rule_orsequent_rule_mapping_changes
      Boolean_algebra_circuit_SAT_orBDD_mapping_changes
      natural_language_connective_formalisation_orambiguity_changes
      programming_bitwise_probability_orcausal_distinction_changes
      logical_connective_record_changes
      constraint_model_changes
      reasoning_rule_changes
      version_orprovenance_changes
  }

}

END FLOW