Exponential Distribution Ontology

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

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

BEGIN_FLOW

ExponentialDistribution :=
    ContinuousProbabilityDistribution
    ∧ PositiveSupport
    ∧ ConstantHazardRate
    ∧ MemorylessProperty
    ∧ PoissonProcessWaitingTimeModel

ProbabilitySpace :=
    (Ω,F,P)

ExponentialRandomVariable :=
    X~Exponential(λ)

RateParameter :=
    λ

ParameterConstraint :=
    λ>0

Support :=
    [0,∞)

ExponentialPDF :=
    f_X(x)
    =
    λe^(-λx)
    for x≥0

PDFOutsideSupport :=
    f_X(x)=0
    for x<0

PDFNonnegativity :=
    f_X(x)≥0

PDFNormalisation :=
    Integral_0^∞
    λe^(-λx)dx
    =
    1

ExponentialCDF :=
    F_X(x)
    =
    {
        0 if x<0,
        1-e^(-λx) if x≥0
    }

SurvivalFunction :=
    S_X(x)
    =
    P(X>x)
    =
    e^(-λx)

TailProbability :=
    P(X>x)
    =
    e^(-λx)

IntervalProbability :=
    0≤a≤b
    ⇒
    P(a≤X≤b)
    =
    e^(-λa)-e^(-λb)

QuantileFunction :=
    Q(p)
    =
    -ln(1-p)/λ
    for 0≤p<1

Median :=
    ln(2)/λ

Expectation :=
    E[X]
    =
    1/λ

Variance :=
    Var(X)
    =
    1/λ²

StandardDeviation :=
    1/λ

Mode :=
    0

Skewness :=
    2

ExcessKurtosis :=
    6

Moment :=
    E[X^n]
    =
    n!/λ^n
    for nonnegative integer n

MomentGeneratingFunction :=
    M_X(t)
    =
    λ/(λ-t)
    for t<λ

CharacteristicFunction :=
    φ_X(t)
    =
    λ/(λ-it)

LaplaceTransform :=
    L_X(s)
    =
    λ/(λ+s)
    for s>-λ

HazardFunction :=
    h_X(x)
    =
    f_X(x)/S_X(x)
    =
    λ

ConstantHazard :=
    ∀x≥0 :
        h_X(x)=λ

CumulativeHazard :=
    H_X(x)
    =
    λx

MemorylessProperty :=
    P(X>s+t|X>s)
    =
    P(X>t)
    for s,t≥0

MemorylessDerivation :=
    P(X>s+t|X>s)
    =
    e^(-λ(s+t))/e^(-λs)
    =
    e^(-λt)

ContinuousMemorylessUniqueness :=
    ExponentialDistribution
    is unique nondegenerate continuous distribution
    with memoryless property
    under standard regularity assumptions

ResidualLifetime :=
    X-s
    conditioned_on
    X>s

ResidualLifetimeDistribution :=
    X-s | X>s
    ~
    Exponential(λ)

PoissonProcess :=
    CountingProcess
    with rate λ

PoissonProcessWaitingTime :=
    TimeToFirstEvent
    ~
    Exponential(λ)

InterarrivalTime :=
    T_i
    ~
    Exponential(λ)

IndependentInterarrivalTimes :=
    HomogeneousPoissonProcess
    ⇒
    T_1,T_2,...
    iid Exponential(λ)

EventCountRelation :=
    N(t)
    ~
    Poisson(λt)

NoEventRelation :=
    P(N(t)=0)
    =
    e^(-λt)
    =
    P(T_1>t)

FirstEventCDF :=
    P(T_1≤t)
    =
    1-e^(-λt)

WaitingTimeToNthEvent :=
    S_n
    =
    Σ_{i=1..n}T_i

GammaRelation :=
    S_n
    ~
    Gamma(
        shape=n,
        rate=λ
    )

ExponentialAsGamma :=
    Exponential(λ)
    ≡
    Gamma(shape=1,rate=λ)

MinimumOfIndependentExponentials :=
    X_i~Exponential(λ_i)
    independent
    ⇒
    min_i X_i
    ~
    Exponential(
        Σ_iλ_i
    )

CompetingRisks :=
    IndependentExponentialClocks
    → EarliestEventTime
    and event type

ProbabilityClockIIsFirst :=
    P(X_i=min_jX_j)
    =
    λ_i/Σ_jλ_j

MinimumRate :=
    λ_total
    =
    Σ_iλ_i

ExponentialScaling :=
    X~Exponential(λ)
    ∧ c>0
    ⇒
    cX
    ~
    Exponential(λ/c)

StandardExponential :=
    Z~Exponential(1)

StandardisationByRate :=
    λX
    ~
    Exponential(1)

InverseTransformSampling :=
    U~Uniform(0,1)
    ⇒
    X
    =
    -ln(1-U)/λ
    ~
    Exponential(λ)

EquivalentInverseSampling :=
    U~Uniform(0,1)
    ⇒
    -ln(U)/λ
    ~
    Exponential(λ)

RandomGeneration :=
    UniformRandomVariate
    → LogTransform
    → ExponentialVariate

ExponentialLikelihood :=
    X_1,...,X_n
    iid Exponential(λ)

Likelihood :=
    L(λ|Data)
    =
    λ^n
    exp(
        -λΣ_i x_i
    )

LogLikelihood :=
    ℓ(λ)
    =
    n log λ
    -
    λΣ_i x_i

MLELambda :=
    λ_hat
    =
    n/Σ_i x_i
    =
    1/X_bar

MeanParameterisation :=
    θ
    =
    1/λ

ScaleParameter :=
    θ

ScaleFormPDF :=
    f(x)
    =
    (1/θ)e^(-x/θ)
    for x≥0

ParameterisationMapping :=
    θ=1/λ

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

GammaExponentialConjugacy :=
    GammaPrior
    ∧ iid ExponentialData
    → GammaPosterior

PosteriorShape :=
    α_post
    =
    α+n

PosteriorRate :=
    β_post
    =
    β+Σ_i x_i

ReliabilityInterpretation :=
    X
    =
    LifetimeUntilFailure

ReliabilityFunction :=
    R(t)
    =
    P(X>t)
    =
    e^(-λt)

FailureRate :=
    λ

MeanTimeToFailure :=
    MTTF
    =
    1/λ

ConstantFailureRateModel :=
    ExponentialLifetime
    assumes
    age-independent instantaneous failure rate

SurvivalAnalysisRelation :=
    ExponentialDistribution
    provides
    constant-hazard survival model

Censoring :=
    Lifetime
    may be partially observed
    due to right_or_left censoring

RightCensoredLikelihoodContribution :=
    S_X(c)
    =
    e^(-λc)

ObservedFailureLikelihoodContribution :=
    f_X(x)
    =
    λe^(-λx)

CensoredExponentialLikelihood :=
    Product(
        failure density contributions,
        censoring survival contributions
    )

ExponentialRegressionRelation :=
    Rate
    may depend_on
    covariates
    under parametric survival models

ContinuousTimeMarkovChainRelation :=
    ExponentialHoldingTimes
    arise in
    continuous-time Markov chains

HoldingTime :=
    TimeUntilNextStateTransition

CTMCHoldingTime :=
    Exponential(
        total outgoing transition rate
    )

QueueingRelation :=
    ExponentialInterarrivalOrServiceTimes
    used in
    Markovian queueing models

M_M_1Relation :=
    PoissonArrivals
    ∧ ExponentialServiceTimes
    → M/M/1 queue model

Entropy :=
    h(X)
    =
    1-ln(λ)
    in natural-log units

KLDivergenceRelation :=
    ExponentialDistributions
    permit closed-form KL divergence
    under valid rate parameters

ExponentialConstraint :=
    ConstraintOn(
        λ,
        Support,
        PDF,
        Hazard,
        Memorylessness
    )

SupportConstraint :=
    X≥0

RateConstraint :=
    λ>0

NormalisationConstraint :=
    Integral_0^∞f(x)dx=1

HazardConstraint :=
    h(x)=λ

ExponentialConsistency :=
    Rate
    ∧ Support
    ∧ PDF
    ∧ CDF
    ∧ Hazard
    ∧ Moments
    jointly_compatible

InvalidExponentialDistribution :=
    λ≤0
    ∨ NegativeSupportClaim
    ∨ PDFNormalisationFailure
    ∨ NonconstantHazardClaimForPureExponentialModel

ExponentialValidation :=
    ResolveRate
    → ValidateRate
    → ResolveSupport
    → ConstructPDF
    → ValidateNormalisation
    → ConstructCDF
    → ValidateHazard
    → ValidateMoments

ExponentialDistributionState := {
    RandomVariable,
    Rate,
    Scale,
    Support,
    PDF,
    CDF,
    SurvivalFunction,
    Hazard,
    Mean,
    Variance,
    ProcessRelations,
    Evidence,
    Confidence,
    Provenance
}

ExponentialEvidence :=
    WaitingTimeData
    ∨ LifetimeData
    ∨ PoissonProcessModel
    ∨ FailureRate
    ∨ TheoreticalDerivation

ExponentialUpdate :=
    NewWaitingTimeRateOrModelEvidence
    → UpdateState
    → RecomputePDF
    → RecomputeCDF
    → RecomputeSurvival
    → RecomputeHazard
    → Revalidate

SEMANTIC_EQUIVALENCE(ExponentialA,ExponentialB) :=
    same(λ)
    ⇒
    same(ExponentialProbabilityMeasure)

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

CoreClasses := {
    ExponentialDistribution,
    ContinuousDistribution,
    ExponentialRandomVariable,
    RateParameter,
    ScaleParameter,
    Support,
    ExponentialPDF,
    ExponentialCDF,
    SurvivalFunction,
    HazardFunction,
    InterarrivalTime,
    PoissonProcess,
    ReliabilityFunction,
    ExponentialLikelihood,
    ExponentialConstraint
}

CoreRelations := {
    distributionOf,
    hasRate,
    hasScale,
    hasSupport,
    hasPDF,
    hasCDF,
    hasSurvivalFunction,
    hasHazard,
    waitingTimeFor,
    interarrivalOf,
    relatedTo,
    sampledFrom,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    ExponentialDistribution --distributionOf--> ExponentialRandomVariable
    ExponentialDistribution --hasRate--> RateParameter
    ExponentialDistribution --hasScale--> ScaleParameter
    ExponentialDistribution --hasSupport--> Support
    ExponentialDistribution --hasPDF--> ExponentialPDF
    ExponentialDistribution --hasCDF--> ExponentialCDF
    ExponentialDistribution --hasSurvivalFunction--> SurvivalFunction
    ExponentialDistribution --hasHazard--> HazardFunction
    ExponentialRandomVariable --waitingTimeFor--> Event
    InterarrivalTime --interarrivalOf--> PoissonProcess
    ExponentialDistribution --tracesTo--> Provenance

InferenceRules := {
    X~Exponential(λ)
        ⇒
        f_X(x)=λe^(-λx)
        for x≥0,

    X~Exponential(λ)
        ⇒
        F_X(x)=1-e^(-λx)
        for x≥0,

    X~Exponential(λ)
        ⇒
        P(X>x)=e^(-λx),

    X~Exponential(λ)
        ⇒
        E[X]=1/λ,

    X~Exponential(λ)
        ⇒
        Var(X)=1/λ²,

    X~Exponential(λ)
        ⇒
        P(X>s+t|X>s)=P(X>t),

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

    λ≤0
        ⇒
        InvalidExponentialDistribution
}

CanonicalExponentialRepresentation :=
    ParseExponentialModel
    → ResolveRandomVariable
    → ResolveRateOrScale
    → CanonicaliseParameterisation
    → ResolveSupport
    → ConstructPDF
    → ConstructCDF
    → ConstructSurvivalFunction
    → ResolveHazard
    → ComputeMoments
    → ValidateExponentialDistribution

ExponentialDistributionGraph :=
    G=(V,E)

V := {
    ExponentialDistributions,
    ExponentialRandomVariables,
    RateParameters,
    ScaleParameters,
    Supports,
    PDFs,
    CDFs,
    SurvivalFunctions,
    Hazards,
    PoissonProcesses,
    InterarrivalTimes,
    ReliabilityModels,
    Likelihoods,
    Evidence,
    ProvenanceNodes
}

E := {
    distributionOf,
    hasRate,
    hasScale,
    hasSupport,
    hasPDF,
    hasCDF,
    hasSurvivalFunction,
    hasHazard,
    waitingTimeFor,
    interarrivalOf,
    relatedTo,
    sampledFrom,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(ExponentialDistributionResolution) :=
    weighted_mean(
        RandomVariableResolution,
        RateOrScaleResolution,
        ParameterisationConsistency,
        SupportValidity,
        PDFConsistency,
        HazardConsistency,
        ProcessModelValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectExponentialDistributionIntent
    → IdentifyWaitingTimeOrLifetimeVariable
    → ResolveRateOrScale
    → IdentifyRequestedProbabilityOrProperty
    → ResolvePoissonProcessOrReliabilityContext

AI_REASONING_FLOW :=
    Query
    → ParseExponentialProblem
    → ResolveProbabilitySpace
    → ResolveExponentialRandomVariable
    → ResolveRateOrScale
    → CanonicaliseParameterisation
    → ValidateRate
    → ConstructPDF
    → ConstructCDFAndSurvivalFunction
    → ComputeIntervalOrTailProbability
    → ApplyMemorylessPropertyIfRelevant
    → ComputeMeanVarianceQuantileOrHazardIfRequired
    → ResolvePoissonProcessRelationIfRequired
    → ResolveReliabilityRelationIfRequired
    → ValidateExponentialModel
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseExponentialDistributionEntities,
    ParseTypedRelations,
    ResolveExponentialRandomVariables,
    ResolveRates,
    ResolveScales,
    CanonicaliseParameterisations,
    EvaluateExponentialPDFs,
    EvaluateExponentialCDFs,
    EvaluateSurvivalFunctions,
    EvaluateHazards,
    ComputeIntervalProbabilities,
    ComputeTailProbabilities,
    ApplyMemorylessProperty,
    ComputeMeans,
    ComputeVariances,
    ComputeQuantiles,
    ResolvePoissonProcessRelations,
    ResolveReliabilityModels,
    EstimateExponentialRates,
    ApplyGammaExponentialUpdate,
    ValidateExponentialDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewWaitingTimeRateScaleOrConstraint
    → ValidateInput
    → IdentifyAffectedExponentialClaims
    → UpdateExponentialState
    → CanonicaliseRateScale
    → RecomputePDF
    → RecomputeCDF
    → RecomputeSurvivalAndHazard
    → RecomputeMoments
    → RevalidateProcessRelations
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

RateUpdate :=
    ChangedRate
    ⇒ revalidate(λ>0)
    → recompute(
        Scale,
        PDF,
        CDF,
        Survival,
        Hazard,
        Mean,
        Variance
    )

ScaleUpdate :=
    ChangedScale
    ⇒
    λ=1/Scale
    → RateUpdate

DataUpdate :=
    NewWaitingTimeOrLifetimeData
    ⇒ reevaluate(
        RateEstimate,
        ModelFit,
        PosteriorIfBayesian
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        ExponentialDistribution,
        MemorylessProperty,
        PoissonProcessWaitingTime,
        ExponentialValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ExponentialDistributionEntityResolution,
    ProbabilitySpace,
    ExponentialRandomVariable,
    Rate,
    Scale,
    Support,
    PDF,
    CDF,
    SurvivalFunction,
    HazardFunction,
    RequestedProbability,
    Mean,
    Variance,
    Quantile,
    PoissonProcessRelation,
    ReliabilityRelation,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA