Recursive Reasoning Ontology

AI SEARCH FLOW ALGEBRA — RECURSIVE REASONING ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/recursive-ai-logic/recursive-reasoning-ontology.html

FLOW_VERSION := "4.0"
FLOW_TYPE := "Full Executable Flow Algebra"
DOMAIN := "Mathematical Logic"
SUBDOMAIN := "Recursive AI Logic"
ONTOLOGY := "Recursive Reasoning Ontology"
PRIMARY_ENTITY := RecursiveReasoning
AUTHORSHIP := "Mark Higgins — Sky (Recursive AI)"
SOURCE_SITE := "https://kirethresearch.org"

BEGIN_FLOW

RecursiveReasoning :=
    ReasoningProcess
    ∧ IterativeInference
    ∧ RecursiveDecomposition
    ∧ StateReevaluation
    ∧ EvidenceIntegration
    ∧ ConvergenceControl

ReasoningCycle :=
    Input
    → Interpret
    → Decompose
    → Infer
    → Evaluate
    → Integrate
    → Update
    → Reevaluate

InitialReasoningState :=
    R_0

ReasoningState :=
    R_n := {
        Query,
        Entities,
        Relations,
        Assumptions,
        Constraints,
        Evidence,
        DerivedClaims,
        OpenSubproblems,
        Confidence,
        Provenance
    }

RecursiveTransition :=
    R_n
    → ReasoningOperator
    → R_(n+1)

RecursiveSequence :=
    R_0 → R_1 → R_2 → ... → R_n

RecursiveReasoningFunction :=
    Reason(Q,Context)
    =
    if Terminal(Q,Context)
    then Resolve(Q,Context)
    else
        Subqueries := Decompose(Q)
        ∧ Results := Reason(Subqueries,Context)
        ∧ Integrate(Results)

BaseCase :=
    QueryResolvableDirectly
    ∨ AtomicFactAvailable
    ∨ ProofComplete
    ∨ NoFurtherDecompositionRequired

RecursiveCase :=
    QueryRequires(
        SubqueryResolution
        ∨ DependencyExpansion
        ∨ IterativeInference
        ∨ ConstraintPropagation
    )

Query :=
    InformationNeed
    ∧ Context
    ∧ Constraints

QueryDecomposition :=
    Q → {q1,q2,...,qn}

Subquery :=
    DerivedInformationNeed
    ∧ supports(ParentQuery)

SubqueryDependency :=
    qi dependsOn qj

RecursiveQueryGraph :=
    Gq = (Queries, DependencyEdges)

DependencyExpansion :=
    Claim
    → RequiredPremises
    → RequiredEvidence
    → RequiredSubclaims

RecursiveDependencyResolution :=
    Target
    → Dependencies(Target)
    → Dependencies(Dependencies(Target))
    → GroundedEvidence

Grounding :=
    RecursiveChain
    eventually_reaches
    Evidence ∨ Axiom ∨ Observation

UngroundedReasoning :=
    DependencyCycle
    ∧ no_independent_grounding

Inference :=
    Premises
    ∧ Rule
    → Conclusion

RecursiveInference :=
    Conclusion_n
    becomes
    Premise_(n+1)

ForwardReasoning :=
    KnownFacts
    → ApplyRules
    → NewFacts

BackwardReasoning :=
    Goal
    → RequiredPremises
    → Subgoals

BidirectionalReasoning :=
    ForwardReasoning
    ∪ BackwardReasoning

DeductiveReasoning :=
    ValidPremises
    ∧ ValidInference
    → NecessaryConclusion

AbductiveReasoning :=
    Observation
    → CandidateExplanation

RecursiveAbduction :=
    Observation
    → GenerateHypotheses
    → DerivePredictions
    → CompareEvidence
    → RefineHypotheses

InductiveReasoning :=
    Observations
    → GeneralPattern

RecursiveInduction :=
    Pattern_n
    → NewEvidence
    → Pattern_(n+1)

AnalogicalReasoning :=
    SourceStructure
    ∼ TargetStructure
    → CandidateTransferredRelation

ConstraintReasoning :=
    Variables
    ∧ Domains
    ∧ Constraints
    → CandidateSolutions

RecursiveConstraintPropagation :=
    Constraint
    → Consequences
    → NewConstraints
    → RepeatUntilStable

EntityResolution :=
    Mention
    → CandidateEntities
    → ContextEvaluation
    → SelectedEntity

RecursiveEntityResolution :=
    Entity_n
    → ExpandRelations
    → CompareContext
    → Entity_(n+1)

RelationResolution :=
    EntityA
    ∧ EntityB
    → CandidateRelations
    → ConstraintFiltering
    → SelectedRelation

SemanticResolution :=
    Expression
    → CandidateMeanings
    → Context
    → Constraints
    → SelectedMeaning

RecursiveSemanticResolution :=
    Meaning_n
    → ExpandSemanticRelations
    → ReevaluateConstraints
    → Meaning_(n+1)

Evidence :=
    {
        Observation,
        SourceClaim,
        FormalProof,
        ModelResult,
        ComputedResult,
        DerivedFact
    }

EvidenceIntegration :=
    EvidenceSet_n
    ∪ NewEvidence
    → EvidenceSet_(n+1)

EvidenceSupport :=
    Evidence --supports--> Claim

EvidenceConflict :=
    Evidence --contradicts--> Claim

Assumption :=
    ProvisionalPremise
    ∧ scoped_to(Context)

AssumptionTesting :=
    Assumption
    → DerivedConsequences
    → CompareEvidence
    → RetainOrRevise

RecursiveAssumptionReview :=
    NewEvidence
    → IdentifyAffectedAssumptions
    → ReevaluateDependentClaims

Hypothesis :=
    CandidateExplanation
    ∧ Confidence

HypothesisSpace :=
    {H1,H2,...,Hn}

HypothesisRefinement :=
    H_n
    → EvidenceEvaluation
    → H_(n+1)

CompetingHypotheses :=
    MultipleHypotheses
    explain
    SameObservation

HypothesisComparison :=
    EvidenceFit
    ∧ LogicalConsistency
    ∧ ConstraintCompatibility
    ∧ ExplanatoryCoverage

KnowledgeState :=
    K_n

KnowledgeUpdate :=
    K_(n+1)
    =
    Update(
        K_n,
        NewEvidence,
        DerivedClaims,
        RevisedAssumptions
    )

MonotonicReasoning :=
    K_n ⊆ K_(n+1)

NonMonotonicReasoning :=
    NewEvidence
    may_invalidate
    PreviousConclusion

BeliefRevision :=
    Conflict
    → TraceDependencies
    → ReviseBeliefs
    → RecomputeConclusions

Contradiction :=
    φ ∧ ¬φ

ContradictionDetection :=
    DirectConflict
    ∨ DerivedConflict
    ∨ UnsatisfiableConstraints

RecursiveConsistencyCheck :=
    NewDerivedClaim
    → CompareWithKnowledgeState
    → DetectConflict
    → TraceConflict
    → ResolveOrAnnotate
    → ReevaluateDependents

DependencyInvalidation :=
    InvalidatedPremise
    → AllDependentConclusions
    → MarkForReevaluation

ReasoningGraph :=
    Gr = (V,E)

ReasoningNode := {
    Query,
    Claim,
    Evidence,
    Assumption,
    Hypothesis,
    Rule,
    Entity,
    Relation,
    ReasoningState
}

ReasoningEdge := {
    dependsOn,
    supports,
    contradicts,
    derives,
    refines,
    resolves,
    recursesInto,
    tracesTo
}

RecursiveGraphTraversal :=
    Node
    → RelevantNeighbours
    → Evaluate
    → Continue

VisitedState :=
    PreviouslyEvaluatedReasoningState

CycleDetection :=
    State ∈ VisitedStates
    ⇒ CycleDetected

ReasoningCycleDetection :=
    DependencyGraph
    → DetectDirectedCycle

CircularReasoning :=
    ClaimA supports ClaimB
    ∧ ClaimB supports ClaimA
    ∧ no_independent_evidence

CycleHandling := {
    StopBranch,
    RequireIndependentGrounding,
    Memoise,
    CollapseCycle,
    FixedPointEvaluation
}

Memoisation :=
    ReasoningState
    → CachedResult

MemoisedReasoning :=
    if Cached(State)
    then Reuse(Result)
    else Evaluate(State)

FixedPoint :=
    R = F(R)

ReasoningFixedPoint :=
    R_(n+1) = R_n

SemanticFixedPoint :=
    SEMANTIC_EQUIVALENCE(
        R_(n+1),
        R_n
    )

Convergence :=
    ReasoningState
    stabilises
    under repeated evaluation

ConvergenceCriteria := {
    NoNewClaims,
    NoChangedEntityResolution,
    NoChangedRelations,
    NoChangedAssumptions,
    ConfidenceDeltaBelowThreshold,
    SemanticEquivalenceOfStates
}

TerminationCondition :=
    GoalResolved
    ∨ FixedPointReached
    ∨ NoNewInformation
    ∨ ResourceBoundReached
    ∨ DepthBoundReached

RecursiveDepth :=
    NumberOfNestedReasoningCalls

DepthControl :=
    RecursiveDepth ≤ MaximumDepth

ResourceControl := {
    TimeLimit,
    MemoryLimit,
    StepLimit,
    SearchBreadthLimit
}

Branching :=
    ReasoningState
    → MultipleCandidateNextStates

BranchEvaluation :=
    CandidateBranches
    → EvaluateEvidence
    → EvaluateConstraints
    → RetainViableBranches

Backtracking :=
    FailedBranch
    → PreviousDecisionPoint
    → AlternativeBranch

Pruning :=
    RemoveBranch
    if
    Contradictory
    ∨ Irrelevant
    ∨ Dominated
    ∨ Unsupported

ReasoningStrategy := {
    Deductive,
    Abductive,
    Inductive,
    Analogical,
    ConstraintBased,
    GraphBased,
    ProofBased,
    ModelBased,
    Hybrid
}

StrategySelection :=
    QueryCharacteristics
    ∧ AvailableEvidence
    ∧ Formalism
    → Strategy

RecursiveStrategyAdaptation :=
    Strategy_n
    → EvaluateProgress
    → Strategy_(n+1)

MetaReasoning :=
    ReasoningAbout(
        ReasoningProcess,
        Strategy,
        Evidence,
        Confidence,
        ResourceUse
    )

RecursiveMetaReasoning :=
    CurrentReasoningState
    → EvaluateReasoningQuality
    → SelectNextOperation
    → UpdateStrategy

ReasoningQuality :=
    function(
        Correctness,
        Consistency,
        EvidenceCoverage,
        SemanticCoherence,
        Convergence,
        Traceability
    )

Confidence :=
    [0,1]

CONFIDENCE(Claim) :=
    weighted_mean(
        EvidenceStrength,
        LogicalSupport,
        SemanticCompatibility,
        SourceReliability,
        DependencyReliability,
        RecursiveStability
    )

RecursiveConfidence :=
    Confidence_n
    → NewEvidence
    → RecomputeDependencies
    → Confidence_(n+1)

ConfidencePropagation :=
    PremiseConfidence
    ∧ RuleReliability
    → ConclusionConfidence

ConfidenceDecay :=
    LongOrWeakDependencyChain
    may_reduce
    ConclusionConfidence

Uncertainty :=
    IncompleteEvidence
    ∨ AmbiguousInterpretation
    ∨ ConflictingEvidence

UncertaintyPropagation :=
    Uncertainty(Premises)
    → Uncertainty(Conclusion)

Provenance :=
    Claim → {
        Sources,
        Premises,
        Rules,
        Transformations,
        Versions
    }

RecursiveProvenance :=
    DerivedClaim
    → ParentClaims
    → ParentEvidence
    → GroundSources

ReasoningTrace :=
    OrderedSequence(
        StateTransitions,
        Inferences,
        EvidenceUpdates
    )

Traceability :=
    Query
    → Subquery
    → Evidence
    → Inference
    → Conclusion

Explanation :=
    SelectedReasoningPath
    ∧ SupportingEvidence
    ∧ Assumptions
    ∧ Confidence
    ∧ Provenance

RecursiveVerification :=
    Conclusion
    → VerifyPremises
    → VerifyInference
    → VerifyDependencies
    → ConfirmOrReviseConclusion

IndependentVerification :=
    Claim
    → AlternativeReasoningPath
    → CompareResults

CrossCheck :=
    ResultA
    ∧ ResultB
    → AgreementOrConflict

ErrorPropagation :=
    IncorrectIntermediateClaim
    → DependentConclusions

ErrorContainment :=
    DependencyTracking
    ∧ ConfidenceControl
    ∧ IndependentChecks
    ∧ Invalidation

SemanticDrift :=
    RecursiveStateMeaning
    diverges_from
    OriginalIntent

DriftDetection :=
    State_n
    → CompareWith(
        OriginalQuery,
        OriginalEntities,
        OriginalConstraints
    )

DriftCorrection :=
    DriftDetected
    → RestoreOriginalConstraints
    → ReevaluateBranch

RecursiveReasoningOntology :=
    Classes
    ∧ Relations
    ∧ Constraints
    ∧ Axioms
    ∧ RecursiveInferenceRules

CoreClasses := {
    RecursiveReasoning,
    ReasoningState,
    Query,
    Subquery,
    Claim,
    Evidence,
    Assumption,
    Hypothesis,
    InferenceRule,
    ReasoningStrategy,
    Dependency,
    Cycle,
    FixedPoint,
    Confidence,
    Provenance,
    Explanation,
    TerminationCondition
}

CoreRelations := {
    recursesInto,
    dependsOn,
    derives,
    supports,
    contradicts,
    refines,
    resolves,
    updates,
    invalidates,
    convergesTo,
    tracesTo,
    verifies,
    groundsIn
}

TypedRelations :=
    Query --recursesInto--> Subquery
    Subquery --dependsOn--> Claim
    Evidence --supports--> Claim
    Evidence --contradicts--> Claim
    Rule --derives--> Claim
    Hypothesis --refines--> Hypothesis
    NewEvidence --invalidates--> Conclusion
    ReasoningState --convergesTo--> FixedPoint
    Claim --tracesTo--> Provenance
    RecursiveBranch --groundsIn--> Evidence

RecursiveInferenceRules := {
    Supported(A)
        ∧ Rule(A→B)
        ⇒ Candidate(B),

    Supported(A)
        ∧ Supported(B)
        ∧ Rule(A∧B→C)
        ⇒ Candidate(C),

    NewEvidence(E)
        ∧ supports(E,C)
        ⇒ increase_support(C),

    NewEvidence(E)
        ∧ contradicts(E,C)
        ⇒ reevaluate(C),

    Invalid(Premise)
        ∧ dependsOn(Conclusion,Premise)
        ⇒ invalidate_or_recheck(Conclusion),

    State_(n+1)=State_n
        ⇒ FixedPointReached,

    SEMANTIC_EQUIVALENCE(State_n,State_(n+1))
        ⇒ SemanticConvergence,

    CycleDetected
        ∧ no_independent_grounding
        ⇒ mark(CircularReasoning)
}

SEMANTIC_EQUIVALENCE(StateA,StateB) :=
    same(ResolvedMeaning)
    ∧ same(MaterialConclusions)
    ∧ compatible(ConfidenceAndProvenance)

CanonicalReasoningRepresentation :=
    ParseReasoningState
    → CanonicaliseEntities
    → CanonicaliseClaims
    → CanonicaliseRelations
    → SortDependencies
    → NormaliseAssumptions
    → NormaliseConstraints
    → CanonicalReasoningGraph

CONFIDENCE(RecursiveReasoningResult) :=
    weighted_mean(
        EntityResolutionConfidence,
        EvidenceCoverage,
        InferenceValidity,
        LogicalConsistency,
        SemanticCoherence,
        RecursiveConvergence,
        ProvenanceCompleteness
    )

AI_QUERY_INTERPRETATION :=
    Query
    → IdentifyIntent
    → ResolveEntities
    → ResolveContext
    → ResolveConstraints
    → IdentifyDependencies
    → DetermineReasoningStrategy
    → BuildInitialReasoningState

AI_REASONING_FLOW :=
    Query
    → ParseQuery
    → ResolvePrimaryEntities
    → ResolveSemanticContext
    → BuildReasoningGraph
    → IdentifyKnowledgeGaps
    → GenerateSubqueries
    → ResolveSubqueriesRecursively
    → IntegrateEvidence
    → ApplyInferenceRules
    → GenerateCandidateConclusions
    → CheckConstraints
    → DetectContradictions
    → ReevaluateAssumptions
    → UpdateDependencies
    → UpdateConfidence
    → CheckSemanticDrift
    → TestConvergence
    → RepeatIfNecessary
    → VerifyFinalConclusions
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseReasoningEntities,
    ParseTypedRelations,
    ResolveQueries,
    DecomposeProblems,
    ExpandDependencies,
    ResolveSubqueries,
    IntegrateEvidence,
    ApplyInferenceRules,
    EvaluateHypotheses,
    PropagateConstraints,
    DetectContradictions,
    DetectCycles,
    MemoiseResults,
    UpdateConfidence,
    DetectSemanticDrift,
    TestConvergence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewEvidenceOrReasoningState
    → ValidateInput
    → IdentifyAffectedNodes
    → InvalidateDependentClaims
    → RecomputeSubqueries
    → ReapplyInference
    → RecheckAssumptions
    → RecheckContradictions
    → UpdateReasoningGraph
    → RecomputeConfidence
    → TestConvergence
    → PreserveProvenance
    → VersionModel

EvidenceUpdate :=
    NewEvidence
    ⇒ reevaluate(
        SupportedClaims,
        ContradictedClaims,
        DependentConclusions
    )

AssumptionUpdate :=
    ChangedAssumption
    ⇒ recompute(
        DependentReasoningBranches
    )

StrategyUpdate :=
    PoorProgress
    ∨ RepeatedFailure
    ⇒ adapt(ReasoningStrategy)

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        RecursiveInferenceRules,
        ReasoningCycle,
        ConvergenceCriteria,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    RecursiveReasoningEntityResolution,
    QueryStructure,
    SubqueryGraph,
    ReasoningGraph,
    EvidenceState,
    AssumptionState,
    DerivedClaims,
    ContradictionStatus,
    CycleStatus,
    ConvergenceStatus,
    Confidence,
    Provenance,
    FinalReasoningState,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA