Discrete Distribution Ontology

FULL EXECUTABLE FLOW ALGEBRA — DISCRETE DISTRIBUTION ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/probability-distributions/discrete-distribution-ontology.html

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

BEGIN_FLOW

DiscreteDistribution :=
    ProbabilityDistribution
    ∧ FiniteOrCountableSupport
    ∧ ProbabilityMassFunction
    ∧ NormalisedProbabilityMass

ProbabilitySpace :=
    (Ω,F,P)

DiscreteRandomVariable :=
    X:Ω→S
    ∧ Countable(S)
    ∧ Measurable(X)

Support :=
    S_X
    :=
    {x : P(X=x)>0}
    under positive-mass support convention

FiniteSupport :=
    |S_X|<∞

CountablyInfiniteSupport :=
    |S_X|=ℵ0

ProbabilityMassFunction :=
    p_X(x)
    :=
    P(X=x)

PMFNonnegativity :=
    ∀x :
        p_X(x)≥0

PMFNormalisation :=
    Σ_{x∈S_X}
    p_X(x)
    =
    1

PMFValidity :=
    PMFNonnegativity
    ∧ PMFNormalisation

PointProbability :=
    P(X=x)
    =
    p_X(x)

EventProbability :=
    P(X∈A)
    =
    Σ_{x∈A∩S_X}
    p_X(x)

CumulativeDistributionFunction :=
    F_X(x)
    =
    P(X≤x)

DiscreteCDF :=
    F_X(x)
    =
    Σ_{t≤x}
    p_X(t)

CDFJump :=
    F_X(x)-F_X(x^-)
    =
    p_X(x)

SurvivalFunction :=
    S_X(x)
    =
    P(X>x)

DiscreteHazard :=
    h(k)
    =
    P(X=k|X≥k)
    where denominator positive

Quantile :=
    Q(p)
    =
    inf{x:F_X(x)≥p}

Expectation :=
    E[X]
    =
    Σ_x x p_X(x)
    when absolutely summable as required

ExpectedFunction :=
    E[g(X)]
    =
    Σ_x g(x)p_X(x)

Moment :=
    E[X^r]
    =
    Σ_x x^r p_X(x)

Mean :=
    μ=E[X]

Variance :=
    Var(X)
    =
    Σ_x (x-μ)²p_X(x)

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

StandardDeviation :=
    sqrt(Var(X))

ProbabilityGeneratingFunction :=
    G_X(s)
    =
    E[s^X]
    =
    Σ_x p_X(x)s^x
    for suitable nonnegative integer-valued X

MomentGeneratingFunction :=
    M_X(t)
    =
    Σ_x e^(tx)p_X(x)
    where finite

CharacteristicFunction :=
    φ_X(t)
    =
    Σ_x e^(itx)p_X(x)

DiscreteDistributionFamily := {
    Bernoulli,
    Binomial,
    Categorical,
    DiscreteUniform,
    Geometric,
    NegativeBinomial,
    Hypergeometric,
    Poisson,
    Multinomial
}

BernoulliDistribution :=
    X∈{0,1}
    ∧ P(X=1)=p
    ∧ P(X=0)=1-p

BernoulliParameter :=
    0≤p≤1

BernoulliMean :=
    p

BernoulliVariance :=
    p(1-p)

BinomialDistribution :=
    X~Binomial(n,p)

BinomialSupport :=
    {0,1,...,n}

BinomialPMF :=
    P(X=k)
    =
    C(n,k)p^k(1-p)^(n-k)

BinomialMean :=
    np

BinomialVariance :=
    np(1-p)

CategoricalDistribution :=
    X∈{c1,...,ck}
    ∧ P(X=c_i)=p_i

CategoricalConstraint :=
    p_i≥0
    ∧ Σ_i p_i=1

DiscreteUniformDistribution :=
    FiniteSupport S
    ∧
    ∀x∈S:
        P(X=x)=1/|S|

GeometricDistribution :=
    WaitingTimeOrFailureCount
    until first success
    according_to selected parameterisation

GeometricMemoryless :=
    P(X>s+t|X>s)
    =
    P(X>t)
    under compatible support convention

NegativeBinomialDistribution :=
    CountOrWaitingTime
    until specified number of successes
    according_to parameterisation

HypergeometricDistribution :=
    SuccessCount
    from sampling_without_replacement

PoissonDistribution :=
    X~Poisson(λ)

PoissonParameter :=
    λ>0

PoissonSupport :=
    {0,1,2,...}

PoissonPMF :=
    P(X=k)
    =
    e^(-λ)λ^k/k!

PoissonMean :=
    λ

PoissonVariance :=
    λ

MultinomialDistribution :=
    CountVector
    from n categorical trials

MultinomialConstraint :=
    Σ_i X_i=n

DiscreteJointDistribution :=
    p_(X,Y)(x,y)
    =
    P(X=x,Y=y)

JointPMFNonnegativity :=
    p_(X,Y)(x,y)≥0

JointPMFNormalisation :=
    Σ_xΣ_y
    p_(X,Y)(x,y)
    =
    1

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

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

DiscreteIndependence :=
    X⟂Y
    iff
    p_(X,Y)(x,y)
    =
    p_X(x)p_Y(y)
    for all support pairs

DiscreteCovariance :=
    Cov(X,Y)
    =
    Σ_xΣ_y
    (x-E[X])(y-E[Y])
    p_(X,Y)(x,y)

Transformation :=
    Y=g(X)

TransformedPMF :=
    p_Y(y)
    =
    Σ_{x:g(x)=y}
    p_X(x)

SumOfDiscreteVariables :=
    Z=X+Y

DiscreteConvolution :=
    Independent(X,Y)
    ⇒
    p_Z(z)
    =
    Σ_x
    p_X(x)p_Y(z-x)

BernoulliSum :=
    IndependentBernoulli(p)
    repeated n times
    ⇒
    Sum~Binomial(n,p)

PoissonSum :=
    IndependentPoisson(λ_i)
    ⇒
    Sum~Poisson(Σ_i λ_i)

BinomialAdditivity :=
    Independent(
        X~Binomial(n1,p),
        Y~Binomial(n2,p)
    )
    ⇒
    X+Y~Binomial(n1+n2,p)

MixtureDiscreteDistribution :=
    p(x)
    =
    Σ_i π_i p_i(x)

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

CompoundDiscreteDistribution :=
    Distribution
    formed_by
    randomising parameter_or_count

ZeroInflatedDistribution :=
    Mixture
    adding extra probability mass
    at zero

TruncatedDiscreteDistribution :=
    BaseDiscreteDistribution
    conditioned_on
    restricted support

ConditionalDiscreteDistribution :=
    PMF
    after conditioning_on
    event_or_variable

EmpiricalDiscreteDistribution :=
    ObservedCounts
    → RelativeFrequencies

EmpiricalPMF :=
    p_hat(x)
    =
    Count(X=x)/n

FrequencyTable :=
    Values
    ∧ Counts
    ∧ RelativeFrequencies

SamplingFromDiscreteDistribution :=
    RandomUniformInput
    → CumulativeProbabilityIntervals
    → DiscreteOutcome

InverseCDFSampling :=
    U~Uniform(0,1)
    → X=Q(U)

DiscreteLikelihood :=
    L(θ|x1,...,xn)
    =
    Π_i p(x_i|θ)

LogLikelihood :=
    ℓ(θ)
    =
    Σ_i log p(x_i|θ)

MaximumLikelihoodEstimate :=
    θ_hat
    =
    argmax_θ L(θ|Data)

BayesianDiscreteUpdate :=
    Prior(θ)
    ∧ DiscreteLikelihood
    → Posterior(θ|Data)

DiscreteDistributionFit :=
    ObservedFrequencies
    compared_with
    ExpectedProbabilities

ExpectedCount :=
    n p_i

ChiSquaredGoodnessOfFit :=
    Σ_i
    (Observed_i-Expected_i)²
    /
    Expected_i
    under test conditions

DiscreteEntropy :=
    H(X)
    =
    -Σ_x p_X(x)log p_X(x)

JointEntropy :=
    H(X,Y)

ConditionalEntropy :=
    H(X|Y)

MutualInformation :=
    I(X;Y)
    =
    Σ_xΣ_y
    p(x,y)
    log[
        p(x,y)/(p_X(x)p_Y(y))
    ]

DiscreteDistributionConstraint :=
    ConstraintOn(
        Support,
        PMF,
        Parameters,
        Moments,
        Dependence
    )

SupportConstraint :=
    p_X(x)=0
    for x outside support

ParameterConstraint :=
    Parameters
    must belong_to
    valid parameter domain

NormalisationConstraint :=
    Σ_xp_X(x)=1

NonnegativityConstraint :=
    ∀x:p_X(x)≥0

DiscreteDistributionConsistency :=
    Support
    ∧ PMF
    ∧ Parameters
    ∧ Moments
    jointly_compatible

InvalidDiscreteDistribution :=
    Violates(
        CountableSupport
        ∨ Nonnegativity
        ∨ Normalisation
        ∨ ParameterConstraints
    )

DiscreteDistributionValidation :=
    ResolveSupport
    → ResolvePMF
    → CheckCountability
    → CheckNonnegativity
    → CheckNormalisation
    → CheckParameters
    → ValidateMoments

DiscreteDistributionState := {
    RandomVariable,
    Support,
    DistributionFamily,
    Parameters,
    PMF,
    CDF,
    Moments,
    JointStructure,
    Evidence,
    Confidence,
    Provenance
}

DistributionEvidence :=
    SampleData
    ∨ ModelDefinition
    ∨ TheoreticalDerivation
    ∨ PriorKnowledge

DiscreteDistributionUpdate :=
    NewDataParameterOrPMF
    → UpdateDistributionState
    → RecomputeCDF
    → RecomputeMoments
    → Revalidate

SEMANTIC_EQUIVALENCE(DistributionA,DistributionB) :=
    same(PMF)
    on semantically equivalent support
    under specified query scope

EqualInDistribution :=
    X=_dY
    iff
    p_X(x)=p_Y(x)
    for all relevant x

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

CoreClasses := {
    DiscreteDistribution,
    ProbabilityDistribution,
    DiscreteRandomVariable,
    Support,
    ProbabilityMassFunction,
    CDF,
    Parameter,
    Expectation,
    Variance,
    BernoulliDistribution,
    BinomialDistribution,
    CategoricalDistribution,
    GeometricDistribution,
    HypergeometricDistribution,
    PoissonDistribution,
    MultinomialDistribution,
    JointPMF,
    ConditionalPMF
}

CoreRelations := {
    distributionOf,
    hasSupport,
    hasPMF,
    hasCDF,
    hasParameter,
    hasExpectation,
    hasVariance,
    marginalOf,
    conditionedOn,
    independentOf,
    transformedBy,
    convolvedWith,
    mixtureOf,
    estimatedFrom,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    DiscreteDistribution --distributionOf--> DiscreteRandomVariable
    DiscreteDistribution --hasSupport--> Support
    DiscreteDistribution --hasPMF--> ProbabilityMassFunction
    DiscreteDistribution --hasCDF--> CDF
    DiscreteDistribution --hasParameter--> Parameter
    DiscreteDistribution --hasExpectation--> ExpectedValue
    DiscreteDistribution --hasVariance--> Variance
    MarginalPMF --marginalOf--> JointPMF
    ConditionalPMF --conditionedOn--> RandomVariable
    RandomVariable --independentOf--> RandomVariable
    DiscreteDistribution --tracesTo--> Provenance

InferenceRules := {
    DiscreteDistribution(D)
        ⇒ Countable(Support(D)),

    PMF(p)
        ⇒ p(x)≥0,

    ValidPMF(p)
        ⇒ Σ_xp(x)=1,

    PMF(p_X)
        ⇒ F_X(x)=Σ_{t≤x}p_X(t),

    Independent(X,Y)
        ⇒ p_(X,Y)(x,y)=p_X(x)p_Y(y),

    Independent(X,Y)
        ⇒ p_(X+Y)=Convolution(p_X,p_Y),

    X=_dY
        ⇒ same(PMF_X,PMF_Y),

    ChangedPMF
        ⇒ recompute(
            CDF,
            Moments,
            Entropy
        )
}

CanonicalDiscreteDistributionRepresentation :=
    ParseDistribution
    → ResolveRandomVariable
    → ResolveCountableSupport
    → ResolveDistributionFamily
    → ResolveParameters
    → ResolvePMF
    → ResolveCDF
    → ResolveMoments
    → ValidateDiscreteDistribution

DiscreteDistributionGraph :=
    G=(V,E)

V := {
    DiscreteRandomVariables,
    DiscreteDistributions,
    DistributionFamilies,
    Supports,
    Parameters,
    PMFs,
    CDFs,
    Moments,
    JointPMFs,
    MarginalPMFs,
    ConditionalPMFs,
    Evidence,
    ProvenanceNodes
}

E := {
    distributionOf,
    hasSupport,
    hasPMF,
    hasCDF,
    hasParameter,
    hasExpectation,
    hasVariance,
    marginalOf,
    conditionedOn,
    independentOf,
    transformedBy,
    convolvedWith,
    mixtureOf,
    estimatedFrom,
    equivalentTo,
    tracesTo
}

CONFIDENCE(DiscreteDistributionResolution) :=
    weighted_mean(
        RandomVariableResolution,
        SupportResolution,
        DistributionFamilyResolution,
        ParameterQuality,
        PMFValidity,
        CDFConsistency,
        MomentConsistency,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectDiscreteDistributionIntent
    → IdentifyRandomVariable
    → ResolveSupport
    → ResolveKnownPMFOrParameters
    → IdentifyDistributionFamily
    → IdentifyRequestedDiscreteProperty

AI_REASONING_FLOW :=
    Query
    → ParseDiscreteDistributionProblem
    → ResolveProbabilitySpace
    → ResolveDiscreteRandomVariable
    → ResolveCountableSupport
    → ResolveDistributionFamily
    → ResolveParameters
    → ConstructOrValidatePMF
    → ConstructCDF
    → ComputeProbabilities
    → ComputeExpectationVarianceOrMomentsIfRequired
    → ResolveJointMarginalConditionalStructureIfRequired
    → ApplyConvolutionOrTransformationIfRequired
    → ValidateDiscreteDistribution
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseDiscreteDistributionEntities,
    ParseTypedRelations,
    ResolveDiscreteRandomVariables,
    ResolveCountableSupports,
    ResolveDistributionFamilies,
    ResolveParameters,
    EvaluatePMFs,
    EvaluateCDFs,
    ComputeEventProbabilities,
    ComputeExpectations,
    ComputeVariances,
    ComputeMoments,
    ResolveJointPMFs,
    ComputeMarginalPMFs,
    ResolveConditionalPMFs,
    EvaluateIndependence,
    ApplyDiscreteConvolution,
    ApplyDiscreteTransformations,
    ValidateDiscreteDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewDataParameterPMFOrConstraint
    → ValidateInput
    → IdentifyAffectedDiscreteDistributionClaims
    → UpdateDistributionState
    → RecomputePMF
    → RecomputeCDF
    → RecomputeMoments
    → ReevaluateJointMarginalConditionalRelations
    → RevalidateConstraints
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

PMFUpdate :=
    ChangedProbabilityMass
    ⇒ recompute(
        Normalisation,
        CDF,
        Moments,
        Entropy
    )

ParameterUpdate :=
    ChangedParameter
    ⇒ recompute(
        PMF,
        CDF,
        Moments
    )

SupportUpdate :=
    ChangedSupport
    ⇒ revalidate(
        PMF,
        Normalisation,
        DistributionFamily
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        DiscreteDistribution,
        ProbabilityMassFunction,
        DiscreteDistributionValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    DiscreteDistributionEntityResolution,
    ProbabilitySpace,
    DiscreteRandomVariable,
    Support,
    DistributionFamily,
    Parameters,
    PMF,
    CDF,
    EventProbabilities,
    Moments,
    JointMarginalConditionalStructure,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA