Direct Proof Ontology

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

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

FLOW_ALGEBRA DirectProofOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN DirectProofOntology := {
    DirectProof,
    Proof,
    FormalProof,
    ProofTheory,
    Derivation,
    ProofStep,
    Premise,
    Assumption,
    Hypothesis,
    Conclusion,
    Theorem,
    Formula,
    Proposition,
    Implication,
    Conjunction,
    Disjunction,
    UniversalStatement,
    ExistentialStatement,
    Definition,
    Axiom,
    Lemma,
    Inference,
    InferenceRule,
    ModusPonens,
    UniversalInstantiation,
    ExistentialInstantiation,
    AlgebraicTransformation,
    EqualitySubstitution,
    Deduction,
    ForwardReasoning,
    ProofVerification,
    ValidProof,
    InvalidProof
}

DEFINE ENTITY_TYPES := {
    DIRECT_PROOF,
    PROOF,
    FORMULA,
    PREMISE,
    ASSUMPTION,
    CONCLUSION,
    DEFINITION,
    AXIOM,
    LEMMA,
    INFERENCE_RULE,
    PROOF_STEP,
    DERIVATION,
    VERIFICATION_RESULT,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    STARTS_FROM,
    HAS_PREMISE,
    HAS_ASSUMPTION,
    HAS_CONCLUSION,
    HAS_STEP,
    USES_RULE,
    USES_DEFINITION,
    USES_AXIOM,
    USES_LEMMA,
    DERIVES,
    INFERRED_FROM,
    DEPENDS_ON,
    PRECEDES,
    ESTABLISHES,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF
}

SET DirectProof.type = DIRECT_PROOF
SET DirectProof.parent = Proof
SET DirectProof.context = ProofTheory
SET DirectProof.role =
    "establish a target conclusion by beginning with accepted premises or hypotheses and deriving the conclusion through a forward sequence of valid inference steps"

RULE direct_implication_strategy:
    Goal(phi -> psi)
    -> Assume(phi)
    -> Derive(psi)
    -> Conclude(phi -> psi)

RULE direct_universal_strategy:
    Goal(∀x phi(x))
    -> Let(a) be arbitrary_element_of_domain
    -> Derive(phi(a))
    -> Conclude(∀x phi(x))
       IF a has_no_special_unjustified_properties

RULE direct_existential_strategy:
    Goal(∃x phi(x))
    -> ProvideWitness(t)
    -> Derive(phi(t))
    -> Conclude(∃x phi(x))

RULE premise_use:
    Premise(phi)
    -> Available(phi)

RULE definition_expansion:
    Available(statement_using_concept_C)
    ∧ Definition(C)=D
    -> MayRewriteUsing(D)

RULE axiom_use:
    Axiom(phi)
    ∧ axiom_available_in_system
    -> Available(phi)

RULE lemma_use:
    Lemma(phi)
    ∧ previously_established(phi)
    -> Available(phi)

RULE modus_ponens:
    Available(phi)
    ∧ Available(phi -> psi)
    -> DERIVES(psi)

RULE conjunction_introduction:
    Available(phi)
    ∧ Available(psi)
    -> DERIVES(phi ∧ psi)

RULE conjunction_elimination:
    Available(phi ∧ psi)
    -> DERIVES(phi)
    ∧ DERIVES(psi)

RULE equality_substitution:
    Available(a=b)
    ∧ Available(phi(a))
    -> DERIVES(phi(b))
       WHEN substitution_valid=TRUE

RULE transitive_equality:
    Available(a=b)
    ∧ Available(b=c)
    -> DERIVES(a=c)

RULE universal_instantiation:
    Available(∀x phi(x))
    ∧ Term(t)
    -> DERIVES(phi(t))
       WHEN t is admissible

RULE existential_witness:
    Goal(∃x phi(x))
    ∧ Term(t)
    ∧ DERIVES(phi(t))
    -> ESTABLISHES(t,Goal)

RULE direct_proof_validity:
    DirectProof(pi)
    ∧ valid_initial_premises(pi)
    ∧ FOR_ALL derived_step s [
        follows_by_permitted_rule(s)
    ]
    ∧ final_step(pi)=target_conclusion(pi)
    -> ValidProof(pi)

RULE direct_proof_invalidity:
    DirectProof(pi)
    ∧ EXISTS step s [
        unsupported(s)
        OR invalid_rule_application(s)
    ]
    -> InvalidProof(pi)

DEFINE DIRECT_PROOF_MODEL := {
    input: {
        premises,
        hypotheses,
        definitions,
        axioms,
        established_lemmas
    },
    reasoning_direction:
        "forward from accepted information toward the target",
    output:
        Conclusion,
    requirement:
        "every transformation or inference must preserve logical validity"
}

DEFINE IMPLICATION_PROOF_MODEL := {
    target: "P → Q",
    method: {
        "assume P",
        "derive consequences of P together with available premises",
        "reach Q",
        "discharge the assumption when required by the formal proof system"
    }
}

DEFINE UNIVERSAL_PROOF_MODEL := {
    target: "∀x P(x)",
    method: {
        "select an arbitrary element a from the relevant domain",
        "prove P(a) without relying on special properties of a",
        "generalise to all x"
    }
}

DEFINE EXISTENTIAL_PROOF_MODEL := {
    target: "∃x P(x)",
    method: {
        "construct or identify a witness t",
        "prove P(t)",
        "apply existential introduction"
    }
}

DEFINE FORWARD_REASONING_MODEL := {
    start_state:
        "known true statements",
    transition:
        "valid inference or equivalence-preserving transformation",
    end_state:
        "target conclusion"
}

DEFINE CRITICAL_DISTINCTIONS := {
    direct_vs_contradiction: {
        direct:
            "derives the conclusion from accepted premises without making negation of the target the central proof assumption",
        contradiction:
            "assumes a negation or incompatible condition and derives contradiction"
    },
    direct_vs_contrapositive: {
        direct:
            "for P→Q, reasons from P toward Q",
        contrapositive:
            "replaces the target with ¬Q→¬P when logically appropriate"
    },
    proof_vs_example: {
        example:
            "shows a statement for selected instances",
        proof:
            "establishes the required general claim under its quantified conditions"
    }
}

DEFINE EXAMPLE_1 := {
    theorem:
        "If n is even, then n² is even.",
    hypothesis:
        "n is even",
    definition:
        "n = 2k for some integer k",
    derivation: {
        "n² = (2k)²",
        "n² = 4k²",
        "n² = 2(2k²)",
        "2k² is an integer",
        "therefore n² is even"
    },
    method: DirectProof
}

DEFINE EXAMPLE_2 := {
    premises: {
        "P",
        "P → Q",
        "Q → R"
    },
    derivation: {
        "Q by Modus Ponens",
        "R by Modus Ponens"
    },
    conclusion: "R"
}

DEFINE EXAMPLE_3 := {
    target: "∃x(x²=4)",
    witness: 2,
    verification: "2²=4",
    conclusion: "∃x(x²=4)"
}

DEFINE PROOF_PLANNING_PIPELINE :=
    TargetStatement
    -> ClassifyLogicalForm
    -> IF implication
       THEN AssumeAntecedent
    -> IF universal
       THEN SelectArbitraryElement
    -> IF existential
       THEN SearchForWitness
    -> GatherDefinitionsAxiomsPremisesLemmas
    -> GenerateForwardConsequences
    -> SelectUsefulIntermediateResults
    -> ReachTarget
    -> ConstructDirectProof

DEFINE PROOF_EXECUTION_PIPELINE :=
    InitialPremises
    -> NormaliseDefinitions
    -> ApplyPermittedInferenceRules
    -> ApplyValidAlgebraicOrLogicalTransformations
    -> RecordDependencies
    -> GenerateIntermediateStatements
    -> CompareWithTarget
    -> RepeatUntilTargetOrFailure
    -> ReturnProofArtifact

DEFINE PROOF_VERIFICATION_PIPELINE :=
    CandidateDirectProof
    -> ValidateHypotheses
    -> ValidateDefinitionsUsed
    -> ValidateEachInferenceRule
    -> ValidateEachTransformation
    -> CheckQuantifierSideConditions
    -> CheckWitnessConditions
    -> CheckFinalStatementMatchesGoal
    -> Return ValidProof OR InvalidProof

DEFINE DIRECT_PROOF_GRAPH_MODEL := {
    root_nodes:
        "premises, hypotheses, axioms, definitions and established lemmas",
    intermediate_nodes:
        DerivedStatements,
    terminal_node:
        TargetConclusion,
    edges:
        {
            DERIVES,
            USES_RULE,
            USES_DEFINITION,
            DEPENDS_ON
        },
    preferred_direction:
        "roots -> conclusion"
}

DEFINE ONTOLOGY_RELATIONS := {
    DirectProof IS_SUBTYPE_OF Proof,
    DirectProof IS_COMPONENT_OF ProofTheory,
    DirectProof STARTS_FROM Premise,
    DirectProof MAY_START_FROM Hypothesis,
    DirectProof HAS_STEP ProofStep,
    DirectProof HAS_CONCLUSION Conclusion,
    ProofStep USES_RULE InferenceRule,
    ProofStep MAY_USE Definition,
    ProofStep MAY_USE Axiom,
    ProofStep MAY_USE Lemma,
    DirectProof DEPENDS_ON ForwardReasoning,
    ValidDirectProof ESTABLISHES Theorem
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "direct proof" <=> DirectProof,
    "proof by direct argument" <=> DirectProof,
    "direct argument" <=> DirectProof WHEN mathematical_proof_context=TRUE,
    "forward proof" <=> DirectProof WHEN proof_context=TRUE,
    "forward reasoning" <=> ForwardReasoning
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation, generation and verification of direct mathematical proofs",
    preserve_goal_identity: TRUE,
    preserve_premise_identity: TRUE,
    preserve_step_order: TRUE,
    preserve_dependencies: TRUE,
    preserve_rule_identity: TRUE,
    track_definition_expansion: TRUE,
    detect_goal_logical_form: TRUE,
    support_forward_reasoning: TRUE,
    support_witness_construction: TRUE,
    support_arbitrary_element_reasoning: TRUE,
    verify_quantifier_side_conditions: TRUE,
    distinguish_direct_from_indirect_methods: TRUE,
    reasoning_mode: "symbolic + forward + dependency-aware + goal-directed"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    direct_proof_classification: 0.99,
    formal_rule_application: proof_system_dependent,
    implication_strategy_mapping: 0.99,
    universal_strategy_mapping: 0.99,
    existential_strategy_mapping: 0.99,
    algebraic_transformation_validation: domain_dependent,
    automated_direct_proof_search: search_space_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        accepted_starting_information,
        forward_derivation,
        valid_step_requirement,
        dependency_tracking,
        target_conclusion,
        implication_direct_strategy
    },
    extensible_layers: {
        algebraic_direct_proofs,
        number_theoretic_direct_proofs,
        set_theoretic_direct_proofs,
        combinatorial_direct_proofs,
        quantified_direct_proofs,
        automated_forward_reasoning,
        proof_assistant_direct_tactics
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + DIRECT_PROOF_MODEL
    + IMPLICATION_PROOF_MODEL
    + UNIVERSAL_PROOF_MODEL
    + EXISTENTIAL_PROOF_MODEL
    + FORWARD_REASONING_MODEL
    + CRITICAL_DISTINCTIONS
    + PROOF_PLANNING_PIPELINE
    + PROOF_EXECUTION_PIPELINE
    + PROOF_VERIFICATION_PIPELINE
    + DIRECT_PROOF_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: DirectProofOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/proof-theory/direct-proof-ontology.html",
    parent_domain: ProofTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: DirectProof,
    forward_reasoning_enabled: TRUE,
    implication_reasoning_enabled: TRUE,
    quantified_reasoning_enabled: TRUE,
    proof_verification_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW