AI Logic

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

BEGIN_FLOW

ENTITY AILogic {
 TYPE := FormalArtificialIntelligenceReasoningFramework
 DEFINITION := "A formal framework integrating logical representation, inference, constraints, uncertainty, knowledge structures and machine reasoning so AI systems can derive, test, revise and explain conclusions."
}
ENTITY Knowledge { TYPE := MachineRepresentableInformation }
ENTITY Inference { TYPE := ReasoningTransformation }
ENTITY Query { TYPE := ReasoningGoal }
ENTITY Conclusion { TYPE := DerivedOrEvaluatedResult }

RELATIONSHIP AILogic --represents--> Knowledge
RELATIONSHIP AILogic --uses--> Inference
RELATIONSHIP AILogic --evaluates--> Query
RELATIONSHIP AILogic --produces--> Conclusion
RELATIONSHIP AILogic --supports--> ArtificialIntelligence
RELATIONSHIP AILogic --supports--> AutomatedReasoning

AI_LOGIC_SYSTEM {
 COMPONENTS := {
  KnowledgeRepresentation,FormalLanguage,Semantics,
  InferenceRules,ReasoningStrategy,Constraints,
  UncertaintyModel,Provenance,Explanation
 }
}

KNOWLEDGE_BASE {
 MAY_INCLUDE := {
  Facts,Rules,OntologyAxioms,Constraints,
  Probabilities,Defaults,Context,Provenance
 }
}

ASSERTED_KNOWLEDGE { ORIGIN := ExternalSourceOrInput }
DERIVED_KNOWLEDGE { ORIGIN := FormalInference }
PREDICTED_KNOWLEDGE { ORIGIN := StatisticalOrLearnedModel }
HYPOTHESISED_KNOWLEDGE { ORIGIN := AbductiveOrGenerativeProcess }

KNOWLEDGE_STATUS_DISTINCTION {
 Asserted != Derived != Predicted != Hypothesised
}

LOGIC_FAMILIES {
 INCLUDE := {
  PropositionalLogic,
  PredicateLogic,
  DescriptionLogic,
  ModalLogic,
  TemporalLogic,
  FuzzyLogic,
  NonMonotonicLogic,
  ParaconsistentLogic,
  ProbabilisticLogic,
  RuleLogic,
  ConstraintLogic
 }
}

KNOWLEDGE_REPRESENTATION {
 Entities + Concepts + Relations + Rules + Constraints + Context
 -> MachineInterpretableKnowledge
}

ONTOLOGY {
 Classes + Individuals + Properties + Axioms
 -> FormalConceptualModel
}

KNOWLEDGE_GRAPH {
 Entities + TypedRelations + Schema + Provenance
 -> SemanticGraph
}

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
}

SOUNDNESS {
 Derivable(C) -> Entailed(C)
 REQUIRE sound_proof_system
}

COMPLETENESS {
 Entailed(C) -> Derivable(C)
 REQUIRE logic_and_calculus_specific_theorem
}

DEDUCTIVE_REASONING {
 premises_and_rules -> logically_necessary_conclusion
}

INDUCTIVE_REASONING {
 observations -> generalisation_or_prediction
 STATUS := AmpliativeSupport
}

ABDUCTIVE_REASONING {
 observations -> candidate_explanatory_hypotheses
 STATUS := CandidateExplanation
}

ANALOGICAL_REASONING {
 source_structure + target_similarity -> defeasible_transfer
}

RULE_BASED_REASONING {
 Facts + Rules -> DerivedFacts
}

CONSTRAINT_REASONING {
 Variables + Domains + Constraints -> Propagation + Search
}

FORWARD_CHAINING {
 Facts -> ApplicableRules -> NewFacts -> FixedPointOrGoal
}

BACKWARD_CHAINING {
 Goal -> SupportingRules -> Subgoals -> ProofOrFailureStatus
}

RESOLUTION {
 ClausesWithComplementaryLiterals -> Resolvent
}

FIRST_ORDER_RESOLUTION {
 Clauses + Unification -> Resolvent
}

UNIFICATION {
 Expressions -> Substitution -> MatchingExpressions
}

SAT_REASONING {
 BooleanFormula -> SatisfyingAssignmentOrUNSAT
}

SMT_REASONING {
 BooleanStructure + TheoryConstraints -> ModelOrUNSAT
}

THEOREM_PROVING {
 Axioms + Conjecture -> ProofSearch -> ProofOrSearchStatus
}

MODEL_CHECKING {
 Model + FormalProperty -> SatisfactionResult
}

COUNTERMODEL {
 Model satisfying premises
 AND falsifying conclusion
 -> NonEntailment
}

INFERENCE_ENGINE {
 KnowledgeBase + Query + ReasoningProcedure -> ReasoningResult
}

RULE_ENGINE {
 WorkingMemory + RuleBase -> MatchSelectActCycle
}

CONSTRAINT_PROPAGATION {
 Constraints -> RemoveUnsupportedValues -> ReducedDomains
}

SEARCH {
 Alternatives -> Branch -> Evaluate -> BacktrackOrContinue
}

HEURISTIC_SEARCH {
 prioritises promising_states
 WARNING := FailureDoesNotProveNonExistence
}

NONMONOTONIC_REASONING {
 Defaults + Exceptions + Priorities -> DefeasibleConclusions
}

DEFAULT_REASONING {
 Normally P -> Q
 unless defeated
}

BELIEF_REVISION {
 CurrentBeliefs + NewInformation -> RevisedBeliefs
}

TRUTH_MAINTENANCE {
 SupportingKnowledgeChanges -> UpdateDependentConclusions
}

RETRACTION {
 RemovedOrDefeatedSupport -> RetractUnsupportedConclusion
}

OPEN_WORLD_ASSUMPTION {
 MissingFact DOES_NOT imply False
}

CLOSED_WORLD_ASSUMPTION {
 MissingOrUnprovableFact MAY imply False
 REQUIRE explicit_semantics
}

NEGATION_AS_FAILURE {
 not P := FailureToProve(P)
 MUST_NOT_CONFLATE_WITH := ClassicalNegation
}

UNCERTAINTY_MODELS {
 INCLUDE := {
  Probability,
  FuzzyDegree,
  Confidence,
  Possibility,
  BeliefFunction
 }
}

UNCERTAINTY_SEMANTICS_WARNING {
 Probability,
 FuzzyTruth,
 Confidence,
 Possibility
 MUST_NOT be treated_as_interchangeable
}

BAYESIAN_REASONING {
 Prior + Likelihood + Evidence -> Posterior
}

BAYES_RULE {
 P(H|E)=P(E|H)P(H)/P(E)
}

FUZZY_INFERENCE {
 FuzzyInputs + FuzzyRules -> FuzzyOutput
}

POSSIBILISTIC_REASONING {
 Possibility + NecessityMeasures -> UncertaintyReasoning
 REQUIRE possibility_theory_semantics
}

CAUSAL_REASONING {
 CausalModel + EvidenceOrIntervention -> CausalInference
}

CAUSAL_WARNING {
 Correlation DOES_NOT by_itself establish Causation
}

TEMPORAL_REASONING {
 Events + States + Time + TemporalRules -> TemporalConclusions
}

SPATIAL_REASONING {
 Entities + Locations + SpatialRelations -> SpatialConclusions
}

PLANNING_LOGIC {
 InitialState + Actions + Goals + Constraints -> Plan
}

ACTION {
 Preconditions + Effects
}

STATE_TRANSITION {
 State_t + Action -> State_t+1
}

GOAL_REASONING {
 CurrentState + GoalCondition -> RequiredActionsOrSubgoals
}

AGENT_REASONING {
 Beliefs + Goals + Intentions + Observations -> DecisionsOrActions
}

EPISTEMIC_LOGIC_RELATIONSHIP {
 AgentKnowledgeAndBelief -> EpistemicReasoning
}

DEONTIC_LOGIC_RELATIONSHIP {
 Obligations + Permissions + Prohibitions -> NormativeReasoning
}

DYNAMIC_LOGIC_RELATIONSHIP {
 Programs + Actions + ModalOperators -> StateTransitionReasoning
}

MULTI_AGENT_REASONING {
 MultipleAgents + Beliefs + Communication + Goals -> InteractionReasoning
}

KNOWLEDGE_GRAPH_REASONING {
 GraphStatements + Ontology + Rules -> DerivedStatements
}

ONTOLOGY_REASONING {
 Axioms -> Classification -> InstanceInference -> ConsistencyChecking
}

INSTANCE_PROPAGATION {
 a instance_of C
 C subclass_of D
 -> a instance_of D
}

SEMANTIC_CONSTRAINT {
 FormalRestriction -> AdmissibilityOrValidationCondition
}

VALIDATION {
 DataOrKnowledge + Constraints -> ConformanceReport
}

VALIDATION_VS_ENTAILMENT {
 Validation := ConformanceCheck
 Entailment := SemanticConsequence
 MUST_REMAIN_DISTINCT := TRUE
}

SHACL_RELATIONSHIP {
 GraphValidation MAY use SHACLStyleConstraints
}

OWL_RELATIONSHIP {
 OntologySemantics MAY use OWLDescriptionLogicAxioms
}

RDF_RELATIONSHIP {
 GraphKnowledge MAY use RDFTriples
}

PROVENANCE {
 KnowledgeItem -> Source -> Time -> Evidence -> Derivation
}

JUSTIFICATION {
 Conclusion -> SupportingFactsRulesAxioms
}

EXPLANATION {
 ReasoningResult -> InferenceTrace -> Justification -> Provenance
}

INFERENCE_TRACE {
 RECORD := {
  Step,
  Premises,
  RuleOrModel,
  Bindings,
  Conclusion,
  ResultStatus,
  Dependencies
 }
}

LOGICAL_AI_VS_MACHINE_LEARNING {
 LogicalAI := ExplicitSymbolsRulesSemantics
 MachineLearning := LearnedStatisticalOrFunctionalModels
 MAY_COMBINE := TRUE
}

NEURO_SYMBOLIC_AI {
 LearnedRepresentations + SymbolicKnowledge + LogicalReasoning -> HybridAI
}

SYMBOL_GROUNDING {
 Symbols -> PerceptsDataOrReferents
}

GROUNDING_WARNING {
 ungrounded_symbol MAY produce semantically_invalid_reasoning
}

LLM_RELATIONSHIP {
 LanguageModel MAY generate {
  CandidateFacts,
  Hypotheses,
  Rules,
  Queries,
  Explanations
 }
 REQUIRE ValidationBeforeFormalAcceptance
}

LLM_OUTPUT_STATUS {
 GeneratedStatement := CandidateKnowledge
 until ValidatedOrFormallyDerived
}

RETRIEVAL_AUGMENTED_REASONING {
 Query -> RetrieveEvidence -> ConstructContext -> ReasonOrGenerate -> Validate
}

RAG_WARNING {
 RetrievedText := EvidenceOrContext
 NOT automatically FormalTruth
}

TOOL_AUGMENTED_REASONING {
 AI -> SelectTool -> ExecuteTool -> ObserveResult -> UpdateReasoningState
}

TOOL_RESULT {
 SHOULD preserve {
  Source,
  Time,
  Parameters,
  ResultStatus
 }
}

RECURSIVE_REASONING {
 Result_n -> Evaluate -> GenerateNextSubproblem -> Result_n+1
}

RECURSION_TERMINATION {
 STOP_WHEN := {
  GoalSatisfied,
  FixedPoint,
  ProofComplete,
  ResourceLimit,
  NoValidProgress
 }
}

SELF_CORRECTION {
 CandidateReasoning -> Verification -> ErrorDetection -> Revision
}

VERIFICATION {
 CHECK {
  Syntax,
  Semantics,
  RuleValidity,
  Evidence,
  Constraints,
  Consistency
 }
}

HALLUCINATION_CONTROL {
 GeneratedClaim -> EvidenceCheck -> FormalConsistencyCheck -> StatusLabel
}

UNKNOWN_STATUS {
 InsufficientInformation
 MUST_NOT be converted_to TrueOrFalseWithoutBasis
}

AI_REASONING_STATUS {
 MAY_INCLUDE := {
  Proven,
  Entailed,
  Supported,
  Predicted,
  Hypothesised,
  Contradicted,
  Unknown,
  Invalid,
  Timeout
 }
}

STATUS_SEMANTICS {
 each_status MUST have explicit_definition
}

KNOWLEDGE_UPDATE {
 NewFactOrEvidence -> Validate -> Integrate -> RecomputeAffectedConclusions
}

INCREMENTAL_REASONING {
 ChangedKnowledge -> AffectedDependencies -> PartialRecomputation
}

CACHE_INVALIDATION {
 SupportingKnowledgeChange -> InvalidateAffectedCache
}

MATERIALISATION {
 PrecomputeEntailments -> StoreDerivedKnowledge
}

QUERY_TIME_REASONING {
 DeriveConclusionsDuringQuery
}

RESOURCE_LIMIT {
 MAY_INCLUDE := {
  Time,
  Memory,
  SearchDepth,
  ToolCalls,
  InferenceSteps
 }
}

COMPUTATIONAL_COMPLEXITY {
 depends_on := {
  Logic,
  Representation,
  Query,
  SearchSpace,
  ReasoningTask
 }
}

DECIDABILITY {
 TargetProblemHasTerminatingCorrectDecisionProcedure
}

APPROXIMATE_REASONING {
 MAY trade completeness_or_precision for efficiency
 REQUIRE explicit_approximation_metadata
}

CORRECTNESS_FIRST {
 Optimisation MUST_NOT silently alter semantics
}

AI_LOGIC_PIPELINE {
 INPUT := Query Q

 IDENTIFY task
 IDENTIFY knowledge_sources
 IDENTIFY representation
 IDENTIFY logic_or_reasoning_framework
 IDENTIFY uncertainty_model
 IDENTIFY constraints

 RETRIEVE required_knowledge
 VALIDATE source_and_structure
 RESOLVE entities
 CHECK consistency

 SELECT inference_method
 EXECUTE reasoning
 VERIFY intermediate_steps

 IF uncertainty_present:
  APPLY declared_uncertainty_semantics

 IF contradictions_present:
  APPLY declared_conflict_policy

 IF new_evidence_arrives:
  UPDATE knowledge
  RETRACT_or_REVISE affected_conclusions

 BUILD inference_trace
 BUILD justification
 BUILD provenance
 ASSIGN result_status

 VALIDATE final_result
 RETURN answer_with_trace
}

AI_LOGIC_VS_CLASSICAL_LOGIC {
 ClassicalLogic := FormalTruthPreservingConsequence
 AILogic := BroaderAIReasoningLayerCombiningMultipleFormalisms
}

AI_LOGIC_VS_KNOWLEDGE_REPRESENTATION {
 KnowledgeRepresentation := StructuresInformation
 AILogic := ReasonsOverStructuredInformation
}

AI_LOGIC_VS_INFERENCE_ENGINE {
 InferenceEngine := ComputationalMechanism
 AILogic := FormalSemanticFramework
}

AI_LOGIC_VS_HEURISTIC {
 Heuristic := SearchOrDecisionShortcut
 Logic := FormalConsequenceFramework
 HEURISTIC_MUST_NOT be presented_as Proof
}

APPLICATION_RELATIONSHIPS {
 AILogic --supports--> ArtificialIntelligence
 AILogic --supports--> KnowledgeRepresentation
 AILogic --supports--> AutomatedReasoning
 AILogic --supports--> ExpertSystems
 AILogic --supports--> KnowledgeGraphs
 AILogic --supports--> Ontologies
 AILogic --supports--> Planning
 AILogic --supports--> DecisionSupport
 AILogic --supports--> FormalVerification
 AILogic --supports--> NeuroSymbolicAI
 AILogic --supports--> ExplainableAI
}

ONTOLOGY_LINKS {
 PARENT := MathematicalLogicOntologies

 RELATED := {
  LogicalReasoningOntology,
  KnowledgeRepresentationLogicOntology,
  PredicateLogicOntology,
  ModalLogicOntology,
  FuzzyLogicOntology,
  DeductiveReasoningOntology,
  InductiveReasoningOntology,
  AbductiveReasoningOntology,
  RuleBasedReasoningOntology,
  NonMonotonicReasoningOntology,
  KnowledgeGraphLogicOntology,
  InferenceEngineOntology,
  SemanticConstraintOntology
 }
}

SEMANTIC_EQUIVALENCE {
 AILogic ≈ LogicBasedArtificialIntelligence
  WHEN SymbolicFormalReasoningContext

 AIInference ≈ MachineReasoning
  WHEN InferenceProcessFormallyDefined

 NeuroSymbolicAI ≈ HybridLearnedSymbolicReasoning
  WHEN BothComponentsPresent
}

CONSTRAINTS {
 C1 := EveryFormalReasoningResult MUST identify inference_or_semantic_basis
 C2 := AssertedDerivedPredictedHypothesisedKnowledge MUST remain distinguishable
 C3 := DeductiveEntailment MUST_NOT be conflated with inductive_abductive_statistical_support
 C4 := ProbabilityFuzzyTruthConfidencePossibility MUST remain semantically_distinct
 C5 := OpenClosedWorldAssumptions MUST be explicit where relevant
 C6 := GeneratedLanguageModelContent MUST_NOT automatically become verified_formal_knowledge
 C7 := ValidationResults MUST remain distinct from LogicalEntailments
 C8 := HeuristicSearchFailure MUST_NOT be presented_as proof_of_nonexistence
 C9 := Contradictions MUST be handled according_to declared_logical_framework
 C10 := ProvenanceAndDependencies SHOULD be preserved for derived_conclusions
 C11 := Approximation MUST be explicit when soundness_completeness_or_precision relaxed
 C12 := FinalResultStatus MUST accurately reflect proof_evidence_prediction_hypothesis_or_uncertainty
}

REASONING_CHAIN Query Q {
 IDENTIFY task
 IDENTIFY knowledge_base
 IDENTIFY representation
 IDENTIFY logic
 IDENTIFY uncertainty_semantics
 IDENTIFY constraints
 IDENTIFY available_reasoners_or_tools

 VALIDATE inputs
 RESOLVE entities
 CHECK consistency
 DECOMPOSE complex_query_into_subproblems

 FOR_EACH subproblem {
  SELECT appropriate_reasoning_method
  EXECUTE
  VERIFY intermediate_result
  RECORD dependencies
 }

 COMBINE compatible_results

 IF conflict:
  APPLY declared_conflict_policy

 IF uncertainty:
  APPLY declared_uncertainty_model

 IF generated_or_predicted_claim:
  LABEL status_correctly
  SEEK validation_if_required

 BUILD recursive_reasoning_trace
 BUILD justification
 BUILD provenance
 VALIDATE constraints
 RETURN result WITH explicit_status
}

CONFIDENCE {
 CORE_AI_LOGIC := 1.00
 LOGICAL_INFERENCE := 1.00
 KNOWLEDGE_REPRESENTATION_RELATIONSHIP := 1.00
 SYMBOLIC_STATISTICAL_DISTINCTION := 1.00
 NONMONOTONIC_UNCERTAINTY_DISTINCTIONS := 1.00
 NEURO_SYMBOLIC_RELATIONSHIP := 0.99
 LLM_FORMAL_KNOWLEDGE_DISTINCTION := 1.00

 SPECIFIC_RESULT :=
  IF task_knowledge_semantics_and_evidence_complete
  THEN FrameworkSpecificConfidence
  ELSE REQUIRE MissingInformation
}

UPDATE_MODEL {
 IMMUTABLE_CORE := {
  FormalSemantics,
  KnowledgeStatusDistinction,
  InferenceValidation,
  Provenance,
  ExplicitResultStatus
 }

 EXTENSIBLE := {
  LogicFamilies,
  ReasoningAlgorithms,
  KnowledgeRepresentations,
  UncertaintyModels,
  PlanningMethods,
  AgentLogics,
  NeuroSymbolicMethods,
  ToolReasoning,
  ApplicationDomains,
  RelatedOntologies
 }

 ON_NEW_KNOWLEDGE {
  IDENTIFY source_and_status
  VALIDATE representation
  RESOLVE entities
  CHECK semantic_consistency
  UPDATE dependencies
  RECOMPUTE affected_conclusions
  UPDATE provenance
  UPDATE confidence
 }
}

AI_CONSUMPTION {
 MACHINE_READABLE := TRUE
 HUMAN_INTERPRETABLE := TRUE
 RECURSIVE_REASONING := TRUE
 ENTITY_RESOLUTION := TRUE
 KNOWLEDGE_STATUS_RESOLUTION := TRUE
 LOGICAL_INFERENCE := TRUE
 RULE_REASONING := TRUE
 CONSTRAINT_REASONING := TRUE
 ONTOLOGY_REASONING := TRUE
 KNOWLEDGE_GRAPH_REASONING := TRUE
 UNCERTAINTY_REASONING := TRUE
 NONMONOTONIC_REASONING := TRUE
 PLANNING_REASONING := TRUE
 TOOL_AUGMENTED_REASONING := TRUE
 SELF_VERIFICATION := TRUE
 PROVENANCE_TRACKING := TRUE
 JUSTIFICATION_GENERATION := TRUE
 VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
 PRIMARY_ENTITY := AILogic
 INTERPRETATION := "AI logic provides a formal reasoning layer connecting symbolic knowledge representation, deduction, rules, constraints, uncertainty, planning, ontologies, knowledge graphs and machine reasoning. It can coordinate learned or language-model components provided generated and predicted claims remain distinct from formally entailed knowledge and are validated with explicit provenance, semantics and result status."
}

END_FLOW