Inference Rule Ontology

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

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

FLOW_ALGEBRA InferenceRuleOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN InferenceRuleOntology := {
    InferenceRule,
    Inference,
    Proof,
    ProofTheory,
    FormalSystem,
    ProofSystem,
    Formula,
    Premise,
    Conclusion,
    RuleSchema,
    RuleInstance,
    SideCondition,
    Derivation,
    ProofStep,
    ModusPonens,
    ModusTollens,
    ConjunctionIntroduction,
    ConjunctionElimination,
    DisjunctionIntroduction,
    ImplicationIntroduction,
    ImplicationElimination,
    NegationIntroduction,
    NegationElimination,
    UniversalIntroduction,
    UniversalElimination,
    ExistentialIntroduction,
    ExistentialElimination,
    StructuralRule,
    Weakening,
    Contraction,
    Exchange,
    CutRule,
    SubstitutionRule,
    SoundRule,
    AdmissibleRule,
    DerivedRule
}

DEFINE ENTITY_TYPES := {
    INFERENCE_RULE,
    RULE_SCHEMA,
    RULE_INSTANCE,
    FORMULA,
    PREMISE,
    CONCLUSION,
    SIDE_CONDITION,
    PROOF,
    PROOF_STEP,
    FORMAL_SYSTEM,
    STRUCTURAL_RULE,
    LOGICAL_RULE,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    HAS_PREMISE,
    HAS_CONCLUSION,
    HAS_SIDE_CONDITION,
    APPLIES_TO,
    DERIVES,
    JUSTIFIES,
    USES_RULE,
    IS_RULE_OF,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON,
    PRESERVES,
    DISCHARGES,
    INTRODUCES,
    ELIMINATES
}

SET InferenceRule.type = INFERENCE_RULE
SET InferenceRule.context = ProofTheory
SET InferenceRule.role =
    "specify a licensed transformation from one or more premises to a conclusion within a formal proof system"

RULE rule_schema:
    PremisePatterns(P1,...,Pn)
    ∧ ConclusionPattern(C)
    ∧ SideConditions(S)
    -> RuleSchema(R: P1,...,Pn / C)

RULE rule_instance:
    RuleSchema(R)
    ∧ Substitution(sigma)
    ∧ premises_match(sigma(P1...Pn))
    ∧ side_conditions_hold(sigma,S)
    -> RuleInstance(R,sigma)

RULE rule_application:
    RuleInstance(R)
    ∧ AvailablePremises(phi1,...,phin)
    ∧ premises_match_rule(phi1,...,phin,R)
    -> DERIVES(Conclusion(R))
    ∧ JUSTIFIES(R,Conclusion(R))

RULE proof_step_validity:
    ProofStep(s)
    ∧ USES_RULE(s,R)
    ∧ required_premises_available(s,R)
    ∧ side_conditions_satisfied(s,R)
    ∧ Formula(s)=instantiated_conclusion(R)
    -> ValidProofStep(s)

RULE modus_ponens:
    Available(P)
    ∧ Available(P -> Q)
    -> DERIVES(Q)

RULE modus_tollens:
    Available(P -> Q)
    ∧ Available(¬Q)
    -> DERIVES(¬P)

RULE conjunction_introduction:
    Available(P)
    ∧ Available(Q)
    -> DERIVES(P ∧ Q)

RULE conjunction_elimination_left:
    Available(P ∧ Q)
    -> DERIVES(P)

RULE conjunction_elimination_right:
    Available(P ∧ Q)
    -> DERIVES(Q)

RULE disjunction_introduction_left:
    Available(P)
    -> DERIVES(P ∨ Q)

RULE implication_introduction:
    Derivation(Gamma ∪ {P} ⊢ Q)
    -> DERIVES(Gamma ⊢ P -> Q)
    ∧ DISCHARGES(P)

RULE implication_elimination:
    Available(P -> Q)
    ∧ Available(P)
    -> DERIVES(Q)

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

RULE universal_elimination:
    Available(∀x P(x))
    ∧ Term(t)
    ∧ FreeFor(t,x,P)
    -> DERIVES(P(t))

RULE universal_introduction:
    DERIVES(P(a))
    ∧ a arbitrary
    ∧ a not_free_in_undischarged_assumptions
    -> DERIVES(∀x P(x))

RULE existential_introduction:
    Available(P(t))
    -> DERIVES(∃x P(x))

RULE existential_elimination:
    Available(∃x P(x))
    ∧ Derivation(Gamma ∪ {P(c)} ⊢ Q)
    ∧ c fresh
    ∧ c not_free_in_Q_or_relevant_open_assumptions
    -> DERIVES(Q)

RULE weakening:
    Sequent(Gamma ⊢ Delta)
    -> Sequent(Gamma,A ⊢ Delta)
       OR Sequent(Gamma ⊢ Delta,A)
       WHEN calculus_permits=TRUE

RULE contraction:
    Sequent(Gamma,A,A ⊢ Delta)
    -> Sequent(Gamma,A ⊢ Delta)
       WHEN calculus_permits=TRUE

RULE exchange:
    Sequent(Gamma,A,B,Pi ⊢ Delta)
    -> Sequent(Gamma,B,A,Pi ⊢ Delta)
       WHEN calculus_permits=TRUE

RULE cut:
    Sequent(Gamma ⊢ Delta,A)
    ∧ Sequent(A,Pi ⊢ Lambda)
    -> Sequent(Gamma,Pi ⊢ Delta,Lambda)

RULE derived_rule:
    Rule(R)
    ∧ every_instance_of_R_is_derivable_using_primitive_rules
    -> DerivedRule(R)

RULE admissible_rule:
    Rule(R)
    ∧ adding_R_does_not_increase_set_of_derivable_theorems
    -> AdmissibleRule(R)

RULE sound_rule:
    Rule(R)
    ∧ FOR_ALL interpretations M [
        all_premises_true(M)
        -> conclusion_true(M)
    ]
    -> SoundRule(R)

DEFINE RULE_SCHEMA_MODEL := {
    rule_name: identifier,
    premises: OrderedOrUnorderedFormulaPatterns,
    conclusion: FormulaPattern,
    side_conditions: SetOfConditions,
    proof_system: FormalSystem,
    rule_class: {
        LogicalRule,
        StructuralRule,
        DerivedRule,
        AdmissibleRule
    }
}

DEFINE RULE_INSTANCE_MODEL := {
    schema: RuleSchema,
    substitution: MetaVariableSubstitution,
    concrete_premises: FormulaSet,
    concrete_conclusion: Formula,
    side_condition_status: Boolean
}

DEFINE SOUNDNESS_MODEL := {
    local_rule_soundness:
        "whenever all premises of an instance are true under an interpretation, the conclusion is also true",
    proof_consequence:
        "a proof system built from sound initial principles and sound rules preserves truth from premises to conclusions"
}

DEFINE RULE_CLASSIFICATION := {
    LogicalRule:
        "acts on logical connectives or quantifiers",
    StructuralRule:
        "acts on the organisation or multiplicity of assumptions/sequent contexts",
    PrimitiveRule:
        "included directly in the proof calculus",
    DerivedRule:
        "macro-like rule derivable from primitive rules",
    AdmissibleRule:
        "may be added without creating new theorems, even if not internally derivable in the same form"
}

DEFINE EXAMPLE_1 := {
    rule: ModusPonens,
    premises: {
        "P",
        "P → Q"
    },
    conclusion: "Q"
}

DEFINE EXAMPLE_2 := {
    rule: UniversalElimination,
    premise: "∀x Human(x)",
    substitution: "x := Socrates",
    conclusion: "Human(Socrates)"
}

DEFINE EXAMPLE_3 := {
    rule: ConjunctionIntroduction,
    premises: {
        "P",
        "Q"
    },
    conclusion: "P ∧ Q"
}

DEFINE RULE_APPLICATION_PIPELINE :=
    CandidateProofStep
    -> IdentifyClaimedInferenceRule
    -> LoadRuleSchema
    -> MatchAvailablePremisesToPremisePatterns
    -> SolveMetaVariableSubstitution
    -> InstantiateConclusionPattern
    -> EvaluateSideConditions
    -> CompareInstantiatedConclusionWithClaimedStep
    -> Return ValidRuleApplication OR InvalidRuleApplication

DEFINE RULE_DISCOVERY_PIPELINE :=
    AvailableFormulas
    -> EnumerateRulesInActiveProofSystem
    -> MatchPremisePatterns
    -> FilterBySideConditions
    -> GeneratePossibleConclusions
    -> RankByGoalRelevance
    -> ReturnApplicableRuleInstances

DEFINE PROOF_VERIFICATION_PIPELINE :=
    FormalProof
    -> ForEachDerivedStep
       -> IdentifyRule
       -> ResolveDependencies
       -> VerifyRuleMembershipInSystem
       -> VerifyPremiseMatch
       -> VerifySideConditions
       -> VerifyConclusion
    -> VerifyAssumptionDischarges
    -> Return ProofRuleValidity

DEFINE RULE_GRAPH_MODEL := {
    rule_node: InferenceRule,
    premise_pattern_nodes: FormulaPatterns,
    conclusion_pattern_node: FormulaPattern,
    edges: {
        HAS_PREMISE,
        HAS_CONCLUSION,
        HAS_SIDE_CONDITION
    },
    instantiated_edges:
        "concrete premises --RULE_INSTANCE--> concrete conclusion"
}

DEFINE ONTOLOGY_RELATIONS := {
    InferenceRule IS_COMPONENT_OF ProofTheory,
    InferenceRule IS_RULE_OF ProofSystem,
    InferenceRule HAS_PREMISE FormulaPattern,
    InferenceRule HAS_CONCLUSION FormulaPattern,
    InferenceRule MAY_HAVE SideCondition,
    RuleInstance IS_INSTANCE_OF RuleSchema,
    ProofStep USES_RULE InferenceRule,
    LogicalRule IS_SUBTYPE_OF InferenceRule,
    StructuralRule IS_SUBTYPE_OF InferenceRule,
    DerivedRule IS_SUBTYPE_OF InferenceRule,
    AdmissibleRule IS_SUBTYPE_OF InferenceRule,
    SoundRule PRESERVES Truth
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "inference rule" <=> InferenceRule,
    "rule of inference" <=> InferenceRule,
    "proof rule" <=> InferenceRule,
    "rule schema" <=> RuleSchema,
    "rule instance" <=> RuleInstance,
    "modus ponens" <=> ModusPonens,
    "universal instantiation" <=> UniversalElimination,
    "existential generalisation" <=> ExistentialIntroduction
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation, matching and verification of formal inference rules",
    preserve_rule_identity: TRUE,
    preserve_proof_system_identity: TRUE,
    preserve_premise_order_when_rule_requires: TRUE,
    preserve_conclusion_pattern: TRUE,
    preserve_meta_variable_binding: TRUE,
    preserve_side_conditions: TRUE,
    verify_rule_membership: TRUE,
    verify_rule_instantiation: TRUE,
    distinguish_primitive_derived_admissible_rules: TRUE,
    distinguish_logical_structural_rules: TRUE,
    support_applicable_rule_discovery: TRUE,
    support_recursive_proof_verification: TRUE,
    reasoning_mode: "symbolic + schema-based + constraint-aware + proof-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    rule_schema_mapping: 0.99,
    premise_pattern_matching: 0.99,
    meta_variable_instantiation: 0.99,
    side_condition_verification: rule_dependent,
    standard_rule_mapping: 0.99,
    admissibility_analysis: formal_system_dependent,
    automated_rule_discovery: search_space_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        premise_to_conclusion_structure,
        rule_schema,
        rule_instance,
        proof_system_membership,
        side_condition_validation,
        rule_application_verification
    },
    extensible_layers: {
        natural_deduction_rules,
        sequent_calculus_rules,
        Hilbert_rules,
        resolution_rules,
        modal_logic_rules,
        linear_logic_rules,
        type_theory_rules,
        rewriting_rules,
        automated_rule_matching,
        proof_assistant_rule_formats
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + RULE_SCHEMA_MODEL
    + RULE_INSTANCE_MODEL
    + SOUNDNESS_MODEL
    + RULE_CLASSIFICATION
    + RULE_APPLICATION_PIPELINE
    + RULE_DISCOVERY_PIPELINE
    + PROOF_VERIFICATION_PIPELINE
    + RULE_GRAPH_MODEL
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: InferenceRuleOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/proof-theory/inference-rule-ontology.html",
    parent_domain: ProofTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: InferenceRule,
    rule_schema_enabled: TRUE,
    rule_matching_enabled: TRUE,
    side_condition_validation_enabled: TRUE,
    proof_verification_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW