Inference Engine Ontology

FLOW_ALGEBRA InferenceEngineOntology v1.0
TARGET_URL := "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/knowledge-representation-logic/inference-engine-ontology.html"
LANGUAGE := "en-GB"
DOMAIN := MathematicalOntologies > MathematicalLogicOntologies > KnowledgeRepresentationLogic > InferenceEngineOntology

BEGIN_FLOW

ENTITY InferenceEngine {
 TYPE := AutomatedReasoningSystem
 DEFINITION := "A computational mechanism that applies formal inference rules, logical semantics, constraints or reasoning procedures to a knowledge base to derive conclusions, answer queries, detect inconsistencies and construct explainable reasoning traces."
}
ENTITY KnowledgeBase { TYPE := StructuredKnowledgeStore }
ENTITY Fact { TYPE := AssertedOrDerivedKnowledge }
ENTITY Rule { TYPE := FormalInferenceStructure }
ENTITY Query { TYPE := ReasoningGoal }
ENTITY Conclusion { TYPE := DerivedKnowledge }

RELATIONSHIP InferenceEngine --operates_on--> KnowledgeBase
RELATIONSHIP InferenceEngine --uses--> Rule
RELATIONSHIP InferenceEngine --consumes--> Fact
RELATIONSHIP InferenceEngine --evaluates--> Query
RELATIONSHIP InferenceEngine --produces--> Conclusion
RELATIONSHIP InferenceEngine --produces--> InferenceTrace

INFERENCE_ENGINE {
 COMPONENTS := {
  KnowledgeBase,ReasoningModel,RuleOrAxiomSet,
  MatchingOrProofProcedure,SearchStrategy,
  ConflictPolicy,ExplanationFacility
 }
}
KNOWLEDGE_BASE {
 MAY_INCLUDE := {Facts,Rules,OntologyAxioms,Constraints,Context,Provenance}
}
ASSERTED_FACT { ORIGIN := ExternalSource }
DERIVED_FACT { ORIGIN := InferenceProcess }
ASSERTED_VS_DERIVED { MUST_REMAIN_DISTINCT := TRUE }

INFERENCE_RULE {
 PREMISES := {P1,...,Pn}
 CONCLUSION := C
}
RULE_APPLICATION {
 IF premises_hold AND side_conditions_hold
 THEN derive conclusion
}
SEMANTIC_ENTAILMENT {
 KB entails C IFF every model_of_KB satisfies C
 under declared_semantics
}
SYNTACTIC_DERIVABILITY {
 KB proves C IFF C derivable_using selected_calculus
}
SYNTACTIC_SEMANTIC_DISTINCTION {
 Derivability MUST_NOT be conflated_with Entailment
}
SOUNDNESS {
 IF engine derives C THEN C semantically_entailed
 REQUIRE sound_procedure
}
COMPLETENESS {
 IF C entailed THEN engine_can_derive C
 REQUIRE fragment_and_search_guarantees
}

FORWARD_CHAINING {
 TYPE := DataDrivenReasoning
 START := KnownFacts
 REPEAT {
  MATCH applicable_rules
  DERIVE conclusions
  ADD nonduplicate_facts
 }
 UNTIL := {FixedPoint,GoalReached,ResourceLimit}
}
BACKWARD_CHAINING {
 TYPE := GoalDrivenReasoning
 START := QueryGoal
 FIND supporting_rules_or_axioms
 GENERATE subgoals
 RECURSE
}
HYBRID_REASONING {
 ForwardChaining + BackwardChaining
}
FIXED_POINT {
 KnowledgeState_next=KnowledgeState_current
}
RULE_MATCHING {
 RulePremises + KnownFacts -> Bindings -> ApplicableInference
}
UNIFICATION {
 symbolic_expressions -> substitution -> matching_formulae
}
MOST_GENERAL_UNIFIER {
 ABBREVIATION := MGU
 PROPERTY := every_other_unifier_factors_through_MGU
}
SIDE_CONDITION {
 MAY_INCLUDE := {Freshness,TypeConstraint,ScopeConstraint,TemporalConstraint,ContextConstraint}
}

AGENDA { TYPE := PendingInferenceSet }
CONFLICT_SET { TYPE := SimultaneouslyApplicableInferences }
CONFLICT_RESOLUTION {
 STRATEGIES := {Priority,Specificity,Recency,Salience,GoalRelevance}
 REQUIRE declared_semantics
}

SEARCH {
 STATE := CurrentReasoningState
 ACTION := ValidInferenceStep
 GOAL := TargetConclusionOrModel
}
DEPTH_FIRST_SEARCH { explores_one_branch_deeply }
BREADTH_FIRST_SEARCH { explores_frontier_level_by_level }
BEST_FIRST_SEARCH { prioritises_by_heuristic_score }
HEURISTIC_WARNING {
 failed_heuristic_search DOES_NOT prove non_derivability
}
LOOP_DETECTION {
 repeated_state -> prune_or_memoise
}
MEMOISATION {
 cache solved_subgoals_or_derived_results
}
TABLING {
 store_goal_answers to avoid repeated_recursion
}

PROOF_SEARCH {
 INPUT := KB + Goal + Calculus
 OUTPUT := ProofOrSearchStatus
}
MODEL_SEARCH {
 INPUT := KB + Formula
 OUTPUT := ModelOrCountermodelOrSearchStatus
}
COUNTERMODEL {
 M satisfies KB AND M falsifies Query
 -> query_not_entailed
}
REFUTATION {
 add NOT(Goal)
 derive contradiction
 under compatible calculus
}
RESOLUTION_RELATIONSHIP {
 clauses + complementary_literals + unification -> resolvents
}
TABLEAU_RELATIONSHIP {
 formulae -> expansion_rules -> open_or_closed_branches
}
NATURAL_DEDUCTION_RELATIONSHIP {
 introduction_elimination_rules -> proof
}

DESCRIPTION_LOGIC_REASONING {
 TASKS := {Consistency,Satisfiability,Subsumption,Classification,InstanceChecking,Realisation}
}
ONTOLOGY_REASONING {
 OntologyAxioms -> Entailments -> InferredOntology
}
CLASSIFICATION {
 asserted_hierarchy + axioms -> inferred_hierarchy
}
INSTANCE_REASONING {
 IndividualAssertions + OntologyAxioms -> inferred_types_relations
}
KNOWLEDGE_GRAPH_REASONING {
 GraphStatements + Schema + Rules -> DerivedGraphStatements
}
PROPERTY_PATH_REASONING {
 relation_sequence -> reachable_entities
}
TRANSITIVE_REASONING {
 R(a,b) AND R(b,c) -> R(a,c)
 REQUIRE R declared_transitive
}
SUBCLASS_REASONING {
 C subclass_of D
 D subclass_of E
 -> C subclass_of E
}
INSTANCE_PROPAGATION {
 a instance_of C
 C subclass_of D
 -> a instance_of D
}
DOMAIN_RANGE_REASONING {
 R(a,b) + Domain(R)=C + Range(R)=D
 -> C(a),D(b)
 under suitable_semantics
}

CONSTRAINT_REASONING {
 Variables + Domains + Constraints -> Propagation + Search
}
SAT_REASONING {
 BooleanFormula -> SatisfyingAssignmentOrUNSAT
}
SMT_REASONING {
 BooleanStructure + TheoryConstraints -> ModelOrUNSAT
}
DPLL_T_RELATIONSHIP {
 SATCore + TheorySolver -> SMTReasoning
}
RULE_ENGINE_RELATIONSHIP {
 production_rule_match_select_act_cycle
}
RETE_RELATIONSHIP {
 incremental_pattern_matching MAY accelerate rule_matching
}
LOGIC_PROGRAMMING_RELATIONSHIP {
 Goals + Clauses + Unification -> ResolutionStyleReasoning
}
SLD_RELATIONSHIP {
 HornClauses + SelectedGoal + Unification -> SLDResolution
}
DATALOG_RELATIONSHIP {
 PositiveFunctionFreeRules -> LeastFixedPointEvaluation
}

NONMONOTONIC_REASONING {
 new_information MAY retract prior_conclusions
 REQUIRE nonmonotonic_semantics
}
DEFAULT_REASONING {
 normally P -> Q unless defeated
}
NEGATION_AS_FAILURE {
 not P := failure_to_prove_P
 REQUIRE explicit_semantics
}
PARACONSISTENT_REASONING {
 contradictions do_not_necessarily_explode
 REQUIRE paraconsistent_semantics
}
FUZZY_INFERENCE {
 graded_truth -> fuzzy_rule_evaluation
 REQUIRE fuzzy_semantics
}
PROBABILISTIC_INFERENCE {
 probabilistic_model + evidence -> posterior_or_distribution
 REQUIRE probabilistic_semantics
}
MODAL_INFERENCE {
 modal_formulae -> accessibility_reasoning
}
TEMPORAL_INFERENCE {
 temporal_formulae -> time_or_trace_reasoning
}

INFERENCE_MODE_SELECTION {
 INPUT := KnowledgeRepresentation + QueryType
 IF production_rules: SELECT rule_engine_strategy
 IF first_order_clauses: SELECT resolution_or_tableau
 IF description_logic: SELECT DL_reasoner
 IF constraints: SELECT constraint_solver
 IF BooleanSAT: SELECT SAT_solver
 IF SMT: SELECT SMT_solver
 IF nonmonotonic: SELECT corresponding_semantics
}

QUERY {
 MAY_BE := {
  EntailmentQuery,InstanceQuery,SubsumptionQuery,
  ConsistencyQuery,SatisfiabilityQuery,
  ConstraintQuery,PathQuery,ExplanationQuery
 }
}
QUERY_ANSWER {
 STATUS_MAY_INCLUDE := {
  Entailed,NotEntailed,Contradicted,Satisfiable,
  Unsatisfiable,Unknown,Timeout,FrameworkSpecificStatus
 }
}
UNKNOWN_DISTINCTION {
 Unknown MUST_NOT automatically mean False
}
TIMEOUT_DISTINCTION {
 Timeout MUST_NOT automatically mean NotEntailed
}

INFERENCE_TRACE {
 RECORD := {
  Step,Premises,RuleOrAxiom,Bindings,
  SideConditions,Conclusion,Dependencies
 }
}
PROOF_DAG {
 LEAVES := AssertedFactsOrAxioms
 INTERNAL_NODES := DerivedConclusions
 EDGES := InferenceDependencies
}
JUSTIFICATION {
 Conclusion -> SupportingFactsRulesAndAxioms
}
MINIMAL_JUSTIFICATION {
 subset_minimal_support
}
PROVENANCE {
 DerivedConclusion -> SourceKnowledge -> InferenceProcedure -> TransformationHistory
}
EXPLANATION {
 QueryAnswer -> InferenceTrace -> Justification -> Provenance
}
WHY_QUERY {
 RETURN supporting_reasoning_chain
}
WHY_NOT_QUERY {
 identify missing_premises_blocked_rules_countermodels_or_limits
 where supported
}

TRUTH_MAINTENANCE {
 supporting_knowledge_changes -> update_dependent_conclusions
}
DEPENDENCY_GRAPH {
 DerivedConclusion -> SupportingKnowledge
}
RETRACTION {
 removed_or_defeated_support -> retract_unsupported_conclusions
}
INCREMENTAL_REASONING {
 ChangedKnowledge -> recompute_affected_consequences
}
MATERIALISATION {
 precompute_entailments -> store_derived_knowledge
}
QUERY_TIME_INFERENCE {
 derive_consequences_during_query
}
CACHE_INVALIDATION {
 knowledge_change -> invalidate_affected_cached_results
}

VERIFY_INFERENCE_STEP(S) {
 IDENTIFY premises
 IDENTIFY rule_or_axiom
 CHECK bindings
 CHECK side_conditions
 CHECK conclusion
 RETURN valid_or_failure
}
VERIFY_INFERENCE_TRACE(T) {
 FOR_EACH step:
  VERIFY_INFERENCE_STEP
 RETURN valid_if_all_steps_valid
}
CONSISTENCY_CHECK {
 determine whether KB admits model
 under declared_semantics
}
INCONSISTENCY_EXPLANATION {
 inconsistent_KB -> conflicting_axioms_or_facts
}
UNSAT_CORE {
 subset_of_constraints_or_clauses jointly_unsatisfiable
}
CONFLICT_HANDLING {
 MAY_USE := {Reject,PriorityResolution,BeliefRevision,ParaconsistentReasoning,ManualReview}
}

OPEN_WORLD_ASSUMPTION {
 missing_fact DOES_NOT imply false
}
CLOSED_WORLD_ASSUMPTION {
 missing_or_unprovable_fact MAY imply false
 REQUIRE explicit_semantics
}
UNIQUE_NAME_ASSUMPTION {
 distinct_identifiers DO_NOT automatically imply distinct_entities
}

INFERENCE_ENGINE_VS_RULE_ENGINE {
 RuleEngine := specialised_rule_matching_execution
 InferenceEngine := broader_reasoning_mechanism
}
INFERENCE_ENGINE_VS_SOLVER {
 Solver := algorithm_specialised_for_problem_class
 InferenceEngine := reasoning_orchestration_layer
}
INFERENCE_ENGINE_VS_QUERY_ENGINE {
 QueryEngine := retrieves_or_matches_data
 InferenceEngine := derives_semantic_consequences
}
INFERENCE_ENGINE_VS_SEARCH_ENGINE {
 SearchEngine := information_retrieval
 InferenceEngine := formal_or_semantic_reasoning
 MUST_REMAIN_DISTINCT := TRUE
}

REASONING_PIPELINE {
 INPUT := KnowledgeBase + Query
 IDENTIFY representation_language
 IDENTIFY semantics
 VALIDATE input
 SELECT inference_mode
 EXECUTE reasoning
 VERIFY results
 BUILD explanation
 RETURN answer
}

ENGINE_CONFIGURATION {
 MAY_INCLUDE := {
  ReasoningMode,SearchStrategy,ConflictPolicy,
  ResourceLimits,CachingPolicy,ExplanationLevel,
  OpenClosedWorldPolicy
 }
}
ENGINE_PROFILE {
 supported_languages
 + supported_tasks
 + complexity_limits
 + completeness_guarantees
}
SOUNDNESS_METADATA {
 identifies tasks_fragments where sound
}
COMPLETENESS_METADATA {
 identifies tasks_fragments where complete
}
TERMINATION_METADATA {
 identifies tasks_fragments with guaranteed_termination
}
APPROXIMATE_REASONING {
 MAY trade completeness_or_precision for speed
 REQUIRE explicit_approximation_metadata
}
CORRECTNESS_FIRST {
 optimisation MUST_NOT change logical_results
 unless approximation_explicit
}

APPLICATION_RELATIONSHIPS {
 InferenceEngine --supports--> KnowledgeRepresentation
 InferenceEngine --supports--> ExpertSystems
 InferenceEngine --supports--> SemanticWeb
 InferenceEngine --supports--> KnowledgeGraphs
 InferenceEngine --supports--> Ontologies
 InferenceEngine --supports--> ArtificialIntelligence
 InferenceEngine --supports--> AutomatedTheoremProving
 InferenceEngine --supports--> DecisionSupport
 InferenceEngine --supports--> FormalVerification
 InferenceEngine --supports--> ConstraintSolving
}

ONTOLOGY_LINKS {
 PARENT := KnowledgeRepresentationLogicOntology
 RELATED := {
  KnowledgeRepresentationOntology,
  RuleEngineOntology,
  RuleBasedReasoningOntology,
  LogicalInferenceOntology,
  DescriptionLogicOntology,
  OntologyLogicOntology,
  KnowledgeGraphLogicOntology,
  ResolutionOntology,
  ConstraintReasoningOntology,
  NonMonotonicReasoningOntology,
  AutomatedReasoningOntology
 }
}

SEMANTIC_EQUIVALENCE {
 InferenceEngine ≈ AutomatedReasoningEngine WHEN broad_reasoning_context
 RuleInferenceEngine ≈ RuleEngine WHEN production_rule_context
 ReasoningTrace ≈ InferenceTrace
 DerivedFact ≈ InferredKnowledge
}

CONSTRAINTS {
 C1 := every inference MUST identify applicable logic_calculus_or_semantics
 C2 := asserted and derived knowledge MUST remain distinguishable
 C3 := syntactic derivability MUST_NOT be conflated with semantic entailment
 C4 := failure to find proof MUST_NOT automatically establish non_entailment
 C5 := timeout MUST_NOT be interpreted as logical falsehood
 C6 := search heuristics MUST_NOT change correctness unless approximation_explicit
 C7 := nonmonotonic fuzzy probabilistic and paraconsistent modes MUST identify semantics
 C8 := open_closed_world assumptions MUST be explicit when relevant
 C9 := inference traces MUST preserve premises rules bindings and dependencies
 C10 := cached/materialised conclusions MUST be invalidated when support changes
 C11 := soundness completeness termination claims MUST be scoped to fragments_and_tasks
 C12 := optimisation MUST preserve reasoning_semantics unless approximation_declared
}

REASONING_CHAIN Query Q {
 IDENTIFY knowledge_base KB
 IDENTIFY query Q
 IDENTIFY representation_language
 IDENTIFY semantics
 IDENTIFY inference_task
 IDENTIFY engine_capabilities
 IDENTIFY resource_limits

 VALIDATE knowledge_base
 VALIDATE query
 SELECT inference_mode

 IF forward_reasoning:
  MATCH rules
  DERIVE until goal_or_fixed_point

 IF backward_reasoning:
  DECOMPOSE goal
  SOLVE subgoals
  BUILD proof

 IF model_reasoning:
  SEARCH model_or_countermodel

 IF ontology_reasoning:
  CLASSIFY_or_CHECK_instances_or_consistency

 IF constraint_reasoning:
  PROPAGATE constraints
  SEARCH assignments

 IF nonmonotonic_reasoning:
  CHECK defaults_exceptions_retractions

 IF knowledge_changes:
  INVALIDATE caches
  UPDATE dependencies
  RECOMPUTE affected_conclusions

 VERIFY inference_trace
 BUILD justification
 BUILD provenance
 VALIDATE constraints
 RETURN reasoning_result WITH status_and_trace
}

CONFIDENCE {
 CORE_INFERENCE_ENGINE := 1.00
 FORWARD_BACKWARD_REASONING := 1.00
 SYNTACTIC_SEMANTIC_DISTINCTION := 1.00
 PROOF_MODEL_SEARCH_DISTINCTION := 1.00
 ONTOLOGY_REASONING_RELATIONSHIP := 1.00
 CONSTRAINT_SAT_SMT_RELATIONSHIP := 0.99
 TRACE_VALIDATION := 1.00
 SPECIFIC_RESULT :=
  IF kb_query_semantics_and_engine_profile_complete THEN 1.00
  ELSE REQUIRE missing_information
}

UPDATE_MODEL {
 IMMUTABLE_CORE := {
  KnowledgeBaseQueryStructure,
  InferenceRuleApplication,
  ReasoningModeSelection,
  ResultStatusDistinction,
  InferenceTrace
 }
 EXTENSIBLE := {
  ProofCalculi,
  ModelSearchMethods,
  RuleEngines,
  OntologyReasoners,
  ConstraintSolvers,
  SATSMTSolvers,
  NonClassicalReasoners,
  ExplanationMethods,
  ApplicationDomains,
  RelatedOntologies
 }
 ON_NEW_KNOWLEDGE {
  IDENTIFY new_fact_rule_axiom_or_constraint
  VALIDATE representation
  UPDATE indexes_and_dependencies
  CHECK consistency
  INVALIDATE affected_cache
  DERIVE affected_consequences
  UPDATE provenance
  UPDATE confidence
 }
}

AI_CONSUMPTION {
 MACHINE_READABLE := TRUE
 HUMAN_INTERPRETABLE := TRUE
 RECURSIVE_REASONING := TRUE
 ENTITY_RESOLUTION := TRUE
 RULE_REASONING := TRUE
 PROOF_SEARCH := TRUE
 MODEL_SEARCH := TRUE
 ONTOLOGY_REASONING := TRUE
 KNOWLEDGE_GRAPH_REASONING := TRUE
 CONSTRAINT_REASONING := TRUE
 SAT_SMT_REASONING := TRUE
 NONMONOTONIC_REASONING := TRUE
 TRACE_VALIDATION := TRUE
 JUSTIFICATION_GENERATION := TRUE
 PROVENANCE_TRACKING := TRUE
 TRUTH_MAINTENANCE := TRUE
 VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
 PRIMARY_ENTITY := InferenceEngine
 INTERPRETATION := "An inference engine applies explicit reasoning semantics to structured knowledge in order to derive conclusions, answer queries, find proofs or countermodels, detect inconsistencies and maintain dependent knowledge. It may coordinate rule engines, ontology reasoners, constraint solvers and SAT/SMT procedures while preserving result status, provenance and verifiable inference traces."
}

END_FLOW