Logical Semantics

AI SEARCH FLOW ALGEBRA — LOGICAL SEMANTICS
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/logical-semantics.html

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

BEGIN_FLOW

LogicalSemantics :=
    FormalStudyOfMeaning
    ∧ InterpretationOfLogicalLanguage
    ∧ RelationBetweenSyntaxAndModels
    ∧ TruthConditions
    ∧ SemanticConsequence

FormalLanguage :=
    Alphabet
    ∧ Symbols
    ∧ Terms
    ∧ Formulae
    ∧ FormationRules

Syntax :=
    WellFormedExpressions
    ∧ DerivationRules
    ∧ FormalStructure

Semantics :=
    Interpretation
    ∧ MeaningAssignment
    ∧ TruthEvaluation
    ∧ ModelRelation

SyntaxSemanticsRelation :=
    Syntax
    → Interpretation
    → SemanticValue

Interpretation :=
    Mapping(
        NonLogicalSymbols,
        SemanticObjects
    )

Model :=
    Structure
    ∧ Interpretation
    ∧ satisfies(SetOfFormulae)

Structure :=
    Domain
    ∧ Relations
    ∧ Functions
    ∧ Constants

Domain :=
    NonEmptySetOfObjects

VariableAssignment :=
    Variables → Domain

TermEvaluation :=
    Term
    ∧ Interpretation
    ∧ VariableAssignment
    → DomainElement

FormulaEvaluation :=
    Formula
    ∧ Interpretation
    ∧ VariableAssignment
    → TruthValue

TruthValue :=
    {
        True,
        False
    }

Satisfaction :=
    M,g ⊨ φ

NonSatisfaction :=
    M,g ⊭ φ

SentenceSatisfaction :=
    M ⊨ φ

ModelOfTheory :=
    M ⊨ T
    iff
    ∀φ ∈ T : M ⊨ φ

SemanticTruth :=
    ⊨ φ

Validity :=
    ∀Model M :
        M ⊨ φ

Satisfiability :=
    ∃Model M :
        M ⊨ φ

Unsatisfiability :=
    ¬∃Model M :
        M ⊨ φ

Falsifiability :=
    ∃Model M :
        M ⊭ φ

Contingency :=
    Satisfiable(φ)
    ∧ Falsifiable(φ)

SemanticConsequence :=
    Γ ⊨ φ

SemanticConsequenceMeaning :=
    ∀Model M :
        M ⊨ Γ
        ⇒
        M ⊨ φ

LogicalEquivalence :=
    φ ≡ ψ
    iff
    ∀Model M :
        M ⊨ φ ↔ ψ

SemanticEquivalence :=
    Models(φ) = Models(ψ)

ModelClass :=
    Mod(T)
    :=
    {M | M ⊨ T}

Theory :=
    SetOfSentences

TheorySemantics :=
    T
    → Mod(T)

SemanticClosure :=
    Cn(T)
    :=
    {φ | T ⊨ φ}

ConsistentTheory :=
    Mod(T) ≠ ∅

InconsistentTheory :=
    Mod(T) = ∅

CompleteTheory :=
    ∀Sentence φ :
        T ⊨ φ
        ∨
        T ⊨ ¬φ

CategoricalTheory :=
    AllModelsOf(T)
    are_isomorphic
    under specified cardinality/context

PropositionalSemantics :=
    PropositionalVariables
    ∧ TruthAssignments
    ∧ ConnectiveTruthFunctions

Valuation :=
    v : PropositionalVariables → {True,False}

NegationSemantics :=
    v(¬P) = ¬v(P)

ConjunctionSemantics :=
    v(P ∧ Q)
    =
    v(P) ∧ v(Q)

DisjunctionSemantics :=
    v(P ∨ Q)
    =
    v(P) ∨ v(Q)

ImplicationSemantics :=
    v(P → Q)
    =
    ¬v(P) ∨ v(Q)

BiconditionalSemantics :=
    v(P ↔ Q)
    =
    (v(P) = v(Q))

Tautology :=
    ∀Valuation v :
        v(φ) = True

Contradiction :=
    ∀Valuation v :
        v(φ) = False

PredicateLogicSemantics :=
    Domain
    ∧ Interpretation
    ∧ VariableAssignment
    ∧ QuantifierSemantics

ConstantInterpretation :=
    c^M ∈ Domain(M)

FunctionInterpretation :=
    f^M : D^n → D

PredicateInterpretation :=
    P^M ⊆ D^n

EqualityInterpretation :=
    "="
    → IdentityRelationOn(D)

UniversalQuantifierSemantics :=
    M,g ⊨ ∀x φ
    iff
    ∀d ∈ D :
        M,g[x↦d] ⊨ φ

ExistentialQuantifierSemantics :=
    M,g ⊨ ∃x φ
    iff
    ∃d ∈ D :
        M,g[x↦d] ⊨ φ

FreeVariable :=
    Variable
    ∧ not_bound_by(Quantifier)

BoundVariable :=
    Variable
    ∧ within_scope_of(Quantifier)

Sentence :=
    Formula
    ∧ no_free_variables

Compositionality :=
    Meaning(ComplexExpression)
    =
    function(
        MeaningsOfParts,
        ModeOfCombination
    )

CompositionalSemantics :=
    AtomicMeaning
    → RecursiveSemanticRules
    → ComplexMeaning

Denotation :=
    Expression
    → SemanticObject

Reference :=
    Term
    → Object

Extension :=
    Predicate
    → SetOfObjectsOrTuples

Intension :=
    Expression
    → Function(PossibleWorld, Extension)

PossibleWorldSemantics :=
    Worlds
    ∧ Accessibility
    ∧ WorldRelativeTruth

KripkeModel :=
    M = (W,R,V)

where:
    W := PossibleWorlds
    R := AccessibilityRelation
    V := Valuation

ModalTruth :=
    M,w ⊨ φ

Necessity :=
    M,w ⊨ □φ
    iff
    ∀v :
        R(w,v)
        ⇒ M,v ⊨ φ

Possibility :=
    M,w ⊨ ◇φ
    iff
    ∃v :
        R(w,v)
        ∧ M,v ⊨ φ

TemporalSemantics :=
    States
    ∧ Time
    ∧ Paths
    ∧ TemporalOperators

LinearTemporalModel :=
    InfiniteSequenceOfStates

NextSemantics :=
    M,i ⊨ Xφ
    iff
    M,i+1 ⊨ φ

EventuallySemantics :=
    M,i ⊨ Fφ
    iff
    ∃j ≥ i :
        M,j ⊨ φ

GloballySemantics :=
    M,i ⊨ Gφ
    iff
    ∀j ≥ i :
        M,j ⊨ φ

UntilSemantics :=
    M,i ⊨ φ U ψ
    iff
    ∃j ≥ i :
        M,j ⊨ ψ
        ∧
        ∀k :
            i ≤ k < j
            ⇒ M,k ⊨ φ

ManyValuedSemantics :=
    TruthValues
    with cardinality > 2

ThreeValuedSemantics :=
    {True, False, Unknown}

FuzzySemantics :=
    TruthDegree ∈ [0,1]

ProbabilisticSemantics :=
    Proposition
    → ProbabilityMeasure

IntuitionisticSemantics :=
    ConstructiveTruth
    ∧ InformationGrowth
    ∧ KripkeFrames

IntuitionisticPersistence :=
    w ⊨ φ
    ∧ R(w,v)
    ⇒ v ⊨ φ

AlgebraicSemantics :=
    LogicalLanguage
    → AlgebraicStructure

BooleanAlgebraSemantics :=
    ClassicalPropositionalLogic
    ↔ BooleanAlgebra

HeytingAlgebraSemantics :=
    IntuitionisticLogic
    ↔ HeytingAlgebra

SemanticInterpretationFunction :=
    [[·]]_M

TermDenotation :=
    [[t]]_(M,g)

FormulaDenotation :=
    [[φ]]_(M,g)
    ∈ TruthDomain

Entailment :=
    Premises
    semantically_force
    Conclusion

Countermodel :=
    M
    ∧ M ⊨ Γ
    ∧ M ⊭ φ

CountermodelPrinciple :=
    Γ ⊭ φ
    iff
    ∃Countermodel M

SemanticProofMethod :=
    {
        TruthTable,
        ModelConstruction,
        CountermodelConstruction,
        SemanticTableau,
        KripkeModelAnalysis,
        AlgebraicEvaluation
    }

TruthTable :=
    Enumerate(Valuations)
    → Evaluate(Formula)

SemanticTableau :=
    FormulaSet
    → DecompositionRules
    → Branches
    → {
        Closed,
        Open
    }

ClosedTableau :=
    all_branches_contain_contradiction

OpenTableau :=
    exists_consistent_branch
    → candidate(Model)

ModelChecking :=
    Model M
    ∧ Formula φ
    → Determine(M ⊨ φ)

FiniteModel :=
    |Domain(M)| < ∞

InfiniteModel :=
    |Domain(M)| = ∞

Isomorphism :=
    StructurePreservingBijection

ElementaryEquivalence :=
    M ≡ N
    iff
    same_first_order_sentences(M,N)

ElementaryEmbedding :=
    Embedding
    ∧ preserves(FirstOrderTruth)

Substructure :=
    Structure
    ∧ domain_subset
    ∧ inherited_interpretations

Homomorphism :=
    Mapping
    ∧ preserves(RelevantStructure)

SemanticPreservation :=
    Transformation(φ,ψ)
    ⇒ Meaning(φ) = Meaning(ψ)

NormalisationSemantics :=
    Formula
    → EquivalentNormalForm

CNFEquivalence :=
    φ ≡ CNF(φ)

DNFEquivalence :=
    φ ≡ DNF(φ)

Skolemisation :=
    Formula
    → EquisatisfiableFormula

SkolemSemanticRelation :=
    satisfiable(φ)
    iff
    satisfiable(Skolemised(φ))

Soundness :=
    Γ ⊢ φ
    ⇒ Γ ⊨ φ

Completeness :=
    Γ ⊨ φ
    ⇒ Γ ⊢ φ

SoundProofSystem :=
    no_derivable_semantic_falsehood

CompleteProofSystem :=
    every_semantic_consequence_is_derivable

Compactness :=
    Γ ⊨ φ
    ⇒
    ∃FiniteΓ0 ⊆ Γ :
        Γ0 ⊨ φ

CompactnessSatisfiability :=
    every_finite_subset_of(Γ)_satisfiable
    ⇒ Γ_satisfiable

LowenheimSkolemRelation :=
    FirstOrderTheoryWithInfiniteModel
    → ModelsOfOtherInfiniteCardinalities
    subject_to_theorem_conditions

SemanticParadox :=
    SelfReference
    ∧ TruthPredicate
    ∧ SemanticConstraints
    → potential(Contradiction)

ObjectLanguage :=
    LanguageBeingInterpreted

Metalanguage :=
    LanguageUsedToDescribeSemantics

MetaSemantics :=
    Metalanguage
    → defines(SemanticsOfObjectLanguage)

InterpretationLayer :=
    SyntaxLayer
    → SemanticLayer
    → ModelLayer

OntologySemantics :=
    OntologyEntities
    ∧ Relations
    ∧ Axioms
    → ModelTheoreticInterpretation

LogicalSemanticsOntology :=
    Classes
    ∧ Relations
    ∧ Constraints
    ∧ Axioms
    ∧ InferenceRules

CoreClasses := {
    LogicalSemantics,
    FormalLanguage,
    Syntax,
    Interpretation,
    Model,
    Structure,
    Domain,
    Valuation,
    VariableAssignment,
    Formula,
    Term,
    Theory,
    Satisfaction,
    Truth,
    Validity,
    Satisfiability,
    SemanticConsequence,
    Countermodel,
    PossibleWorld,
    KripkeModel
}

CoreRelations := {
    interprets,
    denotes,
    satisfies,
    falsifies,
    entails,
    models,
    assigns,
    evaluates,
    equivalentTo,
    accessibleFrom,
    preserves,
    instantiates,
    dependsOn
}

TypedRelations :=
    Interpretation --interprets--> FormalLanguage
    Model --satisfies--> Formula
    Model --models--> Theory
    Term --denotes--> DomainElement
    Valuation --assigns--> PropositionalVariable
    Theory --entails--> Formula
    Countermodel --falsifies--> EntailmentClaim
    PossibleWorld --accessibleFrom--> PossibleWorld
    SemanticTransformation --preserves--> Meaning

InferenceRules := {
    M ⊨ Γ
        ∧ Γ ⊨ φ
        ⇒ M ⊨ φ,

    Γ ⊨ φ
        ∧ Γ ⊆ Δ
        ⇒ Δ ⊨ φ,

    φ ≡ ψ
        ⇒ Models(φ) = Models(ψ),

    M ⊨ φ ∧ ψ
        ⇒ M ⊨ φ
        ∧ M ⊨ ψ,

    M ⊨ ∀x φ(x)
        ⇒ M ⊨ φ(a)
        for each domain-appropriate a,

    Countermodel(M,Γ,φ)
        ⇒ Γ ⊭ φ,

    Valid(φ)
        ⇒ Satisfiable(φ),

    Unsatisfiable(Γ)
        ⇒ Γ ⊨ φ
        for every φ
        under classical semantics
}

SemanticIdentity :=
    MeaningA = MeaningB

SEMANTIC_EQUIVALENCE(ExpressionA, ExpressionB) :=
    ∀Interpretation I :
        [[ExpressionA]]_I
        =
        [[ExpressionB]]_I

SemanticSubsumption :=
    Models(A) ⊆ Models(B)

StrongerFormula :=
    A ⊨ B

WeakerFormula :=
    B ⊨ A

SemanticConflict :=
    Models(A ∧ B) = ∅

SemanticCompatibility :=
    Models(A ∧ B) ≠ ∅

CanonicalSemanticRepresentation :=
    ParseExpression
    → ResolveLanguage
    → ResolveInterpretationType
    → NormaliseSemanticObjects
    → ConstructModelConstraints
    → CanonicalSemanticGraph

SemanticGraph :=
    G = (V,E)

V := {
    Languages,
    Expressions,
    Terms,
    Formulae,
    Interpretations,
    Models,
    Domains,
    Assignments,
    TruthValues,
    Theories,
    Countermodels
}

E := {
    interprets,
    denotes,
    satisfies,
    falsifies,
    entails,
    evaluates,
    equivalentTo,
    accessibleFrom,
    preserves
}

CONFIDENCE(LogicalSemanticInterpretation) :=
    weighted_mean(
        LanguageResolution,
        InterpretationPrecision,
        ModelConsistency,
        SemanticRuleValidity,
        ContextCompleteness,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectLogicalSemanticConcept
    → ResolveFormalLanguage
    → ResolveExpression
    → ResolveInterpretation
    → ResolveModelClass
    → IdentifySemanticQuestion

AI_REASONING_FLOW :=
    Query
    → ParseLogicalExpression
    → IdentifySyntax
    → IdentifySemanticFramework
    → ResolveDomain
    → ResolveInterpretation
    → EvaluateTerms
    → EvaluateFormulae
    → DetermineSatisfaction
    → DetermineValidityOrSatisfiability
    → TestSemanticConsequence
    → SearchForCountermodelWhenRequired
    → CompareSemanticEquivalence
    → BuildSemanticRelations
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseSemanticEntities,
    ParseTypedRelations,
    ResolveSyntaxSemanticsBoundary,
    ResolveInterpretations,
    ConstructModels,
    EvaluateTruthConditions,
    TestSatisfaction,
    TestEntailment,
    DetectCountermodels,
    CompareSemanticEquivalence,
    FollowOntologyRelations,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewSemanticEvidence
    → ValidateEvidence
    → ResolveAffectedInterpretations
    → ReevaluateModels
    → DetectSemanticConflict
    → UpdateSemanticGraph
    → RecomputeEntailments
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ModelUpdate :=
    ChangedDomain
    ∨ ChangedInterpretation
    ∨ ChangedValuation
    ⇒ reevaluate(DependentFormulae)

TheoryUpdate :=
    AddedOrRemovedAxiom
    ⇒ recompute(
        ModelClass,
        SemanticConsequences,
        ConsistencyStatus
    )

CountermodelUpdate :=
    ValidCountermodel
    ⇒ mark(EntailmentClaim, False)

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        Satisfaction,
        SemanticConsequence,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    SemanticEntityResolution,
    FormalMeaning,
    Interpretation,
    ModelClass,
    TruthConditions,
    SatisfactionStatus,
    ValidityStatus,
    SatisfiabilityStatus,
    EntailmentStatus,
    CountermodelStatus,
    SemanticEquivalence,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA