Non-Monotonic Reasoning Ontology

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

BEGIN_FLOW

ENTITY NonMonotonicReasoning {
 TYPE := DefeasibleReasoningFramework
 DEFINITION := "Reasoning in which conclusions may be withdrawn when new information is added, supporting defaults, exceptions, priorities and changing knowledge."
}
ENTITY DefeasibleConclusion { TYPE := RetractableConclusion }
ENTITY DefaultRule { TYPE := NonMonotonicInferenceRule }
ENTITY Exception { TYPE := DefeaterOrBlockingCondition }

RELATIONSHIP NonMonotonicReasoning --produces--> DefeasibleConclusion
RELATIONSHIP NonMonotonicReasoning --uses--> DefaultRule
RELATIONSHIP Exception --defeats--> DefaultRule
RELATIONSHIP NonMonotonicReasoning --supports--> BeliefRevision
RELATIONSHIP NonMonotonicReasoning --supports--> CommonsenseReasoning

MONOTONICITY {
 Gamma subseteq Delta
 implies Cn(Gamma) subseteq Cn(Delta)
}
NON_MONOTONICITY {
 EXISTS Gamma subseteq Delta, phi:
  phi in Cn(Gamma)
  AND phi not_in Cn(Delta)
}
CORE_PATTERN {
 GIVEN knowledge K
 DERIVE tentative C
 RECEIVE new_information E
 IF E defeats support_for C:
  RETRACT C
 ELSE RETAIN C
}

DEFAULT_REASONING {
 FORM := Normally, if P then Q
 APPLY IF P established AND no defeating exception established
}
NEGATION_AS_FAILURE {
 not P := failure_to_prove P
 REQUIRE closed_world_or_procedural_semantics
 MUST_NOT_CONFLATE_WITH := classical_negation
}
OPEN_WORLD {
 absence_of_fact does_not_imply_false
}
CLOSED_WORLD {
 nonderivable_fact MAY be treated_as_false
 REQUIRE explicit_semantics
}
DEFEATER {
 TYPE := InformationBlockingOrOverridingInference
}
REBUTTING_DEFEATER {
 supports incompatible_conclusion
}
UNDERCUTTING_DEFEATER {
 attacks inference_link_or_support
}
SPECIFICITY {
 MoreSpecificRule MAY override MoreGeneralRule
 REQUIRE explicit_priority_semantics
}
PRIORITY {
 R1>R2
 means R1 defeats R2 when applicable_and_conflicting
 under declared framework
}

DEFAULT_LOGIC {
 TYPE := NonMonotonicLogic
}
DEFAULT_THEORY {
 COMPONENTS := {BackgroundTheory W,Defaults D}
}
DEFAULT_SCHEMA {
 alpha : beta / gamma
 INTERPRETATION :=
  if alpha holds and beta remains consistent,
  infer gamma
}
NORMAL_DEFAULT {
 alpha : beta / beta
}
DEFAULT_EXTENSION {
 TYPE := FixedPointBeliefSet
 REQUIRE framework_specific_construction
}
MULTIPLE_EXTENSIONS {
 theory MAY have zero_one_or_multiple_extensions
}
SKEPTICAL_REASONING {
 ACCEPT phi IF phi belongs_to all accepted_extensions
}
CREDULOUS_REASONING {
 ACCEPT phi IF phi belongs_to at_least_one accepted_extension
}

CIRCUMSCRIPTION {
 TYPE := NonMonotonicFormalism
 PRINCIPLE := minimise selected abnormality predicates/extensions
}
ABNORMALITY_PREDICATE {
 Ab(x) := exception_indicator
}
PREFERENTIAL_LOGIC {
 models equipped_with preference_relation
 consequence evaluated_on preferred_models
}
RANKED_MODEL {
 lower_rank := more_normal_or_preferred
}

ANSWER_SET_PROGRAMMING {
 ABBREVIATION := ASP
 TYPE := NonMonotonicLogicProgramming
}
STABLE_MODEL_SEMANTICS {
 Program -> CandidateInterpretation -> Reduct -> StableModelTest
}
GL_REDUCT {
 ABBREVIATION := GelfondLifschitzReduct
}
ASP_RULE {
 FORM := Head :- PositiveBody, not NegativeBody
}
ASP_SKEPTICAL_QUERY {
 true_in_all_answer_sets
}
ASP_CREDULOUS_QUERY {
 true_in_some_answer_set
}

DEFEASIBLE_LOGIC {
 TYPE := RuleBasedNonMonotonicLogic
}
STRICT_RULE {
 A -> B
}
DEFEASIBLE_RULE {
 A => B
}
DEFEATER_RULE {
 A ~> B
 PURPOSE := block_competing_inference
}
SUPERIORITY_RELATION {
 R1>R2
 PURPOSE := resolve_conflicting_defeasible_rules
}

ARGUMENTATION_RELATIONSHIP {
 NonMonotonicReasoning --relates_to--> AbstractArgumentation
}
ARGUMENTATION_FRAMEWORK {
 AF := (Arguments,AttackRelation)
}
ACCEPTABILITY_SEMANTICS := {
 Grounded,
 Preferred,
 Stable,
 Complete
}

BELIEF_REVISION {
 CurrentBeliefs + NewInformation -> RevisedBeliefs
}
AGM_RELATIONSHIP {
 OPERATIONS := {Expansion,Revision,Contraction}
}
TRUTH_MAINTENANCE {
 TrackJustifications -> RetractConclusionsWhenSupportInvalidated
}
DEPENDENCY_DIRECTED_RETRACTION {
 removed_support -> dependency_graph -> retract_unsupported_conclusions
}
JUSTIFICATION {
 Conclusion -> Premises + Rule + Assumptions
}

COMMONSENSE_REASONING {
 USES := {Defaults,Exceptions,IncompleteKnowledge,Context}
}
DEFAULT_PERSISTENCE {
 property_persists unless evidence_of_change
}
DIAGNOSTIC_REASONING {
 observations -> candidate_explanation -> revise_with_new_evidence
}
POLICY_REASONING {
 rules + overrides + exceptions -> policy_conclusion
}

PROBABILISTIC_DISTINCTION {
 NonMonotonicity := retractability_of_consequence
 Probability := quantitative_uncertainty
 MUST_NOT_CONFLATE := TRUE
}
FUZZY_DISTINCTION {
 FuzzyTruth := graded_truth
 NonMonotonicReasoning := defeasible_consequence
 MUST_NOT_CONFLATE := TRUE
}
PARACONSISTENT_DISTINCTION {
 Paraconsistency := controls_explosion
 NonMonotonicity := controls_retractability
 MAY_COMBINE := TRUE
 MUST_REMAIN_DISTINCT := TRUE
}

CONFLICT_DETECTION {
 IF derive P AND derive NOT(P):
  identify_conflicting_support
  apply_framework_specific_resolution
}
UNRESOLVED_CONFLICT {
 MAY return undecided_or_multiple_extensions_or_inconsistency
 depending_on semantics
}

DEFEASIBLE_PROOF_TRACE {
 RECORD := {
  Premises,
  Defaults,
  StrictRules,
  Exceptions,
  Priorities,
  Defeaters,
  AcceptedConclusions,
  RetractedConclusions
 }
}

UPDATE_WITH_NEW_INFORMATION(K,E) {
 ADD E
 RECOMPUTE applicable_defaults
 IDENTIFY defeated_inferences
 RETRACT unsupported_conclusions
 DERIVE newly_supported_conclusions
 RETURN updated_belief_state
}

APPLICATION_RELATIONSHIPS {
 NonMonotonicReasoning --supports--> CommonsenseReasoning
 NonMonotonicReasoning --supports--> ArtificialIntelligence
 NonMonotonicReasoning --supports--> KnowledgeRepresentation
 NonMonotonicReasoning --supports--> ExpertSystems
 NonMonotonicReasoning --supports--> Diagnosis
 NonMonotonicReasoning --supports--> Planning
 NonMonotonicReasoning --supports--> PolicyReasoning
 NonMonotonicReasoning --supports--> BeliefRevision
 NonMonotonicReasoning --supports--> LogicProgramming
}

ONTOLOGY_LINKS {
 PARENT := LogicalReasoningOntology
 RELATED := {
  RuleBasedReasoningOntology,
  LogicalInferenceOntology,
  DeductiveReasoningOntology,
  AbductiveReasoningOntology,
  DefaultLogicOntology,
  CircumscriptionOntology,
  AutoepistemicLogicOntology,
  AnswerSetProgrammingOntology,
  DefeasibleLogicOntology,
  BeliefRevisionOntology,
  ArgumentationOntology,
  ParaconsistentLogicOntology
 }
}

SEMANTIC_EQUIVALENCE {
 NonMonotonicReasoning ≈ DefeasibleReasoning WHEN conclusions_are_retractable
 SkepticalConsequence ≈ AcceptedInAllExtensions WHEN extension_semantics
 CredulousConsequence ≈ AcceptedInSomeExtension WHEN extension_semantics
}

CONSTRAINTS {
 C1 := nonmonotonic conclusions MUST be potentially retractable
 C2 := selected formalism and semantics MUST be identified
 C3 := negation_as_failure MUST NOT be conflated with classical negation
 C4 := closed_world assumptions MUST be explicit
 C5 := priorities/specificity MUST NOT be assumed without declared ordering
 C6 := skeptical and credulous consequence MUST remain distinct
 C7 := multiple extensions MUST NOT be collapsed without justification
 C8 := nonmonotonicity MUST NOT be conflated with probability
 C9 := nonmonotonicity MUST NOT be conflated with fuzzy truth
 C10 := paraconsistency and nonmonotonicity MUST remain distinct unless combined explicitly
 C11 := retraction SHOULD preserve dependency/provenance
 C12 := conclusions MUST remain scoped to current knowledge, priorities and semantics
}

REASONING_CHAIN Query Q {
 IDENTIFY knowledge_base K
 IDENTIFY strict_facts
 IDENTIFY defaults
 IDENTIFY exceptions
 IDENTIFY priorities
 IDENTIFY selected_semantics

 DERIVE strict_consequences
 IDENTIFY applicable_defaults
 IDENTIFY defeaters
 RESOLVE priorities_or_specificity

 IF extension_based {
  COMPUTE candidate_extensions
  IF skeptical_query: CHECK all_extensions
  IF credulous_query: CHECK some_extension
 }

 IF ASP_context:
  COMPUTE stable_models

 IF new_information {
  UPDATE knowledge_state
  RETRACT defeated_conclusions
  RECOMPUTE dependencies
 }

 IF conflict:
  APPLY framework_specific_conflict_handling

 BUILD defeasible_proof_trace
 VALIDATE constraints
 RETURN conclusion_status WITH derivation
}

CONFIDENCE {
 CORE_NONMONOTONIC_DEFINITION := 1.00
 DEFAULT_REASONING := 1.00
 SKEPTICAL_CREDULOUS_DISTINCTION := 1.00
 CIRCUMSCRIPTION_CORE := 0.99
 STABLE_MODEL_RELATIONSHIP := 0.99
 BELIEF_REVISION_RELATIONSHIP := 0.99
 PARACONSISTENCY_DISTINCTION := 1.00
 SPECIFIC_RESULT :=
  IF knowledge_rules_priorities_and_semantics_complete THEN 1.00
  ELSE REQUIRE missing_information
}

UPDATE_MODEL {
 IMMUTABLE_CORE := {
  RetractableConsequence,
  DefaultExceptionStructure,
  DefeaterConcept,
  KnowledgeUpdateSensitivity,
  SemanticFrameworkDependence
 }
 EXTENSIBLE := {
  DefaultLogics,
  PreferentialSemantics,
  CircumscriptionMethods,
  StableModelSemantics,
  DefeasibleRuleSystems,
  BeliefRevisionMethods,
  ArgumentationSemantics,
  ApplicationDomains,
  RelatedOntologies
 }
 ON_NEW_KNOWLEDGE {
  IDENTIFY new_fact_or_rule
  UPDATE knowledge_state
  CHECK default_applicability
  CHECK exceptions
  CHECK priorities
  RETRACT defeated_conclusions
  DERIVE new_conclusions
  UPDATE confidence
 }
}

AI_CONSUMPTION {
 MACHINE_READABLE := TRUE
 HUMAN_INTERPRETABLE := TRUE
 RECURSIVE_REASONING := TRUE
 ENTITY_RESOLUTION := TRUE
 DEFAULT_RULE_REASONING := TRUE
 EXCEPTION_REASONING := TRUE
 DEFEATER_REASONING := TRUE
 PRIORITY_REASONING := TRUE
 SKEPTICAL_REASONING := TRUE
 CREDULOUS_REASONING := TRUE
 STABLE_MODEL_REASONING := TRUE
 BELIEF_REVISION := TRUE
 TRUTH_MAINTENANCE := TRUE
 RETRACTION_REASONING := TRUE
 PROVENANCE_TRACKING := TRUE
 VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
 PRIMARY_ENTITY := NonMonotonicReasoning
 INTERPRETATION := "Non-monotonic reasoning supports defeasible conclusions that can be withdrawn when new facts, exceptions or higher-priority rules appear. Default logic, circumscription, defeasible logic and answer-set programming provide different formal semantics for this behaviour while preserving the distinction between tentative consequence and monotonic deduction."
}

END_FLOW