Standard Deviation Ontology

FULL EXECUTABLE FLOW ALGEBRA — STANDARD DEVIATION ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/descriptive-statistics/standard-deviation-ontology.html

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

BEGIN_FLOW

StandardDeviation :=
    MeasureOfDispersion
    ∧ SquareRootOfVariance
    ∧ OriginalUnitScaleMeasure

RandomVariable := X
Mean := μ=E[X]
PopulationVariance := Var(X)=σ²=E[(X-μ)²]
PopulationStandardDeviation := σ=sqrt(Var(X))
VarianceStandardDeviationRelation := σ²=Var(X)

Dataset := {x_1,...,x_n}
SampleSize := n
SampleMean := X_bar=(1/n)Σ_i x_i
SumOfSquaredDeviations := SSD=Σ_i(x_i-X_bar)²
SampleVariance := S²=SSD/(n-1)
SampleStandardDeviation := S=sqrt(S²)
DegreesOfFreedom := n-1

PopulationStyleDatasetSD :=
    sqrt((1/n)Σ_i(x_i-X_bar)²)
    when observed dataset
    is treated_as complete population

Nonnegativity := StandardDeviation≥0

ZeroStandardDeviation :=
    SD(X)=0
    iff X constant almost surely

PositiveStandardDeviation :=
    NonDegenerateRandomVariable
    ∧ FiniteVariance
    ⇒ SD(X)>0

StandardDeviationUnit :=
    SameMeasurementUnitAsSourceVariable

VarianceUnitRelation :=
    Unit(Variance)=Unit(StandardDeviation)²

TranslationInvariance :=
    SD(X+c)=SD(X)

ScalingProperty :=
    SD(aX)=|a|SD(X)

AffineProperty :=
    SD(aX+b)=|a|SD(X)

Standardisation :=
    Z=(X-μ)/σ
    where σ>0

StandardisedMean := E[Z]=0
StandardisedVariance := Var(Z)=1
StandardisedStandardDeviation := SD(Z)=1
ZScore := z=(x-μ)/σ
SampleZScore := z_i=(x_i-X_bar)/S where S>0

PopulationRMSDeviation :=
    sqrt(E[(X-μ)²])

SampleRMSDeviationWithN :=
    sqrt((1/n)Σ_i(x_i-X_bar)²)

SampleSDVsRMSDeviation :=
    OrdinarySampleSD uses n-1
    whereas empirical RMS deviation uses n

StandardDeviationOfSum :=
    SD(X+Y)
    =
    sqrt(
        Var(X)+Var(Y)+2Cov(X,Y)
    )

IndependentSumSD :=
    X⟂Y
    ⇒
    SD(X+Y)
    =
    sqrt(SD(X)²+SD(Y)²)

StandardDeviationOfDifference :=
    SD(X-Y)
    =
    sqrt(
        Var(X)+Var(Y)-2Cov(X,Y)
    )

GeneralLinearCombinationSD :=
    SD(Σ_i a_iX_i)
    =
    sqrt(
        Σ_iΣ_j a_i a_j Cov(X_i,X_j)
    )

SampleMeanStandardDeviation :=
    IIDSample
    with population SD σ
    ⇒
    SD(X_bar)=σ/sqrt(n)

StandardErrorOfMean := SEM=σ/sqrt(n)
EstimatedStandardErrorOfMean := S/sqrt(n)

StandardDeviationVsStandardError :=
    StandardDeviation describes spread_of_observations
    whereas StandardError describes spread_of_estimator

CoefficientOfVariation :=
    CV=StandardDeviation/Mean
    where ratio interpretation meaningful
    and Mean≠0

RelativeStandardDeviation :=
    RSD=StandardDeviation/|Mean|

StandardDeviationVsVariance :=
    StandardDeviation has original units
    whereas Variance has squared units

StandardDeviationVsRange :=
    StandardDeviation uses all observations
    whereas Range uses only extremes

StandardDeviationVsIQR :=
    StandardDeviation is moment-based
    and outlier-sensitive
    whereas IQR is quantile-based
    and more robust

OutlierSensitivity :=
    SquaredDeviationBasis
    makes StandardDeviation
    sensitive_to extreme observations

RobustScaleAlternatives := {
    MedianAbsoluteDeviation,
    InterquartileRange,
    RobustMEstimatorScale
}

NormalDistributionRelation :=
    X~N(μ,σ²)
    ⇒ SD(X)=σ

NormalEmpiricalRule :=
    NormalDistribution
    ⇒
    P(|X-μ|≤σ)≈0.6827
    ∧ P(|X-μ|≤2σ)≈0.9545
    ∧ P(|X-μ|≤3σ)≈0.9973

EmpiricalRuleConstraint :=
    68_95_99_7Rule
    applies_to normal_or_approximately_normal distributions

ChebyshevRelation :=
    FiniteVariance
    ⇒
    P(|X-μ|≥kσ)≤1/k²
    for k>0

BernoulliStandardDeviation :=
    X~Bernoulli(p)
    ⇒ SD(X)=sqrt(p(1-p))

BinomialStandardDeviation :=
    X~Binomial(n,p)
    ⇒ SD(X)=sqrt(np(1-p))

PoissonStandardDeviation :=
    X~Poisson(λ)
    ⇒ SD(X)=sqrt(λ)

UniformStandardDeviation :=
    X~Uniform(a,b)
    ⇒ SD(X)=(b-a)/sqrt(12)

ExponentialStandardDeviation :=
    X~Exponential(λ)
    ⇒ SD(X)=1/λ

GammaStandardDeviation :=
    X~Gamma(α,β)
    ⇒ SD(X)=sqrt(α)/β
    under shape-rate parameterisation

BetaStandardDeviation :=
    X~Beta(α,β)
    ⇒
    SD(X)
    =
    sqrt(
        αβ/
        [(α+β)²(α+β+1)]
    )

LogisticStandardDeviation :=
    X~Logistic(μ,s)
    ⇒ SD(X)=πs/sqrt(3)

StudentTStandardDeviation :=
    T~t_ν
    ∧ ν>2
    ⇒
    SD(T)=sqrt(ν/(ν-2))

CauchyStandardDeviation :=
    X~Cauchy(x0,γ)
    ⇒ StandardDeviationUndefined

WeibullStandardDeviation :=
    X~Weibull(k,λ)
    ⇒
    SD(X)
    =
    λsqrt(
        Γ(1+2/k)-Γ(1+1/k)²
    )

StandardDeviationExistence :=
    FiniteVariance
    ⇒ FiniteStandardDeviation

UndefinedVarianceRelation :=
    VarianceUndefined
    ⇒ StandardDeviationUndefined

SamplingDistributionOfSampleSD :=
    DistributionOfS
    depends_on parent distribution
    and sample size

NormalSampleVarianceRelation :=
    X_i iid N(μ,σ²)
    ⇒
    (n-1)S²/σ²~χ²_(n-1)

NormalSampleSDRelation :=
    sqrt((n-1)S²/σ²)
    follows ChiDistribution(df=n-1)

BiasOfSampleSD :=
    S is generally biased estimator of σ
    even when S² is unbiased for σ²

PooledStandardDeviation :=
    sqrt(PooledVariance)

TwoGroupPooledSD :=
    sqrt(
        [(n1-1)S1²+(n2-1)S2²]
        /
        (n1+n2-2)
    )

EffectSizeRelation :=
    StandardDeviation
    may standardise effect magnitude

CohensD :=
    DifferenceInMeans
    /
    SelectedStandardDeviation
    under specified convention

ProcessControlRelation :=
    StandardDeviation
    quantifies process variability

MeasurementUncertaintyRelation :=
    StandardDeviation
    may quantify repeated-measurement variability
    but is not automatically total measurement uncertainty

ResidualStandardDeviation :=
    sqrt(ResidualVariance)

RegressionResidualSD :=
    sqrt(SSE/ResidualDF)

RootMeanSquaredError :=
    RMSE
    =
    sqrt(MeanSquaredPredictionError)

SDVsRMSE :=
    StandardDeviation measures dispersion around mean
    whereas RMSE measures error relative_to targets

OnlineStandardDeviation :=
    sqrt(OnlineVariance)

WelfordRelation :=
    StreamingMeanAndM2
    → StableVariance
    → StandardDeviation

MissingDataSD :=
    StandardDeviation
    computed_over selected observed values
    under explicit missingness rule

MissingnessConstraint :=
    SDResult
    must record effective count
    and missingness treatment

EmptyDatasetSD := Undefined

SingleObservationSampleSD :=
    n=1
    ⇒ UnbiasedSampleSDUndefined

SingleObservationPopulationStyleSD :=
    n=1
    ⇒ SD=0
    if observed set treated_as complete population

MeasurementScaleConstraint :=
    StandardDeviation
    generally requires
    quantitative interval_or_ratio semantics

NominalSDInvalid :=
    NominalVariable
    ⇒ ArithmeticStandardDeviationNotMeaningful

OrdinalSDCaution :=
    OrdinalVariable
    ⇒
    StandardDeviationInterpretation
    depends_on numeric coding assumptions

UnitCompatibility :=
    InputValues
    must share compatible measurement units

StandardDeviationConstraint :=
    ConstraintOn(
        VariableType,
        MeasurementScale,
        Units,
        Missingness,
        VarianceDefinition,
        MomentExistence
    )

StandardDeviationConsistency :=
    DataScope
    ∧ MeanDefinition
    ∧ VarianceConvention
    ∧ MissingnessRule
    ∧ MeasurementSemantics
    jointly_compatible

InvalidStandardDeviation :=
    EmptyEffectiveDataset
    ∨ InvalidVariance
    ∨ NegativeVarianceInput
    ∨ IncompatibleUnits
    ∨ NominalArithmeticSD
    ∨ UndocumentedMissingness
    ∨ UndefinedVarianceClaim

StandardDeviationValidation :=
    ResolveVariable
    → ResolveVariableType
    → ResolveMeasurementScale
    → ResolveDataScope
    → ResolveObservationsOrDistribution
    → ResolveMissingness
    → ResolveVarianceConvention
    → ComputeOrResolveVariance
    → ValidateVarianceNonnegativity
    → ComputeSquareRoot
    → ValidateUnits
    → ValidateResult

StandardDeviationState := {
    Variable,
    Observations,
    EffectiveCount,
    DataScope,
    Mean,
    Variance,
    StandardDeviationValue,
    MeasurementUnit,
    MissingnessRule,
    PopulationOrSampleConvention,
    Evidence,
    Confidence,
    Provenance
}

SEMANTIC_EQUIVALENCE(StandardDeviationA,StandardDeviationB) :=
    same(DataScope)
    ∧ same(VariableSemantics)
    ∧ same(VarianceConvention)
    ∧ same(MissingnessRule)
    ∧ compatible(MeasurementUnits)

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

CoreClasses := {
    StandardDeviation,
    PopulationStandardDeviation,
    SampleStandardDeviation,
    Variance,
    StandardError,
    ZScore,
    CoefficientOfVariation,
    PooledStandardDeviation,
    ResidualStandardDeviation,
    RobustScaleEstimator,
    StatisticalVariable,
    StatisticalObservation,
    Dataset,
    Sample,
    Population,
    StandardDeviationConstraint
}

CoreRelations := {
    computedFrom,
    summarises,
    squareRootOf,
    estimates,
    hasUnit,
    standardises,
    relatedTo,
    pooledFrom,
    distributedAs,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    StandardDeviation --computedFrom--> Observations
    StandardDeviation --summarises--> StatisticalVariable
    StandardDeviation --squareRootOf--> Variance
    SampleStandardDeviation --estimates--> PopulationStandardDeviation
    StandardDeviation --hasUnit--> MeasurementUnit
    StandardDeviation --standardises--> ZScore
    StandardDeviation --relatedTo--> StandardError
    PooledStandardDeviation --pooledFrom--> GroupVariances
    ScaledSampleStandardDeviation --distributedAs--> ChiDistribution
    StandardDeviation --tracesTo--> Provenance

InferenceRules := {
    FiniteVariance(X)
        ⇒ SD(X)=sqrt(Var(X)),

    SD(X)
        ⇒ SD(X)≥0,

    SD(X)=0
        ⇒ XConstantAlmostSurely,

    SD(X+c)=SD(X),

    SD(aX)=|a|SD(X),

    Independent(X,Y)
        ⇒
        SD(X+Y)
        =
        sqrt(SD(X)²+SD(Y)²),

    IIDSample
        ∧ finite_variance
        ⇒ EstimatedSEM=S/sqrt(n),

    NominalVariable
        ⇒ FlagStandardDeviationAsSemanticallyInvalid,

    UndefinedVariance
        ⇒ FlagStandardDeviationAsUndefined
}

CanonicalStandardDeviationRepresentation :=
    ParseStandardDeviationRequest
    → ResolveVariable
    → ResolveDatasetSamplePopulationOrDistribution
    → ResolveVariableTypeAndMeasurementScale
    → ResolveObservationsOrProbabilityModel
    → ResolveMissingness
    → ResolvePopulationOrSampleVarianceConvention
    → ComputeOrResolveVariance
    → ValidateVariance
    → ComputeStandardDeviation
    → ResolveStandardisationOrStandardErrorRelationsIfRequired
    → ValidateStandardDeviation

StandardDeviationGraph :=
    G=(V,E)

V := {
    StandardDeviations,
    PopulationStandardDeviations,
    SampleStandardDeviations,
    Variances,
    StandardErrors,
    ZScores,
    CoefficientsOfVariation,
    PooledStandardDeviations,
    ResidualStandardDeviations,
    RobustScaleEstimators,
    Variables,
    Observations,
    Datasets,
    Samples,
    Populations,
    Evidence,
    ProvenanceNodes
}

E := {
    computedFrom,
    summarises,
    squareRootOf,
    estimates,
    hasUnit,
    standardises,
    relatedTo,
    pooledFrom,
    distributedAs,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(StandardDeviationResolution) :=
    weighted_mean(
        VariableResolution,
        DataScopeResolution,
        MeasurementScaleValidity,
        ObservationOrDistributionResolution,
        VarianceConventionValidity,
        MissingnessHandling,
        NumericalCalculationValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectStandardDeviationIntent
    → IdentifyVariableAndDataScope
    → DeterminePopulationSampleOrDistributionSD
    → ResolveVarianceConvention
    → IdentifyRequestedComputationStandardisationInferenceOrComparison

AI_REASONING_FLOW :=
    Query
    → ParseStandardDeviationProblem
    → ResolveDatasetSamplePopulationOrDistribution
    → ResolveVariable
    → ResolveVariableTypeAndMeasurementScale
    → ResolveObservationsOrProbabilityDistribution
    → ResolveMissingValues
    → ResolveVarianceConvention
    → ComputeOrResolveVariance
    → ValidateVarianceNonnegativityAndExistence
    → ComputeSquareRoot
    → ValidateMeasurementUnit
    → ResolveZScoreStandardErrorOrCoefficientOfVariationIfRequested
    → ResolveSamplingDistributionIfRelevant
    → ValidateStandardDeviationResult
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseStandardDeviationEntities,
    ParseTypedRelations,
    ResolveVariables,
    ResolveObservations,
    ResolveDatasets,
    ResolveSamples,
    ResolvePopulations,
    ResolveProbabilityDistributions,
    ResolveMeasurementScales,
    ResolveMeasurementUnits,
    ResolveMissingness,
    ResolveVarianceConventions,
    ComputePopulationVariances,
    ComputeSampleVariances,
    ComputePopulationStandardDeviations,
    ComputeSampleStandardDeviations,
    ComputeZScores,
    ComputeStandardErrors,
    ComputeCoefficientsOfVariation,
    ComputePooledStandardDeviations,
    ComputeResidualStandardDeviations,
    ResolveNormalEmpiricalRule,
    ResolveChebyshevBounds,
    ResolveSamplingDistributions,
    ValidateMomentExistence,
    ValidateStandardDeviationSemantics,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewObservationScopeVarianceConventionOrModelEvidence
    → ValidateInput
    → IdentifyAffectedStandardDeviationClaims
    → UpdateStandardDeviationState
    → RecomputeEffectiveObservationSet
    → RecomputeVariance
    → RecomputeStandardDeviation
    → RecomputeStandardisationAndStandardErrors
    → RevalidateSamplingRelations
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ObservationUpdate :=
    AddedRemovedOrCorrectedObservation
    ⇒ recompute(
        EffectiveCount,
        Mean,
        Variance,
        StandardDeviationValue
    )

VarianceConventionUpdate :=
    ChangedPopulationOrSampleConvention
    ⇒ recompute(
        Variance,
        StandardDeviationValue
    )

ModelUpdate :=
    ChangedProbabilityDistribution
    ⇒ reevaluate(
        VarianceExistence,
        StandardDeviationFormula,
        SamplingProperties
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        StandardDeviation,
        StandardDeviationValidation,
        StandardDeviationConstraint,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    StandardDeviationEntityResolution,
    Variable,
    DataScope,
    VariableType,
    MeasurementScale,
    ObservationCount,
    EffectiveObservationCount,
    Mean,
    VarianceConvention,
    VarianceValue,
    StandardDeviationValue,
    MeasurementUnit,
    MissingnessRule,
    StandardisationRelation,
    StandardErrorRelation,
    SamplingDistribution,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA