Probability Rule Ontology

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

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

BEGIN_FLOW

ProbabilityRule :=
    FormalProbabilityTransformation
    ∧ Preconditions
    ∧ InputExpressions
    ∧ OutputExpression
    ∧ ProbabilitySemantics

ProbabilitySpace :=
    (Ω,F,P)

SampleSpace := Ω
Event := A,B,C ∈ F
ProbabilityMeasure := P:F→[0,1]

RuleStructure := {
    RuleName,
    Premises,
    Preconditions,
    Transformation,
    Conclusion,
    ValidityScope
}

RuleApplication :=
    Premises
    ∧ PreconditionsSatisfied
    → Apply(Transformation)
    → Conclusion

RulePrecondition :=
    ConditionRequired
    for sound rule application

RuleConclusion :=
    DerivedProbabilityExpression

ProbabilityExpression :=
    EventProbability
    ∨ ConditionalProbability
    ∨ JointProbability
    ∨ ComplementProbability
    ∨ Expectation
    ∨ Variance
    ∨ ProbabilityBound

KolmogorovRuleSet := {
    NonNegativity,
    Normalisation,
    CountableAdditivity
}

NonNegativityRule :=
    A∈F
    ⇒ P(A)≥0

NormalisationRule :=
    P(Ω)=1

CountableAdditivityRule :=
    PairwiseDisjoint(A_i)
    ⇒
    P(Union_i A_i)=Σ_i P(A_i)

ImpossibleEventRule :=
    P(∅)=0

ProbabilityBoundsRule :=
    A∈F
    ⇒ 0≤P(A)≤1

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

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

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

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

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

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

InclusionExclusionRule :=
    P(Union_i A_i)
    =
    AlternatingSumOfIntersectionProbabilities

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

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

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

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

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

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

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

ConditionalIndependenceRule :=
    Independent(A,B|C)
    ⇒
    P(A∩B|C)
    =
    P(A|C)P(B|C)

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

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

TotalProbabilityRule :=
    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)

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

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

BayesOddsRule :=
    PosteriorOdds
    =
    PriorOdds
    × LikelihoodRatio

CountingProbabilityRule :=
    Finite(Ω)
    ∧ EquallyLikelyOutcomes
    ⇒
    P(A)=|A|/|Ω|

PermutationRule :=
    OrderedSelectionCount
    =
    n!/(n-r)!

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

MultiplicationCountingRule :=
    SequentialIndependentChoiceCounts
    → ProductOfCounts

AdditionCountingRule :=
    MutuallyExclusiveChoiceCounts
    → SumOfCounts

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

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

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

VarianceScaleRule :=
    Var(aX+b)
    =
    a²Var(X)

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

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

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

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

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

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

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

JensenRule :=
    Convex(φ)
    ∧ required_integrability
    ⇒
    φ(E[X])
    ≤ E[φ(X)]

RuleCategory := {
    AxiomRule,
    SetRule,
    AdditionRule,
    ConditionalRule,
    IndependenceRule,
    BayesRule,
    CountingRule,
    ExpectationRule,
    VarianceRule,
    InequalityRule
}

RuleScope :=
    {
        EventProbability,
        RandomVariable,
        ConditionalModel,
        DiscreteModel,
        ContinuousModel,
        GeneralProbabilitySpace
    }

RuleValidity :=
    PreconditionsSatisfied
    ∧ TransformationMathematicallyValid
    within RuleScope

SoundRuleApplication :=
    ValidPremises
    ∧ ValidRule
    ∧ PreconditionsSatisfied
    ⇒ ValidConclusion

InvalidRuleApplication :=
    MissingPrecondition
    ∨ MisresolvedEvent
    ∨ InvalidIndependenceAssumption
    ∨ ZeroConditioningProbability
    ∨ ScopeMismatch

RuleSelection :=
    TargetExpression
    ∧ KnownExpressions
    ∧ StructuralRelations
    → CandidateRules

ApplicableRule :=
    Rule
    whose premises can be matched
    and preconditions satisfied

RuleMatching :=
    RulePattern
    ↔ ProbabilityExpressionGraph

RuleInstantiation :=
    AbstractRuleVariables
    → ConcreteEventsOrRandomVariables

RuleExecution :=
    ResolveInputs
    → ValidatePreconditions
    → InstantiateRule
    → ApplyTransformation
    → SimplifyOutput
    → ValidateResult

ProbabilityConstraint :=
    EquationOrInequality
    over ProbabilityExpressions

ConstraintPropagation :=
    KnownConstraints
    → ApplyApplicableRules
    → DerivedConstraints

RuleChain :=
    Rule_1
    → Rule_2
    → ...
    → Rule_n

ProbabilityDerivation :=
    InitialFacts
    → RuleChain
    → TargetResult

DerivationStep := {
    InputExpressions,
    AppliedRule,
    Preconditions,
    OutputExpression
}

DerivationDependency :=
    Step_n
    dependsOn
    Output(Step_(n-1))

DerivationGraph :=
    Gd=(Expressions,RuleApplications)

RecursiveRuleApplication :=
    DerivedExpression
    → NewKnownExpression
    → ReevaluateApplicableRules

RuleClosure :=
    repeatedly_apply(ApplicableRules)
    until
    TargetResolved
    ∨ NoNewExpressions
    ∨ ResourceBound

RuleConflict :=
    TwoDerivations
    produce
    incompatible probability results

ConflictDetection :=
    DerivedP(A)=p1
    ∧ DerivedP(A)=p2
    ∧ p1≠p2
    ⇒ RuleConflict

ConflictDiagnosis :=
    RuleConflict
    → TracePremises
    → TraceAssumptions
    → CheckPreconditions
    → IdentifyInvalidDependency

ProbabilityValidation :=
    Result p
    must satisfy
    0≤p≤1

ConditionalValidation :=
    P(A|B)
    requires
    P(B)>0

IndependenceValidation :=
    DeclaredIndependence
    must be
    assumption_or_derived_property
    not inferred merely from disjointness

MutualExclusivityValidation :=
    Disjoint(A,B)
    ∧ P(A)>0
    ∧ P(B)>0
    ⇒ not Independent(A,B)

RuleSimplification :=
    DerivedExpression
    → AlgebraicSimplification
    → CanonicalProbabilityExpression

CanonicalProbabilityExpression :=
    ResolveEvents
    → ResolveConditioning
    → ResolveSetOperations
    → NormaliseTerms

RuleEquivalence :=
    RuleA
    and RuleB
    produce semantically equivalent outputs
    under equivalent premises

SEMANTIC_EQUIVALENCE(ExpressionA,ExpressionB) :=
    same(ProbabilityQuantity)
    under same
    ProbabilitySpace
    ∧ EventSemantics
    ∧ ConditioningContext
    ∧ Assumptions

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

CoreClasses := {
    ProbabilityRule,
    RuleApplication,
    RulePrecondition,
    RuleConclusion,
    ProbabilityExpression,
    ProbabilityConstraint,
    ProbabilityDerivation,
    DerivationStep,
    ProbabilitySpace,
    Event,
    ConditionalProbability,
    Independence,
    Partition,
    RandomVariable,
    Expectation,
    Variance,
    ProbabilityBound
}

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

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

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

    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),

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

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

    PreconditionsSatisfied(R)
        ∧ InputsMatch(R)
        ⇒ Applicable(R),

    Applicable(R)
        ⇒ Execute(R),

    InvalidPrecondition(R)
        ⇒ RejectRuleApplication(R)
}

CanonicalProbabilityRuleRepresentation :=
    ParseRule
    → ResolveRuleCategory
    → ResolveInputs
    → ResolvePreconditions
    → ResolveTransformation
    → ResolveOutput
    → ValidateScope
    → CanonicalRuleGraph

ProbabilityRuleGraph :=
    G=(V,E)

V := {
    Rules,
    Preconditions,
    ProbabilityExpressions,
    Events,
    RandomVariables,
    Assumptions,
    Constraints,
    DerivationSteps,
    Results,
    ProvenanceNodes
}

E := {
    appliesTo,
    requires,
    consumes,
    derives,
    transforms,
    conditionedOn,
    independentOf,
    dependsOn,
    equivalentTo,
    validates,
    contradicts,
    tracesTo
}

CONFIDENCE(ProbabilityRuleApplication) :=
    weighted_mean(
        ExpressionResolution,
        RuleSelectionAccuracy,
        PreconditionValidation,
        AssumptionQuality,
        CalculationValidity,
        CrossCheckAgreement,
        DerivationTraceQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectProbabilityRuleConcept
    → ResolveTargetExpression
    → ResolveKnownExpressions
    → ResolveEventsAndVariables
    → ResolveAssumptions
    → IdentifyCandidateRules

AI_REASONING_FLOW :=
    Query
    → ParseProbabilityProblem
    → ResolveProbabilitySpace
    → ResolveEventsAndRandomVariables
    → ResolveKnownProbabilityExpressions
    → ResolveTargetExpression
    → BuildConstraintGraph
    → IdentifyCandidateRules
    → MatchRulePremises
    → ValidateRulePreconditions
    → SelectApplicableRule
    → ExecuteRule
    → AddDerivedExpression
    → RecursivelyApplyFurtherRulesIfNeeded
    → SimplifyResult
    → ValidateProbabilitySemantics
    → CrossCheckAlternativeDerivationIfUseful
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseProbabilityRuleEntities,
    ParseTypedRelations,
    ResolveProbabilityExpressions,
    ResolveEvents,
    ResolveRandomVariables,
    IdentifyApplicableRules,
    ValidateRulePreconditions,
    InstantiateRules,
    ExecuteProbabilityRules,
    PropagateConstraints,
    BuildDerivationChains,
    DetectRuleConflicts,
    ValidateProbabilityResults,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewProbabilityFactRuleOrAssumption
    → ValidateInput
    → IdentifyAffectedRuleApplications
    → UpdateConstraintGraph
    → InvalidateDependentDerivations
    → ReevaluateApplicableRules
    → ReexecuteAffectedRuleChains
    → RevalidateResults
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

FactUpdate :=
    ChangedProbabilityExpression
    ⇒ recompute(
        DependentRuleApplications,
        DerivedExpressions
    )

RuleUpdate :=
    ChangedRuleDefinition
    ⇒ revalidate(
        RulePreconditions,
        RuleScope,
        DependentDerivations
    )

AssumptionUpdate :=
    ChangedIndependenceOrModelAssumption
    ⇒ reevaluate(
        ApplicableRules,
        DerivedResults
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        RuleStructure,
        RuleExecution,
        RuleClosure,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ProbabilityRuleEntityResolution,
    ProbabilitySpace,
    KnownExpressions,
    TargetExpression,
    CandidateRules,
    SelectedRule,
    RulePreconditions,
    RuleInstantiation,
    DerivationChain,
    DerivedExpression,
    ValidationStatus,
    ConflictStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA