Semantic Recursion Ontology

AI SEARCH FLOW ALGEBRA — SEMANTIC RECURSION ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/recursive-ai-logic/semantic-recursion-ontology.html

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

BEGIN_FLOW

SemanticRecursion :=
    RecursiveMeaningConstruction
    ∧ CompositionalInterpretation
    ∧ IterativeSemanticResolution
    ∧ FixedPointSemantics
    ∧ ContextPropagation
    ∧ ConvergenceControl

SemanticObject :=
    Expression
    ∨ Entity
    ∨ Relation
    ∨ Proposition
    ∨ Structure

SemanticState :=
    S_n := {
        Expressions,
        ResolvedEntities,
        ResolvedRelations,
        Context,
        Constraints,
        Interpretations,
        SemanticValues,
        Confidence,
        Provenance
    }

InitialSemanticState :=
    S_0

SemanticTransition :=
    S_n
    → SemanticOperator
    → S_(n+1)

SemanticRecursionSequence :=
    S_0 → S_1 → S_2 → ... → S_n

SemanticFunction :=
    [[·]] : Syntax → Meaning

RecursiveSemanticFunction :=
    [[Composite(x1,...,xn)]]
    =
    F(
        [[x1]],
        ...,
        [[xn]]
    )

Compositionality :=
    Meaning(Whole)
    determined_by
    Meaning(Parts)
    ∧ CompositionRule

AtomicMeaning :=
    MeaningAssignedDirectly
    to AtomicExpression

CompositeMeaning :=
    SemanticFunction(
        MeaningsOfImmediateComponents
    )

SemanticBaseCase :=
    AtomicExpression
    ∨ GroundedEntity
    ∨ PrimitiveSemanticValue

SemanticRecursiveCase :=
    CompositeExpression
    → ResolveSubexpressions
    → CombineMeanings

SemanticEvaluation :=
    Expression
    → Decompose
    → EvaluateComponents
    → ComposeMeaning

RecursiveInterpretation :=
    Expression
    → CandidateInterpretation
    → ResolveDependencies
    → ReevaluateInterpretation
    → repeat_until_stable

Interpretation :=
    Mapping(
        SyntaxOrSymbol,
        SemanticObject
    )

SemanticDomain :=
    SetOfPossibleMeanings

Denotation :=
    Expression
    → SemanticObject

Reference :=
    Symbol
    → Entity

Extension :=
    Predicate
    → SetOfEntitiesOrTuples

Intension :=
    Expression
    → Function(Context,Extension)

Context :=
    {
        Domain,
        Scope,
        Time,
        Assumptions,
        Ontology,
        Discourse,
        Constraints
    }

ContextPropagation :=
    ParentContext
    → ChildExpression
    → LocalContext

ContextInheritance :=
    ChildContext
    inherits
    applicable(ParentConstraints)

ContextOverride :=
    LocalContext
    may_refine
    inherited(Context)

SemanticDependency :=
    Meaning(A)
    dependsOn
    Meaning(B)

SemanticDependencyGraph :=
    Gs = (SemanticObjects, DependencyEdges)

RecursiveDependencyResolution :=
    Meaning(Target)
    → Meanings(Dependencies)
    → Meanings(DependenciesOfDependencies)
    → GroundSemanticValues

GroundedMeaning :=
    SemanticValue
    linked_to
    PrimitiveDefinition
    ∨ FormalInterpretation
    ∨ ExternalEvidence
    ∨ OntologyEntity

UngroundedSemanticCycle :=
    Meaning(A)
    dependsOn Meaning(B)
    ∧ Meaning(B) dependsOn Meaning(A)
    ∧ no_independent_grounding

SemanticCycleDetection :=
    DependencyGraph
    → DetectCycle
    → TestGrounding

SemanticCycleHandling := {
    FixedPointEvaluation,
    CollapseStronglyConnectedComponent,
    RequireExternalGrounding,
    MarkUnresolved
}

FixedPoint :=
    M = F(M)

LeastFixedPoint :=
    μF

GreatestFixedPoint :=
    νF

SemanticFixedPointIteration :=
    M_0
    → F(M_0)
    → F²(M_0)
    → ...
    → M*

MonotoneSemanticOperator :=
    A ⊑ B
    ⇒ F(A) ⊑ F(B)

SemanticOrdering :=
    LessInformation
    ⊑
    MoreInformation

BottomMeaning :=
    ⊥
    := UndefinedOrLeastInformation

SemanticConvergence :=
    SEMANTIC_EQUIVALENCE(
        S_n,
        S_(n+1)
    )

ExactSemanticConvergence :=
    S_n = S_(n+1)

ApproximateSemanticConvergence :=
    semantic_distance(S_n,S_(n+1))
    ≤ ε

SemanticStability :=
    NoMaterialMeaningChange
    ∧ NoMaterialRelationChange
    ∧ ConfidenceDeltaBelowThreshold

RecursiveEntitySemantics :=
    EntityMention
    → CandidateEntities
    → CandidateMeanings
    → ContextEvaluation
    → RelationExpansion
    → RevisedEntityMeaning

RecursiveRelationSemantics :=
    RelationMention
    → CandidatePredicates
    → DomainRangeConstraints
    → NeighbourRelations
    → SelectedRelationMeaning

TypedSemanticEntity :=
    Entity
    ∧ SemanticType

TypedSemanticRelation :=
    Predicate(
        SourceType,
        TargetType
    )

OntologySemantics :=
    Classes
    ∧ Properties
    ∧ Individuals
    ∧ Axioms
    → Interpretation

ClassMeaning :=
    Class
    → SetOfInstances

PropertyMeaning :=
    Property
    → Relation

IndividualMeaning :=
    IndividualIdentifier
    → DomainEntity

RecursiveClassResolution :=
    Class
    → Superclasses
    → Restrictions
    → Instances
    → RefinedClassMeaning

Subsumption :=
    A ⊑ B

RecursiveSubsumption :=
    A ⊑ B
    ∧ B ⊑ C
    ⇒ A ⊑ C

Inheritance :=
    Instance(x,A)
    ∧ A ⊑ B
    ⇒ Instance(x,B)

SemanticConstraint :=
    RestrictionOnMeaningOrInterpretation

ConstraintPropagation :=
    SemanticConstraint
    → DependentInterpretations
    → RevisedCandidateMeanings

DomainConstraint :=
    Relation
    → RequiredSourceType

RangeConstraint :=
    Relation
    → RequiredTargetType

CardinalityConstraint :=
    Relation
    → AllowedNumberOfValues

IdentityConstraint :=
    SameAs
    ∨ DifferentFrom

SemanticCompatibility :=
    CandidateMeaning
    ∧ Context
    ∧ Constraints
    are_jointly_consistent

SemanticConflict :=
    CandidateMeanings
    cannot_jointly_satisfy
    ActiveConstraints

Contradiction :=
    MeaningSupports(φ)
    ∧ MeaningSupports(¬φ)

RecursiveSemanticConsistency :=
    NewMeaning
    → CompareWithSemanticState
    → DetectConflict
    → TraceDependencies
    → ReviseOrAnnotate
    → ReevaluateDependents

SemanticDisambiguation :=
    AmbiguousExpression
    → CandidateMeanings
    → ContextFiltering
    → ConstraintFiltering
    → RelationCompatibility
    → SelectedMeaning

RecursiveDisambiguation :=
    SelectedMeaning_n
    → ExpandSemanticNeighbourhood
    → ReevaluateContext
    → SelectedMeaning_(n+1)

Polysemy :=
    Expression
    → MultipleRelatedMeanings

Homonymy :=
    Expression
    → MultipleDistinctMeanings

Coreference :=
    MultipleMentions
    → SameEntity

RecursiveCoreferenceResolution :=
    Mention
    → CandidateAntecedents
    → SemanticCompatibility
    → ContextUpdate
    → ReevaluateMentions

SemanticComposition :=
    MeaningA
    ⊗ MeaningB
    → CompositeMeaning

RecursiveComposition :=
    Compose(
        Resolve(Component1),
        ...,
        Resolve(ComponentN)
    )

SemanticReduction :=
    ComplexMeaning
    → SimplerEquivalentRepresentation

SemanticNormalForm :=
    CanonicalMeaningRepresentation

Canonicalisation :=
    SemanticState
    → NormaliseEntities
    → NormaliseRelations
    → NormaliseConstraints
    → NormaliseMeanings

SemanticEquivalence :=
    Meaning(A) = Meaning(B)

SEMANTIC_EQUIVALENCE(A,B) :=
    same(Denotation)
    ∧ same(TruthConditions)
    ∧ same(RelevantRelations)

ContextualSemanticEquivalence :=
    ∀RelevantContext C :
        Meaning(A,C) = Meaning(B,C)

SemanticSubsumption :=
    Meaning(A)
    more_specific_than
    Meaning(B)

SemanticRefinement :=
    Meaning_n
    → AdditionalEvidence
    → Meaning_(n+1)

RecursiveSemanticRefinement :=
    CandidateMeaning
    → Evidence
    → Constraints
    → RefinedMeaning
    → Repeat

SemanticEvidence :=
    {
        Definition,
        OntologyAxiom,
        RelationPattern,
        ContextualEvidence,
        FormalProof,
        SourceEvidence
    }

EvidenceIntegration :=
    SemanticEvidence
    → UpdateCandidateMeanings
    → RecomputeConfidence

CONFIDENCE(SemanticMeaning) :=
    weighted_mean(
        EntityResolution,
        RelationResolution,
        ContextFit,
        ConstraintConsistency,
        EvidenceStrength,
        RecursiveStability,
        ProvenanceQuality
    )

RecursiveConfidenceUpdate :=
    Confidence_n
    → NewSemanticEvidence
    → RecomputeDependencies
    → Confidence_(n+1)

SemanticUncertainty :=
    Ambiguity
    ∨ MissingContext
    ∨ ConflictingEvidence
    ∨ IncompleteGrounding

UncertaintyPropagation :=
    UncertainComponentMeaning
    → UncertaintyInCompositeMeaning

SemanticProvenance :=
    Meaning
    → {
        SourceExpressions,
        EntityMappings,
        RelationMappings,
        Constraints,
        Evidence,
        Transformations,
        Versions
    }

RecursiveProvenance :=
    CompositeMeaning
    → ComponentMeanings
    → GroundSemanticSources

SemanticTrace :=
    Expression
    → Decomposition
    → ComponentInterpretations
    → Composition
    → FinalMeaning

RecursiveSemanticVerification :=
    Meaning
    → VerifyComponents
    → VerifyRelations
    → VerifyConstraints
    → VerifyComposition
    → ConfirmOrRevise

SemanticDrift :=
    Meaning_n
    diverges_from
    OriginalExpressionIntent

DriftDetection :=
    SemanticState_n
    → CompareWith(
        OriginalExpression,
        OriginalContext,
        OriginalConstraints
    )

DriftCorrection :=
    DriftDetected
    → RestoreOriginalSemanticAnchors
    → Reevaluate

SemanticMemoisation :=
    CanonicalExpression
    ∧ ContextSignature
    → CachedMeaning

MemoisedSemanticRecursion :=
    if Cached(Expression,Context)
    then ReuseMeaning
    else ComputeAndStoreMeaning

RecursiveSemanticSearch :=
    Expression
    → RelatedConcepts
    → RelatedRelations
    → SupportingDefinitions
    → RefinedMeaning

SemanticSearchBound :=
    Depth
    ∨ Breadth
    ∨ RelevanceThreshold
    ∨ ResourceLimit

TerminationCondition :=
    GroundMeaningReached
    ∨ SemanticFixedPointReached
    ∨ NoNewSemanticInformation
    ∨ ConfidenceThresholdReached
    ∨ ResourceBoundReached

SemanticRecursionOntology :=
    Classes
    ∧ Relations
    ∧ Constraints
    ∧ Axioms
    ∧ RecursiveSemanticRules

CoreClasses := {
    SemanticRecursion,
    SemanticState,
    SemanticObject,
    SemanticValue,
    Expression,
    Interpretation,
    Context,
    SemanticDomain,
    Denotation,
    Reference,
    Extension,
    Intension,
    SemanticDependency,
    SemanticConstraint,
    SemanticEvidence,
    FixedPoint,
    SemanticCycle,
    SemanticProvenance
}

CoreRelations := {
    means,
    denotes,
    refersTo,
    dependsOn,
    composesWith,
    refines,
    constrains,
    supports,
    contradicts,
    groundsIn,
    equivalentTo,
    convergesTo,
    tracesTo,
    inheritsFrom
}

TypedRelations :=
    Expression --means--> SemanticValue
    Term --denotes--> DomainEntity
    Symbol --refersTo--> Entity
    Meaning --dependsOn--> Meaning
    SemanticConstraint --constrains--> Interpretation
    SemanticEvidence --supports--> Meaning
    SemanticEvidence --contradicts--> Meaning
    Meaning --groundsIn--> SemanticSource
    SemanticState --convergesTo--> FixedPoint
    Meaning --tracesTo--> SemanticProvenance

RecursiveSemanticRules := {
    AtomicExpression(x)
        ⇒ ResolveAtomicMeaning(x),

    CompositeExpression(f,x1,...,xn)
        ∧ ResolvedMeaning(x1)...ResolvedMeaning(xn)
        ⇒
        Meaning(f(x1,...,xn))
        =
        Compose_f(
            Meaning(x1),...,Meaning(xn)
        ),

    Instance(x,A)
        ∧ A ⊑ B
        ⇒ Instance(x,B),

    Meaning(A) dependsOn Meaning(B)
        ∧ Meaning(B) updated
        ⇒ Reevaluate(Meaning(A)),

    SemanticConflict(A,B)
        ⇒ trigger(SemanticConsistencyReview),

    State_(n+1)=State_n
        ⇒ SemanticFixedPointReached,

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

CanonicalSemanticRecursionRepresentation :=
    ParseSemanticState
    → CanonicaliseExpressions
    → CanonicaliseEntities
    → CanonicaliseRelations
    → ResolveDependencies
    → NormaliseConstraints
    → NormaliseMeanings
    → BuildSemanticRecursionGraph

SemanticRecursionGraph :=
    G = (V,E)

V := {
    Expressions,
    Entities,
    Relations,
    Meanings,
    Contexts,
    Constraints,
    Evidence,
    SemanticStates,
    FixedPoints,
    ProvenanceNodes
}

E := {
    means,
    denotes,
    refersTo,
    dependsOn,
    composesWith,
    refines,
    constrains,
    supports,
    contradicts,
    groundsIn,
    equivalentTo,
    convergesTo,
    tracesTo
}

AI_QUERY_INTERPRETATION :=
    Query
    → DetectSemanticRecursionConcept
    → ResolveExpression
    → ResolveContext
    → ResolveSemanticDependencies
    → IdentifyRequestedMeaningRelation
    → BuildInitialSemanticState

AI_REASONING_FLOW :=
    Query
    → ParseExpression
    → IdentifyAtomicAndCompositeStructure
    → ResolveInitialEntities
    → ResolveInitialRelations
    → ConstructSemanticContext
    → BuildSemanticDependencyGraph
    → ResolveGroundMeanings
    → RecursivelyResolveDependentMeanings
    → ComposeSemanticValues
    → PropagateConstraints
    → DetectSemanticConflicts
    → ReevaluateAmbiguities
    → UpdateConfidence
    → CheckSemanticDrift
    → TestSemanticConvergence
    → IterateIfNecessary
    → CanonicaliseFinalMeaning
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseSemanticRecursionEntities,
    ParseTypedRelations,
    DecomposeExpressions,
    ResolveAtomicMeanings,
    ResolveCompositeMeanings,
    ExpandSemanticDependencies,
    PropagateContext,
    PropagateConstraints,
    ResolveAmbiguity,
    DetectSemanticCycles,
    ComputeFixedPoints,
    CompareSemanticEquivalence,
    UpdateConfidence,
    DetectSemanticDrift,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewSemanticEvidence
    → ValidateEvidence
    → IdentifyAffectedMeanings
    → InvalidateDependentSemanticResults
    → UpdateDependencyGraph
    → RecomputeGroundMeanings
    → ReapplySemanticRecursion
    → RecheckConflicts
    → RecomputeFixedPoint
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ContextUpdate :=
    ChangedContext
    ⇒ reevaluate(
        CandidateMeanings,
        Coreference,
        SemanticCompatibility
    )

OntologyUpdate :=
    ChangedClassOrRelation
    ⇒ recompute(
        DependentEntityMeanings,
        RelationMeanings,
        InheritedSemantics
    )

EvidenceUpdate :=
    NewSemanticEvidence
    ⇒ refine(
        SupportedMeanings,
        ContradictedMeanings
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        RecursiveSemanticRules,
        SemanticEvaluation,
        SemanticConvergence,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    SemanticRecursionEntityResolution,
    ExpressionStructure,
    SemanticContext,
    SemanticDependencyGraph,
    GroundMeanings,
    CompositeMeanings,
    ConstraintStatus,
    SemanticConflictStatus,
    SemanticConvergenceStatus,
    CanonicalMeaning,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA