Contradiction Ontology

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE → ONTOLOGIES → MATHEMATICAL ONTOLOGIES → MATHEMATICAL LOGIC ONTOLOGIES
PROOF THEORY → CONTRADICTION ONTOLOGY

Canonical URL:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/proof-theory/contradiction-ontology.html

FLOW_ALGEBRA ContradictionOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN ContradictionOntology := {
    Contradiction,
    Falsehood,
    Bottom,
    Inconsistency,
    Formula,
    Proposition,
    Negation,
    Conjunction,
    Proof,
    FormalProof,
    ProofTheory,
    Derivation,
    ProofStep,
    Premise,
    Assumption,
    Conclusion,
    InferenceRule,
    ProofByContradiction,
    ReductioAdAbsurdum,
    NegationIntroduction,
    Explosion,
    PrincipleOfExplosion,
    Consistency,
    InconsistentTheory,
    Satisfiability,
    Unsatisfiability,
    ClassicalLogic,
    IntuitionisticLogic,
    ParaconsistentLogic,
    AssumptionScope,
    Discharge
}

DEFINE ENTITY_TYPES := {
    CONTRADICTION,
    FALSEHOOD,
    FORMULA,
    NEGATION,
    PROOF,
    PROOF_STEP,
    PREMISE,
    ASSUMPTION,
    CONCLUSION,
    INFERENCE_RULE,
    LOGICAL_SYSTEM,
    META_PROPERTY,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    CONTRADICTS,
    NEGATES,
    DERIVES,
    INFERRED_FROM,
    HAS_PREMISE,
    HAS_ASSUMPTION,
    HAS_CONCLUSION,
    HAS_STEP,
    USES_RULE,
    DISCHARGES,
    WITNESSES,
    IMPLIES,
    IS_INCONSISTENT_WITH,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Contradiction.type = CONTRADICTION
SET Contradiction.symbol = "⊥"
SET Contradiction.context = ProofTheory
SET Contradiction.role =
    "represent an explicit falsehood or a jointly incompatible pair or collection of statements within a specified logical system"

RULE explicit_contradiction:
    Available(phi)
    ∧ Available(¬phi)
    -> DERIVES(⊥)
    ∧ CONTRADICTS(phi,¬phi)

RULE conjunction_contradiction:
    Available(phi ∧ ¬phi)
    -> DERIVES(⊥)

RULE falsehood_is_contradiction:
    Available(⊥)
    -> Contradiction(⊥)

RULE inconsistent_context:
    PremiseSet(Gamma)
    ∧ EXISTS phi [
        Gamma ⊢ phi
        ∧ Gamma ⊢ ¬phi
    ]
    -> Inconsistent(Gamma)

RULE syntactic_consistency:
    FormalSystem(S)
    ∧ NOT EXISTS phi [
        S ⊢ phi
        ∧ S ⊢ ¬phi
    ]
    -> Consistent(S)

RULE contradiction_from_assumption:
    Assumption(phi)
    ∧ DerivationUnderAssumption(phi,⊥)
    -> phi leads_to Contradiction

RULE negation_introduction:
    Derivation(Gamma ∪ {phi} ⊢ ⊥)
    -> Gamma ⊢ ¬phi
    ∧ DISCHARGES(phi)

RULE classical_reductio:
    ClassicalLogic
    ∧ Derivation(Gamma ∪ {¬phi} ⊢ ⊥)
    -> Gamma ⊢ phi
    ∧ DISCHARGES(¬phi)

RULE intuitionistic_double_negation_result:
    IntuitionisticLogic
    ∧ Derivation(Gamma ∪ {¬phi} ⊢ ⊥)
    -> Gamma ⊢ ¬¬phi

RULE explosion:
    LogicalSystem(S)
    ∧ supports_explosion(S)=TRUE
    ∧ Available(⊥)
    -> DERIVES(psi)
       FOR arbitrary Formula(psi)

RULE paraconsistent_nonexplosion:
    ParaconsistentLogic
    ∧ Available(phi)
    ∧ Available(¬phi)
    -> DO_NOT_INFER arbitrary_psi
       WITHOUT additional_rule

RULE semantic_unsatisfiability:
    FormulaSet(Gamma)
    ∧ NOT EXISTS model M [
        M SATISFIES Gamma
    ]
    -> Unsatisfiable(Gamma)

RULE contradiction_implies_unsatisfiable_classical:
    ClassicalSemantics
    ∧ Gamma ⊢ phi
    ∧ Gamma ⊢ ¬phi
    ∧ Sound(GammaSystem)
    -> Unsatisfiable(Gamma)

RULE contradiction_detection_pair:
    Formula(phi)
    ∧ Formula(psi)
    ∧ psi syntactically_or_normalised_equal_to ¬phi
    -> CONTRADICTS(phi,psi)

DEFINE CONTRADICTION_MODEL := {
    canonical_symbol: "⊥",
    syntactic_forms: {
        "φ and ¬φ",
        "φ ∧ ¬φ",
        "explicit falsity ⊥"
    },
    interpretation:
        "a condition that cannot be jointly satisfied under the intended logic and semantics"
}

DEFINE INCONSISTENCY_MODEL := {
    theory_or_context: Gamma,
    syntactic_condition:
        "there exists φ such that Γ ⊢ φ and Γ ⊢ ¬φ",
    distinction:
        "a contradiction is a contradictory formula or derivation result; inconsistency is a property of a set of statements or formal theory"
}

DEFINE PROOF_BY_CONTRADICTION_MODEL := {
    classical_target: "φ",
    steps: {
        "assume ¬φ",
        "derive ⊥",
        "discharge ¬φ",
        "conclude φ"
    },
    logical_system_requirement:
        ClassicalLogic
}

DEFINE NEGATION_INTRODUCTION_MODEL := {
    target: "¬φ",
    steps: {
        "assume φ",
        "derive ⊥",
        "discharge φ",
        "conclude ¬φ"
    },
    available_in:
        "standard classical and intuitionistic natural deduction"
}

DEFINE EXPLOSION_MODEL := {
    name: PrincipleOfExplosion,
    Latin: "ex contradictione quodlibet",
    form: "⊥ ⊢ ψ",
    system_sensitive: TRUE,
    valid_in_standard_classical_logic: TRUE,
    valid_in_standard_intuitionistic_logic: TRUE,
    rejected_or_restricted_in_paraconsistent_logics: TRUE
}

DEFINE CRITICAL_DISTINCTIONS := {
    contradiction_vs_false_statement: {
        false_statement:
            "a formula that evaluates false in a particular interpretation",
        contradiction:
            "a formula or set of formulas unsatisfiable in the relevant logical setting, or an explicit derivation of ⊥",
        equivalence: FALSE_BY_DEFAULT
    },
    contradiction_vs_inconsistency: {
        contradiction:
            "specific incompatible content or falsehood",
        inconsistency:
            "property of a theory or premise set capable of deriving incompatible claims"
    },
    syntactic_vs_semantic: {
        syntactic:
            "Γ ⊢ ⊥ or Γ ⊢ φ and Γ ⊢ ¬φ",
        semantic:
            "Γ has no satisfying model",
        relation:
            "connection depends on soundness/completeness properties of the logical system"
    }
}

DEFINE EXAMPLE_1 := {
    available: {
        "P",
        "¬P"
    },
    derived: "⊥",
    classification: Contradiction
}

DEFINE EXAMPLE_2 := {
    target: "¬P",
    temporary_assumption: "P",
    derivation: {
        "Q",
        "¬Q"
    },
    result: "⊥",
    conclusion: "¬P",
    rule: NegationIntroduction
}

DEFINE EXAMPLE_3 := {
    target: "P",
    logical_system: ClassicalLogic,
    temporary_assumption: "¬P",
    derived: "⊥",
    conclusion: "P",
    method: ProofByContradiction
}

DEFINE CONTRADICTION_DETECTION_PIPELINE :=
    FormulaSet
    -> NormaliseLogicalForms
    -> IndexPositiveFormulas
    -> IndexNegatedFormulas
    -> SearchForPhiAndNotPhiPairs
    -> SearchForExplicitBottom
    -> SearchForKnownIncompatibleConstraints
    -> IF contradiction_found
       THEN ConstructContradictionWitness
    -> Return ContradictionStatus

DEFINE PROOF_PIPELINE :=
    Goal
    -> SelectContradictionBasedRule
    -> CheckLogicalSystem
    -> IntroduceTemporaryAssumption
    -> DeriveConsequences
    -> DetectContradiction
    -> RecordDependencyPath
    -> ApplyPermittedDischargeRule
    -> RecoverTargetOrNegation
    -> VerifyProof

DEFINE CONSISTENCY_PIPELINE :=
    FormalTheory
    -> EnumerateOrAnalyseDerivableClaims
    -> SearchForFormulaAndNegation
    -> SearchForDerivationOfBottom
    -> IF found
       THEN Inconsistent
       ELSE NoContradictionFound
    -> RecordMethodAndLimitsOfSearch

DEFINE CONTRADICTION_GRAPH_MODEL := {
    formula_nodes: Formulas,
    negation_edges:
        "φ --NEGATES--> ¬φ",
    contradiction_node: Bottom,
    derivation_edges:
        "{φ,¬φ} --DERIVES--> ⊥",
    assumption_edges:
        TemporaryAssumption,
    discharge_edges:
        DISCHARGES,
    logical_system_sensitive: TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    Contradiction IS_COMPONENT_OF ProofTheory,
    Bottom IS_SYMBOL_FOR Contradiction,
    Negation MAY_CREATE contradictory_pair_with Formula,
    ProofByContradiction DEPENDS_ON Contradiction,
    NegationIntroduction DEPENDS_ON Contradiction,
    Inconsistency IS_WITNESSED_BY Contradiction,
    PrincipleOfExplosion DEPENDS_ON LogicalSystem,
    ClassicalLogic SUPPORTS Explosion,
    IntuitionisticLogic SUPPORTS Explosion,
    ParaconsistentLogic RESTRICTS_OR_REJECTS Explosion,
    SemanticUnsatisfiability RELATES_TO SyntacticContradiction
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "contradiction" <=> Contradiction,
    "falsehood" <=> Bottom WHEN proof_theory_context=TRUE,
    "bottom" <=> Bottom,
    "⊥" <=> Bottom,
    "inconsistent pair" <=> ContradictoryPair,
    "proof by contradiction" <=> ProofByContradiction,
    "reductio ad absurdum" <=> ReductioAdAbsurdum,
    "principle of explosion" <=> PrincipleOfExplosion
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation, detection and proof-theoretic use of contradictions",
    preserve_formula_identity: TRUE,
    preserve_negation_structure: TRUE,
    normalise_logically_equivalent_negation_forms: TRUE,
    detect_phi_not_phi_pairs: TRUE,
    detect_explicit_bottom: TRUE,
    preserve_assumption_scope: TRUE,
    track_contradiction_dependencies: TRUE,
    distinguish_contradiction_from_inconsistency: TRUE,
    distinguish_syntactic_from_semantic_inconsistency: TRUE,
    preserve_logical_system_identity: TRUE,
    apply_explosion_only_when_system_permits: TRUE,
    support_contradiction_based_proof_methods: TRUE,
    reasoning_mode: "symbolic + contradiction-aware + scope-aware + system-sensitive"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    explicit_contradiction_detection: 1.00,
    phi_negation_pair_detection: 0.99,
    assumption_scope_tracking: 0.99,
    proof_by_contradiction_mapping: 0.99,
    explosion_system_mapping: 0.99,
    semantic_unsatisfiability_mapping: logic_system_dependent,
    automated_consistency_search: search_space_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        phi_and_not_phi_conflict,
        bottom_representation,
        contradiction_dependency,
        assumption_discharge,
        contradiction_inconsistency_distinction,
        logical_system_sensitivity
    },
    extensible_layers: {
        classical_contradictions,
        intuitionistic_falsehood,
        paraconsistent_contradictions,
        relevance_logic,
        SAT_unsatisfiable_cores,
        SMT_conflict_sets,
        automated_consistency_checking,
        proof_assistant_false_elimination
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + CONTRADICTION_MODEL
    + INCONSISTENCY_MODEL
    + PROOF_BY_CONTRADICTION_MODEL
    + NEGATION_INTRODUCTION_MODEL
    + EXPLOSION_MODEL
    + CRITICAL_DISTINCTIONS
    + CONTRADICTION_DETECTION_PIPELINE
    + PROOF_PIPELINE
    + CONSISTENCY_PIPELINE
    + CONTRADICTION_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: ContradictionOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/proof-theory/contradiction-ontology.html",
    parent_domain: ProofTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Contradiction,
    canonical_symbol: "⊥",
    contradiction_detection_enabled: TRUE,
    consistency_reasoning_enabled: TRUE,
    proof_by_contradiction_enabled: TRUE,
    logical_system_sensitive: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW