Conditional Probability Ontology

FULL EXECUTABLE FLOW ALGEBRA — CONDITIONAL PROBABILITY ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/probability-rules/conditional-probability-ontology.html

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

BEGIN_FLOW

ConditionalProbability :=
    ProbabilityOf(EventA)
    given
    EventB
    ∧ P(B)>0

ProbabilitySpace :=
    (Ω,F,P)

Event :=
    A,B,C ∈ F

ConditioningEvent :=
    B
    ∧ P(B)>0

ConditionalProbabilityDefinition :=
    P(A|B)
    =
    P(A∩B)/P(B)

ConditionalSampleSpace :=
    B

ConditionalMeasure :=
    P_B(A)
    :=
    P(A∩B)/P(B)

ConditionalMeasureNormalisation :=
    P_B(B)=1

ConditionalMeasureBounds :=
    0≤P(A|B)≤1

ConditionalImpossibleEvent :=
    P(∅|B)=0

ConditionalCertainEvent :=
    P(B|B)=1

ConditionalComplementRule :=
    P(A^c|B)
    =
    1-P(A|B)

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

ConditionalFiniteAdditivity :=
    A∩C=∅
    ⇒
    P(A∪C|B)
    =
    P(A|B)+P(C|B)

ConditionalMonotonicity :=
    A⊆C
    ⇒
    P(A|B)≤P(C|B)

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

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

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

ThreeEventChainRule :=
    P(A∩B∩C)
    =
    P(A)
    P(B|A)
    P(C|A∩B)

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

ConditionalChainRule :=
    P(A∩B|C)
    =
    P(A|C)
    P(B|A∩C)
    where conditioning probabilities are defined

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

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

ConditionalTotalProbability :=
    Partition({B_i})
    ∧ P(C)>0
    ⇒
    P(A|C)
    =
    Σ_i
    P(A|B_i∩C)
    P(B_i|C)
    where terms are defined

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

SimpleBayes :=
    P(A|B)
    =
    P(B|A)P(A)/P(B)

PriorProbability :=
    P(A)

Likelihood :=
    P(B|A)

EvidenceProbability :=
    P(B)

PosteriorProbability :=
    P(A|B)

BayesianUpdate :=
    Prior
    ∧ Likelihood
    ∧ Evidence
    → Posterior

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

ConditionalOdds :=
    Odds(A|B)
    =
    P(A|B)/(1-P(A|B))

LikelihoodRatio :=
    P(B|A)/P(B|A^c)

OddsBayesRule :=
    PosteriorOdds
    =
    PriorOdds
    × LikelihoodRatio

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

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

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

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

ConditionalIndependenceEquivalent :=
    A⟂B|C
    ∧ P(B∩C)>0
    ⇒
    P(A|B∩C)=P(A|C)

PairwiseConditionalIndependence :=
    EachPairIndependent
    given C

MutualConditionalIndependence :=
    JointConditionalDistribution
    factorises
    given C

ConditioningCanCreateDependence :=
    A⟂B
    does_not_imply
    A⟂B|C

ConditioningCanRemoveDependence :=
    Dependent(A,B)
    may_become
    Independent(A,B|C)

ConditionalRandomVariable :=
    RandomVariable
    considered_under
    conditioned probability model

ConditionalDistribution :=
    Law(X|Y)

ConditionalPMF :=
    P(X=x|Y=y)
    =
    P(X=x,Y=y)/P(Y=y)
    where P(Y=y)>0

ConditionalDensity :=
    f_(X|Y)(x|y)
    =
    f_(X,Y)(x,y)/f_Y(y)
    where f_Y(y)>0

ConditionalCDF :=
    F_(X|Y)(x|y)
    =
    P(X≤x|Y=y)
    under appropriate regular conditional framework

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

ConditionalExpectationDiscrete :=
    E[X|Y=y]
    =
    Σ_x x P(X=x|Y=y)

ConditionalExpectationContinuous :=
    E[X|Y=y]
    =
    Integral x f_(X|Y)(x|y)dx
    where defined

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

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

ConditionalVariance :=
    Var(X|Y)
    =
    E[
        (X-E[X|Y])²
        |Y
    ]

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

ConditionalCovariance :=
    Cov(X,Y|Z)

ConditionalProbabilityTable :=
    CPT
    :=
    TabularRepresentationOf
    P(X|Parents(X))

BayesianNetwork :=
    DAG
    ∧ ConditionalProbabilityDistributions

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

EvidenceConditioning :=
    Observe(E=e)
    → RestrictOrUpdate
    ProbabilityModel

PosteriorDistribution :=
    PriorDistribution
    updated_by
    Evidence

SequentialConditioning :=
    P(A|B,C)
    :=
    P(A|B∩C)

EvidenceSequence :=
    E1,E2,...,En

SequentialBayesianUpdate :=
    Prior
    → ConditionOn(E1)
    → ConditionOn(E2)
    → ...
    → Posterior

ConditioningOrder :=
    P(A|B∩C)
    =
    P(A|C∩B)
    when conditioning event has positive probability

ZeroProbabilityConditioning :=
    P(B)=0
    ⇒ ElementaryRatioDefinitionUndefined

RegularConditionalProbability :=
    ProbabilityKernel
    representing
    conditional probability
    where existence conditions hold

ProbabilityKernel :=
    K(y,A)
    such_that
    for fixed y:
        A↦K(y,A) is probability measure
    and for fixed A:
        y↦K(y,A) is measurable

ConditioningOnRandomVariable :=
    P(A|Y)
    represented_as
    ConditionalExpectation(1_A|σ(Y))

SigmaAlgebraConditioning :=
    P(A|G)
    :=
    E[1_A|G]

ConditionalProbabilityAsRandomVariable :=
    P(A|G)
    is G-measurable

Information :=
    SigmaAlgebra
    representing
    known events

MoreInformation :=
    G⊆H

ConditioningRefinement :=
    ConditionOn(H)
    uses
    at_least_as_much_information_as
    ConditionOn(G)

ConditionalProbabilityConstraint :=
    EquationOrInequality
    involving
    P(A|B)

ConditionalConstraintPropagation :=
    KnownConditionalRelations
    → ApplyRules
    → DerivedProbabilities

ConditionalProbabilityQuery :=
    GivenEvents
    ∧ KnownProbabilities
    ∧ ConditioningInformation
    → RequestedConditionalProbability

ConditionalProbabilityValidation :=
    CheckEvents
    → CheckP(Condition)>0
    → CheckIntersections
    → ApplyRule
    → ValidateBounds

ConditionalProbabilityConflict :=
    DerivedConditionalProbability
    outside [0,1]
    ∨ inconsistent_with
    joint_and_marginal_probabilities

DenominatorConflict :=
    RatioDefinitionRequested
    ∧ P(B)=0

JointMarginalConflict :=
    P(A|B)P(B)
    ≠
    P(A∩B)

IndependenceConflict :=
    DeclaredIndependent(A,B)
    ∧ P(A|B)≠P(A)
    with P(B)>0

ConditionalModelConsistency :=
    Marginals
    ∧ JointProbabilities
    ∧ ConditionalProbabilities
    ∧ IndependenceClaims
    jointly_compatible

ConditionalProbabilityState := {
    ProbabilitySpace,
    Events,
    JointProbabilities,
    Marginals,
    ConditioningEvents,
    ConditionalProbabilities,
    IndependenceRelations,
    Evidence,
    Confidence,
    Provenance
}

ConditionalUpdate :=
    NewEvidenceOrProbability
    → RecomputeConditionals
    → RecomputePosteriors
    → ReevaluateIndependence
    → RecheckConsistency

SEMANTIC_EQUIVALENCE(ConditionalA,ConditionalB) :=
    same(TargetEvent)
    ∧ same(ConditioningInformation)
    ∧ same(ConditionalProbabilityValue)
    under same probability model

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

CoreClasses := {
    ConditionalProbability,
    ProbabilitySpace,
    Event,
    ConditioningEvent,
    ConditionalMeasure,
    JointProbability,
    MarginalProbability,
    Independence,
    ConditionalIndependence,
    Partition,
    BayesTheorem,
    ConditionalDistribution,
    ConditionalExpectation,
    ProbabilityKernel,
    Evidence,
    PosteriorDistribution
}

CoreRelations := {
    conditionedOn,
    hasProbability,
    intersects,
    independentOf,
    conditionallyIndependentOf,
    derivedFrom,
    updates,
    partitions,
    hasPosterior,
    dependsOn,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    ConditionalProbability --conditionedOn--> Event
    Event --hasProbability--> ProbabilityValue
    JointProbability --derivedFrom--> EventIntersection
    Event --independentOf--> Event
    Event --conditionallyIndependentOf--> Event
    Partition --partitions--> SampleSpace
    Evidence --updates--> ProbabilityModel
    PriorDistribution --hasPosterior--> PosteriorDistribution
    ConditionalProbability --tracesTo--> Provenance

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

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

    Independent(A,B)
        ∧ P(B)>0
        ⇒ P(A|B)=P(A),

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

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

    ConditionalIndependent(A,B|C)
        ⇒ P(A∩B|C)=P(A|C)P(B|C),

    P(B)=0
        ⇒ RatioConditionalProbability(A|B)
        is Undefined,

    ValidConditionalProbability(q)
        ⇒ 0≤q≤1
}

CanonicalConditionalProbabilityRepresentation :=
    ParseConditionalExpression
    → ResolveTargetEvent
    → ResolveConditioningEvent
    → ResolveJointProbability
    → ResolveMarginals
    → ResolveIndependence
    → ResolveEvidenceContext
    → ValidateDenominator
    → CanonicaliseExpression

ConditionalProbabilityGraph :=
    G=(V,E)

V := {
    ProbabilitySpaces,
    Events,
    ConditioningEvents,
    JointProbabilities,
    Marginals,
    ConditionalProbabilities,
    IndependenceRelations,
    Partitions,
    Evidence,
    PriorDistributions,
    PosteriorDistributions,
    ProbabilityKernels
}

E := {
    conditionedOn,
    hasProbability,
    intersects,
    independentOf,
    conditionallyIndependentOf,
    derivedFrom,
    updates,
    partitions,
    hasPosterior,
    dependsOn,
    equivalentTo,
    tracesTo
}

CONFIDENCE(ConditionalProbabilityResult) :=
    weighted_mean(
        EventResolution,
        ConditioningResolution,
        JointProbabilityQuality,
        MarginalProbabilityQuality,
        IndependenceAssumptionQuality,
        RuleApplicability,
        CalculationValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectConditionalProbabilityIntent
    → IdentifyTargetEvent
    → IdentifyConditioningEventOrInformation
    → ResolveKnownJointAndMarginalProbabilities
    → ResolveIndependenceAssumptions
    → IdentifyRequestedConditionalQuantity

AI_REASONING_FLOW :=
    Query
    → ParseConditionalProbabilityQuery
    → ResolveProbabilitySpace
    → ResolveTargetEvent
    → ResolveConditioningEvent
    → ValidateConditioningProbability
    → ResolveJointProbability
    → ResolveMarginalProbabilities
    → ResolveIndependenceOrConditionalIndependence
    → SelectConditionalRule
    → ApplyBayesOrTotalProbabilityIfRequired
    → ComputeConditionalProbability
    → ValidateBounds
    → CrossCheckJointMarginalConsistency
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseConditionalProbabilityEntities,
    ParseTypedRelations,
    ResolveEvents,
    ResolveConditioningContexts,
    EvaluateJointProbabilities,
    EvaluateMarginals,
    EvaluateConditionalProbabilities,
    EvaluateIndependence,
    EvaluateConditionalIndependence,
    ApplyChainRule,
    ApplyTotalProbability,
    ApplyBayesTheorem,
    ResolveConditionalDistributions,
    ResolveConditionalExpectations,
    ValidateConditionalModels,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewEvidenceJointMarginalOrConditionalProbability
    → ValidateInput
    → IdentifyAffectedConditionalRelations
    → UpdateProbabilityGraph
    → RecomputeConditionals
    → RecomputeBayesianPosteriors
    → ReevaluateIndependence
    → RecheckModelConsistency
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

JointProbabilityUpdate :=
    ChangedJointProbability
    ⇒ recompute(
        ConditionalProbabilities,
        IndependenceStatus
    )

MarginalUpdate :=
    ChangedMarginalProbability
    ⇒ recompute(
        ConditionalProbabilities,
        BayesUpdates
    )

EvidenceUpdate :=
    NewConditioningEvidence
    ⇒ update(
        PosteriorProbabilities,
        ConditionalDistributions
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        ConditionalProbabilityDefinition,
        ChainRule,
        BayesTheorem,
        ConditionalIndependence,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ConditionalProbabilityEntityResolution,
    ProbabilitySpace,
    TargetEvent,
    ConditioningEvent,
    JointProbability,
    MarginalProbabilities,
    ConditionalProbability,
    IndependenceStatus,
    ConditionalIndependenceStatus,
    BayesianUpdate,
    ModelConsistency,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA