Binomial Distribution Ontology

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

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

BEGIN_FLOW

BinomialDistribution :=
    DiscreteProbabilityDistribution
    ∧ FixedNumberOfTrials
    ∧ BernoulliTrials
    ∧ ConstantSuccessProbability
    ∧ IndependentTrials
    ∧ SuccessCountRandomVariable

ProbabilitySpace := (Ω,F,P)

BernoulliTrial :=
    Trial
    with
    Success ∨ Failure

SuccessProbability := p
FailureProbability := q := 1-p
TrialCount := n

ParameterConstraints :=
    n∈NonnegativeIntegers
    ∧ 0≤p≤1

BernoulliIndicator :=
    I_i
    =
    1 if trial_i succeeds
    else 0

IIDBernoulliTrials :=
    I_1,...,I_n
    independent
    ∧ identically distributed
    ∧ I_i~Bernoulli(p)

SuccessCount :=
    X
    :=
    Σ_{i=1..n} I_i

BinomialRandomVariable :=
    X~Binomial(n,p)

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

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

BinomialCoefficient :=
    C(n,k)
    =
    n!/[k!(n-k)!]

PMFNormalisation :=
    Σ_{k=0..n}
    C(n,k)p^k(1-p)^(n-k)
    =
    1

BinomialCDF :=
    F_X(k)
    =
    Σ_{j=0..floor(k)}
    C(n,j)p^j(1-p)^(n-j)

UpperTail :=
    P(X≥k)
    =
    Σ_{j=k..n}
    C(n,j)p^j(1-p)^(n-j)

IntervalProbability :=
    P(a≤X≤b)
    =
    Σ_{k=a..b}P(X=k)

NoSuccesses :=
    P(X=0)
    =
    (1-p)^n

AtLeastOneSuccess :=
    P(X≥1)
    =
    1-(1-p)^n

AllSuccesses :=
    P(X=n)
    =
    p^n

ExactlyOneSuccess :=
    P(X=1)
    =
    np(1-p)^(n-1)

Expectation :=
    E[X]
    =
    np

Variance :=
    Var(X)
    =
    np(1-p)

StandardDeviation :=
    sqrt(np(1-p))

Mode :=
    floor((n+1)p)
    with two adjacent modes
    when (n+1)p is integer
    under standard convention

Skewness :=
    (1-2p)
    /
    sqrt(np(1-p))
    when variance positive

MomentGeneratingFunction :=
    M_X(t)
    =
    [(1-p)+pe^t]^n

CharacteristicFunction :=
    φ_X(t)
    =
    [(1-p)+pe^(it)]^n

ProbabilityGeneratingFunction :=
    G_X(s)
    =
    [(1-p)+ps]^n

BinomialAsSumOfBernoulli :=
    X
    =
    Σ_i I_i

ExpectationDerivation :=
    E[X]
    =
    Σ_iE[I_i]
    =
    np

VarianceDerivation :=
    Independence(I_i)
    ⇒
    Var(X)
    =
    Σ_iVar(I_i)
    =
    np(1-p)

SymmetryAtHalf :=
    p=1/2
    ⇒
    P(X=k)=P(X=n-k)

DegenerateAtZero :=
    p=0
    ⇒
    P(X=0)=1

DegenerateAtN :=
    p=1
    ⇒
    P(X=n)=1

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

PoissonBinomialRelation :=
    SumOfIndependentBernoulliVariables
    with unequal p_i
    generally follows
    PoissonBinomialDistribution

BinomialTrialAssumptions := {
    FixedN,
    BinaryOutcomePerTrial,
    ConstantP,
    IndependentTrials
}

AssumptionViolation :=
    ViolationOfAny(BinomialTrialAssumptions)
    ⇒
    StandardBinomialModelMayBeInvalid

SamplingWithoutReplacement :=
    GenerallyInducesDependence
    and changing success probability

HypergeometricContrast :=
    FinitePopulation
    ∧ SamplingWithoutReplacement
    → HypergeometricModel
    under standard conditions

BinomialLikelihood :=
    L(p|k,n)
    =
    C(n,k)
    p^k
    (1-p)^(n-k)

LogLikelihood :=
    ℓ(p)
    =
    constant
    +
    k log p
    +
    (n-k)log(1-p)

MLEProbability :=
    p_hat
    =
    k/n
    for n>0

SampleProportion :=
    p_hat
    =
    X/n

ExpectationSampleProportion :=
    E[p_hat]=p

VarianceSampleProportion :=
    Var(p_hat)
    =
    p(1-p)/n

BetaPrior :=
    p~Beta(α,β)

BetaBinomialConjugacy :=
    Prior Beta(α,β)
    ∧ X=k successes in n trials
    ⇒
    Posterior
    Beta(
        α+k,
        β+n-k
    )

NormalApproximation :=
    X~Binomial(n,p)
    ≈
    N(
        np,
        np(1-p)
    )
    under suitable conditions

ContinuityCorrection :=
    IntegerBoundary
    adjusted_by
    0.5
    when using normal approximation

PoissonApproximation :=
    X~Binomial(n,p)
    ≈
    Poisson(np)
    when n large and p small
    under suitable conditions

RareEventLimit :=
    n→∞
    ∧ p→0
    ∧ np→λ
    ⇒
    Binomial(n,p)
    → Poisson(λ)

LawOfLargeNumbersRelation :=
    X/n
    → p
    under repeated Bernoulli sampling

CentralLimitRelation :=
    [X-np]
    /
    sqrt(np(1-p))
    → N(0,1)
    under limiting conditions

ExactBinomialTest :=
    BinomialNullModel
    → TailProbability
    under H0

LogisticRegressionRelation :=
    BinomialOrBernoulliResponse
    ∧
    logit(p)=LinearPredictor

BinomialConstraint :=
    ConstraintOn(
        n,
        p,
        Support,
        PMF,
        TrialAssumptions
    )

NormalisationConstraint :=
    Σ_kP(X=k)=1

SupportConstraint :=
    X∈{0,...,n}

BinomialConsistency :=
    Parameters
    ∧ Support
    ∧ PMF
    ∧ Moments
    ∧ TrialAssumptions
    jointly_compatible

InvalidBinomialDistribution :=
    n<0
    ∨ noninteger(n)
    ∨ p<0
    ∨ p>1
    ∨ PMFNormalisationFailure
    ∨ incompatible trial model

BinomialValidation :=
    ResolveN
    → ResolveP
    → ValidateParameterDomains
    → ResolveTrialStructure
    → CheckBinomialAssumptions
    → ConstructPMF
    → ValidateNormalisation
    → ValidateMoments

BinomialDistributionState := {
    RandomVariable,
    TrialCount,
    SuccessProbability,
    FailureProbability,
    Support,
    PMF,
    CDF,
    Mean,
    Variance,
    TrialAssumptions,
    Evidence,
    Confidence,
    Provenance
}

SEMANTIC_EQUIVALENCE(BinomialA,BinomialB) :=
    same(n)
    ∧ same(p)
    ⇒ same(BinomialProbabilityMeasure)

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

CoreClasses := {
    BinomialDistribution,
    DiscreteDistribution,
    BinomialRandomVariable,
    BernoulliTrial,
    BernoulliIndicator,
    TrialCount,
    SuccessProbability,
    FailureProbability,
    Support,
    BinomialPMF,
    BinomialCDF,
    Mean,
    Variance,
    SampleProportion,
    BinomialLikelihood,
    BinomialConstraint
}

CoreRelations := {
    distributionOf,
    countsSuccessesIn,
    hasTrialCount,
    hasSuccessProbability,
    hasFailureProbability,
    hasSupport,
    hasPMF,
    hasCDF,
    hasMean,
    hasVariance,
    sumOf,
    approximatedBy,
    sampledFrom,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    BinomialDistribution --distributionOf--> BinomialRandomVariable
    BinomialRandomVariable --countsSuccessesIn--> BernoulliTrials
    BinomialDistribution --hasTrialCount--> TrialCount
    BinomialDistribution --hasSuccessProbability--> SuccessProbability
    BinomialDistribution --hasFailureProbability--> FailureProbability
    BinomialDistribution --hasSupport--> Support
    BinomialDistribution --hasPMF--> BinomialPMF
    BinomialDistribution --hasCDF--> BinomialCDF
    BinomialDistribution --hasMean--> Mean
    BinomialDistribution --hasVariance--> Variance
    BinomialRandomVariable --sumOf--> BernoulliIndicator
    BinomialDistribution --tracesTo--> Provenance

InferenceRules := {
    IIDBernoulli(I_1,...,I_n,p)
        ⇒
        Σ_iI_i~Binomial(n,p),

    X~Binomial(n,p)
        ⇒
        P(X=k)=C(n,k)p^k(1-p)^(n-k),

    X~Binomial(n,p)
        ⇒ E[X]=np,

    X~Binomial(n,p)
        ⇒ Var(X)=np(1-p),

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

    p=0
        ⇒ X=0 almost_surely,

    p=1
        ⇒ X=n almost_surely,

    Violate(BinomialTrialAssumptions)
        ⇒ Flag(BinomialModelRisk)
}

CanonicalBinomialRepresentation :=
    ParseBinomialModel
    → ResolveRandomVariable
    → ResolveTrialCount
    → ResolveSuccessProbability
    → ResolveBernoulliTrialStructure
    → ValidateAssumptions
    → ConstructPMF
    → ConstructCDF
    → ComputeMoments
    → ValidateBinomialDistribution

BinomialDistributionGraph :=
    G=(V,E)

V := {
    BinomialDistributions,
    BinomialRandomVariables,
    BernoulliTrials,
    BernoulliIndicators,
    TrialCounts,
    SuccessProbabilities,
    FailureProbabilities,
    Supports,
    PMFs,
    CDFs,
    Means,
    Variances,
    Likelihoods,
    Approximations,
    Evidence,
    ProvenanceNodes
}

E := {
    distributionOf,
    countsSuccessesIn,
    hasTrialCount,
    hasSuccessProbability,
    hasFailureProbability,
    hasSupport,
    hasPMF,
    hasCDF,
    hasMean,
    hasVariance,
    sumOf,
    approximatedBy,
    sampledFrom,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(BinomialDistributionResolution) :=
    weighted_mean(
        RandomVariableResolution,
        TrialCountResolution,
        SuccessProbabilityQuality,
        IndependenceAssumptionValidity,
        ConstantProbabilityAssumptionValidity,
        PMFConsistency,
        DataFit,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectBinomialDistributionIntent
    → IdentifyTrialCount
    → IdentifySuccessProbability
    → IdentifyRequestedSuccessCountOrProbability
    → ResolveTrialAssumptions

AI_REASONING_FLOW :=
    Query
    → ParseBinomialProblem
    → ResolveProbabilitySpace
    → ResolveBernoulliTrialStructure
    → ResolveN
    → ResolveP
    → ValidateFixedTrialCount
    → ValidateBinaryOutcomes
    → ValidateConstantSuccessProbability
    → ValidateIndependence
    → ConstructBinomialPMF
    → ComputeRequestedProbability
    → ComputeMeanVarianceOrOtherPropertiesIfRequired
    → ApplyApproximationIfRequestedAndValid
    → ValidateBinomialModel
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseBinomialEntities,
    ParseTypedRelations,
    ResolveBernoulliTrials,
    ResolveTrialCounts,
    ResolveSuccessProbabilities,
    ValidateBinomialAssumptions,
    EvaluateBinomialPMFs,
    EvaluateBinomialCDFs,
    ComputeExactProbabilities,
    ComputeTailProbabilities,
    ComputeExpectations,
    ComputeVariances,
    EstimateSuccessProbability,
    ApplyBetaBinomialUpdate,
    EvaluateNormalApproximation,
    EvaluatePoissonApproximation,
    ValidateBinomialDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewNPEvidenceOrTrialStructure
    → ValidateInput
    → IdentifyAffectedBinomialClaims
    → UpdateBinomialState
    → RecomputePMF
    → RecomputeCDF
    → RecomputeMoments
    → ReevaluateApproximations
    → RevalidateAssumptions
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

TrialCountUpdate :=
    ChangedN
    ⇒ recompute(
        Support,
        PMF,
        CDF,
        Mean,
        Variance
    )

ProbabilityUpdate :=
    ChangedP
    ⇒ revalidate(0≤p≤1)
    → recompute(
        PMF,
        CDF,
        Mean,
        Variance,
        ApproximationQuality
    )

EvidenceUpdate :=
    NewSuccessFailureData
    ⇒ reevaluate(
        ParameterEstimate,
        PosteriorIfBayesian,
        ModelFit
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        BinomialDistribution,
        BinomialPMF,
        BinomialTrialAssumptions,
        BinomialValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    BinomialDistributionEntityResolution,
    ProbabilitySpace,
    BinomialRandomVariable,
    TrialCount,
    SuccessProbability,
    FailureProbability,
    TrialAssumptionStatus,
    Support,
    PMF,
    CDF,
    RequestedProbability,
    Mean,
    Variance,
    ApproximationStatus,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA