Formal Semantics Ontology

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

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

BEGIN_FLOW

FormalSemantics :=
    MathematicalSpecificationOfMeaning
    ∧ FormalLanguageInterpretation
    ∧ SemanticDomains
    ∧ SemanticFunctions
    ∧ TruthOrBehaviourConditions

Purpose :=
    assign_precise_meaning(FormalExpressions)
    ∧ remove(Ambiguity)
    ∧ enable(FormalReasoning)
    ∧ support(Verification)
    ∧ preserve(SemanticEquivalence)

FormalLanguage :=
    Syntax
    ∧ Grammar
    ∧ Terms
    ∧ Expressions
    ∧ Formulae

Syntax :=
    Symbols
    ∧ FormationRules
    ∧ WellFormedExpressions

SemanticDomain :=
    MathematicalStructure
    ∧ contains(PossibleMeanings)

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

Interpretation :=
    Mapping(
        SyntacticConstructs,
        SemanticObjects
    )

Meaning :=
    SemanticValue(Expression)

SemanticEvaluation :=
    Expression
    ∧ Environment
    ∧ Store
    → SemanticValue

Environment :=
    Identifier → Denotation

Store :=
    Location → Value

State :=
    Variable → Value

Configuration :=
    Program
    ∧ State

SemanticJudgement :=
    Context ⊢ Expression ⇓ Value
    ∨
    Configuration → Configuration'
    ∨
    Model ⊨ Formula

SemanticRelation :=
    Syntax
    ↔ Meaning

Compositionality :=
    Meaning(CompoundExpression)
    =
    function(
        MeaningsOfComponents,
        SyntacticComposition
    )

PrincipleOfCompositionality :=
    semantic_value(whole)
    determined_by
    semantic_values(parts)
    ∧ mode_of_combination(parts)

DenotationalSemantics :=
    Syntax
    → MathematicalObjects

Denotation :=
    [[Expression]]Environment

DenotationalMeaning :=
    Program
    → MathematicalFunction
    ∨ DomainElement

ExpressionSemantics :=
    [[e]]ρ

CommandSemantics :=
    [[C]] : State → State

PartialCommandSemantics :=
    [[C]] : State ⇀ State

FunctionSemantics :=
    [[f]] : InputDomain → OutputDomain

DenotationalComposition :=
    [[C1 ; C2]]
    =
    [[C2]] ∘ [[C1]]

SemanticEquation :=
    [[Construct]]
    =
    FunctionOf(SubconstructMeanings)

OperationalSemantics :=
    MeaningByComputationSteps

SmallStepSemantics :=
    Configuration
    → Configuration'

MultiStepSemantics :=
    Configuration
    →* Configuration'

BigStepSemantics :=
    Configuration
    ⇓ Result

TransitionRelation :=
    → ⊆ Configuration × Configuration

ReflexiveTransitiveClosure :=
    →*

Termination :=
    ⟨P,s⟩ →* ⟨skip,s'⟩

Divergence :=
    InfiniteTransitionSequence

StuckConfiguration :=
    NonFinalConfiguration
    ∧ noApplicableTransition

EvaluationRelation :=
    ⟨e,σ⟩ ⇓ v

OperationalRule :=
    Premises
    ─────────
    Conclusion

StructuralOperationalSemantics :=
    TransitionRules
    defined_over
    SyntaxStructure

NaturalSemantics :=
    BigStepInferenceRules

AxiomaticSemantics :=
    MeaningByLogicalProperties

HoareTriple :=
    {P} C {Q}

Precondition :=
    Predicate(StateBefore)

Postcondition :=
    Predicate(StateAfter)

PartialCorrectness :=
    {P} C {Q}
    iff
    P(s)
    ∧ C terminates_in s'
    ⇒ Q(s')

TotalCorrectness :=
    PartialCorrectness
    ∧ Termination

WeakestPrecondition :=
    wp(C,Q)

AxiomaticMeaning :=
    SetOfValidAssertionsAbout(Program)

HoareAssignment :=
    {Q[x←E]} x:=E {Q}

HoareSequence :=
    {P} C1 {R}
    ∧ {R} C2 {Q}
    ⇒ {P} C1;C2 {Q}

HoareConditional :=
    {P∧B} C1 {Q}
    ∧ {P∧¬B} C2 {Q}
    ⇒
    {P} if B then C1 else C2 {Q}

HoareLoop :=
    {I∧B} C {I}
    ⇒
    {I} while B do C {I∧¬B}

ModelTheoreticSemantics :=
    Formula
    → TruthRelativeTo(Model, Assignment)

Model :=
    Domain
    ∧ Interpretation

Satisfaction :=
    M,g ⊨ φ

Validity :=
    ∀M,g : M,g ⊨ φ

Satisfiability :=
    ∃M,g : M,g ⊨ φ

SemanticConsequence :=
    Γ ⊨ φ

AlgebraicSemantics :=
    Syntax
    → AlgebraicStructure

FixedPointSemantics :=
    RecursiveDefinition
    → FixedPointOfSemanticOperator

SemanticOperator :=
    F : D → D

LeastFixedPoint :=
    μF

GreatestFixedPoint :=
    νF

Monotonicity :=
    x ⊑ y
    ⇒ F(x) ⊑ F(y)

CompletePartialOrder :=
    CPO
    ∧ supports(LimitsOfChains)

Continuity :=
    F(lub(chain))
    =
    lub(F(chain))

RecursiveProgramMeaning :=
    least_fixed_point(SemanticFunctional)

DomainTheory :=
    PartialInformation
    ∧ ApproximationOrdering
    ∧ Limits
    ∧ FixedPoints

BottomElement :=
    ⊥
    := Undefined
    ∨ Nontermination
    ∨ LeastInformation

Approximation :=
    x ⊑ y

SemanticApproximation :=
    MeaningA ⊑ MeaningB

TypedSemantics :=
    Expression
    ∧ TypeEnvironment
    → Type
    ∧ Meaning

TypingJudgement :=
    Γ ⊢ e : τ

TypeSoundness :=
    WellTypedPrograms
    do_not_go_wrong
    under_defined_semantics

Progress :=
    WellTypedTerm
    ⇒ Value
    ∨ CanTakeStep

Preservation :=
    Γ ⊢ e : τ
    ∧ e → e'
    ⇒ Γ ⊢ e' : τ

TypeSafety :=
    Progress
    ∧ Preservation

StaticSemantics :=
    CompileTimeMeaningConstraints

DynamicSemantics :=
    RuntimeEvaluationBehaviour

StaticSemanticComponents := {
    Scope,
    Binding,
    TypeRules,
    NameResolution,
    DeclarationConstraints
}

DynamicSemanticComponents := {
    Evaluation,
    StateTransition,
    FunctionApplication,
    ControlFlow,
    Effects
}

Binding :=
    Identifier
    → Declaration

Scope :=
    RegionWhereBindingApplies

FreeVariable :=
    Variable
    ∧ not_bound

BoundVariable :=
    Variable
    ∧ associated_with(Binder)

Substitution :=
    Expression[x←Term]

CaptureAvoidingSubstitution :=
    Substitution
    ∧ preserves(BindingStructure)

AlphaEquivalence :=
    ExpressionsDifferOnlyByBoundVariableNames

BetaReduction :=
    (λx.e) v
    → e[x←v]

LambdaSemantics :=
    LambdaExpression
    → FunctionMeaning

CallByValue :=
    evaluate(argument)
    before substitution/application

CallByName :=
    substitute(argument)
    before evaluation

EvaluationStrategy := {
    CallByValue,
    CallByName,
    CallByNeed,
    NormalOrder,
    ApplicativeOrder
}

ControlFlowSemantics :=
    Sequence
    ∨ Branch
    ∨ Loop
    ∨ FunctionCall
    ∨ Exception

StatefulSemantics :=
    Expression
    ∧ Store
    → Value
    ∧ UpdatedStore

SideEffect :=
    Evaluation
    → StateChange

ExceptionSemantics :=
    NormalResult
    ∨ ExceptionalResult

NondeterministicSemantics :=
    Configuration
    → Set(NextConfigurations)

ConcurrentSemantics :=
    Processes
    ∧ Interleavings
    ∧ Synchronisation
    ∧ Communication

InterleavingSemantics :=
    GlobalExecution
    formed_from
    ComponentSteps

TraceSemantics :=
    Program
    → Set(ExecutionTraces)

Trace :=
    Sequence(Events ∨ States)

Bisimulation :=
    Relation R
    such_that
    RelatedStatesMutuallyMatchTransitions

StrongBisimulation :=
    exact_step_matching

WeakBisimulation :=
    observable_step_matching
    modulo(SilentTransitions)

ObservationalEquivalence :=
    Programs
    indistinguishable_under
    DefinedObservations

ContextualEquivalence :=
    ∀ProgramContext C :
        Observation(C[P])
        =
        Observation(C[Q])

SemanticEquivalence :=
    [[P]] = [[Q]]

OperationalEquivalence :=
    Behaviour(P) ≈ Behaviour(Q)

FullAbstraction :=
    DenotationalEquivalence
    iff
    ObservationalEquivalence

Adequacy :=
    DenotationalMeaning
    correctly_reflects
    OperationalObservation

SoundSemanticTranslation :=
    SourceMeaning(P)
    =
    TargetMeaning(Translate(P))

SemanticPreservation :=
    P → P'
    ⇒ Meaning(P) = Meaning(P')
    under specified observation model

CompilerCorrectness :=
    Semantics(SourceProgram)
    ≈
    Semantics(CompiledProgram)

Refinement :=
    ImplementationBehaviour
    ⊆ SpecificationBehaviour

SemanticRefinement :=
    [[Implementation]]
    ⊑
    [[Specification]]

AbstractSemantics :=
    ConcreteSemanticDomain
    → AbstractSemanticDomain

AbstractionFunction :=
    α : Concrete → Abstract

ConcretisationFunction :=
    γ : Abstract → Set(Concrete)

GaloisConnection :=
    α(c) ⊑ a
    iff
    c ⊑ γ(a)

AbstractInterpretation :=
    SoundApproximationOf(ConcreteSemantics)

SoundAbstraction :=
    ConcreteBehaviour
    ⊆ concretisation(AbstractBehaviour)

ProgramAnalysis :=
    FormalSemantics
    → AbstractSemantics
    → ComputableApproximation

SemanticError :=
    WellFormedSyntax
    ∧ UndefinedOrInvalidMeaning

UndefinedBehaviour :=
    Execution
    outside_defined_semantic_rules

SemanticAmbiguity :=
    OneExpression
    → MultipleUnintendedMeanings

FormalSemanticsGoal :=
    minimise(Ambiguity)
    ∧ maximise(Precision)
    ∧ enable(MechanicalReasoning)

SemanticSpecification :=
    SyntaxDefinition
    ∧ SemanticDomains
    ∧ SemanticFunctions
    ∧ InferenceRules
    ∧ EquivalenceRelations

SemanticConsistency :=
    Rules
    do_not_assign
    incompatible_meanings
    under same context

SemanticCompleteness :=
    EveryRelevantWellFormedConstruct
    has_defined_semantics

MechanisedSemantics :=
    FormalSemantics
    ∧ encoded_in(ProofAssistant ∨ ExecutableFramework)

ExecutableSemantics :=
    SemanticRules
    ∧ machine_executable

SemanticValidation :=
    FormalMeaning
    compared_with
    IntendedMeaning

SemanticVerification :=
    prove(PropertiesOfSemanticDefinition)

MetaTheory :=
    PropertiesOf(FormalSemantics)

MetaTheoreticProperties := {
    Determinism,
    Confluence,
    Progress,
    Preservation,
    Normalisation,
    Termination,
    TypeSafety,
    Equivalence
}

Determinism :=
    C → C1
    ∧ C → C2
    ⇒ C1 = C2

Confluence :=
    C →* C1
    ∧ C →* C2
    ⇒
    ∃C3 :
        C1 →* C3
        ∧ C2 →* C3

NormalForm :=
    Configuration
    ∧ no_reduction_applies

Normalisation :=
    every_relevant_term
    eventually_reaches(NormalForm)

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

CoreClasses := {
    FormalSemantics,
    FormalLanguage,
    Syntax,
    SemanticDomain,
    SemanticFunction,
    Interpretation,
    Environment,
    Store,
    State,
    Configuration,
    DenotationalSemantics,
    OperationalSemantics,
    AxiomaticSemantics,
    ModelTheoreticSemantics,
    AlgebraicSemantics,
    TraceSemantics,
    Expression,
    Program,
    Value,
    Transition,
    SemanticJudgement
}

CoreRelations := {
    interprets,
    denotes,
    evaluatesTo,
    transitionsTo,
    satisfies,
    assignsMeaning,
    preserves,
    refines,
    approximates,
    equivalentTo,
    dependsOn,
    composesWith
}

TypedRelations :=
    FormalSemantics --assignsMeaning--> FormalLanguage
    SemanticFunction --maps--> Syntax
    Expression --denotes--> SemanticValue
    Configuration --transitionsTo--> Configuration
    Model --satisfies--> Formula
    Implementation --refines--> Specification
    AbstractSemantics --approximates--> ConcreteSemantics
    Transformation --preserves--> SemanticMeaning
    Program --evaluatesTo--> Result

InferenceRules := {
    C → C'
        ∧ C' →* C''
        ⇒ C →* C'',

    Γ ⊢ e : τ
        ∧ e → e'
        ∧ Preservation
        ⇒ Γ ⊢ e' : τ,

    Γ ⊢ e : τ
        ∧ Progress
        ⇒ Value(e) ∨ ∃e' : e → e',

    [[P]] = [[Q]]
        ⇒ SemanticEquivalent(P,Q),

    Bisimilar(P,Q)
        ⇒ candidate(ObservationalEquivalent(P,Q)),

    SoundAbstraction(A,C)
        ∧ PropertyHolds(A)
        ⇒ PropertyHolds(C)
        for properties preserved by abstraction,

    Semantics(Source)
        = Semantics(Target)
        ⇒ SemanticsPreserved(Translation)
}

SEMANTIC_EQUIVALENCE(ExpressionA, ExpressionB) :=
    [[ExpressionA]]
    =
    [[ExpressionB]]

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

SemanticCompatibility :=
    Meanings
    ∧ Constraints
    have_nonempty_consistent_interpretation

CanonicalSemanticRepresentation :=
    ParseSyntax
    → ResolveBindings
    → ResolveSemanticFramework
    → NormaliseSemanticDomains
    → GenerateSemanticRelations
    → CanonicalSemanticGraph

FormalSemanticGraph :=
    G = (V,E)

V := {
    Languages,
    SyntaxConstructs,
    Expressions,
    SemanticDomains,
    SemanticValues,
    Environments,
    Stores,
    States,
    Configurations,
    Models,
    Traces,
    SemanticRules
}

E := {
    interprets,
    denotes,
    evaluatesTo,
    transitionsTo,
    satisfies,
    assignsMeaning,
    preserves,
    refines,
    approximates,
    equivalentTo
}

CONFIDENCE(FormalSemanticInterpretation) :=
    weighted_mean(
        SyntaxResolution,
        SemanticRulePrecision,
        DomainDefinitionQuality,
        MetaTheoryValidation,
        EquivalenceEvidence,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectFormalSemanticsConcept
    → ResolveLanguage
    → ResolveSyntacticConstruct
    → ResolveSemanticFramework
    → ResolveSemanticDomain
    → IdentifyMeaningQuestion

AI_REASONING_FLOW :=
    Query
    → ParseFormalExpression
    → ResolveSyntax
    → ResolveBindingsAndTypes
    → SelectSemanticFramework
    → ConstructSemanticEnvironment
    → ApplySemanticRules
    → ComputeOrDeriveMeaning
    → EvaluateStateTransitions
    → TestSemanticProperties
    → CompareEquivalentExpressions
    → CheckSemanticPreservation
    → BuildFormalSemanticRelations
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseFormalSemanticEntities,
    ParseTypedRelations,
    ResolveSyntax,
    ResolveBindings,
    ResolveSemanticDomains,
    ApplyDenotationalRules,
    ApplyOperationalRules,
    ApplyAxiomaticRules,
    EvaluateSemanticJudgements,
    CompareSemanticEquivalence,
    CheckRefinement,
    CheckSemanticPreservation,
    FollowOntologyRelations,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewSemanticEvidence
    → ValidateEvidence
    → IdentifyAffectedSemanticRules
    → ReevaluateMeanings
    → DetectSemanticConflict
    → UpdateFormalSemanticGraph
    → RecomputeEquivalenceRelations
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

LanguageUpdate :=
    ChangedSyntax
    ∨ ChangedBindingRules
    ⇒ reevaluate(DependentSemanticDefinitions)

SemanticRuleUpdate :=
    ChangedSemanticRule
    ⇒ recompute(
        DependentEvaluations,
        Equivalences,
        MetaTheoreticResults
    )

SemanticDomainUpdate :=
    ChangedDomain
    ⇒ revalidate(
        SemanticFunctions,
        FixedPoints,
        AbstractInterpretations
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        DenotationalSemantics,
        OperationalSemantics,
        AxiomaticSemantics,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    FormalSemanticEntityResolution,
    SyntaxResolution,
    SemanticFramework,
    SemanticDomain,
    SemanticMeaning,
    EvaluationRelation,
    TransitionBehaviour,
    EquivalenceStatus,
    RefinementStatus,
    SemanticPreservationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA