Event Ontology

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

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

BEGIN_FLOW

Event :=
    SetOfOutcomes
    ∧ SubsetOf(SampleSpace)
    ∧ MeasurableWhenMemberOf(SigmaAlgebra)

RandomExperiment :=
    Process
    ∧ OutcomeUncertainBeforeObservation

SampleSpace :=
    Ω := SetOfAllPossibleOutcomes

Outcome :=
    ω ∈ Ω

EventSet :=
    A ⊆ Ω

MeasurableEvent :=
    A ∈ F

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

ProbabilitySpace :=
    (Ω,F,P)

EventOccurrence :=
    Event A occurs
    iff
    realised outcome ω∈A

ElementaryEvent :=
    {ω}

SimpleEvent :=
    Event
    containing
    one elementary outcome
    under discrete elementary representation

CompoundEvent :=
    Event
    containing
    multiple outcomes

CertainEvent :=
    Ω

ImpossibleEvent :=
    ∅

ProperEvent :=
    A
    such_that
    ∅⊂A⊂Ω

ComplementaryEvent :=
    A^c
    =
    Ω\A

EventComplement :=
    complement(A)

UnionEvent :=
    A∪B

IntersectionEvent :=
    A∩B

DifferenceEvent :=
    A\B

SymmetricDifference :=
    A△B
    =
    (A\B)∪(B\A)

SubsetRelation :=
    A⊆B

ProperSubset :=
    A⊂B

EventEquality :=
    A=B
    iff
    same outcomes

DisjointEvents :=
    A∩B=∅

MutuallyExclusiveEvents :=
    DisjointEvents

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

CollectivelyExhaustiveEvents :=
    Union_i A_i=Ω

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

EventAlgebra :=
    Events
    ∧ SetOperations

BooleanEventAlgebra :=
    Union
    ∧ Intersection
    ∧ Complement

DeMorganEventLaw1 :=
    (A∪B)^c
    =
    A^c∩B^c

DeMorganEventLaw2 :=
    (A∩B)^c
    =
    A^c∪B^c

IdempotentUnion :=
    A∪A=A

IdempotentIntersection :=
    A∩A=A

CommutativeUnion :=
    A∪B=B∪A

CommutativeIntersection :=
    A∩B=B∩A

AssociativeUnion :=
    (A∪B)∪C
    =
    A∪(B∪C)

AssociativeIntersection :=
    (A∩B)∩C
    =
    A∩(B∩C)

DistributiveIntersection :=
    A∩(B∪C)
    =
    (A∩B)∪(A∩C)

DistributiveUnion :=
    A∪(B∩C)
    =
    (A∪B)∩(A∪C)

Absorption1 :=
    A∪(A∩B)=A

Absorption2 :=
    A∩(A∪B)=A

ComplementUnion :=
    A∪A^c=Ω

ComplementIntersection :=
    A∩A^c=∅

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

EventProbability :=
    P(A)

ProbabilityBounds :=
    0≤P(A)≤1

CertainEventProbability :=
    P(Ω)=1

ImpossibleEventProbability :=
    P(∅)=0

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)

ThreeEventInclusionExclusion :=
    P(A∪B∪C)
    =
    P(A)+P(B)+P(C)
    -P(A∩B)-P(A∩C)-P(B∩C)
    +P(A∩B∩C)

CountableSubadditivity :=
    P(Union_i A_i)
    ≤
    Σ_i P(A_i)

UnionBound :=
    P(Union_i A_i)
    ≤
    Σ_i P(A_i)

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)

ConditionalProbability :=
    P(A|B)
    =
    P(A∩B)/P(B)
    where P(B)>0

ConditioningEvent :=
    B
    ∧ P(B)>0

ConditionalEventModel :=
    RestrictAttentionTo(B)

MultiplicationRule :=
    P(A∩B)
    =
    P(A|B)P(B)

ChainRule :=
    P(A1∩...∩An)
    =
    P(A1)
    Π_{i=2..n}
    P(A_i | A1∩...∩A_(i-1))

Independence :=
    A ⟂ B
    iff
    P(A∩B)
    =
    P(A)P(B)

ConditionalIndependence :=
    A ⟂ B | C
    iff
    P(A∩B|C)
    =
    P(A|C)P(B|C)

PairwiseIndependence :=
    ∀i≠j :
        P(A_i∩A_j)
        =
        P(A_i)P(A_j)

MutualIndependence :=
    ForEveryFiniteIndexSubset J,
    P(Intersection_{j∈J}A_j)
    =
    Π_{j∈J}P(A_j)

IndependentComplementRule :=
    A⟂B
    ⇒
    A^c⟂B
    ∧ A⟂B^c
    ∧ A^c⟂B^c

MutualExclusivityVsIndependence :=
    A∩B=∅
    ∧ P(A)>0
    ∧ P(B)>0
    ⇒
    not Independent(A,B)

PartitionEventProbability :=
    Partition{B_i}
    → TotalProbability

LawOfTotalProbability :=
    P(A)
    =
    Σ_i P(A|B_i)P(B_i)

BayesTheorem :=
    P(B_j|A)
    =
    P(A|B_j)P(B_j)
    /
    Σ_i P(A|B_i)P(B_i)

NullEvent :=
    A
    ∧ P(A)=0

AlmostSureEvent :=
    A
    ∧ P(A)=1

ProbabilityZeroEvent :=
    P(A)=0

ProbabilityOneEvent :=
    P(A)=1

NullDoesNotNecessarilyMeanImpossible :=
    P(A)=0
    ↛ A=∅

ProbabilityOneDoesNotNecessarilyMeanCertainSet :=
    P(A)=1
    ↛ A=Ω

EventIndicator :=
    1_A(ω)
    =
    {
        1 if ω∈A,
        0 otherwise
    }

IndicatorRandomVariable :=
    1_A

IndicatorExpectation :=
    E[1_A]
    =
    P(A)

EventFromRandomVariable :=
    {ω : X(ω)∈B}

ThresholdEvent :=
    {X≤x}
    ∨ {X<x}
    ∨ {X≥x}
    ∨ {X>x}

EqualityEvent :=
    {X=x}

IntervalEvent :=
    {a≤X≤b}

JointEvent :=
    {X∈A,Y∈B}

RandomVariableEventMapping :=
    B in target space
    → X^{-1}(B) in Ω

Measurability :=
    X^{-1}(B)
    ∈ F
    for measurable B

GeneratedEvent :=
    Event
    created_by
    LogicalOrSetOperation

EventGenerator :=
    Collection C
    such_that
    σ(C)=F

GeneratedSigmaAlgebra :=
    σ(C)

BorelEvent :=
    MemberOf(BorelSigmaAlgebra)

CylinderEvent :=
    Event
    depending_on
    finitely_many coordinates
    in product/path space

TailEvent :=
    Event
    unaffected_by
    changing finitely many initial coordinates
    in sequence setting

TailSigmaAlgebra :=
    Intersection_n
    σ(X_n,X_(n+1),...)

KolmogorovZeroOneLaw :=
    IndependentSequence
    ∧ TailEvent(A)
    ⇒ P(A)∈{0,1}

LimsupEvent :=
    limsup A_n
    =
    Intersection_n Union_{k≥n} A_k

LiminfEvent :=
    liminf A_n
    =
    Union_n Intersection_{k≥n} A_k

InfinitelyOftenEvent :=
    {A_n i.o.}
    =
    limsup A_n

EventuallyAlwaysEvent :=
    liminf A_n

BorelCantelliFirst :=
    Σ_n P(A_n)<∞
    ⇒
    P(limsup A_n)=0

BorelCantelliSecond :=
    Independent(A_n)
    ∧ Σ_n P(A_n)=∞
    ⇒
    P(limsup A_n)=1

EventSequence :=
    {A_n}

IncreasingEventSequence :=
    A_n⊆A_(n+1)

DecreasingEventSequence :=
    A_n⊇A_(n+1)

EventLimit :=
    lim A_n
    when limsup A_n=liminf A_n

EventConstraint :=
    Predicate
    defining
    subset of Ω

ConstraintDefinedEvent :=
    A
    =
    {ω∈Ω | C(ω)}

EventQuery :=
    Condition
    → ResolveSetOfOutcomes
    → ComputeProbabilityOrRelation

EventExpression :=
    BooleanCombination
    of primitive events

EventExpressionParsing :=
    Expression
    → EventAST
    → SetSemantics

EventASTNode := {
    PrimitiveEvent,
    Union,
    Intersection,
    Complement,
    Difference,
    ConditionalContext
}

EventNormalisation :=
    EventExpression
    → ApplySetIdentities
    → CanonicalEventExpression

EventEquivalence :=
    A=B

SemanticEventEquivalence :=
    SameOutcomeSet
    under specified sample space

SEMANTIC_EQUIVALENCE(EventA,EventB) :=
    ∀ω∈Ω :
        [ω∈EventA ↔ ω∈EventB]

EventSubsumption :=
    A⊆B

EventDisjointness :=
    A∩B=∅

EventCompatibility :=
    A∩B≠∅

EventContradiction :=
    A∩B=∅
    where simultaneous occurrence is required

EventEvidence :=
    ExperimentDefinition
    ∨ OutcomeObservation
    ∨ RandomVariableCondition
    ∨ ModelConstraint

ObservedEvent :=
    A
    ∧ realised outcome ω∈A

UnobservedEvent :=
    A
    ∧ realised outcome ω∉A

EventState := {
    SampleSpace,
    EventDefinition,
    EventMembersOrConstraint,
    Probability,
    ConditionalRelations,
    IndependenceRelations,
    Evidence,
    Confidence,
    Provenance
}

EventUpdate :=
    NewOutcomeModelOrConstraint
    → ReevaluateEventMembership
    → RecomputeProbability
    → ReevaluateRelations

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

CoreClasses := {
    Event,
    RandomExperiment,
    SampleSpace,
    Outcome,
    SigmaAlgebra,
    ProbabilitySpace,
    ElementaryEvent,
    CompoundEvent,
    CertainEvent,
    ImpossibleEvent,
    ComplementEvent,
    UnionEvent,
    IntersectionEvent,
    ConditionalEvent,
    IndependentEvent,
    NullEvent,
    AlmostSureEvent,
    EventSequence
}

CoreRelations := {
    subsetOf,
    containsOutcome,
    complementOf,
    unionOf,
    intersectionOf,
    disjointFrom,
    independentOf,
    conditionedOn,
    hasProbability,
    belongsTo,
    generatedBy,
    equivalentTo,
    dependsOn,
    tracesTo
}

TypedRelations :=
    Event --subsetOf--> SampleSpace
    Event --containsOutcome--> Outcome
    Event --belongsTo--> SigmaAlgebra
    ComplementEvent --complementOf--> Event
    UnionEvent --unionOf--> Event
    IntersectionEvent --intersectionOf--> Event
    Event --disjointFrom--> Event
    Event --independentOf--> Event
    ConditionalProbability --conditionedOn--> Event
    Event --hasProbability--> ProbabilityValue
    Event --tracesTo--> Provenance

InferenceRules := {
    A∈F
        ⇒ A⊆Ω,

    ω∈A
        ⇒ EventOccurs(A,ω),

    A∩B=∅
        ⇒ Disjoint(A,B),

    A⊆B
        ⇒ P(A)≤P(B),

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

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

    Independent(A,B)
        ⇒ P(A∩B)=P(A)P(B),

    A=B
        ⇒ P(A)=P(B),

    SEMANTIC_EQUIVALENCE(A,B)
        ⇒ EventEquivalent(A,B)
}

CanonicalEventRepresentation :=
    ParseEventExpression
    → ResolveSampleSpace
    → ResolvePrimitiveEvents
    → ApplySetOperations
    → ResolveEventConstraint
    → NormaliseExpression
    → ValidateMeasurability
    → BuildEventGraph

EventGraph :=
    G=(V,E)

V := {
    SampleSpaces,
    Outcomes,
    Events,
    SigmaAlgebras,
    ProbabilityMeasures,
    ConditionalRelations,
    IndependenceRelations,
    EventExpressions,
    Evidence,
    ProvenanceNodes
}

E := {
    subsetOf,
    containsOutcome,
    complementOf,
    unionOf,
    intersectionOf,
    disjointFrom,
    independentOf,
    conditionedOn,
    hasProbability,
    belongsTo,
    generatedBy,
    equivalentTo,
    dependsOn,
    tracesTo
}

CONFIDENCE(EventResolution) :=
    weighted_mean(
        SampleSpaceResolution,
        EventDefinitionQuality,
        ConstraintResolution,
        MeasurabilityStatus,
        ProbabilityConsistency,
        RelationResolution,
        EvidenceQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectEventConcept
    → ResolveSampleSpace
    → IdentifyPrimitiveEvents
    → ParseEventOperations
    → ResolveKnownProbabilities
    → IdentifyRequestedEventRelation

AI_REASONING_FLOW :=
    Query
    → ParseEventQuery
    → ResolveRandomExperiment
    → ResolveSampleSpace
    → ResolvePrimitiveEvents
    → ConstructEventSetsOrConstraints
    → ApplyUnionIntersectionComplementDifference
    → ValidateEventMeasurability
    → ResolveEventRelations
    → ResolveConditionalStructure
    → ResolveIndependence
    → ComputeProbabilityIfRequested
    → CheckEventConsistency
    → CanonicaliseEventExpression
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseEventEntities,
    ParseTypedRelations,
    ResolveSampleSpaces,
    ResolveOutcomes,
    ParseEventExpressions,
    ApplySetOperations,
    ValidateMeasurability,
    EvaluateEventMembership,
    EvaluateEventProbability,
    EvaluateConditionalProbability,
    EvaluateIndependence,
    EvaluatePartitions,
    EvaluateEventSequences,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewOutcomeEventEvidenceOrConstraint
    → ValidateInput
    → IdentifyAffectedEvents
    → UpdateEventDefinitions
    → RecomputeMembership
    → RevalidateMeasurability
    → RecomputeProbabilities
    → ReevaluateConditionalRelations
    → ReevaluateIndependence
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

SampleSpaceUpdate :=
    ChangedSampleSpace
    ⇒ revalidate(
        EventSubsets,
        EventMembership,
        SigmaAlgebraMembership
    )

EventDefinitionUpdate :=
    ChangedEventConstraint
    ⇒ recompute(
        EventMembers,
        Probability,
        EventRelations
    )

ProbabilityUpdate :=
    ChangedProbabilityMeasure
    ⇒ recompute(
        EventProbabilities,
        ConditionalProbabilities,
        IndependenceStatus
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        EventOccurrence,
        EventAlgebra,
        ConditionalProbability,
        Independence,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    EventEntityResolution,
    RandomExperiment,
    SampleSpace,
    EventDefinition,
    EventType,
    EventExpression,
    OutcomeMembership,
    MeasurabilityStatus,
    EventRelations,
    Probability,
    ConditionalRelations,
    IndependenceRelations,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA