Probability Ontology

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

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

BEGIN_FLOW

Probability :=
    QuantificationOfUncertainty
    ∧ MeasureOfEventLikelihood
    ∧ ValueIn[0,1]
    ∧ DefinedRelativeTo(ProbabilityModel)

RandomExperiment :=
    Process
    ∧ OutcomeNotKnownWithCertainty

Outcome :=
    ElementaryResult(RandomExperiment)

SampleSpace :=
    Ω := SetOfPossibleOutcomes

Event :=
    A ⊆ Ω

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

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

ProbabilitySpace :=
    (Ω,F,P)

ProbabilityValue :=
    P(A)

ImpossibleEvent :=
    ∅

CertainEvent :=
    Ω

ProbabilityOfImpossibleEvent :=
    P(∅)=0

ProbabilityOfCertainEvent :=
    P(Ω)=1

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

    Normalisation:
        P(Ω)=1,

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

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

Complement :=
    A^c := Ω\A

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

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

DisjointEvents :=
    A∩B=∅

FiniteAdditivity :=
    Disjoint(A,B)
    ⇒
    P(A∪B)=P(A)+P(B)

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

EventDifference :=
    A\B

DifferenceProbability :=
    P(A\B)
    =
    P(A)-P(A∩B)

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

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

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

Conditioning :=
    PriorProbabilityModel
    ∧ ObservedCondition
    → ConditionalProbabilityModel

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)

EquivalentIndependenceCondition :=
    P(B)>0
    ∧ A⟂B
    ⇒ P(A|B)=P(A)

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 :=
    ∀FiniteIndexSet J :
        P(Intersection_{j∈J}A_j)
        =
        Π_{j∈J}P(A_j)

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

LawOfTotalProbability :=
    Partition{B_i}
    ⇒
    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)

PriorProbability :=
    P(H)

Likelihood :=
    P(E|H)

EvidenceProbability :=
    P(E)

PosteriorProbability :=
    P(H|E)

BayesianUpdate :=
    Prior
    ∧ Likelihood
    ∧ Evidence
    → Posterior

Odds :=
    P(A)/(1-P(A))
    where P(A)≠1

PosteriorOdds :=
    PriorOdds
    × LikelihoodRatio

LikelihoodRatio :=
    P(E|H1)/P(E|H0)

FiniteUniformProbability :=
    Finite(Ω)
    ∧ EquallyLikelyOutcomes
    ⇒
    P(A)=|A|/|Ω|

ClassicalProbability :=
    FavourableOutcomes
    /
    EquallyLikelyPossibleOutcomes

FrequencyProbability :=
    Probability
    interpreted_through
    LongRunRelativeFrequency

SubjectiveProbability :=
    Probability
    interpreted_as
    DegreeOfBelief

ObjectiveProbability :=
    Probability
    interpreted_as
    FeatureOfPhysicalOrStochasticModel

PropensityProbability :=
    Probability
    interpreted_as
    DispositionOfExperimentalSetup

LogicalProbability :=
    Probability
    interpreted_as
    DegreeOfSupportGivenInformation

ProbabilityInterpretation := {
    Classical,
    Frequentist,
    Bayesian,
    Subjective,
    Propensity,
    Logical
}

ProbabilityAssignment :=
    Event
    → ProbabilityValue

ValidProbabilityAssignment :=
    Assignment
    ∧ satisfies(KolmogorovAxioms)

ProbabilityConstraint :=
    EquationOrInequality
    over ProbabilityTerms

ProbabilityConstraintExamples := {
    P(A)=p,
    P(A|B)=q,
    P(A∩B)=r,
    A⊆B,
    A⟂B
}

ConstraintPropagation :=
    KnownProbabilityRelations
    → DerivedProbabilityRelations

ProbabilityInference :=
    KnownEvents
    ∧ KnownProbabilities
    ∧ StructuralRelations
    → UnknownProbability

ProbabilityQuery :=
    GivenInformation
    → RequestedProbability

ProbabilityReasoningFlow :=
    ParseQuery
    → DefineSampleSpace
    → DefineEvents
    → ResolveKnownProbabilities
    → ResolveSetRelations
    → ResolveConditionalRelations
    → ResolveIndependence
    → SelectProbabilityRule
    → Compute
    → Validate

ProbabilityValidation :=
    ComputedProbability
    must_satisfy
    0≤P≤1

ModelConsistency :=
    AllProbabilityAssignments
    ∧ Constraints
    jointly_satisfy
    ProbabilityAxioms

ProbabilityConflict :=
    Constraints
    imply
    InvalidProbabilityAssignment

NegativeProbabilityConflict :=
    P(A)<0

OverUnityConflict :=
    P(A)>1

NormalisationConflict :=
    P(Ω)≠1

AdditivityConflict :=
    Disjoint(A,B)
    ∧ P(A∪B)≠P(A)+P(B)

MonotonicityConflict :=
    A⊆B
    ∧ P(A)>P(B)

ConditionalConflict :=
    P(A|B)
    inconsistent_with
    P(A∩B)/P(B)

IndependenceConflict :=
    DeclaredIndependent(A,B)
    ∧ P(A∩B)≠P(A)P(B)

NullEvent :=
    A
    ∧ P(A)=0

AlmostSureEvent :=
    A
    ∧ P(A)=1

ProbabilityZero :=
    P(A)=0

ProbabilityOne :=
    P(A)=1

ZeroDoesNotNecessarilyMeanImpossible :=
    P(A)=0
    ↛ A=∅
    in continuous probability spaces

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

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

Distribution :=
    P_X(B)
    =
    P(X∈B)

ProbabilityMassFunction :=
    p_X(x)
    =
    P(X=x)

ProbabilityDensityFunction :=
    f_X(x)
    with
    P(X∈A)
    =
    Integral_A f_X(x)dx

CumulativeDistributionFunction :=
    F_X(x)
    =
    P(X≤x)

ExpectedValue :=
    E[X]

IndicatorVariable :=
    1_A

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

JointProbability :=
    P(X∈A,Y∈B)

MarginalProbability :=
    JointProbability
    → SumOrIntegrateOtherVariables

ConditionalDistribution :=
    P(X∈A|Y)

ProbabilityTree :=
    SequentialEvents
    ∧ ConditionalBranches

TreePathProbability :=
    Product(
        ConditionalProbabilitiesAlongPath
    )

TreeOutcomeProbability :=
    Sum(
        ProbabilitiesOfCompatiblePaths
    )

ContingencyTable :=
    JointCountsOrProbabilities
    of categorical events

VennRepresentation :=
    SetRelations
    representing
    EventOperations

ProbabilityGraph :=
    Nodes(Events)
    ∧ Edges(ConditionalOrDependenceRelations)

BayesianNetwork :=
    DirectedAcyclicGraph
    ∧ ConditionalProbabilityDistributions

BayesianNetworkFactorisation :=
    P(X1,...,Xn)
    =
    Π_i P(X_i | Parents(X_i))

ConditionalIndependenceGraph :=
    GraphStructure
    encodes
    ConditionalIndependenceRelations

Uncertainty :=
    IncompleteCertaintyAboutOutcome

AleatoricUncertainty :=
    IntrinsicRandomness

EpistemicUncertainty :=
    UncertaintyFromIncompleteKnowledge

ProbabilityEvidence :=
    Observation
    ∨ FrequencyData
    ∨ PriorKnowledge
    ∨ ModelAssumption

ProbabilityUpdate :=
    NewEvidence
    → UpdateRelevantProbabilities

RecursiveProbabilityUpdate :=
    ProbabilityState_n
    → NewEvidence
    → RecomputeDependencies
    → ProbabilityState_(n+1)

ProbabilityState := {
    Events,
    ProbabilityAssignments,
    ConditionalProbabilities,
    IndependenceRelations,
    Constraints,
    Evidence,
    Confidence,
    Provenance
}

SemanticEquivalence :=
    TwoProbabilityExpressions
    represent
    same probability quantity

SEMANTIC_EQUIVALENCE(A,B) :=
    same(EventMeaning)
    ∧ same(ConditioningContext)
    ∧ same(ProbabilityValue)
    under same model

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

CoreClasses := {
    Probability,
    RandomExperiment,
    Outcome,
    SampleSpace,
    Event,
    SigmaAlgebra,
    ProbabilityMeasure,
    ProbabilitySpace,
    ConditionalProbability,
    Independence,
    Partition,
    RandomVariable,
    Distribution,
    ProbabilityConstraint,
    ProbabilityEvidence,
    ProbabilityState
}

CoreRelations := {
    hasOutcome,
    belongsTo,
    subsetOf,
    hasProbability,
    conditionedOn,
    independentOf,
    partitions,
    measurableWithRespectTo,
    distributedAs,
    derivedFrom,
    constrains,
    updates,
    equivalentTo,
    dependsOn,
    tracesTo
}

TypedRelations :=
    RandomExperiment --hasOutcome--> Outcome
    Outcome --belongsTo--> SampleSpace
    Event --subsetOf--> SampleSpace
    Event --hasProbability--> ProbabilityValue
    ConditionalProbability --conditionedOn--> Event
    Event --independentOf--> Event
    Partition --partitions--> SampleSpace
    RandomVariable --measurableWithRespectTo--> SigmaAlgebra
    RandomVariable --distributedAs--> Distribution
    ProbabilityEvidence --updates--> ProbabilityState
    ProbabilityAssignment --tracesTo--> Provenance

InferenceRules := {
    A∈F
        ⇒ 0≤P(A)≤1,

    P(Ω)=1
        ⇒ P(∅)=0,

    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),

    Partition({B_i})
        ⇒ P(A)=Σ_i P(A|B_i)P(B_i),

    Prior(H)
        ∧ Likelihood(E|H)
        ⇒ Posterior(H|E),

    ComputedProbability(p)
        ∧ (p<0 ∨ p>1)
        ⇒ InvalidProbabilityResult
}

CanonicalProbabilityRepresentation :=
    ParseProbabilityExpression
    → ResolveExperiment
    → ResolveSampleSpace
    → ResolveEvents
    → ResolveConditioning
    → ResolveIndependence
    → NormaliseProbabilityExpression
    → ValidateAgainstAxioms

CONFIDENCE(ProbabilityResult) :=
    weighted_mean(
        EventResolution,
        ModelAssumptionQuality,
        InputProbabilityReliability,
        RuleApplicability,
        ConstraintConsistency,
        CalculationValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectProbabilityIntent
    → IdentifyExperiment
    → IdentifyEvents
    → IdentifyKnownProbabilities
    → IdentifyConditionalInformation
    → IdentifyIndependenceAssumptions
    → IdentifyRequestedProbability

AI_REASONING_FLOW :=
    Query
    → ParseProbabilityQuery
    → ResolveRandomExperiment
    → ConstructOrResolveSampleSpace
    → ResolveRelevantEvents
    → ResolveKnownProbabilityAssignments
    → ResolveEventSetRelations
    → ResolveConditioning
    → ResolveIndependence
    → BuildProbabilityConstraints
    → SelectProbabilityIdentityOrTheorem
    → ComputeRequestedProbability
    → ValidateBoundsAndAxioms
    → DetectConflicts
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseProbabilityEntities,
    ParseTypedRelations,
    ResolveExperiments,
    ResolveSampleSpaces,
    ResolveEvents,
    ResolveProbabilityAssignments,
    EvaluateSetRelations,
    EvaluateConditionalProbability,
    EvaluateIndependence,
    ApplyBayesTheorem,
    ApplyTotalProbability,
    PropagateProbabilityConstraints,
    DetectProbabilityConflicts,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewProbabilityEvidenceOrConstraint
    → ValidateInput
    → IdentifyAffectedEvents
    → UpdateProbabilityState
    → RecomputeDependentProbabilities
    → ReevaluateConditionalRelations
    → ReevaluateIndependence
    → RecheckProbabilityAxioms
    → DetectConflicts
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

EventUpdate :=
    ChangedEventDefinition
    ⇒ reevaluate(
        EventRelations,
        ProbabilityAssignments,
        ConditionalProbabilities
    )

ProbabilityAssignmentUpdate :=
    ChangedProbability
    ⇒ recompute(
        DependentProbabilityExpressions,
        ModelConsistency
    )

IndependenceUpdate :=
    ChangedIndependenceAssumption
    ⇒ recompute(
        Factorisations,
        JointProbabilities,
        ConditionalProbabilities
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        ProbabilityMeasure,
        ConditionalProbability,
        Independence,
        BayesTheorem,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ProbabilityEntityResolution,
    RandomExperiment,
    SampleSpace,
    EventStructure,
    ProbabilityAssignments,
    ConditionalRelations,
    IndependenceRelations,
    ProbabilityConstraints,
    DerivedProbability,
    ModelConsistency,
    ConflictStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA