Mean Ontology

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

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

BEGIN_FLOW

Mean :=
    MeasureOfCentralTendency
    ∧ NumericalSummary
    ∧ AggregateStatistic

ArithmeticMean :=
    SumOfValues
    /
    NumberOfValues

Dataset :=
    {x_1,x_2,...,x_n}

SampleSize :=
    n

SampleMean :=
    X_bar
    =
    (1/n)
    Σ_{i=1..n}x_i

Population :=
    {x_1,x_2,...,x_N}

PopulationSize :=
    N

FinitePopulationMean :=
    μ
    =
    (1/N)
    Σ_{i=1..N}x_i

RandomVariableMean :=
    μ
    =
    E[X]

DiscreteExpectation :=
    E[X]
    =
    Σ_x
    xP(X=x)
    when expectation exists

ContinuousExpectation :=
    E[X]
    =
    Integral_{-∞}^{∞}
    x f_X(x)dx
    when expectation exists

ExpectationExistence :=
    E[|X|]<∞
    ⇒
    E[X] exists finitely

MeanAsBalancePoint :=
    Σ_i
    (x_i-X_bar)
    =
    0

ZeroDeviationProperty :=
    Σ_i(x_i-X_bar)=0

LeastSquaresProperty :=
    X_bar
    =
    argmin_c
    Σ_i(x_i-c)^2

TranslationProperty :=
    Mean(X+c)
    =
    Mean(X)+c

ScalingProperty :=
    Mean(aX)
    =
    aMean(X)

AffineProperty :=
    Mean(aX+b)
    =
    aMean(X)+b

LinearityOfExpectation :=
    E[aX+bY]
    =
    aE[X]+bE[Y]
    when expectations exist

MeanOfSum :=
    E[
        Σ_iX_i
    ]
    =
    Σ_iE[X_i]

IndependenceNotRequiredForLinearity :=
    LinearityOfExpectation
    does_not_require
    independence

CombinedMean :=
    Groups
    with sizes n_j
    and means μ_j
    ⇒
    OverallMean
    =
    Σ_jn_jμ_j
    /
    Σ_jn_j

WeightedMean :=
    X_bar_w
    =
    Σ_iw_ix_i
    /
    Σ_iw_i

WeightConstraint :=
    Σ_iw_i
    ≠
    0

PositiveWeightedMean :=
    w_i≥0
    ∧ Σ_iw_i>0

NormalisedWeights :=
    w_i*
    =
    w_i/Σ_jw_j

WeightedMeanEquivalent :=
    X_bar_w
    =
    Σ_iw_i*x_i

FrequencyWeightedMean :=
    DistinctValues x_j
    with frequencies f_j
    ⇒
    Mean
    =
    Σ_jf_jx_j
    /
    Σ_jf_j

GroupedDataMean :=
    ClassMidpoints m_j
    ∧ Frequencies f_j
    ⇒
    ApproximateMean
    =
    Σ_jf_jm_j
    /
    Σ_jf_j

GeometricMean :=
    G
    =
    (
        Π_i x_i
    )^(1/n)
    for x_i>0

LogGeometricMean :=
    logG
    =
    (1/n)
    Σ_i logx_i

HarmonicMean :=
    H
    =
    n
    /
    Σ_i(1/x_i)
    where x_i≠0
    and domain assumptions hold

QuadraticMean :=
    RMS
    =
    sqrt(
        (1/n)
        Σ_ix_i²
    )

RootMeanSquare :=
    QuadraticMean

PowerMean :=
    M_p
    =
    [
        (1/n)
        Σ_i x_i^p
    ]^(1/p)
    under valid domain

PowerMeanLimitZero :=
    p→0
    ⇒
    M_p→GeometricMean
    for positive values

ArithmeticMeanAsPowerMean :=
    p=1
    ⇒
    M_p=ArithmeticMean

HarmonicMeanAsPowerMean :=
    p=-1
    ⇒
    M_p=HarmonicMean

QuadraticMeanAsPowerMean :=
    p=2
    ⇒
    M_p=RMS

MeanInequality :=
    For positive values:
    HarmonicMean
    ≤ GeometricMean
    ≤ ArithmeticMean
    ≤ QuadraticMean

TrimmedMean :=
    Mean
    after removing
    specified proportion
    from lower_and_upper tails

WinsorisedMean :=
    Mean
    after replacing
    extreme observations
    with selected boundary values

RobustMeanAlternative :=
    TrimmedMean
    ∨ WinsorisedMean

MeanSensitivity :=
    ArithmeticMean
    sensitive_to
    extreme values

OutlierInfluence :=
    ExtremeValue
    may substantially alter
    ArithmeticMean

MedianComparison :=
    Mean
    and Median
    describe different aspects
    of distribution centre

SymmetricDistributionRelation :=
    For many symmetric distributions
    with existing expectation:
        Mean≈Median
    and in exactly symmetric integrable distributions:
        Mean=CentreOfSymmetry

SkewedDistributionRelation :=
    Mean
    may be pulled
    toward longer tail

SampleMeanEstimator :=
    X_bar
    estimates
    PopulationMean μ

UnbiasedSampleMean :=
    E[X_bar]
    =
    μ
    under identically distributed observations
    with finite mean

VarianceOfSampleMean :=
    IIDSample
    with variance σ²
    ⇒
    Var(X_bar)
    =
    σ²/n

StandardErrorOfMean :=
    SEM
    =
    σ/√n

EstimatedStandardError :=
    S/√n

FinitePopulationCorrection :=
    SamplingWithoutReplacement
    from finite population
    ⇒
    SEM_FPC
    =
    σ/√n
    ×
    sqrt(
        (N-n)/(N-1)
    )
    under simple random sampling

LawOfLargeNumbersRelation :=
    X_bar
    → μ
    under theorem conditions

CentralLimitTheoremRelation :=
    sqrt(n)
    (
        X_bar-μ
    )
    /
    σ
    → N(0,1)
    under CLT conditions

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

MeanConfidenceInference :=
    SampleMean
    ∧ StandardError
    ∧ ReferenceDistribution
    → ConfidenceIntervalForMean

KnownVarianceMeanInterval :=
    X_bar
    ±
    z_(1-α/2)
    σ/√n
    under applicable assumptions

UnknownVarianceNormalMeanInterval :=
    X_bar
    ±
    t_(1-α/2,n-1)
    S/√n
    under normal iid assumptions

MeanDifference :=
    Δ
    =
    Mean(X)-Mean(Y)

DifferenceOfSampleMeans :=
    X_bar-Y_bar

PairedMeanDifference :=
    Mean(
        X_i-Y_i
    )

GrandMean :=
    Mean
    across all observations
    or weighted group means

ConditionalMean :=
    E[Y|X=x]

ConditionalExpectation :=
    Function
    mapping conditioning information
    to expected value

RegressionMeanFunction :=
    μ(x)
    =
    E[Y|X=x]

MeanVector :=
    μ
    =
    E[X]
    for random vector X

ComponentwiseMean :=
    μ_j
    =
    E[X_j]

RunningMean :=
    M_n
    =
    M_(n-1)
    +
    (x_n-M_(n-1))/n

OnlineMeanUpdate :=
    PreviousMean
    ∧ PreviousCount
    ∧ NewValue
    → UpdatedMean

BatchMeanUpdate :=
    GroupA(n_A,μ_A)
    ∧ GroupB(n_B,μ_B)
    ⇒
    CombinedMean
    =
    (n_Aμ_A+n_Bμ_B)/(n_A+n_B)

MissingDataMean :=
    Mean
    computed_over
    selected observed values
    under explicit missingness rule

CompleteCaseMean :=
    Mean
    over nonmissing observations
    for target variable

MissingnessConstraint :=
    MeanResult
    must record
    denominator_and_missingness treatment

NaiveMissingValueCodingRisk :=
    NumericMissingCode
    treated_as substantive value
    ⇒
    InvalidMeanRisk

UnitConstraint :=
    Values
    must have
    compatible measurement units

MeanUnit :=
    SameMeasurementUnit
    as input variable
    for arithmetic mean

MeasurementScaleConstraint :=
    ArithmeticMean
    generally requires
    quantitative interval_or_ratio semantics
    for meaningful interpretation

NominalMeanInvalid :=
    NominalVariable
    ⇒
    ArithmeticMeanNotMeaningful

OrdinalMeanCaution :=
    OrdinalVariable
    ⇒
    ArithmeticMeanInterpretation
    depends_on coding_and_scale assumptions

MeanOfBinaryVariable :=
    X∈{0,1}
    ⇒
    Mean(X)
    =
    ProportionOfOnes

BernoulliMean :=
    X~Bernoulli(p)
    ⇒
    E[X]=p

BinomialMean :=
    X~Binomial(n,p)
    ⇒
    E[X]=np

PoissonMean :=
    X~Poisson(λ)
    ⇒
    E[X]=λ

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

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

GammaMean :=
    X~Gamma(α,β)
    under shape-rate parameterisation
    ⇒
    E[X]=α/β

BetaMean :=
    X~Beta(α,β)
    ⇒
    E[X]=α/(α+β)

CauchyMean :=
    X~Cauchy(x0,γ)
    ⇒
    OrdinaryMeanUndefined

UndefinedMean :=
    Distribution
    may not possess
    finite expectation

MeanExistenceValidation :=
    RandomVariable
    → CheckExpectationExistence
    → ComputeMeanOnlyIfDefined

MeanConstraint :=
    ConstraintOn(
        DataType,
        MeasurementScale,
        Units,
        Missingness,
        Weights,
        ExpectationExistence
    )

MeanConsistency :=
    InputValues
    ∧ Count
    ∧ WeightingRule
    ∧ MissingnessRule
    ∧ MeasurementSemantics
    jointly_compatible

InvalidMean :=
    EmptyEffectiveDataset
    ∨ IncompatibleUnits
    ∨ InvalidWeights
    ∨ NominalArithmeticMean
    ∨ UndocumentedMissingness
    ∨ UndefinedExpectationClaim

MeanValidation :=
    ResolveVariable
    → ResolveVariableType
    → ResolveMeasurementScale
    → ResolveUnits
    → ResolveObservations
    → ResolveMissingness
    → ResolveWeights
    → SelectMeanType
    → ValidateDomain
    → ComputeMean
    → ValidateResult

MeanState := {
    Variable,
    Observations,
    Count,
    MeanType,
    Weights,
    MissingnessRule,
    MeasurementUnit,
    MeanValue,
    SamplingContext,
    Evidence,
    Confidence,
    Provenance
}

SEMANTIC_EQUIVALENCE(MeanA,MeanB) :=
    same(DataScope)
    ∧ same(VariableSemantics)
    ∧ same(MeanDefinition)
    ∧ same(WeightingRule)
    ∧ same(MissingnessRule)

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

CoreClasses := {
    Mean,
    ArithmeticMean,
    SampleMean,
    PopulationMean,
    WeightedMean,
    GeometricMean,
    HarmonicMean,
    QuadraticMean,
    TrimmedMean,
    WinsorisedMean,
    ConditionalMean,
    MeanVector,
    StatisticalVariable,
    StatisticalObservation,
    Population,
    Sample,
    MeanConstraint
}

CoreRelations := {
    computedFrom,
    summarises,
    estimates,
    hasWeight,
    hasCount,
    hasUnit,
    conditionedOn,
    transformedBy,
    combinedFrom,
    distributedAs,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    ArithmeticMean --computedFrom--> Observations
    Mean --summarises--> StatisticalVariable
    SampleMean --estimates--> PopulationMean
    WeightedMean --hasWeight--> Weight
    Mean --hasCount--> ObservationCount
    Mean --hasUnit--> MeasurementUnit
    ConditionalMean --conditionedOn--> VariableOrInformation
    Mean --transformedBy--> AffineTransformation
    CombinedMean --combinedFrom--> GroupMeans
    SampleMean --distributedAs--> SamplingDistribution
    Mean --tracesTo--> Provenance

InferenceRules := {
    Values(x_1,...,x_n)
        ∧ n>0
        ⇒
        ArithmeticMean
        =
        Σ_ix_i/n,

    WeightedValues(x_i,w_i)
        ∧ Σ_iw_i≠0
        ⇒
        WeightedMean
        =
        Σ_iw_ix_i/Σ_iw_i,

    ArithmeticMean(X)
        ⇒
        Σ_i(x_i-X_bar)=0,

    Mean(X+c)
        =
        Mean(X)+c,

    Mean(aX)
        =
        aMean(X),

    BinaryVariable(X)
        ∧ Coding(X)={0,1}
        ⇒
        Mean(X)=ProportionOfOnes,

    IIDSample
        ∧ finite_variance
        ⇒
        Var(X_bar)=σ²/n,

    NominalVariable
        ⇒
        FlagArithmeticMeanAsSemanticallyInvalid,

    UndefinedExpectation
        ⇒
        FlagMeanAsUndefined
}

CanonicalMeanRepresentation :=
    ParseMeanRequest
    → ResolveVariable
    → ResolveDataScope
    → ResolveMeanType
    → ResolveMeasurementScale
    → ResolveUnits
    → ResolveObservations
    → ResolveWeightsAndMissingness
    → ValidateDomain
    → ComputeMean
    → ResolveSamplingRelationIfRequired
    → ValidateMean

MeanGraph :=
    G=(V,E)

V := {
    Means,
    ArithmeticMeans,
    SampleMeans,
    PopulationMeans,
    WeightedMeans,
    GeometricMeans,
    HarmonicMeans,
    TrimmedMeans,
    ConditionalMeans,
    Variables,
    Observations,
    Samples,
    Populations,
    Weights,
    Units,
    Evidence,
    ProvenanceNodes
}

E := {
    computedFrom,
    summarises,
    estimates,
    hasWeight,
    hasCount,
    hasUnit,
    conditionedOn,
    transformedBy,
    combinedFrom,
    distributedAs,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(MeanResolution) :=
    weighted_mean(
        VariableResolution,
        DataScopeResolution,
        MeanTypeResolution,
        MeasurementScaleValidity,
        UnitCompatibility,
        MissingnessHandling,
        WeightingValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectMeanIntent
    → IdentifyVariableAndDataScope
    → IdentifyArithmeticWeightedGeometricHarmonicOrOtherMean
    → ResolveWeightsMissingnessAndUnits
    → IdentifyDescriptiveOrInferentialContext

AI_REASONING_FLOW :=
    Query
    → ParseMeanProblem
    → ResolveDatasetSampleOrPopulation
    → ResolveVariable
    → ResolveVariableTypeAndMeasurementScale
    → ResolveObservations
    → ResolveMeasurementUnits
    → ResolveMissingness
    → ResolveWeights
    → SelectMeanDefinition
    → ValidateMeanDomain
    → ComputeMean
    → ResolveStandardErrorOrSamplingDistributionIfRequested
    → CompareWithOtherCentreMeasuresIfRequested
    → ValidateMeanResult
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseMeanEntities,
    ParseTypedRelations,
    ResolveVariables,
    ResolveObservations,
    ResolveSamples,
    ResolvePopulations,
    ResolveMeasurementScales,
    ResolveMeasurementUnits,
    ResolveWeights,
    ResolveMissingness,
    ComputeArithmeticMeans,
    ComputeWeightedMeans,
    ComputeGeometricMeans,
    ComputeHarmonicMeans,
    ComputeQuadraticMeans,
    ComputeTrimmedMeans,
    ComputeCombinedMeans,
    ComputeConditionalMeans,
    ResolvePopulationMeans,
    ResolveSampleMeanSamplingDistributions,
    ComputeStandardErrors,
    ValidateExpectationExistence,
    ValidateMeanSemantics,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewObservationWeightDefinitionOrScope
    → ValidateInput
    → IdentifyAffectedMeanClaims
    → UpdateMeanState
    → RecomputeEffectiveObservationSet
    → RecomputeMean
    → RecomputeSamplingPropertiesIfRequired
    → RevalidateConstraints
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ObservationUpdate :=
    AddedRemovedOrCorrectedObservation
    ⇒ recompute(
        Count,
        MeanValue,
        SamplingStatistics
    )

WeightUpdate :=
    ChangedWeight
    ⇒ recompute(
        WeightedMean,
        EffectiveWeightTotal
    )

DefinitionUpdate :=
    ChangedMeanTypeOrMissingnessRule
    ⇒ reevaluate(
        EligibleObservations,
        MeanValue,
        SemanticInterpretation
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        ArithmeticMean,
        MeanValidation,
        MeanConstraint,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    MeanEntityResolution,
    Variable,
    DataScope,
    MeanType,
    ObservationCount,
    EffectiveObservationCount,
    Weights,
    MissingnessRule,
    MeasurementScale,
    MeasurementUnit,
    MeanValue,
    SamplingDistribution,
    StandardError,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA