Probability Theory Ontology

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

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

BEGIN_FLOW

ProbabilityTheory :=
    MathematicalTheoryOfRandomness
    ∧ ProbabilitySpaces
    ∧ RandomVariables
    ∧ ProbabilityDistributions
    ∧ Expectation
    ∧ Dependence
    ∧ LimitBehaviour

RandomExperiment :=
    Process
    ∧ OutcomeUncertainBeforeObservation

Outcome :=
    ω

SampleSpace :=
    Ω := SetOfAllPossibleOutcomes

Event :=
    A ⊆ Ω

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

MeasurableSpace :=
    (Ω,F)

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

ProbabilitySpace :=
    (Ω,F,P)

KolmogorovAxioms := {
    P(A)≥0,
    P(Ω)=1,
    PairwiseDisjoint(A_i)
        ⇒ P(Union_i A_i)=Σ_i P(A_i)
}

ProbabilityBounds :=
    0≤P(A)≤1

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

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

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

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

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

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)

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

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)

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

Measurability :=
    ∀B∈B(R) :
        X^{-1}(B)∈F

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

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

DiscreteRandomVariable :=
    RandomVariable
    ∧ CountableRange

ContinuousRandomVariable :=
    RandomVariable
    ∧ DistributionRepresentableByDensity
    where applicable

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

ProbabilityDensityFunction :=
    f_X(x)≥0
    ∧ Integral f_X(x)dx=1

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

CDFProperties := {
    NonDecreasing,
    RightContinuous,
    LimitMinusInfinity=0,
    LimitPlusInfinity=1
}

JointDistribution :=
    Distribution(X1,...,Xn)

MarginalDistribution :=
    JointDistribution
    → SumOrIntegrateOtherVariables

ConditionalDistribution :=
    Distribution(X|Y)

IndependentRandomVariables :=
    X ⟂ Y
    iff
    JointDistributionFactorises

Expectation :=
    E[X]
    :=
    Integral_Ω X dP

DiscreteExpectation :=
    E[X]=Σ_x x p_X(x)

ContinuousExpectation :=
    E[X]=Integral x f_X(x)dx

LinearityOfExpectation :=
    E[aX+bY]=aE[X]+bE[Y]

Moment :=
    E[X^k]

CentralMoment :=
    E[(X-E[X])^k]

Variance :=
    Var(X)=E[(X-E[X])²]

VarianceIdentity :=
    Var(X)=E[X²]-(E[X])²

StandardDeviation :=
    sqrt(Var(X))

Covariance :=
    Cov(X,Y)
    =
    E[(X-E[X])(Y-E[Y])]

Correlation :=
    Corr(X,Y)
    =
    Cov(X,Y)/(SD(X)SD(Y))

IndependentCovariance :=
    Independence(X,Y)
    ∧ finite_second_moments
    ⇒ Cov(X,Y)=0

UncorrelatedDoesNotGenerallyImplyIndependent :=
    Cov(X,Y)=0
    ↛ X ⟂ Y

MomentGeneratingFunction :=
    M_X(t)=E[e^(tX)]
    where finite

CharacteristicFunction :=
    φ_X(t)=E[e^(itX)]

ProbabilityGeneratingFunction :=
    G_X(s)=E[s^X]
    for suitable integer-valued X

CommonDistributions := {
    Bernoulli,
    Binomial,
    Geometric,
    NegativeBinomial,
    Hypergeometric,
    Poisson,
    DiscreteUniform,
    ContinuousUniform,
    Normal,
    Exponential,
    Gamma,
    Beta,
    ChiSquared,
    StudentT,
    FDistribution,
    LogNormal,
    Weibull
}

Bernoulli :=
    X∈{0,1}
    ∧ P(X=1)=p

Binomial :=
    X~Binomial(n,p)

Poisson :=
    X~Poisson(λ)

Uniform :=
    X~Uniform(a,b)

Normal :=
    X~N(μ,σ²)

Exponential :=
    X~Exponential(λ)

Gamma :=
    X~Gamma(shape,rate_or_scale)

Beta :=
    X~Beta(α,β)

TransformationOfRandomVariable :=
    Y=g(X)

DistributionTransformation :=
    Distribution(X)
    ∧ Function(g)
    → Distribution(g(X))

JacobianMethod :=
    ContinuousTransformation
    → DensityTransformation

SumOfRandomVariables :=
    Z=X+Y

Convolution :=
    Independent(X,Y)
    ⇒
    f_Z(z)
    =
    Integral f_X(x)f_Y(z-x)dx

ConditionalExpectation :=
    E[X|G]
    or
    E[X|Y]

TowerProperty :=
    E[E[X|G]]
    =
    E[X]

NestedConditioning :=
    H⊆G
    ⇒
    E[E[X|G]|H]
    =
    E[X|H]

LawOfTotalExpectation :=
    E[X]
    =
    E[E[X|Y]]

LawOfTotalVariance :=
    Var(X)
    =
    E[Var(X|Y)]
    +
    Var(E[X|Y])

IndicatorVariable :=
    1_A

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

MarkovInequality :=
    X≥0
    ⇒
    P(X≥a)
    ≤ E[X]/a
    for a>0

ChebyshevInequality :=
    P(|X-μ|≥kσ)
    ≤ 1/k²

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

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

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

SequenceOfRandomVariables :=
    {X_n}

AlmostSureConvergence :=
    X_n → X almost_surely
    iff
    P({ω : X_n(ω)→X(ω)})=1

ConvergenceInProbability :=
    ∀ε>0 :
        P(|X_n-X|>ε)→0

ConvergenceInDistribution :=
    F_{X_n}(x)→F_X(x)
    at continuity points

ConvergenceInMeanSquare :=
    E[(X_n-X)²]→0

ConvergenceRelations := {
    MeanSquareConvergence ⇒ ConvergenceInProbability,
    AlmostSureConvergence ⇒ ConvergenceInProbability,
    ConvergenceInProbability ⇒ ConvergenceInDistribution
}

LawOfLargeNumbers :=
    SampleMean
    → ExpectedValue
    under theorem assumptions

WeakLawOfLargeNumbers :=
    SampleMean
    → μ
    in probability

StrongLawOfLargeNumbers :=
    SampleMean
    → μ
    almost surely
    under theorem assumptions

CentralLimitTheorem :=
    ProperlyNormalisedSum
    → StandardNormal
    in distribution
    under theorem assumptions

StochasticProcess :=
    {X_t | t∈T}

DiscreteTimeProcess :=
    T countable

ContinuousTimeProcess :=
    T interval_or_continuous_index_set

FiniteDimensionalDistribution :=
    Distribution(X_t1,...,X_tn)

MarkovProperty :=
    Future
    conditionally_independent_of
    Past
    given Present

MarkovChain :=
    StateSpace
    ∧ TransitionProbabilities
    ∧ MarkovProperty

TransitionProbability :=
    P_ij
    =
    P(X_(n+1)=j | X_n=i)

TransitionMatrix :=
    P=[P_ij]

ChapmanKolmogorov :=
    P^(n+m)
    =
    P^n P^m

StationaryDistribution :=
    π
    ∧ πP=π

Martingale :=
    {X_n,F_n}
    ∧ Integrable(X_n)
    ∧ E[X_(n+1)|F_n]=X_n

Submartingale :=
    E[X_(n+1)|F_n]≥X_n

Supermartingale :=
    E[X_(n+1)|F_n]≤X_n

Filtration :=
    F_0⊆F_1⊆...⊆F

AdaptedProcess :=
    X_n measurable_with_respect_to F_n

StoppingTime :=
    τ
    ∧ {τ≤n}∈F_n

ProbabilityKernel :=
    State
    → ProbabilityMeasure

RegularConditionalProbability :=
    ConditionalProbability
    represented_as
    probability_kernel
    where existence conditions hold

ProductProbabilitySpace :=
    ProductSampleSpace
    ∧ ProductSigmaAlgebra
    ∧ ProductMeasure

IndependenceViaProductMeasure :=
    JointLaw
    =
    ProductOfMarginalLaws

MeasureZero :=
    P(A)=0

AlmostEverywhere :=
    PropertyHoldsOutsideMeasureZeroSet

AbsoluteContinuity :=
    Q≪P

RadonNikodymDerivative :=
    dQ/dP
    where theorem conditions hold

ChangeOfMeasure :=
    ProbabilityMeasureP
    → ProbabilityMeasureQ

ProbabilityTheoryModel :=
    ProbabilitySpace
    ∧ RandomVariables
    ∧ Distributions
    ∧ DependenceStructure
    ∧ Assumptions

ProbabilityTheoryConsistency :=
    Model
    satisfies
    MeasureAxioms
    ∧ DistributionConstraints
    ∧ DependenceConstraints

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

CoreClasses := {
    ProbabilityTheory,
    ProbabilitySpace,
    SampleSpace,
    SigmaAlgebra,
    Event,
    ProbabilityMeasure,
    RandomVariable,
    Distribution,
    JointDistribution,
    ConditionalDistribution,
    Expectation,
    Variance,
    Covariance,
    Independence,
    ConditionalExpectation,
    StochasticProcess,
    MarkovChain,
    Martingale,
    Convergence
}

CoreRelations := {
    hasProbability,
    belongsTo,
    measurableWithRespectTo,
    distributedAs,
    conditionedOn,
    independentOf,
    convergesTo,
    hasExpectation,
    hasVariance,
    hasCovariance,
    indexedBy,
    adaptedTo,
    dependsOn,
    derivedFrom,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    Event --hasProbability--> ProbabilityValue
    Event --belongsTo--> SigmaAlgebra
    RandomVariable --measurableWithRespectTo--> SigmaAlgebra
    RandomVariable --distributedAs--> Distribution
    ConditionalDistribution --conditionedOn--> RandomVariable
    RandomVariable --independentOf--> RandomVariable
    RandomVariableSequence --convergesTo--> RandomVariable
    RandomVariable --hasExpectation--> ExpectedValue
    RandomVariable --hasVariance--> Variance
    StochasticProcess --indexedBy--> IndexSet
    Process --adaptedTo--> Filtration

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

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

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

    Independent(X,Y)
        ∧ integrability_conditions
        ⇒ E[XY]=E[X]E[Y],

    X≥0
        ⇒ P(X≥a)≤E[X]/a
        for a>0,

    MeanSquareConvergence(X_n,X)
        ⇒ ConvergenceInProbability(X_n,X),

    ConvergenceInProbability(X_n,X)
        ⇒ ConvergenceInDistribution(X_n,X),

    ValidProbabilitySpace
        ∧ MeasurableRandomVariable(X)
        ⇒ DistributionExists(X)
}

SEMANTIC_EQUIVALENCE(ModelA,ModelB) :=
    same(RelevantProbabilityLaws)
    ∧ same(DependenceStructure)
    ∧ same(ExpectedQuantities)
    under specified query scope

CanonicalProbabilityTheoryRepresentation :=
    ParseModel
    → ResolveProbabilitySpace
    → ResolveRandomVariables
    → ResolveDistributions
    → ResolveDependence
    → ResolveExpectationAndMoments
    → ResolveConvergenceStructure
    → ValidateMeasureConstraints
    → BuildProbabilityTheoryGraph

ProbabilityTheoryGraph :=
    G=(V,E)

V := {
    SampleSpaces,
    SigmaAlgebras,
    Events,
    ProbabilityMeasures,
    RandomVariables,
    Distributions,
    Expectations,
    Variances,
    DependenceRelations,
    StochasticProcesses,
    ConvergenceRelations
}

E := {
    hasProbability,
    belongsTo,
    measurableWithRespectTo,
    distributedAs,
    conditionedOn,
    independentOf,
    convergesTo,
    hasExpectation,
    hasVariance,
    indexedBy,
    adaptedTo,
    dependsOn
}

CONFIDENCE(ProbabilityTheoryInference) :=
    weighted_mean(
        ProbabilitySpaceResolution,
        DistributionResolution,
        AssumptionValidity,
        DependenceResolution,
        TheoremApplicability,
        CalculationValidity,
        EvidenceQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectProbabilityTheoryConcept
    → ResolveProbabilitySpace
    → IdentifyRandomVariables
    → IdentifyDistributions
    → IdentifyDependenceOrConditioning
    → IdentifyRequestedTheoreticalQuantity

AI_REASONING_FLOW :=
    Query
    → ParseProbabilityTheoryProblem
    → ResolveSampleSpaceAndSigmaAlgebra
    → ResolveProbabilityMeasure
    → ResolveRandomVariables
    → ResolveDistributions
    → ResolveJointAndConditionalStructure
    → ResolveIndependence
    → SelectRelevantTheorem
    → CheckTheoremAssumptions
    → ComputeOrDeriveResult
    → ValidateMeasureAndProbabilityConstraints
    → EvaluateConvergenceIfRelevant
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseProbabilityTheoryEntities,
    ParseTypedRelations,
    ResolveProbabilitySpaces,
    ResolveMeasurability,
    ResolveRandomVariables,
    ResolveDistributions,
    EvaluateExpectation,
    EvaluateVarianceAndCovariance,
    EvaluateConditionalExpectation,
    EvaluateIndependence,
    ApplyProbabilityInequalities,
    EvaluateConvergence,
    AnalyseStochasticProcesses,
    ValidateProbabilityModels,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewProbabilityEvidenceModelOrAssumption
    → ValidateInput
    → IdentifyAffectedVariables
    → UpdateProbabilitySpaceOrDistribution
    → RecomputeDependentQuantities
    → ReevaluateDependence
    → ReevaluateTheoremApplicability
    → RecheckModelConsistency
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

DistributionUpdate :=
    ChangedDistribution
    ⇒ recompute(
        Expectations,
        Variances,
        TailProbabilities,
        DependentResults
    )

DependenceUpdate :=
    ChangedIndependenceOrConditionalRelation
    ⇒ recompute(
        JointDistributions,
        Factorisations,
        ConditionalResults
    )

ProcessUpdate :=
    ChangedTransitionOrProcessModel
    ⇒ reevaluate(
        MarkovProperties,
        Stationarity,
        LongRunBehaviour
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        ProbabilitySpace,
        RandomVariable,
        ConditionalExpectation,
        ConvergenceRelations,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ProbabilityTheoryEntityResolution,
    ProbabilitySpace,
    RandomVariables,
    DistributionStructure,
    DependenceStructure,
    ConditionalStructure,
    Expectations,
    Variances,
    ConvergenceStatus,
    StochasticProcessStructure,
    ModelConsistency,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF  FLOW ALGEBRA