Standard Error Ontology

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

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

BEGIN_FLOW

StandardError :=
    MeasureOfSamplingUncertainty
    ∧ StandardDeviationOfSamplingDistribution
    ∧ EstimatorPrecisionMeasure

Parameter := θ
Estimator := θ_hat
SamplingDistribution := DistributionOf(θ_hat)

StandardErrorDefinition :=
    SE(θ_hat)
    =
    sqrt(Var(θ_hat))

StandardErrorNonnegativity := SE(θ_hat)≥0
StandardErrorUnit := SameUnitAsEstimator

StandardErrorVsStandardDeviation :=
    StandardDeviation
    describes dispersion_of_observations
    whereas StandardError
    describes dispersion_of_estimator

Sample := {X_1,...,X_n}
SampleSize := n
PopulationMean := μ
PopulationVariance := σ²
PopulationStandardDeviation := σ
SampleMean := X_bar=(1/n)Σ_iX_i

MeanSamplingVariance :=
    IIDSample
    ∧ Var(X_i)=σ²
    ⇒ Var(X_bar)=σ²/n

MeanStandardError :=
    SE(X_bar)=σ/sqrt(n)

EstimatedMeanStandardError :=
    SE_hat(X_bar)=S/sqrt(n)

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

SampleSizeRelation :=
    HoldingPopulationVariationConstant
    ⇒ SE(X_bar) proportional_to 1/sqrt(n)

PrecisionRelation :=
    SmallerStandardError
    ⇒ GreaterEstimatorPrecision
    under same estimand_and_model

StandardErrorDoesNotMeasureBias :=
    SmallSE ↛ UnbiasedEstimator

BiasPrecisionDistinction :=
    Bias concerns estimator centre
    whereas StandardError concerns estimator spread

MeanSquaredErrorRelation :=
    MSE(θ_hat)
    =
    Var(θ_hat)+Bias(θ_hat)²

FinitePopulationCorrection :=
    FPC=sqrt((N-n)/(N-1))

MeanSEWithoutReplacement :=
    SimpleRandomSamplingWithoutReplacement
    ⇒
    SE(X_bar)
    =
    σ/sqrt(n)
    × sqrt((N-n)/(N-1))

SampleProportion :=
    p_hat=X/n

ProportionVariance :=
    Var(p_hat)=p(1-p)/n

ProportionStandardError :=
    SE(p_hat)=sqrt(p(1-p)/n)

EstimatedProportionSE :=
    sqrt(p_hat(1-p_hat)/n)

DifferenceOfIndependentMeans :=
    D=X_bar1-X_bar2

DifferenceMeanVariance :=
    IndependentSamples
    ⇒
    Var(D)=σ1²/n1+σ2²/n2

DifferenceMeanStandardError :=
    SE(D)
    =
    sqrt(σ1²/n1+σ2²/n2)

EstimatedDifferenceMeanSE :=
    sqrt(S1²/n1+S2²/n2)

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

PooledMeanDifferenceSE :=
    S_p sqrt(1/n1+1/n2)

PairedData :=
    D_i=X_i-Y_i

PairedMeanStandardError :=
    SE(D_bar)=S_D/sqrt(n)

RegressionCoefficient :=
    β_hat_j

RegressionCoefficientSE :=
    SE(β_hat_j)
    =
    sqrt(EstimatedVarianceOfCoefficient_j)

LinearRegressionCovarianceMatrix :=
    Var(β_hat)
    =
    σ²(X^TX)^(-1)

EstimatedRegressionCovariance :=
    S_e²(X^TX)^(-1)

CoefficientTStatistic :=
    t
    =
    (β_hat_j-β_j0)
    /
    SE(β_hat_j)

FisherZTransformation :=
    z
    =
    0.5ln((1+r)/(1-r))

FisherZStandardError :=
    SE(z)≈1/sqrt(n-3)
    under bivariate-normal large-sample conditions

VarianceStandardError :=
    SamplingUncertaintyOfVarianceEstimator

NormalSampleVarianceSE :=
    X_i iid N(μ,σ²)
    ⇒
    SE(S²)
    =
    σ²sqrt(2/(n-1))

BootstrapStandardError :=
    SD(θ_hat*_1,...,θ_hat*_B)

BootstrapProcedure :=
    ObservedSample
    → DrawBootstrapSamples
    → ComputeEstimatorReplicates
    → ComputeReplicateStandardDeviation

JackknifeStandardError :=
    LeaveOneOutReplicates
    → EstimateSamplingVariability

AsymptoticStandardError :=
    DerivedFrom
    asymptotic variance
    of estimator

AsymptoticNormality :=
    sqrt(n)(θ_hat-θ)
    →
    N(0,V(θ))

AsymptoticSE :=
    sqrt(V_hat(θ)/n)

FisherInformation :=
    I(θ)

MLEAsymptoticVariance :=
    Var(θ_hat_MLE)
    ≈
    I_n(θ)^(-1)

MLEStandardError :=
    sqrt(
        diagonal(
            EstimatedInformationInverse
        )
    )

RobustStandardError :=
    sqrt(
        diagonal(
            SandwichVariance
        )
    )

HeteroscedasticityConsistentSE :=
    RegressionStandardError
    adjusted_for heteroscedasticity

ClusterRobustSE :=
    StandardError
    adjusted_for within-cluster dependence

SurveyStandardError :=
    StandardError
    accounting_for weights,
    stratification,
    clustering,
    and finite population
    as applicable

DesignEffect :=
    DEFF
    =
    VarianceComplexDesign
    /
    VarianceSimpleRandomReference

DesignAdjustedSE :=
    SE_complex
    ≈
    sqrt(DEFF)×SE_SRS

EffectiveSampleSize :=
    n_eff≈n/DEFF

WeightedMean :=
    μ_hat_w
    =
    Σ_iw_iX_i/Σ_iw_i

InverseVarianceWeight :=
    w_i=1/Var(θ_hat_i)

InverseVarianceWeightedEstimate :=
    θ_hat
    =
    Σ_iw_iθ_hat_i
    /
    Σ_iw_i

InverseVarianceWeightedSE :=
    sqrt(1/Σ_iw_i)
    under independent fixed-effect assumptions

ConfidenceIntervalRelation :=
    Estimate
    ±
    CriticalValue×StandardError

NormalApproximationCI :=
    θ_hat
    ±
    z_(1-α/2)SE(θ_hat)

TBasedCI :=
    θ_hat
    ±
    t_(1-α/2,ν)SE(θ_hat)

HypothesisTestRelation :=
    StandardisedStatistic
    =
    (Estimate-NullValue)
    /
    StandardError

ZStatistic :=
    z
    =
    (θ_hat-θ0)/SE(θ_hat)

TStatistic :=
    t
    =
    (θ_hat-θ0)/EstimatedSE(θ_hat)

StandardErrorAndSampleSize :=
    SE
    often decreases
    approximately as 1/sqrt(n)
    under regular iid settings

StandardErrorAndVariability :=
    GreaterPopulationVariability
    generally increases SE

StandardErrorAndDependence :=
    PositiveDependence
    may increase SE
    relative_to independence assumption

StandardErrorIsNotErrorMagnitude :=
    SE ≠ AbsoluteEstimationError

StandardErrorIsNotDataSpread :=
    SE ≠ StandardDeviationOfRawData

StandardErrorIsNotConfidenceInterval :=
    SE
    is component_of many confidence intervals
    but not itself an interval

StandardErrorConstraint :=
    ConstraintOn(
        Estimator,
        SamplingDesign,
        VarianceModel,
        DependenceStructure,
        SampleSize,
        Weighting
    )

StandardErrorConsistency :=
    Estimator
    ∧ SamplingDistribution
    ∧ VarianceEstimator
    ∧ Design
    ∧ DependenceAssumptions
    jointly_compatible

InvalidStandardError :=
    UndefinedEstimatorVariance
    ∨ NegativeVarianceEstimate
    ∨ IncorrectSampleSize
    ∨ IgnoredRequiredDesignStructure
    ∨ IncompatibleVarianceFormula
    ∨ InvalidWeightInterpretation

StandardErrorValidation :=
    ResolveEstimator
    → ResolveSamplingDesign
    → ResolveSamplingDistributionOrAsymptoticModel
    → ResolveVarianceEstimator
    → ResolveDependenceStructure
    → ResolveWeightsAndClusters
    → ComputeEstimatorVariance
    → ValidateNonnegativity
    → ComputeSquareRoot
    → ValidateUnits
    → ValidateResult

StandardErrorState := {
    Parameter,
    Estimator,
    Estimate,
    SamplingDesign,
    SamplingDistribution,
    VarianceEstimator,
    StandardErrorValue,
    SampleSize,
    Weights,
    ClusterStructure,
    MeasurementUnit,
    Evidence,
    Confidence,
    Provenance
}

SEMANTIC_EQUIVALENCE(StandardErrorA,StandardErrorB) :=
    same(Estimator)
    ∧ same(TargetParameter)
    ∧ same(SamplingDesign)
    ∧ same(VarianceModel)
    ∧ same(DependenceStructure)
    ∧ same(WeightingConvention)

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

CoreClasses := {
    StandardError,
    Estimator,
    SamplingDistribution,
    SamplingVariance,
    MeanStandardError,
    ProportionStandardError,
    RegressionCoefficientSE,
    BootstrapStandardError,
    RobustStandardError,
    ClusterRobustSE,
    SurveyStandardError,
    StandardDeviation,
    ConfidenceInterval,
    TestStatistic,
    Sample,
    Population,
    StandardErrorConstraint
}

CoreRelations := {
    computedFrom,
    measuresPrecisionOf,
    squareRootOf,
    dependsOn,
    estimates,
    usedBy,
    adjustedFor,
    derivedFrom,
    hasSampleSize,
    hasUnit,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    StandardError --measuresPrecisionOf--> Estimator
    StandardError --squareRootOf--> SamplingVariance
    StandardError --dependsOn--> SamplingDistribution
    EstimatedStandardError --estimates--> TrueStandardError
    ConfidenceInterval --usedBy--> StandardError
    TestStatistic --usedBy--> StandardError
    RobustStandardError --adjustedFor--> Heteroscedasticity
    ClusterRobustSE --adjustedFor--> ClusterDependence
    SurveyStandardError --adjustedFor--> SamplingDesign
    StandardError --hasSampleSize--> SampleSize
    StandardError --hasUnit--> MeasurementUnit
    StandardError --tracesTo--> Provenance

InferenceRules := {
    SamplingVariance(θ_hat)
        ⇒
        SE(θ_hat)=sqrt(Var(θ_hat)),

    IIDSample
        ∧ finite_variance
        ⇒
        SE(X_bar)=σ/sqrt(n),

    UnknownPopulationSD
        ⇒
        EstimatedSE(X_bar)=S/sqrt(n),

    BernoulliSample
        ⇒
        SE(p_hat)=sqrt(p(1-p)/n),

    IndependentSamples
        ⇒
        Var(X_bar1-X_bar2)
        =
        σ1²/n1+σ2²/n2,

    SE²=SamplingVariance,

    LargerN
        ∧ StableVarianceStructure
        ⇒
        SmallerSEApproximately,

    IgnoredDependence
        ⇒
        FlagStandardErrorRisk
}

CanonicalStandardErrorRepresentation :=
    ParseStandardErrorRequest
    → ResolveTargetParameter
    → ResolveEstimator
    → ResolveSampleAndDesign
    → ResolveSamplingDistribution
    → ResolveVarianceFormulaOrEstimator
    → ResolveWeightsClustersAndDependence
    → ComputeSamplingVariance
    → ComputeStandardError
    → ResolveConfidenceIntervalOrTestRelationIfRequired
    → ValidateStandardError

StandardErrorGraph :=
    G=(V,E)

V := {
    StandardErrors,
    Estimators,
    Parameters,
    SamplingDistributions,
    SamplingVariances,
    Samples,
    Populations,
    SampleSizes,
    Weights,
    Clusters,
    RobustVarianceEstimators,
    ConfidenceIntervals,
    TestStatistics,
    Evidence,
    ProvenanceNodes
}

E := {
    computedFrom,
    measuresPrecisionOf,
    squareRootOf,
    dependsOn,
    estimates,
    usedBy,
    adjustedFor,
    derivedFrom,
    hasSampleSize,
    hasUnit,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(StandardErrorResolution) :=
    weighted_mean(
        ParameterResolution,
        EstimatorResolution,
        SamplingDesignResolution,
        SamplingDistributionValidity,
        VarianceEstimatorValidity,
        DependenceStructureResolution,
        WeightingAndClusterValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectStandardErrorIntent
    → IdentifyEstimatorAndTargetParameter
    → ResolveSampleSizeAndSamplingDesign
    → IdentifyMeanProportionRegressionBootstrapOrOtherSE
    → ResolveVarianceDependenceWeightingAndClusterStructure

AI_REASONING_FLOW :=
    Query
    → ParseStandardErrorProblem
    → ResolveTargetParameter
    → ResolveEstimator
    → ResolveSampleAndSampleSize
    → ResolveSamplingDesign
    → ResolveSamplingDistributionOrAsymptoticModel
    → ResolveVarianceEstimator
    → ResolveDependenceWeightsAndClusters
    → ComputeSamplingVariance
    → ValidateVarianceNonnegativity
    → ComputeStandardError
    → ResolveConfidenceIntervalTestOrPowerRelationIfRequested
    → ValidateStandardErrorResult
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseStandardErrorEntities,
    ParseTypedRelations,
    ResolveParameters,
    ResolveEstimators,
    ResolveSamples,
    ResolveSampleSizes,
    ResolveSamplingDesigns,
    ResolveSamplingDistributions,
    ResolveVarianceEstimators,
    ResolveDependenceStructures,
    ResolveWeights,
    ResolveClusters,
    ComputeMeanStandardErrors,
    ComputeProportionStandardErrors,
    ComputeDifferenceStandardErrors,
    ComputeRegressionCoefficientSEs,
    ComputeBootstrapStandardErrors,
    ComputeJackknifeStandardErrors,
    ComputeRobustStandardErrors,
    ComputeClusterRobustStandardErrors,
    ComputeSurveyStandardErrors,
    ResolveConfidenceIntervalRelations,
    ResolveHypothesisTestRelations,
    ValidateStandardErrors,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewDataEstimatorDesignVarianceModelOrEvidence
    → ValidateInput
    → IdentifyAffectedStandardErrorClaims
    → UpdateStandardErrorState
    → RecomputeSamplingVariance
    → RecomputeStandardError
    → ReevaluateDependenceAndDesignAdjustments
    → RecomputeConfidenceIntervalsOrTestsIfRequired
    → RevalidateConstraints
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

SampleSizeUpdate :=
    ChangedSampleSize
    ⇒ recompute(
        SamplingVariance,
        StandardErrorValue
    )

VarianceModelUpdate :=
    ChangedVarianceEstimator
    ⇒ recompute(
        SamplingVariance,
        StandardErrorValue,
        ConfidenceInterval,
        TestStatistic
    )

DesignUpdate :=
    ChangedWeightsClustersOrSamplingDesign
    ⇒ reevaluate(
        DesignEffect,
        RobustVariance,
        StandardErrorValue
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        StandardError,
        StandardErrorValidation,
        StandardErrorConstraint,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    StandardErrorEntityResolution,
    TargetParameter,
    Estimator,
    Estimate,
    Sample,
    SampleSize,
    SamplingDesign,
    SamplingDistribution,
    VarianceEstimator,
    SamplingVariance,
    StandardErrorValue,
    Weights,
    ClusterStructure,
    MeasurementUnit,
    ConfidenceIntervalRelation,
    TestStatisticRelation,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA