Probability Space Ontology

FULL EXECUTABLE FLOW ALGEBRA — PROBABILITY SPACE ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/foundations-of-probability/probability-space-ontology.html

FLOW_VERSION := "4.0"
FLOW_TYPE := "Full Executable Flow Algebra"
DOMAIN := "Probability & Statistics Ontologies"
SUBDOMAIN := "Foundations of Probability"
ONTOLOGY := "Probability Space Ontology"
PRIMARY_ENTITY := ProbabilitySpace
AUTHORSHIP := "Mark Higgins — Sky (Recursive AI)"
SOURCE_SITE := "https://kirethresearch.org"

BEGIN_FLOW

ProbabilitySpace :=
    (Ω,F,P)

SampleSpace :=
    Ω := SetOfPossibleOutcomes

SigmaAlgebra :=
    F
    ∧ F ⊆ PowerSet(Ω)
    ∧ Ω ∈ F
    ∧ ClosedUnderComplement
    ∧ ClosedUnderCountableUnion

ProbabilityMeasure :=
    P : F → [0,1]

ProbabilitySpaceValidity :=
    ValidSampleSpace(Ω)
    ∧ ValidSigmaAlgebra(F,Ω)
    ∧ ValidProbabilityMeasure(P,F)

Outcome :=
    ω ∈ Ω

SamplePoint :=
    Outcome

Event :=
    A ∈ F

ElementaryEvent :=
    {ω}
    if {ω}∈F

ImpossibleEvent :=
    ∅

CertainEvent :=
    Ω

MeasurableEvent :=
    Event ∈ F

EventComplement :=
    A^c := Ω\A

EventUnion :=
    A∪B

EventIntersection :=
    A∩B

EventDifference :=
    A\B

DisjointEvents :=
    A∩B=∅

PairwiseDisjoint :=
    ∀i≠j :
        A_i∩A_j=∅

PowerSet :=
    P(Ω)
    :=
    SetOfAllSubsets(Ω)

DiscreteSigmaAlgebra :=
    F=P(Ω)
    for common discrete constructions

TrivialSigmaAlgebra :=
    {∅,Ω}

GeneratedSigmaAlgebra :=
    σ(C)
    :=
    smallest_sigma_algebra_containing(C)

Generator :=
    C
    ∧ σ(C)=F

BorelSigmaAlgebra :=
    B(R)
    :=
    σ(OpenSets(R))

MeasurableSpace :=
    (Ω,F)

ProbabilityMeasureAxioms := {
    NonNegativity:
        ∀A∈F : P(A)≥0,

    Normalisation:
        P(Ω)=1,

    CountableAdditivity:
        PairwiseDisjoint(A_i)
        ⇒
        P(Union_i A_i)
        =
        Σ_i P(A_i)
}

EmptyEventProbability :=
    P(∅)=0

ProbabilityBounds :=
    ∀A∈F :
        0≤P(A)≤1

ComplementProbability :=
    P(A^c)=1-P(A)

Monotonicity :=
    A⊆B
    ⇒ P(A)≤P(B)

FiniteAdditivity :=
    A∩B=∅
    ⇒
    P(A∪B)=P(A)+P(B)

GeneralAdditionRule :=
    P(A∪B)
    =
    P(A)+P(B)-P(A∩B)

ContinuityFromBelow :=
    A_1⊆A_2⊆...
    ⇒
    P(Union_n A_n)
    =
    lim_n P(A_n)

ContinuityFromAbove :=
    A_1⊇A_2⊇...
    ⇒
    P(Intersection_n A_n)
    =
    lim_n P(A_n)

FiniteProbabilitySpace :=
    |Ω|<∞

CountableProbabilitySpace :=
    Ω countable

UncountableProbabilitySpace :=
    Ω uncountable

UniformFiniteProbabilitySpace :=
    Finite(Ω)
    ∧
    ∀ω∈Ω :
        P({ω})=1/|Ω|

DiscreteProbabilitySpace :=
    Countable(Ω)
    ∧ ProbabilityMassFunction

ProbabilityMassFunction :=
    p : Ω→[0,1]
    ∧ Σ_{ω∈Ω}p(ω)=1

DiscreteMeasure :=
    P(A)
    =
    Σ_{ω∈A}p(ω)

ContinuousProbabilitySpace :=
    UncountableSampleSpace
    ∧ MeasureBasedProbability

DensityBasedProbability :=
    P(A)
    =
    Integral_A f dμ
    where density exists

ReferenceMeasure :=
    μ

Density :=
    f=dP/dμ
    where P≪μ

AbsoluteContinuity :=
    P≪μ

RadonNikodymDerivative :=
    dP/dμ

NullEvent :=
    A∈F
    ∧ P(A)=0

AlmostSureEvent :=
    A∈F
    ∧ P(A)=1

AlmostSureProperty :=
    Property
    holds_outside
    NullSet

CompleteProbabilitySpace :=
    ProbabilitySpace
    ∧ every_subset_of_every_null_set
    is_measurable

Completion :=
    (Ω,F,P)
    → CompleteProbabilitySpace

ConditionalProbabilitySpace :=
    OriginalSpace
    ∧ ConditioningEvent B
    where P(B)>0

ConditionalMeasure :=
    P_B(A)
    :=
    P(A∩B)/P(B)

ConditionalMeasureValidity :=
    P(B)>0
    ⇒
    P_B
    is_probability_measure_on_appropriate_event_space

ProductProbabilitySpace :=
    ProductSampleSpace
    ∧ ProductSigmaAlgebra
    ∧ ProductProbabilityMeasure

ProductSampleSpace :=
    Ω1×Ω2

ProductSigmaAlgebra :=
    F1⊗F2

ProductMeasure :=
    P1⊗P2

IndependentCoordinateSpaces :=
    ProductMeasure
    supports
    canonical_independence_of_coordinates

FiniteProductSpace :=
    Π_i (Ω_i,F_i,P_i)

InfiniteProductSpace :=
    ProductOfCountablyOrUncountablyManySpaces
    under measure-existence conditions

RandomVariable :=
    X : Ω→S
    ∧ Measurable(X)

MeasurableFunction :=
    PreimageOfMeasurableSet
    is_measurable

RandomVariableMeasurability :=
    ∀B∈S_sigma :
        X^{-1}(B)∈F

Distribution :=
    P_X
    :=
    P∘X^{-1}

PushforwardProbabilitySpace :=
    (S,S_sigma,P_X)

CanonicalRandomVariable :=
    CoordinateProjection
    on suitable product space

Filtration :=
    {F_t}
    ∧ F_s⊆F_t
    for s≤t

FilteredProbabilitySpace :=
    (Ω,F,{F_t},P)

AdaptedProcess :=
    X_t
    is F_t-measurable
    for every t

StochasticProcess :=
    {X_t | t∈T}
    defined_on
    CommonProbabilitySpace

CommonUnderlyingSpace :=
    MultipleRandomVariables
    share
    (Ω,F,P)

Coupling :=
    JointProbabilitySpace
    with specified marginals

CouplingOfDistributions :=
    ProbabilityMeasure
    on ProductSpace
    whose marginals equal target distributions

CanonicalSpace :=
    SampleSpace
    chosen_as
    SpaceOfPossiblePathsOrOutcomes

PathSpace :=
    SetOfTrajectories

CylinderSet :=
    Event
    determined_by
    finitely_many_coordinates

ProbabilityKernel :=
    K(x,A)
    assigning
    probability_measure_in_A
    for each x
    with measurability_in_x

RegularConditionalProbability :=
    ProbabilityKernel
    representing
    conditional distribution
    where existence conditions hold

ProbabilitySpaceIsomorphism :=
    StructurePreservingBijection
    preserving
    measurable_structure
    ∧ probability_measure
    modulo relevant null-set conventions

MeasurePreservingMap :=
    T : Ω1→Ω2
    ∧ P1(T^{-1}(A))=P2(A)

ProbabilityPreservingTransformation :=
    MeasurePreservingMap
    from probability space to itself

InvariantEvent :=
    T^{-1}(A)=A
    modulo null sets

ErgodicProbabilitySpace :=
    MeasurePreservingSystem
    where invariant events
    have probability 0 or 1
    under ergodicity definition

ProbabilitySpaceConstraint :=
    ConstraintOn(
        Ω,
        F,
        P
    )

SampleSpaceConstraint :=
    RestrictionOnPossibleOutcomes

MeasurabilityConstraint :=
    RequiredEvent
    must_belong_to
    F

NormalisationConstraint :=
    P(Ω)=1

AdditivityConstraint :=
    PairwiseDisjointEvents
    satisfy
    CountableAdditivity

ProbabilitySpaceConsistency :=
    SampleSpace
    ∧ SigmaAlgebra
    ∧ ProbabilityMeasure
    jointly_satisfy
    ProbabilitySpaceAxioms

InvalidProbabilitySpace :=
    Violates(
        SigmaAlgebraClosure
        ∨ NonNegativity
        ∨ Normalisation
        ∨ CountableAdditivity
    )

SigmaAlgebraValidation :=
    CheckContainsOmega
    → CheckComplementClosure
    → CheckCountableUnionClosure

ProbabilityMeasureValidation :=
    CheckDomain(F)
    → CheckNonNegativity
    → CheckNormalisation
    → CheckCountableAdditivity

ProbabilitySpaceValidation :=
    ValidateSampleSpace
    → ValidateSigmaAlgebra
    → ValidateProbabilityMeasure
    → ValidateCrossConstraints

ProbabilitySpaceConstruction :=
    DefineΩ
    → DefineF
    → DefineP
    → VerifyAxioms

EmpiricalProbabilitySpace :=
    ObservedOutcomes
    ∧ EmpiricalMeasure

EmpiricalMeasure :=
    P_n
    :=
    (1/n)Σ_i δ_(X_i)

DiracMeasure :=
    δ_x(A)
    =
    1 if x∈A
    else 0

MixtureMeasure :=
    P
    =
    Σ_i w_i P_i
    where w_i≥0
    ∧ Σ_i w_i=1

ProbabilitySpaceUpdate :=
    NewModelOrEvidence
    → ModifyΩOrFOrP
    → RevalidateAxioms
    → RecomputeDependentStructures

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

CoreClasses := {
    ProbabilitySpace,
    SampleSpace,
    Outcome,
    Event,
    SigmaAlgebra,
    ProbabilityMeasure,
    MeasurableSpace,
    NullEvent,
    AlmostSureEvent,
    ConditionalMeasure,
    ProductProbabilitySpace,
    RandomVariable,
    Distribution,
    Filtration,
    StochasticProcess,
    ProbabilityKernel,
    MeasurePreservingMap
}

CoreRelations := {
    containsOutcome,
    containsEvent,
    measurableWithRespectTo,
    hasSigmaAlgebra,
    hasProbabilityMeasure,
    hasProbability,
    conditionedOn,
    productOf,
    distributedAs,
    pushforwardOf,
    adaptedTo,
    preservesMeasure,
    derivedFrom,
    dependsOn,
    tracesTo
}

TypedRelations :=
    SampleSpace --containsOutcome--> Outcome
    SigmaAlgebra --containsEvent--> Event
    Event --hasProbability--> ProbabilityValue
    ProbabilitySpace --hasSigmaAlgebra--> SigmaAlgebra
    ProbabilitySpace --hasProbabilityMeasure--> ProbabilityMeasure
    RandomVariable --measurableWithRespectTo--> SigmaAlgebra
    RandomVariable --distributedAs--> Distribution
    Distribution --pushforwardOf--> ProbabilityMeasure
    ProductProbabilitySpace --productOf--> ProbabilitySpace
    StochasticProcess --adaptedTo--> Filtration
    MeasurePreservingMap --preservesMeasure--> ProbabilityMeasure

InferenceRules := {
    ValidProbabilitySpace(Ω,F,P)
        ⇒ P(Ω)=1,

    ValidProbabilitySpace(Ω,F,P)
        ⇒ P(∅)=0,

    A∈F
        ⇒ 0≤P(A)≤1,

    A⊆B
        ∧ A,B∈F
        ⇒ P(A)≤P(B),

    A∩B=∅
        ∧ A,B∈F
        ⇒ P(A∪B)=P(A)+P(B),

    P(B)>0
        ⇒ P_B(A)=P(A∩B)/P(B),

    Measurable(X)
        ⇒ PushforwardDistributionExists(X),

    ProductProbabilitySpace(P1,P2)
        ⇒ MarginalsRecover(P1,P2)
        under canonical projections
}

SEMANTIC_EQUIVALENCE(SpaceA,SpaceB) :=
    same(RelevantEventProbabilityStructure)
    ∧ compatible(MeasurableStructure)
    under specified query scope

ProbabilitySpaceEquivalence :=
    MeasurePreservingIsomorphism
    under selected equivalence notion

CanonicalProbabilitySpaceRepresentation :=
    ParseSpaceDefinition
    → CanonicaliseOutcomes
    → CanonicaliseEvents
    → ResolveSigmaAlgebra
    → ResolveProbabilityMeasure
    → ValidateAxioms
    → ResolveDerivedStructures
    → BuildProbabilitySpaceGraph

ProbabilitySpaceGraph :=
    G=(V,E)

V := {
    ProbabilitySpaces,
    SampleSpaces,
    Outcomes,
    Events,
    SigmaAlgebras,
    ProbabilityMeasures,
    RandomVariables,
    Distributions,
    Filtrations,
    ProductSpaces,
    ConditionalMeasures
}

E := {
    containsOutcome,
    containsEvent,
    measurableWithRespectTo,
    hasSigmaAlgebra,
    hasProbabilityMeasure,
    hasProbability,
    conditionedOn,
    productOf,
    distributedAs,
    pushforwardOf,
    adaptedTo,
    preservesMeasure,
    dependsOn
}

CONFIDENCE(ProbabilitySpaceResolution) :=
    weighted_mean(
        SampleSpaceDefinitionQuality,
        SigmaAlgebraResolution,
        ProbabilityMeasureResolution,
        AxiomValidation,
        MeasurabilityConsistency,
        DerivedStructureConsistency,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectProbabilitySpaceConcept
    → IdentifySampleSpace
    → IdentifyEventStructure
    → IdentifySigmaAlgebra
    → IdentifyProbabilityMeasure
    → IdentifyRequestedProperty

AI_REASONING_FLOW :=
    Query
    → ParseProbabilitySpaceProblem
    → ResolveSampleSpace
    → ResolveOutcomes
    → ResolveEventCollection
    → ConstructOrValidateSigmaAlgebra
    → ConstructOrValidateProbabilityMeasure
    → CheckKolmogorovAxioms
    → ResolveConditionalOrProductStructure
    → ResolveRandomVariablesIfPresent
    → ValidateMeasurability
    → DetectModelConflicts
    → BuildProbabilitySpaceGraph
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseProbabilitySpaceEntities,
    ParseTypedRelations,
    ResolveSampleSpaces,
    ResolveOutcomes,
    ResolveEvents,
    ResolveSigmaAlgebras,
    ResolveProbabilityMeasures,
    ValidateKolmogorovAxioms,
    EvaluateConditionalMeasures,
    ConstructProductSpaces,
    ResolveRandomVariableMeasurability,
    ResolvePushforwardDistributions,
    DetectProbabilitySpaceConflicts,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewOutcomeEventMeasureOrConstraint
    → ValidateInput
    → IdentifyAffectedSpaceComponents
    → UpdateΩOrFOrP
    → RevalidateSigmaAlgebra
    → RevalidateProbabilityMeasure
    → RecomputeDerivedMeasures
    → ReevaluateRandomVariables
    → RecheckModelConsistency
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

SampleSpaceUpdate :=
    ChangedOutcomeSet
    ⇒ reevaluate(
        Events,
        SigmaAlgebra,
        ProbabilityMeasureDomain
    )

SigmaAlgebraUpdate :=
    ChangedEventCollection
    ⇒ revalidate(
        ClosureProperties,
        Measurability,
        ProbabilityMeasureDomain
    )

MeasureUpdate :=
    ChangedProbabilityAssignment
    ⇒ revalidate(
        NonNegativity,
        Normalisation,
        Additivity,
        DependentDistributions
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        ProbabilitySpace,
        SigmaAlgebra,
        ProbabilityMeasureAxioms,
        ProbabilitySpaceValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ProbabilitySpaceEntityResolution,
    SampleSpace,
    OutcomeStructure,
    EventStructure,
    SigmaAlgebra,
    ProbabilityMeasure,
    AxiomValidation,
    ConditionalStructure,
    ProductStructure,
    RandomVariableStructure,
    MeasurabilityStatus,
    ModelConsistency,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA