Gaussian Distribution Ontology

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

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

BEGIN_FLOW

GaussianDistribution :=
    NormalDistribution
    ∧ ContinuousProbabilityDistribution
    ∧ GaussianDensity
    ∧ LocationScaleFamily
    ∧ SymmetricBellShapedLaw

GaussianNormalEquivalence :=
    GaussianDistribution
    ≡ NormalDistribution

ProbabilitySpace := (Ω,F,P)

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

ParameterConstraints :=
    μ∈R
    ∧ σ>0

MeanParameter := μ
VarianceParameter := σ²
StandardDeviationParameter := σ
Support := R

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

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

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

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

StandardGaussian :=
    Z~N(0,1)

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

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

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

InverseStandardisation :=
    X=μ+σZ

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

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

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

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

Mean :=
    E[X]=μ

Median := μ
Mode := μ
Variance := Var(X)=σ²
Skewness := 0
Kurtosis := 3
ExcessKurtosis := 0

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

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

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

QuantileFunction :=
    Q_X(p)
    =
    μ+σΦ^(-1)(p)

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

LocationScaleRepresentation :=
    X=μ+σZ
    where Z~N(0,1)

AffineTransformation :=
    Y=aX+b

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

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

LinearCombinationIndependentGaussians :=
    IndependentGaussian(X_i)
    ⇒
    Σ_i a_iX_i
    ~
    N(
        Σ_i a_iμ_i,
        Σ_i a_i²σ_i²
    )

MultivariateGaussian :=
    X~N_d(μ,Σ)

MeanVector := μ
CovarianceMatrix := Σ

CovarianceConstraint :=
    Σ symmetric
    ∧ positive_semidefinite

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

MahalanobisDistanceSquared :=
    (x-μ)^T
    Σ^(-1)
    (x-μ)

GaussianContours :=
    ConstantMahalanobisDistance
    → EllipsoidalDensityContours

MarginalGaussian :=
    MultivariateGaussian
    ⇒ AnySubvector
    is Gaussian

ConditionalGaussian :=
    JointGaussian(X,Y)
    ⇒
    X|Y=y
    is Gaussian
    under regular nonsingular conditions

ConditionalGaussianMean :=
    μ_X
    +
    Σ_XY
    Σ_YY^(-1)
    (y-μ_Y)

ConditionalGaussianCovariance :=
    Σ_XX
    -
    Σ_XY
    Σ_YY^(-1)
    Σ_YX

JointGaussianIndependence :=
    JointlyGaussian(X,Y)
    ∧ Cov(X,Y)=0
    ⇒ X⟂Y

GaussianVectorLinearTransform :=
    X~N_d(μ,Σ)
    ⇒
    AX+b
    ~
    N(
        Aμ+b,
        AΣA^T
    )

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

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

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

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

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

GaussianMeanVarianceIndependence :=
    X_bar ⟂ S²

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

CentralLimitTheoremRelation :=
    ProperlyStandardisedSums
    → StandardGaussian
    in distribution
    under theorem assumptions

GaussianApproximation :=
    TargetDistribution
    approximated_by
    GaussianDistribution
    under suitable conditions

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

PoissonGaussianApproximation :=
    Poisson(λ)
    ≈
    N(λ,λ)
    for sufficiently large λ

EmpiricalRule := {
    Within1Sigma ≈ 0.6827,
    Within2Sigma ≈ 0.9545,
    Within3Sigma ≈ 0.9973
}

GaussianLikelihood :=
    L(μ,σ²|Data)
    =
    Π_i
    [1/(σ√(2π))]
    exp(-(x_i-μ)²/(2σ²))

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

MLEMean :=
    μ_hat=X_bar

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

GaussianConjugacy :=
    GaussianLikelihood
    ∧ suitable GaussianPrior
    → GaussianPosterior
    under known variance assumptions

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

AdditiveGaussianNoise :=
    Y=Signal+ε

GaussianProcess :=
    StochasticProcess
    where every finite collection
    has multivariate Gaussian distribution

GaussianProcessState :=
    MeanFunction
    ∧ CovarianceKernel

MeanFunction :=
    m(x)=E[f(x)]

CovarianceKernel :=
    k(x,x')
    =
    Cov(f(x),f(x'))

GaussianProcessPrior :=
    f~GP(m,k)

GaussianProcessPosterior :=
    PriorGP
    ∧ Observations
    → ConditionalGaussianProcess

GaussianMixtureModel :=
    p(x)
    =
    Σ_i π_i
    N(x|μ_i,Σ_i)

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

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

GaussianDistributionConstraint :=
    ConstraintOn(
        Mean,
        VarianceOrCovariance,
        GaussianDensity,
        Support
    )

VarianceConstraint :=
    σ²>0

MultivariateCovarianceConstraint :=
    Σ symmetric
    ∧ positive_semidefinite

GaussianConsistency :=
    Parameters
    ∧ PDF
    ∧ CDF
    ∧ Moments
    ∧ CovarianceStructure
    jointly_compatible

InvalidGaussianDistribution :=
    σ²≤0
    ∨ InvalidCovarianceMatrix
    ∨ DensityMismatch
    ∨ NormalisationFailure

GaussianValidation :=
    ResolveDimension
    → ResolveMean
    → ResolveVarianceOrCovariance
    → ValidateScaleOrCovariance
    → ConstructDensity
    → ValidateNormalisation
    → ValidateMoments

GaussianDistributionState := {
    RandomVariable,
    Dimension,
    MeanOrMeanVector,
    VarianceOrCovariance,
    PDF,
    CDF,
    Quantiles,
    ConditionalStructure,
    Evidence,
    Confidence,
    Provenance
}

SEMANTIC_EQUIVALENCE(GaussianA,GaussianB) :=
    same(MeanStructure)
    ∧ same(CovarianceStructure)
    ⇒ same(GaussianProbabilityMeasure)

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

CoreClasses := {
    GaussianDistribution,
    NormalDistribution,
    GaussianRandomVariable,
    StandardGaussian,
    GaussianPDF,
    GaussianCDF,
    Mean,
    Variance,
    ZScore,
    MultivariateGaussian,
    CovarianceMatrix,
    ConditionalGaussian,
    GaussianSample,
    GaussianNoise,
    GaussianProcess,
    GaussianMixtureModel,
    GaussianConstraint
}

CoreRelations := {
    equivalentTo,
    distributionOf,
    hasMean,
    hasVariance,
    hasCovariance,
    hasPDF,
    hasCDF,
    standardisesTo,
    transformedBy,
    conditionedOn,
    summedWith,
    sampledFrom,
    approximates,
    generatedBy,
    dependsOn,
    tracesTo
}

TypedRelations :=
    GaussianDistribution --equivalentTo--> NormalDistribution
    GaussianDistribution --distributionOf--> GaussianRandomVariable
    GaussianDistribution --hasMean--> Mean
    GaussianDistribution --hasVariance--> Variance
    MultivariateGaussian --hasCovariance--> CovarianceMatrix
    GaussianDistribution --hasPDF--> GaussianPDF
    GaussianDistribution --hasCDF--> GaussianCDF
    GaussianRandomVariable --standardisesTo--> StandardGaussian
    ConditionalGaussian --conditionedOn--> GaussianRandomVariable
    GaussianSample --sampledFrom--> GaussianDistribution
    GaussianDistribution --tracesTo--> Provenance

InferenceRules := {
    Gaussian(X,μ,σ²)
        ⇒ Normal(X,μ,σ²),

    Normal(X,μ,σ²)
        ⇒ Gaussian(X,μ,σ²),

    X~Gaussian(μ,σ²)
        ⇒ E[X]=μ,

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

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

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

    IndependentGaussian(X,Y)
        ⇒ X+Y
        ~Gaussian(
            μ_X+μ_Y,
            σ_X²+σ_Y²
        ),

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

    σ²≤0
        ⇒ InvalidUnivariateGaussian
}

CanonicalGaussianRepresentation :=
    ParseGaussianDistribution
    → ResolveNormalSynonym
    → ResolveDimension
    → ResolveRandomVariable
    → ResolveMeanStructure
    → ResolveVarianceOrCovariance
    → ValidateParameters
    → ConstructDensity
    → ResolveCDFOrMultivariateStructure
    → ValidateGaussianDistribution

GaussianDistributionGraph :=
    G=(V,E)

V := {
    GaussianDistributions,
    NormalDistributions,
    GaussianRandomVariables,
    StandardGaussians,
    Means,
    Variances,
    CovarianceMatrices,
    PDFs,
    CDFs,
    ZScores,
    ConditionalGaussians,
    GaussianProcesses,
    GaussianMixtures,
    Evidence,
    ProvenanceNodes
}

E := {
    equivalentTo,
    distributionOf,
    hasMean,
    hasVariance,
    hasCovariance,
    hasPDF,
    hasCDF,
    standardisesTo,
    transformedBy,
    conditionedOn,
    summedWith,
    sampledFrom,
    approximates,
    generatedBy,
    dependsOn,
    tracesTo
}

CONFIDENCE(GaussianDistributionResolution) :=
    weighted_mean(
        GaussianNormalEntityResolution,
        DimensionResolution,
        MeanResolution,
        VarianceOrCovarianceValidity,
        DensityConsistency,
        ConditionalStructureValidity,
        EvidenceQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectGaussianDistributionIntent
    → ResolveGaussianNormalEquivalence
    → IdentifyRandomVariableOrVector
    → ResolveMeanAndVarianceOrCovariance
    → IdentifyRequestedGaussianProperty

AI_REASONING_FLOW :=
    Query
    → ParseGaussianDistributionProblem
    → ResolveProbabilitySpace
    → ResolveGaussianNormalSynonymy
    → ResolveUnivariateOrMultivariateForm
    → ResolveMeanStructure
    → ResolveVarianceOrCovariance
    → ValidateParameters
    → ConstructGaussianDensity
    → StandardiseIfUnivariateAndUseful
    → EvaluateCDFIntervalTailOrQuantileIfRequired
    → ResolveConditionalGaussianIfRequired
    → ApplyAffineOrSumClosureIfRequired
    → ResolveGaussianProcessOrMixtureContextIfRequired
    → ValidateGaussianModel
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseGaussianDistributionEntities,
    ParseTypedRelations,
    ResolveGaussianNormalEquivalence,
    ResolveGaussianRandomVariables,
    ResolveMeans,
    ResolveVariances,
    ResolveCovarianceMatrices,
    EvaluateGaussianPDFs,
    EvaluateGaussianCDFs,
    StandardiseGaussianVariables,
    ComputeGaussianProbabilities,
    ComputeQuantiles,
    ApplyAffineTransformations,
    CombineIndependentGaussians,
    ResolveMultivariateGaussians,
    ResolveConditionalGaussians,
    ResolveGaussianProcesses,
    ResolveGaussianMixtures,
    ValidateGaussianDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewDataMeanVarianceCovarianceOrModelEvidence
    → ValidateInput
    → IdentifyAffectedGaussianClaims
    → UpdateGaussianState
    → RecomputeDensity
    → RecomputeCDFOrConditionalStructure
    → RecomputeQuantilesOrPredictions
    → RevalidateGaussianModel
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

MeanUpdate :=
    ChangedMeanOrMeanVector
    ⇒ recompute(
        DensityLocation,
        CDFWhereApplicable,
        ConditionalMeans
    )

CovarianceUpdate :=
    ChangedVarianceOrCovariance
    ⇒ revalidate(
        PositiveVarianceOrPSD
    )
    → recompute(
        DensityScale,
        ConditionalCovariance,
        MahalanobisStructure
    )

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

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        GaussianDistribution,
        GaussianNormalEquivalence,
        GaussianAffineClosure,
        GaussianValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    GaussianDistributionEntityResolution,
    NormalDistributionEquivalence,
    ProbabilitySpace,
    GaussianRandomVariable,
    Dimension,
    MeanOrMeanVector,
    VarianceOrCovariance,
    PDF,
    CDF,
    Standardisation,
    IntervalOrTailProbability,
    Quantile,
    ConditionalGaussianStructure,
    GaussianProcessOrMixtureStructure,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA