Independent Events Ontology

FULL EXECUTABLE FLOW ALGEBRA — INDEPENDENT EVENTS ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/probability-rules/independent-events-ontology.html

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

BEGIN_FLOW

IndependentEvents :=
    Events
    ∧ JointProbabilityFactorisation
    ∧ NoProbabilityUpdateBetweenEvents
    under defined probability model

ProbabilitySpace :=
    (Ω,F,P)

Event :=
    A,B,C ∈ F

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

Symmetry :=
    A⟂B
    ⇒ B⟂A

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

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

JointProbabilityUnderIndependence :=
    P(A∩B)
    =
    P(A)P(B)

ComplementIndependence1 :=
    A⟂B
    ⇒
    A^c⟂B

ComplementIndependence2 :=
    A⟂B
    ⇒
    A⟂B^c

ComplementIndependence3 :=
    A⟂B
    ⇒
    A^c⟂B^c

ComplementJointRule :=
    A⟂B
    ⇒
    P(A^c∩B^c)
    =
    (1-P(A))(1-P(B))

MixedComplementRule :=
    A⟂B
    ⇒
    P(A∩B^c)
    =
    P(A)(1-P(B))

PairwiseIndependence :=
    Collection{A_i}
    ∧
    ∀i≠j :
        P(A_i∩A_j)
        =
        P(A_i)P(A_j)

MutualIndependence :=
    Collection{A_i}
    ∧
    ForEveryFiniteNonemptyIndexSet J:
        P(Intersection_{j∈J}A_j)
        =
        Π_{j∈J}P(A_j)

MutualImpliesPairwise :=
    MutualIndependence
    ⇒ PairwiseIndependence

PairwiseDoesNotGenerallyImplyMutual :=
    PairwiseIndependence
    ↛ MutualIndependence

ThreeEventMutualIndependence :=
    P(A∩B)=P(A)P(B)
    ∧ P(A∩C)=P(A)P(C)
    ∧ P(B∩C)=P(B)P(C)
    ∧ P(A∩B∩C)=P(A)P(B)P(C)

FiniteIndependentIntersection :=
    MutualIndependence(A1,...,An)
    ⇒
    P(Intersection_i A_i)
    =
    Π_i P(A_i)

FiniteIndependentComplementPattern :=
    MutualIndependence(A1,...,An)
    ⇒
    AnyChoiceOf(A_iOrComplement(A_i))
    remains mutually independent

IndependentUnionComplementRule :=
    A⟂B
    ⇒
    P(A∪B)
    =
    P(A)+P(B)-P(A)P(B)

ProbabilityNeitherIndependentEvents :=
    A⟂B
    ⇒
    P(A^c∩B^c)
    =
    (1-P(A))(1-P(B))

ProbabilityAtLeastOneIndependentEvent :=
    MutualIndependence(A1,...,An)
    ⇒
    P(Union_i A_i)
    =
    1-Π_i(1-P(A_i))
    only when computing complement of none occurring

MutuallyExclusive :=
    A∩B=∅

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

DisjointZeroProbabilityException :=
    A∩B=∅
    ∧ [P(A)=0 ∨ P(B)=0]
    ⇒
    IndependenceConditionMayHold

Dependence :=
    not(A⟂B)

PositiveDependenceIndicator :=
    P(A∩B)
    >
    P(A)P(B)

NegativeDependenceIndicator :=
    P(A∩B)
    <
    P(A)P(B)

IndependenceDifference :=
    Δ(A,B)
    =
    P(A∩B)-P(A)P(B)

IndependenceTestExact :=
    Δ(A,B)=0

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

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

ConditionalIndependenceSymmetry :=
    A⟂B|C
    ⇒ B⟂A|C

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

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

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

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

RandomVariable :=
    X:Ω→S

IndependentRandomVariables :=
    X⟂Y
    iff
    P(X∈A,Y∈B)
    =
    P(X∈A)P(Y∈B)
    for all measurable A,B

DiscreteVariableIndependence :=
    p_(X,Y)(x,y)
    =
    p_X(x)p_Y(y)
    for all x,y

ContinuousVariableIndependence :=
    f_(X,Y)(x,y)
    =
    f_X(x)f_Y(y)
    almost everywhere
    where joint density exists

JointDistributionFactorisation :=
    Independence(X,Y)
    ⇒
    Law(X,Y)
    =
    Law(X)⊗Law(Y)

IndependentFunctions :=
    X⟂Y
    ⇒
    g(X)⟂h(Y)
    for measurable g,h

IndependentExpectationFactorisation :=
    X⟂Y
    ∧ required_integrability
    ⇒
    E[g(X)h(Y)]
    =
    E[g(X)]E[h(Y)]

IndependentProductExpectation :=
    X⟂Y
    ∧ integrable
    ⇒
    E[XY]
    =
    E[X]E[Y]

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

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

NormalException :=
    JointlyGaussian(X,Y)
    ∧ Cov(X,Y)=0
    ⇒
    X⟂Y

IndependentVarianceAddition :=
    X⟂Y
    ∧ finite_variances
    ⇒
    Var(X+Y)
    =
    Var(X)+Var(Y)

IndependentSumDistribution :=
    X⟂Y
    ⇒
    Distribution(X+Y)
    =
    Convolution(
        Distribution(X),
        Distribution(Y)
    )

IID :=
    Independent
    ∧ IdenticallyDistributed

IndependentTrials :=
    TrialOutcomes
    mutually independent

BernoulliTrials :=
    IndependentTrials
    ∧ BinaryOutcomes
    ∧ ConstantSuccessProbability

BinomialModel :=
    n IndependentBernoulliTrials
    with success probability p
    ⇒
    SuccessCount ~ Binomial(n,p)

IndependentIncrements :=
    Process
    ∧ increments_over_disjoint_intervals
    are independent

PoissonProcessIndependence :=
    PoissonProcess
    ⇒
    IndependentIncrements
    under standard definition

IndependentSigmaAlgebras :=
    F1,...,Fn
    independent
    iff
    for all A_i∈F_i:
        P(Intersection_i A_i)
        =
        Π_iP(A_i)

EventIndependenceFromSigmaAlgebra :=
    Event A
    independent_of
    SigmaAlgebra G
    iff
    ∀B∈G:
        P(A∩B)=P(A)P(B)

RandomVariableIndependenceViaSigmaAlgebra :=
    X⟂Y
    iff
    σ(X) independent_of σ(Y)

IndependenceEvidence :=
    ModelAssumption
    ∨ ExperimentalDesign
    ∨ FactorisedJointDistribution
    ∨ DerivedProbabilityIdentity

DeclaredIndependence :=
    Independence
    supplied_as
    ModelAssumption

DerivedIndependence :=
    Independence
    established_from
    JointAndMarginalStructure

EmpiricalIndependenceAssessment :=
    SampleData
    → StatisticalAssociationTest
    → EvidenceAboutIndependence
    not logical proof of population independence

IndependenceConstraint :=
    P(A∩B)
    =
    P(A)P(B)

IndependenceValidation :=
    ResolveEvents
    → ResolveMarginals
    → ResolveJointProbability
    → CompareFactorisation
    → DetermineStatus

IndependenceStatus := {
    Independent,
    Dependent,
    ConditionallyIndependent,
    Unknown,
    InconsistentEvidence
}

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

ConditionalIndependenceConflict :=
    DeclaredIndependent(A,B|C)
    ∧ P(A∩B|C)
       ≠P(A|C)P(B|C)

ModelConsistency :=
    IndependenceClaims
    ∧ JointProbabilities
    ∧ Marginals
    ∧ Conditionals
    jointly_compatible

IndependenceGraph :=
    Nodes(RandomVariablesOrEvents)
    ∧ Edges(DependenceOrConditionalIndependenceRelations)

GraphicalModel :=
    Graph
    encoding
    conditional dependence structure

BayesianNetwork :=
    DirectedAcyclicGraph
    ∧ LocalConditionalDistributions

DSeparation :=
    GraphicalCriterion
    for conditional independence
    under Bayesian-network semantics

MarkovRandomField :=
    UndirectedGraph
    representing
    conditional dependence structure

IndependenceQuery :=
    EventsOrVariables
    ∧ ProbabilityModel
    → DetermineIndependenceRelation

IndependenceReasoning :=
    ResolveJoint
    → ResolveMarginals
    → CheckFactorisation
    → CheckConditioning
    → ValidateAssumptions

IndependentEventsState := {
    ProbabilitySpace,
    Events,
    MarginalProbabilities,
    JointProbabilities,
    ConditionalProbabilities,
    IndependenceClaims,
    ConditionalIndependenceClaims,
    Evidence,
    Confidence,
    Provenance
}

IndependenceUpdate :=
    NewJointMarginalConditionalOrStructuralEvidence
    → RecomputeIndependence
    → RecomputeDependentProbabilities
    → RevalidateModel

SEMANTIC_EQUIVALENCE(IndependenceA,IndependenceB) :=
    same(EventOrVariablePairs)
    ∧ same(ConditioningContext)
    ∧ same(FactorisationMeaning)
    under same probability model

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

CoreClasses := {
    IndependentEvents,
    Event,
    ProbabilitySpace,
    JointProbability,
    MarginalProbability,
    ConditionalProbability,
    PairwiseIndependence,
    MutualIndependence,
    ConditionalIndependence,
    DependentEvents,
    RandomVariable,
    IndependentRandomVariables,
    SigmaAlgebra,
    IndependenceConstraint,
    IndependenceEvidence
}

CoreRelations := {
    independentOf,
    dependentOn,
    conditionallyIndependentOf,
    hasJointProbability,
    hasMarginalProbability,
    conditionedOn,
    factorisesAs,
    generatedBy,
    supports,
    contradicts,
    dependsOn,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    Event --independentOf--> Event
    Event --dependentOn--> Event
    Event --conditionallyIndependentOf--> Event
    EventPair --hasJointProbability--> ProbabilityValue
    Event --hasMarginalProbability--> ProbabilityValue
    ConditionalIndependence --conditionedOn--> Event
    JointDistribution --factorisesAs--> ProductOfMarginals
    Evidence --supports--> IndependenceClaim
    Evidence --contradicts--> IndependenceClaim
    IndependenceClaim --tracesTo--> Provenance

InferenceRules := {
    P(A∩B)=P(A)P(B)
        ⇒ Independent(A,B),

    Independent(A,B)
        ⇒ Independent(B,A),

    Independent(A,B)
        ⇒ Independent(A^c,B)
        ∧ Independent(A,B^c)
        ∧ Independent(A^c,B^c),

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

    MutualIndependent(A1,...,An)
        ⇒ PairwiseIndependent(A1,...,An),

    PairwiseIndependent(A1,...,An)
        ↛ MutualIndependent(A1,...,An),

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

    Independent(X,Y)
        ∧ finite_second_moments
        ⇒ Cov(X,Y)=0
}

CanonicalIndependenceRepresentation :=
    ParseIndependenceClaim
    → ResolveProbabilitySpace
    → ResolveEventsOrVariables
    → ResolveConditioningContext
    → ResolveMarginals
    → ResolveJointProbability
    → CheckFactorisation
    → CanonicaliseIndependenceRelation

CONFIDENCE(IndependenceAssessment) :=
    weighted_mean(
        EventOrVariableResolution,
        JointProbabilityQuality,
        MarginalProbabilityQuality,
        ConditioningResolution,
        FactorisationEvidence,
        ModelAssumptionQuality,
        Consistency,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectIndependenceIntent
    → IdentifyEventsOrVariables
    → ResolveProbabilitySpace
    → ResolveConditioningContext
    → ResolveKnownJointAndMarginalInformation
    → IdentifyRequestedIndependenceRelation

AI_REASONING_FLOW :=
    Query
    → ParseIndependenceQuery
    → ResolveProbabilitySpace
    → ResolveEventsOrRandomVariables
    → ResolveMarginalProbabilities
    → ResolveJointProbability
    → ResolveConditioningEventIfAny
    → TestJointFactorisation
    → TestConditionalFactorisationIfRequired
    → CheckComplementRelations
    → DistinguishPairwiseFromMutualIndependence
    → DetectMutualExclusivityConflict
    → DetermineIndependenceStatus
    → RecomputeDependentProbabilityRules
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseIndependentEventEntities,
    ParseTypedRelations,
    ResolveEvents,
    ResolveRandomVariables,
    ResolveJointProbabilities,
    ResolveMarginals,
    ResolveConditionalProbabilities,
    EvaluatePairwiseIndependence,
    EvaluateMutualIndependence,
    EvaluateConditionalIndependence,
    ApplyComplementIndependence,
    DetectDependence,
    EvaluateFactorisations,
    ValidateIndependenceModels,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewJointMarginalConditionalOrIndependenceEvidence
    → ValidateInput
    → IdentifyAffectedIndependenceClaims
    → UpdateProbabilityGraph
    → RecomputeFactorisations
    → ReevaluateConditionalIndependence
    → RecomputeDependentProbabilities
    → RecheckModelConsistency
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

JointProbabilityUpdate :=
    ChangedJointProbability
    ⇒ reevaluate(
        IndependenceStatus,
        ConditionalProbabilities
    )

MarginalUpdate :=
    ChangedMarginalProbability
    ⇒ reevaluate(
        Factorisation,
        IndependenceStatus
    )

ConditioningUpdate :=
    ChangedConditioningContext
    ⇒ reevaluate(
        ConditionalIndependence
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        Independence,
        PairwiseIndependence,
        MutualIndependence,
        ConditionalIndependence,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    IndependentEventsEntityResolution,
    ProbabilitySpace,
    EventsOrVariables,
    MarginalProbabilities,
    JointProbability,
    ConditioningContext,
    PairwiseIndependenceStatus,
    MutualIndependenceStatus,
    ConditionalIndependenceStatus,
    DependenceStatus,
    ModelConsistency,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA