Law of Total Probability Ontology

FULL EXECUTABLE FLOW ALGEBRA — LAW OF TOTAL PROBABILITY ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/probability-rules/law-of-total-probability-ontology.html

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

BEGIN_FLOW

LawOfTotalProbability :=
    PartitionBasedProbabilityDecomposition
    ∧ ConditionalProbabilityAggregation
    ∧ MarginalisationRule
    ∧ ProbabilityNormalisation

ProbabilitySpace :=
    (Ω,F,P)

SampleSpace :=
    Ω

Event :=
    A,B_i,C ∈ F

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

PairwiseDisjoint :=
    ∀i≠j :
        B_i∩B_j=∅

CollectivelyExhaustive :=
    Union_i B_i=Ω

PartitionCell :=
    B_i

PositiveProbabilityPartition :=
    Partition({B_i})
    ∧ P(B_i)>0
    for conditional terms used

EventDecomposition :=
    A
    =
    A∩Ω
    =
    A∩(Union_i B_i)
    =
    Union_i(A∩B_i)

DisjointEventDecomposition :=
    Partition({B_i})
    ⇒
    {A∩B_i}
    pairwise disjoint

FiniteAdditivityStep :=
    P(A)
    =
    Σ_i P(A∩B_i)

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

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

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

FinitePartitionForm :=
    {B_1,...,B_n}
    partition Ω
    ⇒
    P(A)
    =
    Σ_{i=1..n}
    P(A|B_i)P(B_i)

CountablePartitionForm :=
    {B_i}_{i≥1}
    countable partition
    ⇒
    P(A)
    =
    Σ_{i≥1}
    P(A|B_i)P(B_i)
    where conditional terms are defined

JointProbabilityForm :=
    P(A)
    =
    Σ_i P(A∩B_i)

MarginalisationInterpretation :=
    HiddenOrPartitionVariable
    → SumOverItsStates
    → MarginalProbability

RandomVariablePartition :=
    DiscreteRandomVariable Y
    with states y_i
    induces
    B_i={Y=y_i}

DiscreteRandomVariableForm :=
    P(X∈A)
    =
    Σ_y
    P(X∈A|Y=y)P(Y=y)

DiscretePointForm :=
    P(X=x)
    =
    Σ_y
    P(X=x|Y=y)P(Y=y)

JointMarginalForm :=
    p_X(x)
    =
    Σ_y p_(X,Y)(x,y)

ConditionalMarginalForm :=
    p_X(x)
    =
    Σ_y p_(X|Y)(x|y)p_Y(y)

ContinuousAnalogue :=
    f_X(x)
    =
    Integral
    f_(X|Y)(x|y)f_Y(y)dy

ContinuousEventAnalogue :=
    P(X∈A)
    =
    Integral
    P(X∈A|Y=y)
    dP_Y(y)
    under regular conditional probability framework

ExpectationAnalogue :=
    E[g(X)]
    =
    E[
        E[g(X)|Y]
    ]

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

TotalProbabilityAsExpectation :=
    P(A)
    =
    E[
        P(A|Y)
    ]

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

ConditionalIndicatorRelation :=
    P(A|Y)
    =
    E[1_A|Y]

TowerPropertyRelation :=
    E[E[1_A|Y]]
    =
    E[1_A]
    =
    P(A)

BayesTheoremRelation :=
    TotalProbability
    supplies
    denominator
    for BayesTheorem

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

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

PriorProbability :=
    P(B_i)

Likelihood :=
    P(A|B_i)

WeightedLikelihood :=
    P(A|B_i)P(B_i)

EvidenceProbability :=
    Σ_i WeightedLikelihood_i

MixtureModel :=
    LatentComponent
    ∧ ComponentDistributions
    ∧ MixingWeights

MixingWeight :=
    π_i
    =
    P(B_i)

MixtureDensity :=
    f_X(x)
    =
    Σ_i π_i f_i(x)

MixturePMF :=
    p_X(x)
    =
    Σ_i π_i p_i(x)

MixtureNormalisation :=
    π_i≥0
    ∧ Σ_i π_i=1

LatentVariable :=
    Z
    with states z_i

LatentMarginalisation :=
    P(X)
    =
    Σ_z P(X|Z=z)P(Z=z)

HierarchicalProbabilityModel :=
    HigherLevelVariable
    → ConditionalLowerLevelDistribution

HierarchicalMarginal :=
    IntegrateOrSum
    over higher-level latent variable

DiagnosticTesting :=
    ConditionStatus
    partitions population
    into
    Condition
    ∪ NoCondition

PositiveTestProbability :=
    P(Test+)
    =
    P(Test+|Condition)P(Condition)
    +
    P(Test+|NoCondition)P(NoCondition)

Prevalence :=
    P(Condition)

Sensitivity :=
    P(Test+|Condition)

FalsePositiveRate :=
    P(Test+|NoCondition)

DiagnosticEvidenceProbability :=
    Sensitivity×Prevalence
    +
    FalsePositiveRate×(1-Prevalence)

ReliabilityModel :=
    SystemStates
    partition
    possible operating conditions

RiskAggregation :=
    ScenarioPartition
    → ScenarioConditionalRisk
    → WeightedTotalRisk

ScenarioProbability :=
    P(B_i)

ConditionalRisk :=
    P(A|B_i)

TotalRisk :=
    Σ_i ConditionalRisk_i×ScenarioProbability_i

DecisionTreeProbability :=
    Branches
    form partition
    at each decision/chance node

TreeLeafProbability :=
    ProductOfConditionalBranchProbabilities

TreeEventProbability :=
    SumOfRelevantLeafProbabilities

SequentialPartition :=
    B_i
    may represent
    histories_or_states

ChainRuleIntegration :=
    JointProbability
    → SumAcrossPartition
    → MarginalProbability

PartitionRefinement :=
    Partition C
    refines Partition B
    if each C_j⊆some B_i

RefinedTotalProbability :=
    SummingAcrossRefinedPartition
    yields
    same P(A)

PartitionCoarsening :=
    MergePartitionCells
    while preserving
    disjointness_and_exhaustiveness

CoarseTotalProbability :=
    SumOverCoarseCells
    of
    conditional probability × cell probability

PartitionInvariance :=
    AnyValidPartition
    yields
    same marginal P(A)

ZeroProbabilityPartitionCell :=
    B_i
    ∧ P(B_i)=0

ZeroProbabilityHandling :=
    P(A∩B_i)=0
    while elementary ratio P(A|B_i)
    may be undefined

SafeJointForm :=
    P(A)
    =
    Σ_i P(A∩B_i)
    remains valid
    without requiring positive cell probabilities

ConditionalFormRequirement :=
    Use
    P(A|B_i)P(B_i)
    only when
    conditional probability is defined
    or regular conditional framework supplied

InvalidPartition :=
    OverlappingCells
    ∨ NonExhaustiveCells

OverlapConflict :=
    ∃i≠j :
        B_i∩B_j≠∅

ExhaustivenessConflict :=
    Union_i B_i≠Ω

WeightNormalisationConflict :=
    Σ_i P(B_i)≠1
    for claimed partition

ConditionalProbabilityConflict :=
    P(A|B_i)
    outside [0,1]
    ∨ inconsistent_with
    P(A∩B_i)/P(B_i)

TotalProbabilityConflict :=
    ClaimedP(A)
    ≠
    Σ_i P(A∩B_i)

TotalProbabilityValidation :=
    ResolvePartition
    → CheckPairwiseDisjoint
    → CheckExhaustive
    → ResolveCellProbabilities
    → ResolveConditionalProbabilities
    → ComputeWeightedSum
    → ValidateBounds

TotalProbabilityQuery :=
    TargetEvent A
    ∧ Partition {B_i}
    ∧ ConditionalProbabilities
    ∧ PartitionProbabilities
    → P(A)

WeightedContribution :=
    Contribution_i
    :=
    P(A|B_i)P(B_i)

ContributionSum :=
    P(A)
    =
    Σ_i Contribution_i

ContributionBounds :=
    0≤Contribution_i≤P(B_i)

ContributionInterpretation :=
    ProbabilityMass
    of
    A∩B_i

ProbabilityTreeRepresentation :=
    Root
    → PartitionBranches B_i
    → EventBranches A or A^c

TreePathToA :=
    B_i
    → A

TreePathProbability :=
    P(B_i)P(A|B_i)

TreeSumRule :=
    P(A)
    =
    Sum(
        probabilities_of_all_paths_ending_in_A
    )

LawOfTotalProbabilityState := {
    ProbabilitySpace,
    TargetEvent,
    Partition,
    PartitionProbabilities,
    ConditionalProbabilities,
    JointContributions,
    TotalProbability,
    Evidence,
    Confidence,
    Provenance
}

Evidence :=
    ProbabilityAssignments
    ∨ Data
    ∨ ModelAssumptions
    ∨ ConditionalDistributions
    ∨ JointDistributions

TotalProbabilityUpdate :=
    NewPartitionProbabilityOrConditionalEvidence
    → RecomputeContributions
    → RecomputeTotalProbability
    → RevalidateConsistency

SEMANTIC_EQUIVALENCE(TotalA,TotalB) :=
    same(TargetEvent)
    ∧ valid_partition_decompositions
    ∧ same(ResultingMarginalProbability)
    under same probability model

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

CoreClasses := {
    LawOfTotalProbability,
    ProbabilitySpace,
    Event,
    Partition,
    PartitionCell,
    ConditionalProbability,
    JointProbability,
    MarginalProbability,
    RandomVariable,
    LatentVariable,
    MixtureModel,
    WeightedContribution,
    Evidence,
    TotalProbabilityResult
}

CoreRelations := {
    partitions,
    conditionedOn,
    hasProbability,
    contributesTo,
    marginalisesOver,
    derivedFrom,
    weights,
    sumsTo,
    dependsOn,
    supports,
    contradicts,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    Partition --partitions--> SampleSpace
    ConditionalProbability --conditionedOn--> PartitionCell
    PartitionCell --hasProbability--> ProbabilityValue
    WeightedContribution --contributesTo--> MarginalProbability
    MarginalProbability --marginalisesOver--> Partition
    ConditionalProbability --weights--> PartitionProbability
    ContributionSet --sumsTo--> TotalProbabilityResult
    TotalProbabilityResult --tracesTo--> Provenance

InferenceRules := {
    Partition({B_i})
        ⇒ A=Union_i(A∩B_i),

    Partition({B_i})
        ⇒ PairwiseDisjoint(A∩B_i),

    Partition({B_i})
        ⇒ P(A)=Σ_iP(A∩B_i),

    P(B_i)>0
        ⇒ P(A∩B_i)=P(A|B_i)P(B_i),

    Partition({B_i})
        ∧ all_required_conditionals_defined
        ⇒
        P(A)=Σ_iP(A|B_i)P(B_i),

    DiscreteY
        ⇒
        P(X∈A)=Σ_yP(X∈A|Y=y)P(Y=y),

    ValidPartition({B_i})
        ⇒ Σ_iP(B_i)=1,

    InvalidPartition
        ⇒ RejectTotalProbabilityConditionalForm
}

CanonicalTotalProbabilityRepresentation :=
    ParseTargetProbability
    → ResolveTargetEvent
    → ResolvePartition
    → CanonicalisePartitionCells
    → ResolveCellProbabilities
    → ResolveConditionalProbabilities
    → ComputeJointContributions
    → SumContributions
    → ValidateResult

TotalProbabilityGraph :=
    G=(V,E)

V := {
    ProbabilitySpaces,
    TargetEvents,
    Partitions,
    PartitionCells,
    ConditionalProbabilities,
    JointContributions,
    MarginalProbabilities,
    RandomVariables,
    LatentVariables,
    MixtureComponents,
    Evidence,
    ProvenanceNodes
}

E := {
    partitions,
    conditionedOn,
    hasProbability,
    contributesTo,
    marginalisesOver,
    derivedFrom,
    weights,
    sumsTo,
    dependsOn,
    supports,
    contradicts,
    equivalentTo,
    tracesTo
}

CONFIDENCE(TotalProbabilityResult) :=
    weighted_mean(
        TargetEventResolution,
        PartitionValidity,
        PartitionProbabilityQuality,
        ConditionalProbabilityQuality,
        JointContributionConsistency,
        CalculationValidity,
        ModelAssumptionQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectTotalProbabilityIntent
    → IdentifyTargetEvent
    → IdentifyPartitionOrLatentVariable
    → ResolvePartitionProbabilities
    → ResolveConditionalProbabilities
    → IdentifyRequestedMarginalProbability

AI_REASONING_FLOW :=
    Query
    → ParseTotalProbabilityQuery
    → ResolveProbabilitySpace
    → ResolveTargetEvent
    → ResolvePartition
    → ValidatePairwiseDisjointness
    → ValidateExhaustiveness
    → ResolvePartitionProbabilities
    → ResolveConditionalProbabilities
    → ComputeJointContributions
    → SumContributions
    → ValidateProbabilityBounds
    → CrossCheckAgainstKnownMarginalOrJointData
    → ConnectToBayesDenominatorIfRelevant
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseTotalProbabilityEntities,
    ParseTypedRelations,
    ResolveTargetEvents,
    ResolvePartitions,
    ValidatePartitions,
    ResolvePartitionProbabilities,
    ResolveConditionalProbabilities,
    ComputeJointContributions,
    ComputeMarginalProbabilities,
    MarginaliseDiscreteVariables,
    MarginaliseContinuousVariables,
    EvaluateMixtureModels,
    SupplyBayesNormalisation,
    DetectTotalProbabilityConflicts,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewPartitionConditionalJointOrMarginalEvidence
    → ValidateInput
    → IdentifyAffectedTotalProbabilityClaims
    → UpdatePartitionModel
    → RecomputeJointContributions
    → RecomputeMarginalProbability
    → RevalidatePartition
    → RecheckBayesianDependencies
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

PartitionUpdate :=
    ChangedPartition
    ⇒ revalidate(
        Disjointness,
        Exhaustiveness,
        PartitionProbabilities
    )

ConditionalUpdate :=
    ChangedConditionalProbability
    ⇒ recompute(
        WeightedContribution,
        TotalProbability
    )

PriorWeightUpdate :=
    ChangedP(B_i)
    ⇒ recompute(
        WeightedContributions,
        TotalProbability
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        EventDecomposition,
        TotalProbabilityFormula,
        MarginalisationInterpretation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    LawOfTotalProbabilityEntityResolution,
    ProbabilitySpace,
    TargetEvent,
    Partition,
    PartitionValidity,
    PartitionProbabilities,
    ConditionalProbabilities,
    JointContributions,
    MarginalProbability,
    BayesianDenominatorRelation,
    ModelConsistency,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA