Sample Space Ontology

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

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

BEGIN_FLOW

SampleSpace :=
    Ω
    :=
    SetOfAllPossibleOutcomes
    for specified RandomExperiment

RandomExperiment :=
    Process
    ∧ OutcomeUncertainBeforeObservation

Outcome :=
    ω ∈ Ω

SamplePoint :=
    Outcome

SampleSpaceDefinition :=
    RandomExperiment
    → IdentifyPossibleOutcomes
    → ConstructΩ

SampleSpaceCompleteness :=
    EveryPossibleOutcome
    belongs_to
    Ω

SampleSpaceExclusivity :=
    EachRealisedElementaryOutcome
    represented_as
    one sample point
    under chosen outcome granularity

OutcomeGranularity :=
    LevelOfDetail
    used_to_define
    SamplePoints

CoarseSampleSpace :=
    OutcomesGroupedIntoBroaderCategories

FineSampleSpace :=
    OutcomesRepresentedAtGreaterDetail

FiniteSampleSpace :=
    |Ω|<∞

CountablyInfiniteSampleSpace :=
    |Ω|=ℵ0

UncountableSampleSpace :=
    Ω
    has uncountably many elements

DiscreteSampleSpace :=
    FiniteOrCountablyInfinite(Ω)

ContinuousSampleSpace :=
    TypicallyUncountable(Ω)
    ∧ outcomes represented over continuum

EmptySampleSpace :=
    Ω=∅

ValidProbabilitySampleSpace :=
    Ω≠∅
    under standard probability-space construction

SingletonSampleSpace :=
    Ω={ω}

BinarySampleSpace :=
    Ω={ω1,ω2}

UniformFiniteSampleSpace :=
    Finite(Ω)
    ∧ EqualProbabilityAssignedToEachOutcome
    under uniform model

CartesianSampleSpace :=
    Ω
    =
    Ω1×Ω2×...×Ωn

ProductOutcome :=
    (ω1,...,ωn)

RepeatedExperiment :=
    BaseSampleSpace Ω
    repeated n times

RepeatedFiniteSampleSpace :=
    Ω^n

InfiniteSequenceSampleSpace :=
    Ω^N

PathSpace :=
    SetOfPossibleTrajectories

FunctionSpaceSampleSpace :=
    Ω
    =
    SetOfFunctionsOrPaths
    satisfying specified conditions

PermutationSampleSpace :=
    SetOfPermutations
    of specified objects

CombinationSampleSpace :=
    SetOfAllowedSubsets
    of specified size

SequenceSampleSpace :=
    SetOfAllowedSequences

CountSampleSpace :=
    {0,1,2,...}
    or bounded subset

IntervalSampleSpace :=
    Ω⊆R

EuclideanSampleSpace :=
    Ω⊆R^n

CategoricalSampleSpace :=
    Ω={Category1,...,CategoryN}

StateSpaceAsSampleSpace :=
    PossibleSystemStates
    used_as
    outcomes_of_random_experiment

Event :=
    A⊆Ω
    ∧ measurable_when A∈F

ElementaryEvent :=
    {ω}

CertainEvent :=
    Ω

ImpossibleEvent :=
    ∅

EventComplement :=
    Ω\A

EventUnion :=
    A∪B

EventIntersection :=
    A∩B

EventDifference :=
    A\B

PowerSet :=
    P(Ω)
    :=
    SetOfAllSubsetsOfΩ

EventSpace :=
    F⊆P(Ω)

SigmaAlgebra :=
    F
    ∧ Ω∈F
    ∧ ClosedUnderComplement
    ∧ ClosedUnderCountableUnion

SampleSpaceToSigmaAlgebra :=
    Ω
    → ChooseMeasurableEventCollection
    → F

DiscreteFullSigmaAlgebra :=
    F=P(Ω)
    for common finite/countable models

BorelEventSpace :=
    Ω⊆R^n
    → BorelSigmaAlgebra(Ω)

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

ProbabilitySpace :=
    (Ω,F,P)

SampleSpaceRole :=
    DefinesUniverseOfPossibleOutcomes
    ∧ BoundsEvents
    ∧ SupportsProbabilityMeasure
    ∧ SupportsRandomVariables

RandomVariable :=
    X:Ω→S
    ∧ measurable

RandomVariableDomain :=
    Ω

ObservationMap :=
    Outcome
    → ObservedValue

RandomVariableAsObservation :=
    X(ω)
    =
    ValueObservedForOutcome(ω)

MultipleRandomVariables :=
    X1,...,Xn
    defined_on
    CommonSampleSpace

CommonUnderlyingSampleSpace :=
    SharedΩ
    allows
    joint_dependence_structure

JointRandomVariable :=
    X=(X1,...,Xn)
    :
    Ω→S1×...×Sn

JointOutcomeRepresentation :=
    ω
    determines
    all component random-variable values

SampleSpacePartition :=
    {A_i}
    ∧ PairwiseDisjoint(A_i)
    ∧ Union_i A_i=Ω

PartitionCell :=
    A_i⊆Ω

PartitionInducedVariable :=
    Outcome
    → PartitionLabel

RefinementOfPartition :=
    FinerPartition
    distinguishes
    more outcomes

CoarseningOfSampleSpace :=
    Map
    Ω_fine → Ω_coarse

QuotientSampleSpace :=
    Ω/~
    under equivalence relation ~

OutcomeEquivalence :=
    ω1~ω2
    iff
    indistinguishable_under_selected_observations

CanonicalSampleSpace :=
    NaturalOutcomeRepresentation
    selected_for
    model convenience

EquivalentSampleSpaceModels :=
    DifferentOutcomeRepresentations
    producing
    same relevant probability law

SampleSpaceTransformation :=
    T:Ω1→Ω2

PushforwardOutcomeModel :=
    T
    maps
    source outcomes to target outcomes

MeasurePreservingSampleMap :=
    T
    ∧ P1(T^{-1}(A))=P2(A)

SampleSpaceIsomorphism :=
    BijectiveMeasurableMap
    with measurable inverse
    preserving probability measure
    under chosen equivalence definition

SamplingFrame :=
    OperationalSet
    from which units may be sampled

SamplingFrameVsSampleSpace :=
    SamplingFrame
    ≠ ProbabilitySampleSpace
    though related in statistical models

OutcomeEnumeration :=
    FiniteOrCountableΩ
    → List(ω1,ω2,...)

OutcomeGeneration :=
    RandomMechanism
    → ω∈Ω

SampleSpaceConstructionMethods := {
    Enumeration,
    CartesianProduct,
    SetBuilderNotation,
    IntervalDefinition,
    SequenceSpace,
    PathSpace,
    CombinatorialConstruction
}

SetBuilderSampleSpace :=
    Ω={x | Constraint(x)}

ConstraintDefinedSampleSpace :=
    CandidateUniverse
    filtered_by
    OutcomeConstraints

SampleSpaceConstraint :=
    Predicate(ω)

ValidOutcome :=
    ω∈Ω
    iff
    SampleSpaceConstraint(ω)

ImpossibleOutcome :=
    Candidate
    ∧ violates(SampleSpaceConstraint)

ModelAssumption :=
    Assumption
    affecting
    SampleSpaceDefinition

SampleSpaceAmbiguity :=
    RandomExperiment
    admits
    multiple reasonable outcome granularities

GranularityResolution :=
    QueryPurpose
    ∧ Observables
    ∧ ModelRequirements
    → ChosenSampleSpace

SampleSpaceConsistency :=
    Ω
    compatible_with
    ExperimentDefinition
    ∧ EventDefinitions
    ∧ RandomVariableDomains
    ∧ ProbabilityMeasure

SampleSpaceConflict :=
    DefinedOutcome
    excluded_from Ω
    while required_by active model
    ∨
    IncludedOutcome
    violates experiment constraints

CoverageCheck :=
    KnownPossibleOutcomes
    ⊆ Ω

ExclusionCheck :=
    KnownImpossibleOutcomes
    ∩ Ω
    = ∅

DuplicateOutcomeCheck :=
    DistinctSamplePoints
    should represent
    distinct elementary outcomes
    under selected granularity

SampleSpaceValidation :=
    ParseExperiment
    → IdentifyOutcomeDimensions
    → GenerateCandidateOutcomes
    → ApplyConstraints
    → CheckCoverage
    → CheckGranularity
    → ValidateCompatibility

CombinatorialSampleSpace :=
    Outcomes
    generated_by
    CountingStructure

OrderedSelectionSpace :=
    NumberOfOutcomes
    =
    P(n,r)
    when assumptions fit

UnorderedSelectionSpace :=
    NumberOfOutcomes
    =
    C(n,r)
    when assumptions fit

IndependentRepeatedTrialSpace :=
    BaseOutcomeSet^n

BinarySequenceSpace :=
    {0,1}^n
    for n finite binary trials

InfiniteBinarySequenceSpace :=
    {0,1}^N

CoinTossSampleSpace :=
    {H,T}
    for single binary coin model

DiceSampleSpace :=
    {1,2,3,4,5,6}
    for standard six-face outcome model

TwoDiceSampleSpace :=
    {1,...,6}×{1,...,6}

ContinuousMeasurementSpace :=
    IntervalOrSubsetOfR
    according_to physical/model constraints

StochasticProcessSampleSpace :=
    PathSpace
    supporting
    all process trajectories

CylinderEvent :=
    Event
    determined_by
    finitely_many coordinates

CylinderSigmaAlgebra :=
    GeneratedBy(CylinderEvents)

InformationState :=
    AvailableObservations
    about ω

ObservablePartition :=
    OutcomesGroupedBy
    identical observable information

Filtration :=
    IncreasingSequenceOfSigmaAlgebras
    representing
    information over time

UnderlyingOutcome :=
    ω
    remains fixed
    while information about ω may increase
    in standard probability modelling

SampleSpaceEvidence :=
    ExperimentDescription
    ∨ PhysicalConstraints
    ∨ DataSchema
    ∨ ModelDefinition

SampleSpaceUpdate :=
    NewEvidenceOrAssumption
    → ReviseOutcomeSet
    → RevalidateEvents
    → RevalidateRandomVariables
    → RevalidateProbabilityMeasure

SampleSpaceState := {
    Experiment,
    Outcomes,
    OutcomeDimensions,
    Constraints,
    Granularity,
    EventSpace,
    RandomVariableDomains,
    Evidence,
    Confidence,
    Provenance
}

SEMANTIC_EQUIVALENCE(Ω1,Ω2) :=
    same(RelevantOutcomeSemantics)
    ∧ same(QueryRelevantProbabilityStructure)
    under specified mapping

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

CoreClasses := {
    SampleSpace,
    RandomExperiment,
    Outcome,
    SamplePoint,
    Event,
    ElementaryEvent,
    SigmaAlgebra,
    ProbabilitySpace,
    RandomVariable,
    Partition,
    ProductSampleSpace,
    PathSpace,
    SequenceSpace,
    SampleSpaceConstraint,
    OutcomeGranularity
}

CoreRelations := {
    hasOutcome,
    belongsTo,
    contains,
    subsetOf,
    partitions,
    productOf,
    domainOf,
    generatedBy,
    constrainedBy,
    mapsTo,
    refines,
    coarsens,
    equivalentTo,
    dependsOn,
    tracesTo
}

TypedRelations :=
    RandomExperiment --hasOutcome--> Outcome
    Outcome --belongsTo--> SampleSpace
    SampleSpace --contains--> Outcome
    Event --subsetOf--> SampleSpace
    Partition --partitions--> SampleSpace
    ProductSampleSpace --productOf--> SampleSpace
    SampleSpace --domainOf--> RandomVariable
    SampleSpace --constrainedBy--> SampleSpaceConstraint
    FineSampleSpace --refines--> CoarseSampleSpace
    CoarseSampleSpace --coarsens--> FineSampleSpace

InferenceRules := {
    Outcome(ω)
        ∧ possible_under(Experiment,ω)
        ⇒ candidate(ω∈Ω),

    Event(A)
        ⇒ A⊆Ω,

    ElementaryEvent({ω})
        ⇒ ω∈Ω,

    Partition({A_i},Ω)
        ⇒ PairwiseDisjoint(A_i)
        ∧ Union_i A_i=Ω,

    ProductSampleSpace(Ω1,Ω2)
        ⇒ OutcomesAreOrderedPairs(Ω1×Ω2),

    RandomVariable(X)
        ⇒ Domain(X)=Ω
        for its underlying probability space,

    ValidProbabilitySpace(Ω,F,P)
        ⇒ Ω≠∅,

    ChangedSampleSpace(Ω)
        ⇒ revalidate(
            Events,
            SigmaAlgebra,
            RandomVariables,
            ProbabilityMeasure
        )
}

CanonicalSampleSpaceRepresentation :=
    ParseExperiment
    → ResolveOutcomeDimensions
    → ResolveGranularity
    → GenerateOutcomeSet
    → ApplyOutcomeConstraints
    → CanonicaliseOutcomes
    → ResolveEventCompatibility
    → BuildSampleSpaceGraph

SampleSpaceGraph :=
    G=(V,E)

V := {
    RandomExperiments,
    SampleSpaces,
    Outcomes,
    Events,
    Partitions,
    Constraints,
    RandomVariables,
    ProductSpaces,
    SequenceSpaces,
    PathSpaces,
    Evidence
}

E := {
    hasOutcome,
    belongsTo,
    contains,
    subsetOf,
    partitions,
    productOf,
    domainOf,
    generatedBy,
    constrainedBy,
    refines,
    coarsens,
    equivalentTo,
    dependsOn
}

CONFIDENCE(SampleSpaceResolution) :=
    weighted_mean(
        ExperimentDefinitionQuality,
        OutcomeCoverage,
        GranularityFit,
        ConstraintConsistency,
        EventCompatibility,
        RandomVariableCompatibility,
        EvidenceQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectSampleSpaceConcept
    → IdentifyRandomExperiment
    → IdentifyOutcomeDimensions
    → ResolveGranularity
    → IdentifyConstraints
    → IdentifyRequestedSampleSpaceRelation

AI_REASONING_FLOW :=
    Query
    → ParseExperimentDescription
    → ResolveRandomExperiment
    → IdentifyPossibleOutcomeDimensions
    → SelectOutcomeGranularity
    → ConstructCandidateSampleSpace
    → ApplyOutcomeConstraints
    → CheckOutcomeCoverage
    → CheckImpossibleOutcomes
    → ResolveProductOrSequenceStructure
    → ResolveEventCompatibility
    → ResolveRandomVariableDomains
    → ValidateProbabilitySpaceCompatibility
    → BuildSampleSpaceGraph
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseSampleSpaceEntities,
    ParseTypedRelations,
    ResolveRandomExperiments,
    ResolveOutcomes,
    ConstructFiniteSampleSpaces,
    ConstructProductSpaces,
    ConstructSequenceSpaces,
    ConstructPathSpaces,
    ApplyOutcomeConstraints,
    ResolveGranularity,
    ValidateCoverage,
    ValidateEventCompatibility,
    ValidateRandomVariableDomains,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewExperimentEvidenceOutcomeOrConstraint
    → ValidateInput
    → IdentifyAffectedOutcomeDimensions
    → UpdateSampleSpace
    → RecomputePartitions
    → RevalidateEvents
    → RevalidateRandomVariableDomains
    → RevalidateProbabilityMeasureCompatibility
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

OutcomeUpdate :=
    AddedChangedOrRemovedOutcome
    ⇒ reevaluate(
        SampleSpaceCompleteness,
        Events,
        Partitions
    )

ConstraintUpdate :=
    ChangedOutcomeConstraint
    ⇒ reconstruct(
        ValidOutcomeSet
    )

GranularityUpdate :=
    ChangedOutcomeGranularity
    ⇒ remap(
        Outcomes,
        Events,
        RandomVariables
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        SampleSpaceDefinition,
        SampleSpaceValidation,
        ProductSampleSpace,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    SampleSpaceEntityResolution,
    RandomExperiment,
    OutcomeDimensions,
    OutcomeGranularity,
    SampleSpace,
    OutcomeSet,
    EventCompatibility,
    PartitionStructure,
    ProductOrSequenceStructure,
    RandomVariableDomainCompatibility,
    ModelConsistency,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA