Poisson Distribution Ontology

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

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

BEGIN_FLOW

PoissonDistribution :=
    DiscreteProbabilityDistribution
    ∧ NonnegativeIntegerSupport
    ∧ EventCountModel
    ∧ RateParameter
    ∧ EqualMeanVariance

ProbabilitySpace :=
    (Ω,F,P)

PoissonRandomVariable :=
    X~Poisson(λ)

RateParameter :=
    λ

ParameterConstraint :=
    λ>0

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

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

PMFDomain :=
    k∈NonnegativeIntegers

PMFOutsideSupport :=
    P(X=k)=0
    for k outside support

PMFNonnegativity :=
    P(X=k)≥0

PMFNormalisation :=
    Σ_{k=0..∞}
    e^(-λ)λ^k/k!
    =
    1

ExponentialSeriesRelation :=
    Σ_{k=0..∞}
    λ^k/k!
    =
    e^λ

PoissonCDF :=
    F_X(k)
    =
    Σ_{j=0..floor(k)}
    e^(-λ)λ^j/j!

UpperTail :=
    P(X≥k)
    =
    1-P(X≤k-1)

IntervalProbability :=
    P(a≤X≤b)
    =
    Σ_{k=a..b}
    e^(-λ)λ^k/k!

ZeroEventProbability :=
    P(X=0)
    =
    e^(-λ)

AtLeastOneEvent :=
    P(X≥1)
    =
    1-e^(-λ)

ExactlyOneEvent :=
    P(X=1)
    =
    λe^(-λ)

Expectation :=
    E[X]
    =
    λ

Variance :=
    Var(X)
    =
    λ

StandardDeviation :=
    sqrt(λ)

MeanVarianceIdentity :=
    E[X]=Var(X)=λ

Mode :=
    floor(λ)
    when λ is not integer

IntegerLambdaModes :=
    λ integer
    ⇒
    modes at
    λ-1 and λ
    for λ>0

Skewness :=
    1/sqrt(λ)

ExcessKurtosis :=
    1/λ

MomentGeneratingFunction :=
    M_X(t)
    =
    exp(
        λ(e^t-1)
    )

CharacteristicFunction :=
    φ_X(t)
    =
    exp(
        λ(e^(it)-1)
    )

ProbabilityGeneratingFunction :=
    G_X(s)
    =
    exp(
        λ(s-1)
    )

FactorialMoment :=
    E[
        X(X-1)...(X-r+1)
    ]
    =
    λ^r

PoissonRecurrence :=
    P(X=k+1)
    =
    [λ/(k+1)]
    P(X=k)

EventCountInterpretation :=
    X
    counts
    number of events
    in specified interval_or_region

RatePerUnit :=
    r

Exposure :=
    t

ExpectedCount :=
    λ
    =
    r×t

RateScaling :=
    IntervalLengthOrExposure
    changes
    λ proportionally
    under homogeneous rate assumption

PoissonProcess :=
    CountingProcess
    {N(t),t≥0}

PoissonProcessRate :=
    λ_rate>0

PoissonProcessCount :=
    N(t)
    ~
    Poisson(λ_rate t)

IndependentIncrements :=
    CountsInDisjointIntervals
    are independent

StationaryIncrements :=
    CountDistribution
    depends_only_on
    interval length

SmallIntervalProperties :=
    For small h:
        P(one event)≈λ_rate h
        P(two_or_more events)=o(h)

PoissonProcessDefinition :=
    N(0)=0
    ∧ IndependentIncrements
    ∧ StationaryPoissonIncrements
    under standard formulation

IncrementDistribution :=
    N(t+s)-N(s)
    ~
    Poisson(λ_rate t)

InterarrivalTime :=
    T_i
    ~
    Exponential(λ_rate)

WaitingTimeToNthEvent :=
    T_n
    ~
    Gamma(
        shape=n,
        rate=λ_rate
    )

PoissonExponentialRelation :=
    PoissonCounts
    ↔ ExponentialInterarrivalTimes
    under homogeneous Poisson process

Superposition :=
    IndependentPoissonProcesses
    with rates λ_i
    → PoissonProcess
    with rate Σ_iλ_i

PoissonAdditivity :=
    X_i independent
    ∧ X_i~Poisson(λ_i)
    ⇒
    Σ_iX_i
    ~
    Poisson(Σ_iλ_i)

Thinning :=
    PoissonProcessRate λ
    ∧ IndependentlyRetainEachEventWithProbability p
    ⇒
    RetainedProcessRate pλ

ComplementaryThinning :=
    RejectedProcessRate
    =
    (1-p)λ

IndependentThinnedProcesses :=
    Retained
    and rejected processes
    are independent
    under standard thinning theorem

ConditionalSplitting :=
    X_i independent Poisson(λ_i)
    ∧ Total N=Σ_iX_i
    ⇒
    (X_1,...,X_m)|N=n
    ~
    Multinomial(
        n,
        λ_i/Σ_jλ_j
    )

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

PoissonLimitTheorem :=
    n→∞
    ∧ p_n→0
    ∧ np_n→λ
    ⇒
    Binomial(n,p_n)
    → Poisson(λ)

RareEventModel :=
    LargeNumberOfOpportunities
    ∧ SmallEventProbability
    ∧ ApproximateIndependence
    → PoissonApproximation

NormalApproximation :=
    Poisson(λ)
    ≈
    N(λ,λ)
    for sufficiently large λ
    under suitable conditions

ContinuityCorrection :=
    IntegerBoundary
    adjusted_by
    0.5
    in normal approximation

PoissonLikelihood :=
    L(λ|x1,...,xn)
    =
    Π_i
    e^(-λ)
    λ^(x_i)
    /
    x_i!

PoissonLogLikelihood :=
    ℓ(λ)
    =
    -nλ
    +
    (Σ_i x_i)log λ
    -
    Σ_i log(x_i!)

MLELambda :=
    λ_hat
    =
    X_bar

PoissonExposureLikelihood :=
    X_i~Poisson(r t_i)

RateMLE :=
    r_hat
    =
    Σ_iX_i
    /
    Σ_it_i

GammaPrior :=
    λ~Gamma(α,β)
    under selected rate parameterisation

GammaPoissonConjugacy :=
    Prior Gamma(α,β)
    ∧ PoissonCounts
    → GammaPosterior

PosteriorShape :=
    α_post
    =
    α+Σ_i x_i

PosteriorRate :=
    β_post
    =
    β+n
    for unit exposures
    under rate parameterisation

ExposurePosteriorRate :=
    β_post
    =
    β+Σ_i t_i

PosteriorPredictive :=
    IntegratePoissonLikelihood
    over posterior λ

GammaPoissonPredictive :=
    NegativeBinomialTypePredictive
    under common parameterisations

PoissonRegression :=
    CountResponse
    ∧ LogLink
    ∧ PoissonMeanModel

LogLink :=
    log(λ_i)
    =
    x_i^Tβ

ExposureOffset :=
    log(λ_i)
    =
    x_i^Tβ
    +
    log(t_i)

Equidispersion :=
    Var(X)
    =
    E[X]

Overdispersion :=
    ObservedVariance
    >
    PoissonMean
    relative_to model expectation

Underdispersion :=
    ObservedVariance
    <
    PoissonMean
    relative_to model expectation

OverdispersionSignal :=
    MayIndicate(
        Heterogeneity,
        Dependence,
        ExcessZeros,
        ModelMisspecification
    )

ZeroInflatedPoisson :=
    Mixture
    of
    ExtraZeroMass
    and PoissonDistribution

HurdleModel :=
    SeparateZeroProcess
    ∧ PositiveCountDistribution

NegativeBinomialAlternative :=
    CountModel
    often used
    when variance exceeds mean

PoissonGoodnessOfFit :=
    ObservedCounts
    compared_with
    ExpectedPoissonFrequencies

ExpectedFrequency :=
    n×P(X=k)

PoissonEntropy :=
    H(X)
    =
    -Σ_{k=0..∞}
    P(X=k)logP(X=k)

PoissonConstraint :=
    ConstraintOn(
        λ,
        Support,
        PMF,
        MeanVarianceRelation,
        CountProcessAssumptions
    )

SupportConstraint :=
    X∈{0,1,2,...}

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

RateConstraint :=
    λ>0

PoissonConsistency :=
    Rate
    ∧ Support
    ∧ PMF
    ∧ Mean
    ∧ Variance
    jointly_compatible

InvalidPoissonDistribution :=
    λ≤0
    ∨ NonIntegerCountSupport
    ∨ PMFNormalisationFailure
    ∨ incompatible mean_variance claims

PoissonValidation :=
    ResolveRate
    → ValidateRate
    → ResolveCountSupport
    → ConstructPMF
    → ValidateNormalisation
    → ValidateMeanVariance
    → ValidateProcessAssumptionsIfApplicable

PoissonDistributionState := {
    RandomVariable,
    Rate,
    Exposure,
    Support,
    PMF,
    CDF,
    Mean,
    Variance,
    ProcessStructure,
    Evidence,
    Confidence,
    Provenance
}

PoissonEvidence :=
    CountData
    ∨ EventRate
    ∨ ExposureData
    ∨ ProcessDefinition
    ∨ TheoreticalDerivation

PoissonUpdate :=
    NewCountRateExposureOrModelEvidence
    → UpdatePoissonState
    → RecomputePMF
    → RecomputeCDF
    → RecomputeMoments
    → Revalidate

SEMANTIC_EQUIVALENCE(PoissonA,PoissonB) :=
    same(λ)
    ⇒
    same(PoissonProbabilityMeasure)

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

CoreClasses := {
    PoissonDistribution,
    DiscreteDistribution,
    PoissonRandomVariable,
    RateParameter,
    Exposure,
    Support,
    PoissonPMF,
    PoissonCDF,
    Mean,
    Variance,
    PoissonProcess,
    InterarrivalTime,
    PoissonLikelihood,
    PoissonApproximation,
    PoissonRegression,
    PoissonConstraint
}

CoreRelations := {
    distributionOf,
    countsEventsIn,
    hasRate,
    hasExposure,
    hasSupport,
    hasPMF,
    hasCDF,
    hasMean,
    hasVariance,
    incrementOf,
    approximatedBy,
    summedWith,
    thinnedTo,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    PoissonDistribution --distributionOf--> PoissonRandomVariable
    PoissonRandomVariable --countsEventsIn--> IntervalOrRegion
    PoissonDistribution --hasRate--> RateParameter
    PoissonDistribution --hasExposure--> Exposure
    PoissonDistribution --hasSupport--> Support
    PoissonDistribution --hasPMF--> PoissonPMF
    PoissonDistribution --hasCDF--> PoissonCDF
    PoissonDistribution --hasMean--> Mean
    PoissonDistribution --hasVariance--> Variance
    PoissonRandomVariable --incrementOf--> PoissonProcess
    PoissonDistribution --tracesTo--> Provenance

InferenceRules := {
    X~Poisson(λ)
        ⇒
        P(X=k)=e^(-λ)λ^k/k!,

    X~Poisson(λ)
        ⇒ E[X]=λ,

    X~Poisson(λ)
        ⇒ Var(X)=λ,

    Independent(
        X~Poisson(λ1),
        Y~Poisson(λ2)
    )
        ⇒
        X+Y~Poisson(λ1+λ2),

    PoissonProcess(rate=r)
        ⇒
        N(t)~Poisson(rt),

    PoissonProcess(rate=r)
        ⇒
        InterarrivalTime~Exponential(r),

    λ≤0
        ⇒ InvalidPoissonDistribution
}

CanonicalPoissonRepresentation :=
    ParsePoissonModel
    → ResolveRandomVariable
    → ResolveRate
    → ResolveExposure
    → ResolveSupport
    → ConstructPMF
    → ConstructCDF
    → ComputeMoments
    → ResolvePoissonProcessIfApplicable
    → ValidatePoissonDistribution

PoissonDistributionGraph :=
    G=(V,E)

V := {
    PoissonDistributions,
    PoissonRandomVariables,
    RateParameters,
    Exposures,
    Supports,
    PMFs,
    CDFs,
    Means,
    Variances,
    PoissonProcesses,
    InterarrivalTimes,
    Likelihoods,
    Approximations,
    RegressionModels,
    Evidence,
    ProvenanceNodes
}

E := {
    distributionOf,
    countsEventsIn,
    hasRate,
    hasExposure,
    hasSupport,
    hasPMF,
    hasCDF,
    hasMean,
    hasVariance,
    incrementOf,
    approximatedBy,
    summedWith,
    thinnedTo,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(PoissonDistributionResolution) :=
    weighted_mean(
        RandomVariableResolution,
        RateResolution,
        ExposureResolution,
        CountProcessAssumptionValidity,
        PMFConsistency,
        MeanVarianceConsistency,
        DataFit,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectPoissonDistributionIntent
    → IdentifyEventCount
    → ResolveRateAndExposure
    → IdentifyRequestedCountProbability
    → ResolvePoissonProcessContextIfPresent

AI_REASONING_FLOW :=
    Query
    → ParsePoissonProblem
    → ResolveProbabilitySpace
    → ResolveCountRandomVariable
    → ResolveRate
    → ResolveExposure
    → ComputeEffectiveLambda
    → ValidatePoissonAssumptions
    → ConstructPoissonPMF
    → ComputeExactCumulativeOrTailProbability
    → ComputeMeanVarianceOrOtherPropertiesIfRequired
    → ResolvePoissonProcessRelationsIfRequired
    → ApplyApproximationIfRequestedAndValid
    → ValidatePoissonModel
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParsePoissonEntities,
    ParseTypedRelations,
    ResolvePoissonRandomVariables,
    ResolveRates,
    ResolveExposures,
    EvaluatePoissonPMFs,
    EvaluatePoissonCDFs,
    ComputeCountProbabilities,
    ComputeTailProbabilities,
    ComputeMeans,
    ComputeVariances,
    ResolvePoissonProcesses,
    ResolveInterarrivalTimes,
    CombineIndependentPoissonVariables,
    ApplyPoissonThinning,
    EstimatePoissonRates,
    ApplyGammaPoissonUpdate,
    EvaluateBinomialPoissonApproximation,
    EvaluateNormalApproximation,
    ValidatePoissonDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewCountRateExposureOrConstraint
    → ValidateInput
    → IdentifyAffectedPoissonClaims
    → UpdatePoissonState
    → RecomputeEffectiveRate
    → RecomputePMF
    → RecomputeCDF
    → RecomputeMoments
    → ReevaluateProcessRelations
    → RevalidateConstraints
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

RateUpdate :=
    ChangedRate
    ⇒ revalidate(λ>0)
    → recompute(
        PMF,
        CDF,
        Mean,
        Variance
    )

ExposureUpdate :=
    ChangedExposure
    ⇒ recompute(
        EffectiveLambda,
        CountDistribution
    )

DataUpdate :=
    NewCountData
    ⇒ reevaluate(
        RateEstimate,
        Equidispersion,
        ModelFit,
        PosteriorIfBayesian
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        PoissonDistribution,
        PoissonPMF,
        PoissonProcess,
        PoissonValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    PoissonDistributionEntityResolution,
    ProbabilitySpace,
    PoissonRandomVariable,
    Rate,
    Exposure,
    EffectiveLambda,
    Support,
    PMF,
    CDF,
    RequestedProbability,
    Mean,
    Variance,
    PoissonProcessStructure,
    ApproximationStatus,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA