Probability Rules

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

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

BEGIN_FLOW

ProbabilityRules :=
    ProbabilityAxioms
    ∧ EventAlgebra
    ∧ ConditionalProbability
    ∧ Independence
    ∧ CountingRelations
    ∧ BayesianUpdating
    ∧ DerivedProbabilityIdentities

ProbabilitySpace :=
    (Ω,F,P)

SampleSpace :=
    Ω

Event :=
    A,B,C ∈ F

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

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

    Normalisation:
        P(Ω)=1,

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

ProbabilityBounds :=
    0≤P(A)≤1

ImpossibleEventRule :=
    P(∅)=0

CertainEventRule :=
    P(Ω)=1

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

DoubleComplement :=
    (A^c)^c=A

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

DifferenceRule :=
    A⊆B
    ⇒
    P(B\A)=P(B)-P(A)

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

FiniteAdditivity :=
    A∩B=∅
    ⇒
    P(A∪B)=P(A)+P(B)

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

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

InclusionExclusion :=
    P(Union_{i=1..n}A_i)
    =
    Σ(single intersections)
    -Σ(pair intersections)
    +Σ(triple intersections)
    -...
    +(-1)^(n+1)P(Intersection_i A_i)

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

BooleInequality :=
    UnionBound

BonferroniBounds :=
    PartialInclusionExclusionSums
    provide
    alternating upper_and_lower_bounds

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

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

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

ConditionalNormalisation :=
    P(Ω|B)=1
    where P(B)>0

ConditionalComplement :=
    P(A^c|B)
    =
    1-P(A|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)

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

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

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

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

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

Prior :=
    P(H)

Likelihood :=
    P(E|H)

Evidence :=
    P(E)

Posterior :=
    P(H|E)

BayesianUpdate :=
    Posterior
    proportional_to
    Likelihood × Prior

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

PriorOdds :=
    Odds(H)

PosteriorOdds :=
    Odds(H|E)

LikelihoodRatio :=
    P(E|H)/P(E|H^c)

OddsFormBayes :=
    PosteriorOdds
    =
    PriorOdds × LikelihoodRatio

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

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

SymmetryOfIndependence :=
    A⟂B
    ⇒ B⟂A

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

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

MutualIndependence :=
    ∀NonemptyFiniteJ :
        P(Intersection_{j∈J}A_j)
        =
        Π_{j∈J}P(A_j)

MutualImpliesPairwise :=
    MutualIndependence
    ⇒ PairwiseIndependence

PairwiseNotNecessarilyMutual :=
    PairwiseIndependence
    ↛ MutualIndependence

MutuallyExclusive :=
    A∩B=∅

MutuallyExclusivePositiveEventsNotIndependent :=
    A∩B=∅
    ∧ P(A)>0
    ∧ P(B)>0
    ⇒ not(A⟂B)

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

ConditionalIndependenceDoesNotGenerallyImplyUnconditional :=
    A⟂B|C
    ↛ A⟂B

CountingProbabilityRule :=
    EquallyLikelyFiniteOutcomes
    ⇒
    P(A)
    =
    |A|/|Ω|

Factorial :=
    n!
    =
    n(n-1)...1

PermutationRule :=
    P(n,r)
    =
    n!/(n-r)!

CombinationRule :=
    C(n,r)
    =
    n!/[r!(n-r)!]

MultiplicationCountingPrinciple :=
    SequentialChoices
    with counts n1,...,nk
    ⇒
    TotalOutcomes
    =
    Π_i n_i

AdditionCountingPrinciple :=
    MutuallyExclusiveChoiceClasses
    with sizes n1,...,nk
    ⇒
    TotalChoices
    =
    Σ_i n_i

BinomialCoefficientIdentity :=
    C(n,r)=C(n,n-r)

PascalIdentity :=
    C(n,r)
    =
    C(n-1,r-1)+C(n-1,r)

BinomialTheorem :=
    (a+b)^n
    =
    Σ_{k=0..n} C(n,k)a^(n-k)b^k

ExpectationRule :=
    E[X]
    =
    Σ_x x p_X(x)
    or
    Integral x f_X(x)dx

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

LinearityGeneral :=
    E[Σ_i a_iX_i]
    =
    Σ_i a_iE[X_i]

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

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

VarianceShift :=
    Var(X+c)
    =
    Var(X)

VarianceScale :=
    Var(aX)
    =
    a²Var(X)

VarianceSum :=
    Var(X+Y)
    =
    Var(X)+Var(Y)+2Cov(X,Y)

IndependentVarianceSum :=
    X⟂Y
    ∧ finite_second_moments
    ⇒
    Var(X+Y)
    =
    Var(X)+Var(Y)

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

CovarianceLinearity :=
    Cov(aX+bY,Z)
    =
    aCov(X,Z)+bCov(Y,Z)

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

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

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

ChebyshevInequality :=
    finite_variance(X)
    ∧ k>0
    ⇒
    P(|X-E[X]|≥k)
    ≤ Var(X)/k²

StandardChebyshev :=
    P(|X-μ|≥rσ)
    ≤ 1/r²

JensenInequality :=
    Convex(φ)
    ⇒
    φ(E[X])
    ≤ E[φ(X)]
    under integrability conditions

CauchySchwarzProbability :=
    |E[XY]|²
    ≤ E[X²]E[Y²]

ConditionalExpectationLinearity :=
    E[aX+bY|G]
    =
    aE[X|G]+bE[Y|G]

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

TakingOutWhatIsKnown :=
    Y is G-measurable
    ⇒
    E[YX|G]
    =
    Y E[X|G]
    under integrability conditions

ProbabilityRule :=
    FormalTransformation
    from
    KnownProbabilityRelations
    to
    DerivedProbabilityRelation

RulePrecondition :=
    ConditionsRequired
    for valid application

RuleApplication :=
    KnownFacts
    ∧ RulePreconditions
    → DerivedFact

RuleValidation :=
    CandidateRuleApplication
    → CheckEventDefinitions
    → CheckDenominators
    → CheckIndependenceAssumptions
    → CheckMeasureConditions
    → AcceptOrReject

InvalidRuleApplication :=
    RuleUsed
    without
    RequiredPreconditions

ProbabilityConstraint :=
    EquationOrInequality
    over probability expressions

ConstraintPropagation :=
    KnownConstraints
    → ApplyProbabilityRules
    → DerivedConstraints

ProbabilityRuleGraph :=
    G=(Expressions,RuleApplications)

RuleDependency :=
    DerivedExpression
    dependsOn
    InputExpressions
    ∧ AppliedRule

ProbabilityDerivation :=
    Premises
    → RuleSequence
    → Result

DerivationTrace :=
    OrderedSequence(
        ProbabilityRuleApplications
    )

RuleEquivalence :=
    DifferentDerivations
    yield
    same probability identity

SEMANTIC_EQUIVALENCE(ExpressionA,ExpressionB) :=
    same(ProbabilityQuantity)
    under same
    Events
    ∧ ConditioningContext
    ∧ ModelAssumptions

CanonicalProbabilityExpression :=
    ParseExpression
    → ResolveEvents
    → ResolveConditioning
    → ResolveSetOperations
    → ResolveIndependence
    → AlgebraicallyNormalise
    → ValidateProbabilitySemantics

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

CoreClasses := {
    ProbabilityRules,
    ProbabilityRule,
    ProbabilitySpace,
    Event,
    ConditionalProbability,
    Independence,
    Partition,
    BayesRule,
    AdditionRule,
    MultiplicationRule,
    CountingRule,
    ExpectationRule,
    VarianceRule,
    ProbabilityInequality,
    RulePrecondition,
    ProbabilityConstraint,
    ProbabilityDerivation
}

CoreRelations := {
    appliesTo,
    requires,
    derives,
    conditionedOn,
    independentOf,
    partitions,
    equivalentTo,
    dependsOn,
    transforms,
    bounds,
    validates,
    contradicts,
    tracesTo
}

TypedRelations :=
    ProbabilityRule --appliesTo--> ProbabilityExpression
    ProbabilityRule --requires--> RulePrecondition
    RuleApplication --derives--> ProbabilityExpression
    ConditionalProbability --conditionedOn--> Event
    Event --independentOf--> Event
    Partition --partitions--> SampleSpace
    ProbabilityInequality --bounds--> ProbabilityExpression
    ProbabilityDerivation --tracesTo--> Provenance

InferenceRules := {
    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),

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

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

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

    Independent(X,Y)
        ∧ finite_second_moments
        ⇒ Var(X+Y)=Var(X)+Var(Y)
}

CONFIDENCE(ProbabilityRuleResult) :=
    weighted_mean(
        ExpressionResolution,
        EventResolution,
        RuleSelectionAccuracy,
        PreconditionSatisfaction,
        ModelAssumptionQuality,
        CalculationValidity,
        DerivationTraceQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectProbabilityRuleIntent
    → ResolveEventsAndVariables
    → ResolveKnownProbabilityExpressions
    → ResolveAssumptions
    → IdentifyTargetProbabilityExpression

AI_REASONING_FLOW :=
    Query
    → ParseProbabilityExpression
    → ResolveSampleSpace
    → ResolveEvents
    → ResolveKnownProbabilities
    → ResolveSetRelations
    → ResolveConditionalRelations
    → ResolveIndependenceAssumptions
    → IdentifyApplicableProbabilityRules
    → ValidateRulePreconditions
    → ApplyRules
    → PropagateConstraints
    → SimplifyDerivedExpression
    → ValidateProbabilityBounds
    → CrossCheckAlternativeDerivationIfUseful
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseProbabilityRuleEntities,
    ParseTypedRelations,
    ResolveProbabilityExpressions,
    ResolveEvents,
    ApplyComplementRules,
    ApplyAdditionRules,
    ApplyConditionalRules,
    ApplyMultiplicationRules,
    ApplyIndependenceRules,
    ApplyTotalProbability,
    ApplyBayesRule,
    ApplyCountingRules,
    ApplyExpectationRules,
    ApplyVarianceRules,
    ApplyProbabilityInequalities,
    ValidateRulePreconditions,
    CompareSemanticEquivalence,
    PreserveDerivationTrace,
    UpdateConfidence,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewProbabilityFactAssumptionOrRule
    → ValidateInput
    → IdentifyAffectedExpressions
    → UpdateConstraintGraph
    → ReevaluateApplicableRules
    → RecomputeDerivedProbabilities
    → RevalidatePreconditions
    → RecheckProbabilityConsistency
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ProbabilityFactUpdate :=
    ChangedKnownProbability
    ⇒ recompute(
        DependentExpressions,
        ConditionalProbabilities,
        BayesianUpdates
    )

AssumptionUpdate :=
    ChangedIndependenceOrPartitionAssumption
    ⇒ reevaluate(
        ApplicableRules,
        Factorisations,
        DerivedResults
    )

RuleUpdate :=
    ChangedProbabilityRule
    ⇒ recompute(
        DependentDerivations
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        KolmogorovAxioms,
        ConditionalProbability,
        BayesRule,
        Independence,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ProbabilityRuleEntityResolution,
    SampleSpace,
    EventStructure,
    KnownProbabilityExpressions,
    Assumptions,
    ApplicableRules,
    RulePreconditions,
    DerivationTrace,
    DerivedProbabilityExpression,
    ConstraintStatus,
    ProbabilityValidation,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA