Normal Distribution Ontology

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

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

BEGIN_FLOW

NormalDistribution :=
    ContinuousProbabilityDistribution
    ∧ GaussianDensity
    ∧ LocationParameter
    ∧ PositiveScaleParameter
    ∧ Symmetry
    ∧ FiniteMoments

ProbabilitySpace :=
    (Ω,F,P)

NormalRandomVariable :=
    X~N(μ,σ²)

ParameterConstraints :=
    μ∈R
    ∧ σ>0

MeanParameter :=
    μ

VarianceParameter :=
    σ²

StandardDeviationParameter :=
    σ

Support :=
    R

NormalPDF :=
    f_X(x)
    =
    [1/(σ√(2π))]
    exp(
        -(x-μ)²/(2σ²)
    )

PDFNonnegativity :=
    f_X(x)>0
    for all x∈R

PDFNormalisation :=
    Integral_{-∞}^{∞}
    f_X(x)dx
    =
    1

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

NormalCDFIntegral :=
    F_X(x)
    =
    Integral_{-∞}^x
    f_X(t)dt

NoElementaryClosedFormCDF :=
    NormalCDF
    generally evaluated
    numerically_or_via_special_functions

StandardNormalDistribution :=
    Z~N(0,1)

StandardNormalPDF :=
    φ(z)
    =
    [1/√(2π)]
    exp(-z²/2)

StandardNormalCDF :=
    Φ(z)
    =
    P(Z≤z)

Standardisation :=
    Z
    =
    (X-μ)/σ

InverseStandardisation :=
    X
    =
    μ+σZ

NormalProbabilityTransform :=
    P(X≤x)
    =
    Φ((x-μ)/σ)

IntervalProbability :=
    P(a≤X≤b)
    =
    Φ((b-μ)/σ)
    -
    Φ((a-μ)/σ)

UpperTailProbability :=
    P(X>x)
    =
    1-Φ((x-μ)/σ)

Symmetry :=
    f_X(μ-d)
    =
    f_X(μ+d)

CDFSymmetry :=
    Φ(-z)
    =
    1-Φ(z)

Mean :=
    E[X]=μ

Median :=
    μ

Mode :=
    μ

MeanMedianModeEquality :=
    Mean=Median=Mode=μ

Variance :=
    Var(X)=σ²

StandardDeviation :=
    SD(X)=σ

Skewness :=
    0

ExcessKurtosis :=
    0

Kurtosis :=
    3
    under non-excess convention

MomentGeneratingFunction :=
    M_X(t)
    =
    exp(
        μt + (σ²t²)/2
    )

CharacteristicFunction :=
    φ_X(t)
    =
    exp(
        iμt - (σ²t²)/2
    )

Entropy :=
    h(X)
    =
    (1/2)
    log(
        2πeσ²
    )

Quantile :=
    Q_X(p)
    =
    μ+σΦ^{-1}(p)

NormalPercentile :=
    Percentile_p
    =
    μ+σz_p

ZScore :=
    z
    =
    (x-μ)/σ

ZScoreInterpretation :=
    SignedNumberOfStandardDeviations
    from mean

AffineTransformation :=
    Y=aX+b

NormalAffineClosure :=
    X~N(μ,σ²)
    ⇒
    aX+b
    ~
    N(
        aμ+b,
        a²σ²
    )

IndependentNormalSum :=
    X~N(μ_X,σ_X²)
    ∧ Y~N(μ_Y,σ_Y²)
    ∧ X⟂Y
    ⇒
    X+Y
    ~
    N(
        μ_X+μ_Y,
        σ_X²+σ_Y²
    )

IndependentNormalDifference :=
    X-Y
    ~
    N(
        μ_X-μ_Y,
        σ_X²+σ_Y²
    )

LinearCombinationIndependentNormals :=
    X_i independent normal
    ⇒
    Σ_i a_iX_i
    ~
    N(
        Σ_i a_iμ_i,
        Σ_i a_i²σ_i²
    )

JointlyNormalLinearCombination :=
    X jointly multivariate normal
    ⇒
    a^T X
    is univariate normal

MultivariateNormal :=
    X~N_d(μ,Σ)

MultivariateNormalPDF :=
    f_X(x)
    =
    [1/((2π)^(d/2)|Σ|^(1/2))]
    exp(
        -(1/2)
        (x-μ)^T
        Σ^(-1)
        (x-μ)
    )
    for positive-definite Σ

MeanVector :=
    μ

CovarianceMatrix :=
    Σ

MarginalNormality :=
    MultivariateNormal
    ⇒
    every subvector
    is multivariate normal

ConditionalNormality :=
    MultivariateNormal
    ⇒
    ConditionalDistribution
    is normal
    under nonsingularity conditions

ZeroCovarianceIndependence :=
    JointlyNormal(X,Y)
    ∧ Cov(X,Y)=0
    ⇒
    X⟂Y

UncorrelatedGeneralCase :=
    Cov(X,Y)=0
    ↛ Independence
    without joint normality or stronger assumptions

NormalSample :=
    X_1,...,X_n
    iid N(μ,σ²)

SampleMean :=
    X_bar
    =
    (1/n)Σ_iX_i

NormalSampleMean :=
    X_bar
    ~
    N(
        μ,
        σ²/n
    )

SampleMeanStandardisation :=
    (X_bar-μ)/(σ/√n)
    ~
    N(0,1)
    when σ known

SampleVariance :=
    S²
    =
    [1/(n-1)]
    Σ_i(X_i-X_bar)²

NormalSampleVarianceRelation :=
    (n-1)S²/σ²
    ~
    χ²_(n-1)

NormalMeanVarianceIndependence :=
    For iid normal sample:
        X_bar ⟂ S²

StudentTStatistic :=
    (X_bar-μ)/(S/√n)
    ~
    t_(n-1)

CentralLimitTheorem :=
    ProperlyStandardisedSampleMean
    → N(0,1)
    in distribution
    under theorem assumptions

NormalApproximation :=
    NonNormalDistribution
    may_be approximated_by
    NormalDistribution
    under suitable conditions

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

ContinuityCorrection :=
    DiscreteToNormalApproximation
    may adjust interval boundaries
    by 0.5
    for integer-valued variables

PoissonNormalApproximation :=
    X~Poisson(λ)
    ≈
    N(λ,λ)
    for sufficiently large λ
    under suitable accuracy requirements

EmpiricalRuleApproximation := {
    P(|X-μ|≤σ) ≈ 0.6827,
    P(|X-μ|≤2σ) ≈ 0.9545,
    P(|X-μ|≤3σ) ≈ 0.9973
}

NormalLikelihood :=
    L(μ,σ²|x1,...,xn)
    =
    Π_i
    [1/(σ√(2π))]
    exp(
        -(x_i-μ)²/(2σ²)
    )

NormalLogLikelihood :=
    ℓ(μ,σ²)
    =
    -n log σ
    -(n/2)log(2π)
    -
    [1/(2σ²)]
    Σ_i(x_i-μ)²

MLEMean :=
    μ_hat
    =
    X_bar

MLEVariance :=
    σ²_hat_MLE
    =
    (1/n)
    Σ_i(x_i-X_bar)²

UnbiasedSampleVariance :=
    S²
    =
    (1/(n-1))
    Σ_i(x_i-X_bar)²

NormalConjugacy :=
    NormalLikelihood
    with suitable normal prior
    on mean
    → NormalPosterior
    under known variance assumptions

NormalNormalUpdate :=
    Prior μ~N(μ0,τ0²)
    ∧ DataMeanLikelihood
    → PosteriorNormal

PosteriorPrecision :=
    1/τ_n²
    =
    1/τ0²
    +
    n/σ²

PosteriorMean :=
    μ_n
    =
    τ_n²[
        μ0/τ0²
        +
        nX_bar/σ²
    ]

NormalPredictive :=
    PosteriorOrKnownParameterModel
    → PredictiveDistribution

GaussianNoise :=
    ε~N(0,σ²)

AdditiveGaussianNoiseModel :=
    Y
    =
    Signal
    +
    ε

LinearRegressionNormalErrors :=
    Y
    =
    Xβ+ε
    ∧ ε~N(0,σ²I)

NormalResidualModel :=
    Residuals
    assumed
    normally distributed
    under specified regression inference

GaussianProcessRelation :=
    EveryFiniteCollection
    of process values
    jointly multivariate normal

BrownianIncrementRelation :=
    BrownianMotion
    has normal increments
    under standard definition

MaximumEntropyProperty :=
    Among continuous distributions
    with fixed mean and variance,
    NormalDistribution
    maximises
    differential entropy

NormalDistributionConstraint :=
    ConstraintOn(
        μ,
        σ²,
        Support,
        GaussianDensity
    )

VarianceConstraint :=
    σ²>0

NormalisationConstraint :=
    Integral f_X(x)dx=1

NormalDistributionConsistency :=
    Parameters
    ∧ PDF
    ∧ CDF
    ∧ Moments
    jointly_compatible

InvalidNormalDistribution :=
    σ≤0
    ∨ DensityMismatch
    ∨ NormalisationFailure
    ∨ MomentConflict

NormalDistributionValidation :=
    ResolveParameters
    → CheckσPositive
    → ConstructPDF
    → ValidateNormalisation
    → ConstructCDF
    → ValidateMoments
    → ValidateTransformations

NormalDistributionState := {
    RandomVariable,
    Mean,
    Variance,
    StandardDeviation,
    PDF,
    CDF,
    Quantiles,
    SampleModel,
    Evidence,
    Confidence,
    Provenance
}

NormalEvidence :=
    ModelDefinition
    ∨ SampleData
    ∨ TheoreticalDerivation
    ∨ ApproximationAssumption

NormalityAssessment :=
    Data
    → GraphicalDiagnostics
    ∧ StatisticalTests
    ∧ ContextualModelAssessment

NormalityTestResult :=
    EvidenceAboutCompatibility
    with normal model
    not proof of exact normality

NormalDistributionUpdate :=
    NewDataParameterOrModelEvidence
    → UpdateNormalState
    → RecomputePDF
    → RecomputeCDF
    → RecomputeQuantiles
    → Revalidate

SEMANTIC_EQUIVALENCE(NormalA,NormalB) :=
    same(μ)
    ∧ same(σ²)
    ⇒ same(NormalProbabilityMeasure)

EqualNormalDistributions :=
    N(μ1,σ1²)
    =
    N(μ2,σ2²)
    iff
    μ1=μ2
    ∧ σ1²=σ2²

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

CoreClasses := {
    NormalDistribution,
    ContinuousDistribution,
    NormalRandomVariable,
    StandardNormalDistribution,
    Mean,
    Variance,
    StandardDeviation,
    NormalPDF,
    NormalCDF,
    ZScore,
    Quantile,
    MultivariateNormal,
    NormalSample,
    GaussianNoise,
    NormalApproximation,
    NormalConstraint
}

CoreRelations := {
    distributionOf,
    hasMean,
    hasVariance,
    hasStandardDeviation,
    hasPDF,
    hasCDF,
    standardisesTo,
    transformedFrom,
    summedWith,
    approximates,
    sampledFrom,
    conditionedOn,
    estimatedFrom,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    NormalDistribution --distributionOf--> NormalRandomVariable
    NormalDistribution --hasMean--> Mean
    NormalDistribution --hasVariance--> Variance
    NormalDistribution --hasStandardDeviation--> StandardDeviation
    NormalDistribution --hasPDF--> NormalPDF
    NormalDistribution --hasCDF--> NormalCDF
    NormalRandomVariable --standardisesTo--> StandardNormalDistribution
    NormalDistribution --transformedFrom--> StandardNormalDistribution
    NormalSample --sampledFrom--> NormalDistribution
    NormalDistribution --tracesTo--> Provenance

InferenceRules := {
    X~N(μ,σ²)
        ⇒ E[X]=μ,

    X~N(μ,σ²)
        ⇒ Var(X)=σ²,

    X~N(μ,σ²)
        ⇒ (X-μ)/σ~N(0,1),

    X~N(μ,σ²)
        ⇒ aX+b~N(aμ+b,a²σ²),

    IndependentNormal(X,Y)
        ⇒ X+Y~N(
            μ_X+μ_Y,
            σ_X²+σ_Y²
        ),

    JointlyNormal(X,Y)
        ∧ Cov(X,Y)=0
        ⇒ Independent(X,Y),

    Xi iid N(μ,σ²)
        ⇒ X_bar~N(μ,σ²/n),

    σ≤0
        ⇒ InvalidNormalDistribution
}

CanonicalNormalRepresentation :=
    ParseNormalDistribution
    → ResolveRandomVariable
    → ResolveMean
    → ResolveVariance
    → ValidateσPositive
    → ConstructPDF
    → ConstructCDF
    → ResolveStandardisation
    → ResolveMoments
    → ValidateNormalDistribution

NormalDistributionGraph :=
    G=(V,E)

V := {
    NormalRandomVariables,
    NormalDistributions,
    StandardNormal,
    Means,
    Variances,
    StandardDeviations,
    PDFs,
    CDFs,
    ZScores,
    Quantiles,
    MultivariateNormals,
    Samples,
    Evidence,
    ProvenanceNodes
}

E := {
    distributionOf,
    hasMean,
    hasVariance,
    hasStandardDeviation,
    hasPDF,
    hasCDF,
    standardisesTo,
    transformedFrom,
    summedWith,
    approximates,
    sampledFrom,
    conditionedOn,
    estimatedFrom,
    equivalentTo,
    tracesTo
}

CONFIDENCE(NormalDistributionResolution) :=
    weighted_mean(
        RandomVariableResolution,
        ParameterQuality,
        VarianceValidity,
        PDFConsistency,
        CDFConsistency,
        SampleEvidence,
        ApproximationValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectNormalDistributionIntent
    → IdentifyRandomVariable
    → ResolveMeanAndVariance
    → IdentifyRequestedProbabilityOrStatistic
    → DetermineNeedForStandardisationOrApproximation

AI_REASONING_FLOW :=
    Query
    → ParseNormalDistributionProblem
    → ResolveProbabilitySpace
    → ResolveNormalRandomVariable
    → ResolveMean
    → ResolveVariance
    → ValidateParameters
    → StandardiseToZIfUseful
    → EvaluateCDFOrTailProbability
    → ComputeIntervalProbability
    → ComputeQuantileIfRequired
    → ApplyAffineOrSumRulesIfRequired
    → ResolveSamplingDistributionIfRequired
    → ValidateNormalModelOrApproximation
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseNormalDistributionEntities,
    ParseTypedRelations,
    ResolveNormalRandomVariables,
    ResolveMeans,
    ResolveVariances,
    EvaluateNormalPDF,
    EvaluateNormalCDF,
    StandardiseZScores,
    ComputeIntervalProbabilities,
    ComputeTailProbabilities,
    ComputeQuantiles,
    ApplyAffineTransformations,
    CombineIndependentNormals,
    ResolveMultivariateNormals,
    ResolveNormalSamplingDistributions,
    EvaluateNormalApproximations,
    ValidateNormalDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewDataMeanVarianceOrModelEvidence
    → ValidateInput
    → IdentifyAffectedNormalClaims
    → UpdateNormalState
    → RecomputePDF
    → RecomputeCDF
    → RecomputeQuantiles
    → RecomputeSamplingRelations
    → RevalidateNormalModel
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

MeanUpdate :=
    ChangedMean
    ⇒ recompute(
        PDFLocation,
        CDF,
        ZScores,
        Quantiles
    )

VarianceUpdate :=
    ChangedVariance
    ⇒ revalidate(σ²>0)
    → recompute(
        PDFScale,
        CDF,
        ZScores,
        Quantiles
    )

DataUpdate :=
    NewSampleData
    ⇒ reevaluate(
        ParameterEstimates,
        NormalityAssessment,
        Confidence
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        NormalDistribution,
        Standardisation,
        NormalAffineClosure,
        NormalDistributionValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    NormalDistributionEntityResolution,
    ProbabilitySpace,
    NormalRandomVariable,
    Mean,
    Variance,
    StandardDeviation,
    PDF,
    CDF,
    ZScore,
    IntervalProbability,
    TailProbability,
    Quantile,
    SamplingDistribution,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA