Outcome Ontology

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

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

BEGIN_FLOW

Outcome :=
    ElementaryResult
    ∧ ProducedBy(RandomExperiment)
    ∧ MemberOf(SampleSpace)

RandomExperiment :=
    Process
    ∧ OutcomeNotKnownWithCertaintyBeforeObservation

OutcomeSymbol :=
    ω

SampleSpace :=
    Ω := SetOfAllPossibleOutcomes

OutcomeMembership :=
    ω ∈ Ω

SamplePoint :=
    Outcome

ElementaryOutcome :=
    IndivisibleOutcome
    under selected model granularity

CompositeObservedResult :=
    Observation
    potentially represented_by
    multiple elementary outcomes

OutcomeGranularity :=
    LevelOfDetail
    defining
    ElementaryOutcome

FineOutcome :=
    Outcome
    represented_with
    greater detail

CoarseOutcome :=
    EquivalenceClassOfFineOutcomes

OutcomeRefinement :=
    CoarseOutcome
    → SetOfFineOutcomes

OutcomeCoarsening :=
    FineOutcome
    → CoarseOutcome

OutcomeSpaceConstruction :=
    RandomExperiment
    → IdentifyOutcomeDimensions
    → ApplyConstraints
    → GenerateOutcomes
    → ConstructSampleSpace

PossibleOutcome :=
    CandidateResult
    satisfying
    ExperimentConstraints

ImpossibleOutcome :=
    CandidateResult
    violating
    ExperimentConstraints

ObservedOutcome :=
    Outcome
    realised_in
    TrialOrObservation

UnobservedOutcome :=
    PossibleOutcome
    not realised
    in specified trial

Trial :=
    OneExecution(RandomExperiment)

TrialResult :=
    ObservedOutcome

RepeatedTrials :=
    Trial_1,...,Trial_n

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

FiniteOutcomeSequence :=
    OutcomeSequence
    ∧ finite_length

InfiniteOutcomeSequence :=
    (ω1,ω2,...)

OrderedOutcome :=
    Outcome
    where component order is semantically relevant

UnorderedOutcome :=
    Outcome
    represented_without
    component ordering

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

ProductOutcome :=
    ElementOf(
        Ω1×...×Ωn
    )

CategoricalOutcome :=
    Outcome
    represented_by
    Category

NumericalOutcome :=
    Outcome
    represented_by
    Number

BinaryOutcome :=
    Outcome ∈ {0,1}
    or equivalent two-category set

CountOutcome :=
    Outcome ∈ {0,1,2,...}

ContinuousOutcome :=
    Outcome
    represented_in
    ContinuousDomain

PathOutcome :=
    EntireTrajectory
    in stochastic-process sample space

FunctionOutcome :=
    Function
    representing
    realised path_or_structure

PermutationOutcome :=
    Permutation
    generated_by
    random experiment

CombinationOutcome :=
    SelectedSubset
    generated_by
    random experiment

Event :=
    A ⊆ Ω

OutcomeEventRelation :=
    ω∈A
    iff
    EventAOccurs
    for realised outcome ω

ElementaryEvent :=
    {ω}

CertainEvent :=
    Ω

ImpossibleEvent :=
    ∅

EventIndicator :=
    1_A(ω)
    =
    1 if ω∈A
    else 0

OutcomeToEventMapping :=
    Outcome
    → SetOfEventsContainingOutcome

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

OutcomeProbability :=
    P({ω})
    when singleton is measurable

DiscreteOutcomeProbability :=
    p(ω)
    =
    P({ω})

ContinuousOutcomePointProbability :=
    In many absolutely continuous models,
    P({ω})=0

ProbabilityZeroOutcome :=
    Outcome
    whose singleton event
    has probability zero

PossibleButZeroProbability :=
    ω∈Ω
    ∧ P({ω})=0
    can occur in continuous models

PositiveProbabilityOutcome :=
    P({ω})>0

UniformFiniteOutcome :=
    FiniteUniformModel
    ⇒
    P({ω})=1/|Ω|

OutcomeWeight :=
    NonnegativeWeight
    normalised_into
    Probability

OutcomeFrequency :=
    CountOfObservedOccurrences

RelativeFrequency :=
    Count(Outcome)/NumberOfTrials

EmpiricalOutcomeProbability :=
    RelativeFrequency
    under empirical measure

LongRunFrequency :=
    RelativeFrequency
    considered_as
    number_of_trials increases

OutcomeDistribution :=
    ProbabilityAssignments
    across
    possible outcomes

RandomVariable :=
    X:Ω→S

OutcomeValue :=
    X(ω)

Observation :=
    MeasuredOrRecordedValue
    derived_from
    Outcome

ObservationMap :=
    h:Ω→ObservationSpace

OutcomeVsObservation :=
    Outcome
    may_contain_more_information_than
    RecordedObservation

ObservationalEquivalence :=
    ω1 ~ ω2
    iff
    h(ω1)=h(ω2)

ObservablePartition :=
    Ω/~

LatentOutcome :=
    UnderlyingOutcome
    not directly observed

ObservedVariable :=
    FunctionOf(Outcome)

MultipleRandomVariables :=
    X1(ω),...,Xn(ω)

JointObservation :=
    (X1(ω),...,Xn(ω))

OutcomeDeterminesRandomVariableValues :=
    Fixedω
    ⇒
    each X_i(ω)
    determined

Randomness :=
    UncertaintyAboutWhichOutcomeWillOccur
    before observation

OutcomeAfterObservation :=
    RealisedOutcome
    no longer uncertain
    for that trial

OutcomeIndependence :=
    Independence
    applies primarily to
    EventsOrRandomVariables
    rather_than isolated realised outcomes

OutcomeDependenceContext :=
    OutcomeComponents
    may encode
    dependent random quantities

ConditionalOutcomeSpace :=
    ConditioningEvent B
    → restrict attention to
    outcomes ω∈B

ConditionedPossibleOutcome :=
    ω∈B

PosteriorOutcomeWeight :=
    ProbabilityOfOutcome
    updated_given
    Evidence

BayesianOutcomeUpdate :=
    PriorOutcomeProbabilities
    ∧ EvidenceLikelihood
    → PosteriorOutcomeProbabilities

OutcomeConstraint :=
    Predicate(ω)

ValidOutcome :=
    OutcomeConstraint(ω)=True

OutcomeValidation :=
    CandidateOutcome
    → ApplyExperimentConstraints
    → ValidOrInvalid

OutcomeConsistency :=
    Outcome
    compatible_with
    SampleSpace
    ∧ EventStructure
    ∧ ObservationModel
    ∧ ProbabilityModel

OutcomeConflict :=
    ω declared possible
    ∧ ω violates active experiment constraints

DuplicateOutcomeRepresentation :=
    TwoIdentifiers
    representing
    same elementary result

OutcomeIdentity :=
    same elementary result
    under selected granularity

OutcomeCanonicalisation :=
    RawOutcome
    → NormaliseRepresentation
    → ResolveGranularity
    → CanonicalOutcome

OutcomeEncoding :=
    Outcome
    → SymbolicOrNumericRepresentation

OutcomeDecoding :=
    Representation
    → Outcome

OutcomeLabel :=
    HumanOrMachineReadableIdentifier

OutcomeDimension :=
    ComponentOfStructuredOutcome

MultidimensionalOutcome :=
    (ω1,...,ωd)

OutcomeProjection :=
    π_i(ω1,...,ωd)
    =
    ω_i

MarginalOutcomeSpace :=
    Projection(ProductSampleSpace)

OutcomeTransformation :=
    T:Ω→Ω'

TransformedOutcome :=
    T(ω)

PushforwardProbability :=
    P'(A)
    =
    P(T^{-1}(A))

MeasurePreservingOutcomeTransformation :=
    T
    ∧ P(T^{-1}(A))=P'(A)

OutcomeSymmetry :=
    Transformation
    preserving
    relevant probability structure

ExchangeableOutcomes :=
    JointOutcomeDistribution
    invariant_under
    permutations
    of indexed components

OutcomeTree :=
    SequentialExperiment
    → BranchingPossibleOutcomes

OutcomePath :=
    Root
    → SequentialBranches
    → TerminalOutcome

PathProbability :=
    ProductOfConditionalBranchProbabilities
    when chain rule applies

OutcomeGraph :=
    Nodes(PartialOrCompleteOutcomes)
    ∧ Edges(PossibleTransitions)

PartialOutcome :=
    IncompleteSpecification
    of final outcome

CompleteOutcome :=
    FullySpecifiedSamplePoint

OutcomeExtension :=
    PartialOutcome
    → MoreSpecificOutcome

OutcomePrefix :=
    InitialSegment
    of sequence outcome

CylinderEvent :=
    SetOfInfiniteOutcomes
    sharing
    finite prefix constraints

StochasticProcessOutcome :=
    ω
    represents
    entire sample path

TimeIndexedObservation :=
    X_t(ω)

OutcomeProvenance :=
    OutcomeRepresentation
    → {
        ExperimentDefinition,
        TrialIdentifier,
        ObservationMethod,
        TransformationHistory,
        Version
    }

OutcomeEvidence :=
    ExperimentObservation
    ∨ SensorReading
    ∨ RecordedTrialResult
    ∨ SimulationResult

SimulatedOutcome :=
    Outcome
    generated_by
    ComputationalRandomModel

EmpiricalOutcome :=
    Outcome
    recorded_from
    ObservedExperiment

OutcomeState := {
    Experiment,
    SampleSpace,
    Outcome,
    Granularity,
    Constraints,
    Events,
    Observations,
    Probability,
    Provenance
}

OutcomeUpdate :=
    NewExperimentDefinitionOrEvidence
    → RevalidateOutcome
    → ReclassifyEvents
    → RecomputeProbabilityRelations

SEMANTIC_EQUIVALENCE(OutcomeA,OutcomeB) :=
    same(ElementaryResultMeaning)
    under specified
    Experiment
    ∧ Granularity
    ∧ ObservationContext

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

CoreClasses := {
    Outcome,
    RandomExperiment,
    Trial,
    SampleSpace,
    SamplePoint,
    ElementaryOutcome,
    ObservedOutcome,
    PossibleOutcome,
    ImpossibleOutcome,
    Event,
    RandomVariable,
    Observation,
    OutcomeSequence,
    ProductOutcome,
    PathOutcome,
    OutcomeConstraint,
    OutcomeEvidence
}

CoreRelations := {
    producedBy,
    belongsTo,
    realisedIn,
    containedIn,
    mappedBy,
    observedAs,
    hasProbability,
    refines,
    coarsens,
    extends,
    transformedBy,
    generatedBy,
    equivalentTo,
    dependsOn,
    tracesTo
}

TypedRelations :=
    Outcome --producedBy--> RandomExperiment
    Outcome --belongsTo--> SampleSpace
    ObservedOutcome --realisedIn--> Trial
    Outcome --containedIn--> Event
    Outcome --mappedBy--> RandomVariable
    Outcome --observedAs--> Observation
    Outcome --hasProbability--> ProbabilityValue
    FineOutcome --coarsens--> CoarseOutcome
    CoarseOutcome --refines--> FineOutcomeSet
    Outcome --transformedBy--> Transformation
    Outcome --tracesTo--> OutcomeProvenance

InferenceRules := {
    Outcome(ω)
        ∧ producedBy(ω,E)
        ⇒ ω∈SampleSpace(E),

    ω∈A
        ∧ A⊆Ω
        ⇒ EventOccurs(A,ω),

    ElementaryEvent({ω})
        ⇒ ω∈Ω,

    ValidOutcome(ω)
        ⇒ satisfies(ω,ActiveOutcomeConstraints),

    P({ω})>0
        ⇒ ω is PossibleOutcome,

    P({ω})=0
        does_not_imply
        ImpossibleOutcome(ω),

    X:Ω→S
        ∧ ω∈Ω
        ⇒ X(ω)∈S,

    TransformedOutcome(ω')=T(ω)
        ⇒ ω'∈TargetSampleSpace
        when T is valid
}

CanonicalOutcomeRepresentation :=
    ParseOutcome
    → ResolveExperiment
    → ResolveSampleSpace
    → ResolveGranularity
    → ResolveOutcomeDimensions
    → ApplyConstraints
    → ResolveObservationMapping
    → CanonicaliseOutcome

OutcomeSemanticGraph :=
    G=(V,E)

V := {
    RandomExperiments,
    Trials,
    SampleSpaces,
    Outcomes,
    Events,
    RandomVariables,
    Observations,
    Constraints,
    Transformations,
    Evidence,
    ProvenanceNodes
}

E := {
    producedBy,
    belongsTo,
    realisedIn,
    containedIn,
    mappedBy,
    observedAs,
    hasProbability,
    refines,
    coarsens,
    extends,
    transformedBy,
    generatedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(OutcomeResolution) :=
    weighted_mean(
        ExperimentResolution,
        SampleSpaceResolution,
        GranularityResolution,
        ConstraintConsistency,
        ObservationMappingQuality,
        ProbabilityModelConsistency,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectOutcomeConcept
    → IdentifyRandomExperiment
    → ResolveSampleSpace
    → ResolveOutcomeGranularity
    → IdentifyOutcomeOrObservation
    → IdentifyRequestedOutcomeRelation

AI_REASONING_FLOW :=
    Query
    → ParseOutcomeDescription
    → ResolveRandomExperiment
    → ResolveSampleSpace
    → IdentifyOutcomeDimensions
    → ResolveGranularity
    → ValidateCandidateOutcome
    → ResolveEventMembership
    → ResolveRandomVariableMappings
    → ResolveObservedRepresentation
    → ResolveProbabilityIfDefined
    → DetectOutcomeConflicts
    → CanonicaliseOutcome
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseOutcomeEntities,
    ParseTypedRelations,
    ResolveRandomExperiments,
    ResolveSampleSpaces,
    ResolveOutcomeGranularity,
    ValidateOutcomes,
    ResolveEventMembership,
    ResolveRandomVariableMappings,
    ResolveObservationMappings,
    EvaluateOutcomeProbability,
    ResolveProductAndSequenceOutcomes,
    ApplyOutcomeTransformations,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewOutcomeExperimentEvidenceOrConstraint
    → ValidateInput
    → IdentifyAffectedOutcomes
    → UpdateOutcomeDefinitions
    → RevalidateSampleSpaceMembership
    → RecomputeEventMembership
    → RecomputeObservationMappings
    → RecomputeProbabilityRelations
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ExperimentUpdate :=
    ChangedExperimentDefinition
    ⇒ reevaluate(
        PossibleOutcomes,
        SampleSpace,
        OutcomeConstraints
    )

GranularityUpdate :=
    ChangedOutcomeGranularity
    ⇒ remap(
        OutcomeIdentity,
        Events,
        Observations
    )

ObservationUpdate :=
    ChangedObservationMapping
    ⇒ reevaluate(
        ObservationalEquivalence,
        RecordedOutcomes
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        OutcomeMembership,
        OutcomeValidation,
        OutcomeToEventMapping,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    OutcomeEntityResolution,
    RandomExperiment,
    Trial,
    SampleSpace,
    Outcome,
    OutcomeType,
    OutcomeGranularity,
    ConstraintStatus,
    EventMembership,
    ObservationMapping,
    RandomVariableValues,
    ProbabilityRelation,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA