Indirect Proof Ontology

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

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

FLOW_ALGEBRA IndirectProofOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN IndirectProofOntology := {
    IndirectProof,
    Proof,
    FormalProof,
    ProofTheory,
    Derivation,
    ProofStep,
    Premise,
    Assumption,
    Hypothesis,
    Conclusion,
    Theorem,
    Formula,
    Proposition,
    Negation,
    Implication,
    Contradiction,
    Inconsistency,
    ReductioAdAbsurdum,
    ProofByContradiction,
    ProofByContrapositive,
    Contrapositive,
    DoubleNegation,
    LawOfExcludedMiddle,
    ClassicalLogic,
    IntuitionisticLogic,
    InferenceRule,
    ModusTollens,
    ModusPonens,
    AssumptionScope,
    Discharge,
    ValidProof,
    InvalidProof,
    ProofVerification
}

DEFINE ENTITY_TYPES := {
    INDIRECT_PROOF,
    PROOF,
    FORMULA,
    PREMISE,
    ASSUMPTION,
    CONCLUSION,
    NEGATION,
    CONTRADICTION,
    INFERENCE_RULE,
    PROOF_STEP,
    DERIVATION,
    LOGICAL_SYSTEM,
    SCOPE,
    VERIFICATION_RESULT,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    STARTS_FROM,
    HAS_PREMISE,
    HAS_ASSUMPTION,
    HAS_CONCLUSION,
    HAS_STEP,
    USES_RULE,
    NEGATES,
    CONTRADICTS,
    DERIVES,
    INFERRED_FROM,
    DEPENDS_ON,
    DISCHARGES,
    EQUIVALENT_TO,
    ESTABLISHES,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF
}

SET IndirectProof.type = INDIRECT_PROOF
SET IndirectProof.parent = Proof
SET IndirectProof.context = ProofTheory
SET IndirectProof.role =
    "establish a conclusion by reasoning through a logically related assumption or reformulation, such as contradiction or contraposition"

RULE contradiction_strategy_classical:
    ClassicalLogic
    ∧ Goal(phi)
    -> Assume(¬phi)
    -> Derive(Contradiction)
    -> Discharge(¬phi)
    -> Conclude(phi)

RULE contradiction_for_negated_goal:
    Goal(¬phi)
    -> Assume(phi)
    -> Derive(Contradiction)
    -> Discharge(phi)
    -> Conclude(¬phi)

RULE contrapositive_equivalence_classical:
    Formula(phi -> psi)
    -> EQUIVALENT_TO(
        phi -> psi,
        ¬psi -> ¬phi
    )
       IN ClassicalLogic

RULE proof_by_contrapositive:
    Goal(phi -> psi)
    ∧ ClassicalLogic
    -> GoalTransform(¬psi -> ¬phi)
    -> Assume(¬psi)
    -> Derive(¬phi)
    -> Conclude(phi -> psi)

RULE modus_tollens:
    Available(phi -> psi)
    ∧ Available(¬psi)
    -> DERIVES(¬phi)

RULE contradiction_detection:
    Available(phi)
    ∧ Available(¬phi)
    -> DERIVES(Contradiction)

RULE contradiction_from_falsehood:
    DERIVES(False)
    -> Contradiction

RULE explosion_classical:
    ClassicalLogic
    ∧ Available(Contradiction)
    -> DERIVES(psi)
       FOR arbitrary psi
       WHEN proof_system_supports_explosion=TRUE

RULE double_negation_elimination:
    ClassicalLogic
    ∧ Available(¬¬phi)
    -> DERIVES(phi)

RULE double_negation_introduction:
    Available(phi)
    -> DERIVES(¬¬phi)

RULE excluded_middle:
    ClassicalLogic
    -> Available(phi ∨ ¬phi)

RULE indirect_proof_validity:
    IndirectProof(pi)
    ∧ valid_initial_premises(pi)
    ∧ valid_temporary_assumption(pi)
    ∧ FOR_ALL derived_step s [
        follows_by_permitted_rule(s)
    ]
    ∧ valid_assumption_discharge(pi)
    ∧ final_step(pi)=target_conclusion(pi)
    -> ValidProof(pi)

RULE indirect_proof_invalidity:
    IndirectProof(pi)
    ∧ (
        unsupported_contradiction(pi)
        OR invalid_negation(pi)
        OR invalid_goal_transformation(pi)
        OR invalid_discharge(pi)
    )
    -> InvalidProof(pi)

DEFINE INDIRECT_PROOF_MODEL := {
    input: {
        premises,
        target_conclusion,
        proof_system
    },
    strategy:
        "replace or supplement the target with a logically related temporary assumption or equivalent goal",
    requirement:
        "the indirect inference must be licensed by the active logical system",
    output:
        Conclusion
}

DEFINE CONTRADICTION_MODEL := {
    target: "φ",
    classical_method: {
        "assume ¬φ",
        "derive ψ and ¬ψ, or derive falsity ⊥",
        "discharge ¬φ",
        "conclude φ"
    },
    system_constraint:
        "the final move from contradiction under ¬φ to φ depends on the proof system"
}

DEFINE NEGATION_INTRODUCTION_MODEL := {
    target: "¬φ",
    method: {
        "assume φ",
        "derive contradiction",
        "discharge φ",
        "conclude ¬φ"
    },
    constructive_status:
        "available in standard intuitionistic natural deduction"
}

DEFINE CONTRAPOSITIVE_MODEL := {
    original: "P → Q",
    contrapositive: "¬Q → ¬P",
    classical_equivalence: TRUE,
    proof_strategy:
        "assume ¬Q and derive ¬P"
}

DEFINE LOGICAL_SYSTEM_CONSTRAINTS := {
    ClassicalLogic: {
        proof_by_contradiction_for_positive_goal: TRUE,
        double_negation_elimination: TRUE,
        excluded_middle: TRUE
    },
    IntuitionisticLogic: {
        negation_introduction: TRUE,
        proof_of_not_not_phi_does_not_generally_imply_phi: TRUE,
        unrestricted_classical_reductio: FALSE
    }
}

DEFINE CRITICAL_DISTINCTIONS := {
    contradiction_vs_contrapositive: {
        contradiction:
            "assumes negation of a target and derives inconsistency",
        contrapositive:
            "for an implication, proves the logically related implication from negated consequent to negated antecedent"
    },
    contradiction_vs_example_failure: {
        contradiction:
            "formal derivation of incompatible statements or falsity",
        failed_example:
            "does not by itself constitute a formal contradiction"
    },
    indirect_vs_direct: {
        direct:
            "moves from premises or antecedent toward the stated target",
        indirect:
            "uses a negated target, contradiction, contrapositive or another licensed reformulation"
    }
}

DEFINE EXAMPLE_1 := {
    theorem:
        "There is no greatest prime number.",
    indirect_assumption:
        "there is a greatest prime p",
    construction:
        "N = product_of_all_primes_up_to_p + 1",
    contradiction:
        "N has a prime divisor not among the assumed complete finite list",
    conclusion:
        "there is no greatest prime"
}

DEFINE EXAMPLE_2 := {
    target: "P → Q",
    method: ProofByContrapositive,
    transformed_target: "¬Q → ¬P",
    assumption: "¬Q",
    derived: "¬P",
    conclusion: "P → Q"
}

DEFINE EXAMPLE_3 := {
    target: "¬P",
    assumption: "P",
    derivation: {
        "Q",
        "¬Q"
    },
    contradiction: "Q ∧ ¬Q",
    conclusion: "¬P"
}

DEFINE PROOF_PLANNING_PIPELINE :=
    TargetStatement
    -> IdentifyLogicalForm
    -> SelectIndirectStrategy
    -> CheckProofSystemPermissions
    -> IF contradiction
       THEN ConstructNegatedOrOpposingAssumption
    -> IF contrapositive
       THEN TransformImplicationGoal
    -> GatherPremisesDefinitionsAxiomsLemmas
    -> GenerateConsequences
    -> SearchForContradictionOrTransformedTarget
    -> DischargeTemporaryAssumption
    -> RecoverOriginalConclusion

DEFINE CONTRADICTION_SEARCH_PIPELINE :=
    TemporaryAssumption
    -> AddToPremiseContext
    -> DeriveConsequences
    -> DetectFormulaAndNegationPair
    -> DetectExplicitFalsehood
    -> DetectViolationOfEstablishedConstraint
    -> IF contradiction_found
       THEN RecordDependencyPath
    -> ELSE ContinueSearchOrFail

DEFINE PROOF_VERIFICATION_PIPELINE :=
    CandidateIndirectProof
    -> IdentifyActiveLogicalSystem
    -> ValidateTemporaryAssumption
    -> ValidateEachInferenceStep
    -> ValidateContradictionClaim
    -> ValidateGoalTransformation
    -> ValidateAssumptionScope
    -> ValidateDischargeRule
    -> ValidateFinalConclusion
    -> Return ValidProof OR InvalidProof

DEFINE INDIRECT_PROOF_GRAPH_MODEL := {
    root_nodes: {
        Premises,
        TemporaryAssumption
    },
    intermediate_nodes:
        DerivedStatements,
    contradiction_node:
        optional_Contradiction,
    terminal_node:
        TargetConclusion,
    edges: {
        DERIVES,
        CONTRADICTS,
        DEPENDS_ON,
        DISCHARGES
    },
    proof_system_sensitive: TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    IndirectProof IS_SUBTYPE_OF Proof,
    IndirectProof IS_COMPONENT_OF ProofTheory,
    ProofByContradiction IS_SUBTYPE_OF IndirectProof,
    ProofByContrapositive IS_SUBTYPE_OF IndirectProof,
    ProofByContradiction HAS_ASSUMPTION NegatedTarget,
    ProofByContradiction DERIVES Contradiction,
    ProofByContrapositive DEPENDS_ON Contrapositive,
    Contrapositive NEGATES ConsequentAndAntecedent,
    IndirectProof DEPENDS_ON LogicalSystem,
    ValidIndirectProof ESTABLISHES Theorem
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "indirect proof" <=> IndirectProof,
    "proof by contradiction" <=> ProofByContradiction,
    "reductio ad absurdum" <=> ReductioAdAbsurdum,
    "reductio" <=> ReductioAdAbsurdum WHEN proof_context=TRUE,
    "proof by contrapositive" <=> ProofByContrapositive,
    "contrapositive proof" <=> ProofByContrapositive,
    "indirect argument" <=> IndirectProof WHEN mathematical_proof_context=TRUE
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation, generation and verification of indirect mathematical proofs",
    preserve_goal_identity: TRUE,
    preserve_temporary_assumption_identity: TRUE,
    preserve_negation_structure: TRUE,
    preserve_step_dependencies: TRUE,
    preserve_assumption_scope: TRUE,
    preserve_logical_system: TRUE,
    detect_contradictions: TRUE,
    distinguish_contradiction_from_contrapositive: TRUE,
    validate_goal_transformations: TRUE,
    validate_discharge: TRUE,
    prevent_classical_inference_in_nonclassical_system_without_permission: TRUE,
    support_recursive_contradiction_search: TRUE,
    reasoning_mode: "symbolic + indirect + contradiction-aware + system-sensitive"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    indirect_proof_classification: 0.99,
    contradiction_detection_formal: 0.99,
    contrapositive_mapping: 0.99,
    assumption_scope_tracking: 0.99,
    logical_system_constraint_mapping: 0.99,
    automated_indirect_proof_search: search_space_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        temporary_assumption,
        indirect_goal_relation,
        contradiction_detection,
        assumption_discharge,
        logical_system_sensitivity,
        contrapositive_structure
    },
    extensible_layers: {
        classical_reductio,
        intuitionistic_negation_proofs,
        contrapositive_proofs,
        minimal_logic_indirect_methods,
        automated_contradiction_search,
        SAT_SMT_refutation_methods,
        proof_assistant_indirect_tactics
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + INDIRECT_PROOF_MODEL
    + CONTRADICTION_MODEL
    + NEGATION_INTRODUCTION_MODEL
    + CONTRAPOSITIVE_MODEL
    + LOGICAL_SYSTEM_CONSTRAINTS
    + CRITICAL_DISTINCTIONS
    + PROOF_PLANNING_PIPELINE
    + CONTRADICTION_SEARCH_PIPELINE
    + PROOF_VERIFICATION_PIPELINE
    + INDIRECT_PROOF_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: IndirectProofOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/proof-theory/indirect-proof-ontology.html",
    parent_domain: ProofTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: IndirectProof,
    contradiction_reasoning_enabled: TRUE,
    contrapositive_reasoning_enabled: TRUE,
    logical_system_sensitive: TRUE,
    proof_verification_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW