Logical Reasoning

FLOW_ALGEBRA LogicalReasoningOntology v1.0
TARGET_URL := "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/logical-reasoning.html"
LANGUAGE := "en-GB"
DOMAIN := MathematicalOntologies > MathematicalLogicOntologies > LogicalReasoningOntology

BEGIN_FLOW

ENTITY LogicalReasoning {
 TYPE := FormalInferenceProcess
 DEFINITION := "The systematic derivation and validation of conclusions from premises using explicit logical forms, inference rules, semantic relations and proof procedures."
}
ENTITY Premise { TYPE := PropositionOrFormula }
ENTITY Conclusion { TYPE := PropositionOrFormula }
ENTITY Inference { TYPE := PremiseToConclusionRelation }

RELATIONSHIP LogicalReasoning --uses--> Premise
RELATIONSHIP LogicalReasoning --produces--> Conclusion
RELATIONSHIP LogicalReasoning --uses--> InferenceRule
RELATIONSHIP LogicalReasoning --supports--> Proof
RELATIONSHIP LogicalReasoning --supports--> DecisionProcedure

ARGUMENT { FORM := Premises Γ therefore Conclusion C }

SEMANTIC_ENTAILMENT {
 Γ ⊨ C
 IFF every model satisfying Γ also satisfies C
}
SYNTACTIC_DERIVABILITY {
 Γ ⊢ C
 IFF C is derivable from Γ using declared proof rules
}
SOUNDNESS {
 IF Γ ⊢ C THEN Γ ⊨ C
 REQUIRE sound_proof_system
}
COMPLETENESS {
 IF Γ ⊨ C THEN Γ ⊢ C
 REQUIRE logic_specific_completeness_theorem
}
SATISFIABILITY {
 F satisfiable IFF EXISTS model M: M⊨F
}
VALIDITY {
 F valid IFF FOR_ALL relevant models M: M⊨F
}
LOGICAL_EQUIVALENCE {
 P ≡ Q IFF P⊨Q AND Q⊨P
}

DEDUCTIVE_REASONING {
 PURPOSE := truth_preserving_inference
}
MODUS_PONENS {
 P
 P->Q
 THEREFORE Q
}
MODUS_TOLLENS {
 P->Q
 ¬Q
 THEREFORE ¬P
}
HYPOTHETICAL_SYLLOGISM {
 P->Q
 Q->R
 THEREFORE P->R
}
DISJUNCTIVE_SYLLOGISM {
 P∨Q
 ¬P
 THEREFORE Q
}
CONJUNCTION_INTRODUCTION {
 P
 Q
 THEREFORE P∧Q
}
CONJUNCTION_ELIMINATION {
 P∧Q
 THEREFORE P
}
PROOF_BY_CASES {
 P∨Q
 P->R
 Q->R
 THEREFORE R
}
PROOF_BY_CONTRADICTION {
 ASSUME ¬C
 DERIVE contradiction
 CONCLUDE C
 REQUIRE classical_or_compatible_reductio_rule
}

INDUCTIVE_REASONING {
 TYPE := AmpliativeReasoning
 CONCLUSION := supported_but_not_deductively_guaranteed_in_general
}
ABDUCTIVE_REASONING {
 TYPE := ExplanatoryReasoning
 INPUT := Observation + BackgroundKnowledge
 OUTPUT := CandidateExplanation
 WARNING := explanation_does_not_equal_deductive_proof
}
ANALOGICAL_REASONING {
 SOURCE := S
 TARGET := T
 IDENTIFY shared_structure
 TRANSFER candidate_relation
 VALIDATE differences
 CONCLUSION := defeasible_unless_formal_equivalence_established
}


PROPOSITIONAL_REASONING {
 METHODS := {TruthTables,NormalForms,Resolution,NaturalDeduction,SemanticEvaluation}
}
PREDICATE_REASONING {
 METHODS := {QuantifierRules,Unification,Resolution,ModelReasoning,NaturalDeduction}
}
UNIVERSAL_INSTANTIATION {
 ∀x P(x) THEREFORE P(a)
}
EXISTENTIAL_GENERALISATION {
 P(a) THEREFORE ∃x P(x)
}
EXISTENTIAL_INSTANTIATION {
 ∃x P(x)
 INTRODUCE fresh_witness c
 REQUIRE eigenvariable_restrictions
}
UNIVERSAL_GENERALISATION {
 DERIVE P(x)
 CONCLUDE ∀x P(x)
 REQUIRE proof_system_variable_restrictions
}
QUANTIFIER_NEGATION {
 ¬∀xP(x) ≡ ∃x¬P(x)
 ¬∃xP(x) ≡ ∀x¬P(x)
 under classical predicate semantics
}

RESOLUTION {
 TYPE := InferenceRule
}
PROPOSITIONAL_RESOLUTION {
 (P∨A)
 (¬P∨B)
 THEREFORE (A∨B)
}
FIRST_ORDER_RESOLUTION {
 Clauses -> Unification -> ComplementaryLiteralResolution -> Resolvent
}
UNIFICATION {
 INPUT := terms_or_atoms
 OUTPUT := substitution θ
 GOAL := make_expressions_identical
}
MOST_GENERAL_UNIFIER {
 ABBREVIATION := MGU
 PROPERTY := every_other_unifier_factors_through_MGU
}
RESOLUTION_REFUTATION {
 TEST Γ⊨C BY:
 Γ∪{¬C} -> clausify -> resolution -> empty_clause
}
CNF { FORM := conjunction_of_disjunctions_of_literals }
DNF { FORM := disjunction_of_conjunctions_of_literals }
SKOLEMISATION {
 PURPOSE := eliminate_existential_quantifiers_in_clausification
 PRESERVES := equisatisfiability
 WARNING := not_ordinary_logical_equivalence
}

NATURAL_DEDUCTION {
 RULE_CLASSES := {IntroductionRules,EliminationRules}
}
SEQUENT_CALCULUS {
 SEQUENT := Γ⊢Δ
}
CUT_RULE {
 Γ⊢A
 A,Π⊢Δ
 THEREFORE Γ,Π⊢Δ
}
CUT_ELIMINATION {
 REQUIRE proof_system_specific_theorem
}

TRUTH_TABLE_REASONING {
 VARIABLES := {p1,...,pn}
 ROWS := 2^n
}
TRUTH_TABLE_ENTAILMENT {
 Γ⊨C IFF every row satisfying Γ also satisfies C
}
COUNTERMODEL {
 REQUIRE M⊨Γ AND M⊭C
 CONSEQUENCE := Γ does_not_entail C
}
MODEL_CHECKING {
 INPUT := Model M, Formula F
 OUTPUT := truth_of_F_in_M
}
PROOF_SEARCH {
 INPUT := Γ,C,ProofSystem
 EXPLORE valid_inference_steps
 RETURN proof_if_found
}
DECISION_PROCEDURE {
 REQUIRE termination_and_correct_yes_no_answer_for_target_problem
}


MONOTONIC_REASONING {
 IF Γ⊢C THEN Γ∪Δ⊢C
 in monotonic logics
}
NONMONOTONIC_REASONING {
 adding_information MAY invalidate_prior_defeasible_conclusion
}
PARACONSISTENT_REASONING {
 PURPOSE := reason_with_contradictions_without_arbitrary_explosion
}
CLASSICAL_EXPLOSION {
 P∧¬P ⊢ Q
 under classical logic
}
INTUITIONISTIC_REASONING {
 classical_principles MUST_NOT be assumed unless derivable
}
MODAL_REASONING {
 OPERATORS := {Necessity,Possibility}
 REQUIRE modal_system_and_semantics
}
TEMPORAL_REASONING {
 OPERATORS := {Next,Eventually,Globally,Until}
 REQUIRE temporal_semantics
}
FUZZY_REASONING {
 TRUTH_VALUES := graded
 REQUIRE fuzzy_operator_and_inference_semantics
}

FALLACY_DETECTION {
 EXAMPLES := {AffirmingTheConsequent,DenyingTheAntecedent}
}
AFFIRMING_THE_CONSEQUENT {
 P->Q
 Q
 THEREFORE P
 STATUS := invalid_in_classical_logic
}
DENYING_THE_ANTECEDENT {
 P->Q
 ¬P
 THEREFORE ¬Q
 STATUS := invalid_in_classical_logic
}

PROOF_TRACE {
 RECORD := {
  Premises,
  Assumptions,
  RuleAppliedPerStep,
  DerivedFormulae,
  DischargedAssumptions,
  FinalConclusion
 }
}

ARGUMENT_VALIDATION(Γ,C,Logic L) {
 IDENTIFY syntax_and_semantics_of_L
 IF finite_propositional_classical
  THEN truth_table_SAT_resolution_or_natural_deduction
 ELSE IF proof_system_available
  THEN attempt_derivation
 IF model_search_available
  THEN search_for_countermodel
 RETURN validated_status
}

APPLICATION_RELATIONSHIPS {
 LogicalReasoning --supports--> Mathematics
 LogicalReasoning --supports--> ProofTheory
 LogicalReasoning --supports--> ModelTheory
 LogicalReasoning --supports--> AutomatedTheoremProving
 LogicalReasoning --supports--> ArtificialIntelligence
 LogicalReasoning --supports--> FormalVerification
 LogicalReasoning --supports--> KnowledgeRepresentation
 LogicalReasoning --supports--> ComputerScience
}

ONTOLOGY_LINKS {
 PARENT := MathematicalLogicOntologies
 RELATED := {
  PropositionalLogicOntology,
  PredicateLogicOntology,
  BooleanLogicOntology,
  ModalLogicOntology,
  FuzzyLogicOntology,
  ProofTheoryOntology,
  ModelTheoryOntology,
  ResolutionOntology,
  NaturalDeductionOntology,
  LogicalEquivalenceOntology,
  SatisfiabilityOntology
 }
}

SEMANTIC_EQUIVALENCE {
 LogicalReasoning ≈ FormalReasoning WHEN explicit_logical_rules_govern_inference
 SemanticEntailment ≈ ModelTheoreticConsequence
 SyntacticDerivability ≈ ProvabilityInSpecifiedProofSystem
 Countermodel ≈ ModelRefutingEntailment
}

CONSTRAINTS {
 C1 := reasoning MUST identify the logical system when validity depends on it
 C2 := syntactic derivability and semantic entailment MUST remain distinct
 C3 := inference rules MUST be applied only when premises and side conditions hold
 C4 := soundness/completeness claims MUST be relative to specified systems
 C5 := induction and abduction MUST NOT be presented as deductive entailment
 C6 := Skolemisation MUST be treated as equisatisfiability-preserving
 C7 := classical principles MUST NOT automatically transfer to non-classical logics
 C8 := contradiction consequences MUST respect selected logic
 C9 := countermodels MUST satisfy premises while falsifying conclusion
 C10 := quantifier rules MUST obey variable restrictions
 C11 := proof traces MUST preserve rule-by-rule validity
 C12 := conclusions MUST remain scoped to premises and assumptions
}

REASONING_CHAIN Query Q {
 IDENTIFY target_claim
 IDENTIFY premises Γ
 IDENTIFY logical_language
 IDENTIFY logic L
 IDENTIFY proof_or_semantic_framework
 PARSE formulae
 NORMALISE where useful

 IF deductive_entailment_requested {
  ATTEMPT proof_search
  ATTEMPT countermodel_search_if_needed
 }
 IF propositional_classical
  THEN use truth_table_SAT_resolution_or_natural_deduction
 IF first_order
  THEN manage quantifiers_unification_and_resolution
 IF modal_temporal_fuzzy_or_nonclassical
  THEN invoke corresponding_semantic_constraints
 IF contradiction_found
  THEN determine logic_specific_consequence_policy
 IF proof_found
  THEN validate every_inference_step
 IF countermodel_found
  THEN return non_entailment_with_countermodel

 BUILD proof_trace
 VALIDATE constraints
 RETURN result WITH derivation
}

CONFIDENCE {
 CORE_DEDUCTIVE_REASONING := 1.00
 CLASSICAL_INFERENCE_RULES := 1.00
 SEMANTIC_ENTAILMENT := 1.00
 SYNTACTIC_DERIVABILITY := 1.00
 RESOLUTION_CORE := 1.00
 QUANTIFIER_RULES := 0.99
 NONCLASSICAL_TRANSFER_RESTRICTION := 1.00
 SPECIFIC_RESULT :=
  IF premises_logic_and_rules_complete THEN 1.00
  ELSE REQUIRE missing_information
}

UPDATE_MODEL {
 IMMUTABLE_CORE := {
  PremiseConclusionDistinction,
  InferenceRuleConcept,
  SemanticEntailment,
  SyntacticDerivability,
  ValidityConditions
 }
 EXTENSIBLE := {
  ProofSystems,
  LogicalLanguages,
  DecisionProcedures,
  NonClassicalLogics,
  AutomatedReasoningMethods,
  DefeasibleReasoning,
  ApplicationDomains,
  RelatedOntologies
 }
 ON_NEW_KNOWLEDGE {
  IDENTIFY logical_framework
  VALIDATE syntax
  VALIDATE inference_rules
  CHECK semantic_assumptions
  CHECK proof_steps
  CHECK countermodels
  CHECK semantic_consistency
  ADD relationship IF non_contradictory
  UPDATE confidence
 }
}

AI_CONSUMPTION {
 MACHINE_READABLE := TRUE
 HUMAN_INTERPRETABLE := TRUE
 RECURSIVE_REASONING := TRUE
 ENTITY_RESOLUTION := TRUE
 FORMULA_RESOLUTION := TRUE
 INFERENCE_RULE_REASONING := TRUE
 PROOF_SEARCH := TRUE
 COUNTERMODEL_REASONING := TRUE
 UNIFICATION_REASONING := TRUE
 RESOLUTION_REASONING := TRUE
 QUANTIFIER_REASONING := TRUE
 LOGIC_SELECTION := TRUE
 PROOF_TRACE_GENERATION := TRUE
 VALIDATION_REQUIRED := TRUE
}

FLOW_HASH {
 TARGET := TARGET_URL
 SUBJECT := "Logical Reasoning Ontology"
 VERSION := "1.0"
 CANONICAL_SIGNATURE := HASH(TARGET + SUBJECT + DOMAIN + VERSION)
}

OUTPUT {
 PRIMARY_ENTITY := LogicalReasoning
 INTERPRETATION := "Logical reasoning derives and evaluates conclusions from premises using explicitly defined logical systems, inference rules, proof procedures and semantic models. It distinguishes derivability from entailment, proof from countermodel, and deductive guarantee from inductive, abductive or defeasible support."
}

END_FLOW