Median Ontology

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

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

BEGIN_FLOW

Median :=
    MeasureOfCentralTendency
    ∧ OrderStatisticSummary
    ∧ PositionalStatistic
    ∧ RobustLocationMeasure

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

SampleSize :=
    n

OrderedDataset :=
    x_(1)≤x_(2)≤...≤x_(n)

OrderStatistic :=
    x_(k)
    =
    kth smallest observed value

SampleMedian :=
    Median(Dataset)

OddSampleMedian :=
    n odd
    ⇒
    Median
    =
    x_((n+1)/2)

EvenSampleMedian :=
    n even
    ⇒
    Median
    =
    [
        x_(n/2)
        +
        x_(n/2+1)
    ]/2
    under common numerical convention

EvenOrdinalMedian :=
    n even
    ∧ ordinal semantics
    ⇒
    MedianIntervalOrConvention
    must be explicitly defined

PopulationMedian :=
    m
    satisfying
    P(X≤m)≥1/2
    ∧
    P(X≥m)≥1/2

ContinuousUniqueMedian :=
    F(m)=1/2
    when continuous strictly increasing CDF
    around median

MedianAsQuantile :=
    Median
    =
    Q(0.5)

SecondQuartile :=
    Q2
    =
    Median

FiftiethPercentile :=
    P50
    =
    Median

MedianPosition :=
    50PercentCumulativePosition

LowerHalf :=
    Observations
    below_or_at Median
    under selected partition convention

UpperHalf :=
    Observations
    above_or_at Median
    under selected partition convention

BalanceByCount :=
    Median
    divides ordered data
    into approximately equal counts

AbsoluteDeviationObjective :=
    Median
    ∈
    argmin_c
    Σ_i|x_i-c|

L1Optimality :=
    Median
    minimises
    sum_of_absolute_deviations

MeanComparison :=
    Mean
    minimises squared deviations
    whereas
    Median
    minimises absolute deviations

Robustness :=
    Median
    resistant_to
    extreme values

BreakdownPoint :=
    SampleMedian
    has high finite-sample robustness
    relative_to arithmetic mean

OutlierSensitivity :=
    ExtremeMagnitude
    has limited direct influence
    on Median
    unless ordering crosses central positions

TranslationEquivariance :=
    Median(X+c)
    =
    Median(X)+c

PositiveScalingEquivariance :=
    a>0
    ⇒
    Median(aX)
    =
    aMedian(X)

AffineEquivariance :=
    a≠0
    ⇒
    Median(aX+b)
    =
    aMedian(X)+b
    with quantile convention handled consistently

MonotonicTransformation :=
    g strictly increasing
    ⇒
    Median(g(X))
    =
    g(Median(X))
    under compatible median definition

DecreasingTransformation :=
    g strictly decreasing
    ⇒
    Median relation
    follows reversed quantile ordering
    under compatible convention

WeightedMedian :=
    Value m
    where cumulative weight
    reaches at least
    half total weight

WeightConstraint :=
    w_i≥0
    ∧ Σ_iw_i>0

WeightedMedianProcedure :=
    SortByValue
    → AccumulateWeights
    → FindHalfWeightPosition

FrequencyMedian :=
    Values
    with frequencies
    → WeightedMedian
    using frequencies as weights

GroupedDataMedian :=
    EstimatedMedian
    from cumulative frequencies
    and median class
    under interpolation convention

MedianClass :=
    ClassInterval
    containing
    cumulative position n/2

GroupedMedianApproximation :=
    L
    +
    [
        (n/2-CF_prev)/f_m
    ]h
    under standard grouped-data notation

MedianAbsoluteDeviation :=
    MAD
    =
    Median(
        |X_i-Median(X)|
    )

RobustScaleRelation :=
    Median
    ∧ MAD
    → RobustLocationScaleSummary

InterquartileRangeRelation :=
    Median
    lies_between
    Q1 and Q3

FiveNumberSummary := {
    Minimum,
    Q1,
    Median,
    Q3,
    Maximum
}

BoxPlotRelation :=
    Median
    represented_as
    central line
    within box

SymmetricDistributionRelation :=
    For symmetric distribution
    with unique centre:
        Median=CentreOfSymmetry

MeanMedianSymmetryRelation :=
    SymmetricDistribution
    with finite mean
    and unique centre
    ⇒
    Mean=Median=Centre
    when mean exists

SkewnessRelation :=
    DifferenceBetweenMeanAndMedian
    may indicate asymmetry
    but is not a complete skewness measure

PositiveSkewTypicalPattern :=
    Mean>Median
    often occurs
    in right-skewed distributions
    but not universal theorem

NegativeSkewTypicalPattern :=
    Mean<Median
    often occurs
    in left-skewed distributions
    but not universal theorem

SampleMedianEstimator :=
    SampleMedian
    estimates
    PopulationMedian

MedianConsistency :=
    SampleMedian
    → PopulationMedian
    under regularity conditions

AsymptoticMedianDistribution :=
    For iid continuous distribution
    with density f(m)>0:
        sqrt(n)(Median_n-m)
        → N(
            0,
            1/[4f(m)^2]
        )

ApproximateMedianVariance :=
    1/
    [
        4n f(m)^2
    ]
    under asymptotic conditions

NormalDistributionMedian :=
    X~N(μ,σ²)
    ⇒
    Median(X)=μ

UniformDistributionMedian :=
    X~Uniform(a,b)
    ⇒
    Median(X)
    =
    (a+b)/2

ExponentialDistributionMedian :=
    X~Exponential(λ)
    ⇒
    Median(X)
    =
    ln2/λ

LogisticDistributionMedian :=
    X~Logistic(μ,s)
    ⇒
    Median(X)=μ

CauchyDistributionMedian :=
    X~Cauchy(x0,γ)
    ⇒
    Median(X)=x0

WeibullDistributionMedian :=
    X~Weibull(k,λ)
    ⇒
    Median(X)
    =
    λ(ln2)^(1/k)

BetaDistributionMedian :=
    GenerallyRequires
    numerical quantile evaluation
    except special cases

DiscreteDistributionMedian :=
    Any m satisfying
    P(X≤m)≥1/2
    ∧ P(X≥m)≥1/2

NonUniqueMedian :=
    Distribution
    may admit
    interval_or_set of medians

MedianSet :=
    {
        m:
        P(X≤m)≥1/2
        ∧
        P(X≥m)≥1/2
    }

BinaryVariableMedian :=
    DependsOn
    proportion of zeros_and_ones
    and median convention

OrdinalVariableMedian :=
    Meaningful
    because category order exists

NominalVariableMedian :=
    UndefinedOrSemanticallyInvalid
    because no intrinsic ordering

QuantitativeVariableMedian :=
    Valid
    when values are orderable

MissingDataMedian :=
    Median
    computed_from
    selected observed values
    under explicit missingness rule

MissingnessConstraint :=
    MedianResult
    must record
    effective observation set

MissingCodeRisk :=
    NumericMissingCode
    treated_as substantive value
    ⇒
    InvalidMedianRisk

MedianUnit :=
    SameMeasurementUnit
    as original variable
    for ordinary numeric median

MedianOfRatios :=
    NotGenerallyEqual
    to
    RatioOfMedians

MedianOfSums :=
    NotGenerallyEqual
    to
    SumOfMedians

MedianNonlinearity :=
    Median(X+Y)
    ≠
    Median(X)+Median(Y)
    in general

MedianAggregation :=
    MedianOfGroupMedians
    generally
    ≠
    OverallMedian

CombinedMedian :=
    Requires
    pooled order information
    or sufficient distributional information

RunningMedian :=
    Median
    updated_as
    observations arrive

OnlineMedian :=
    Requires
    data structure
    preserving lower_and_upper order partitions

SlidingWindowMedian :=
    Median
    over moving observation window

MedianFilter :=
    ReplaceValue
    with local-window median
    for robust signal_or_image smoothing

RobustStatisticsRelation :=
    Median
    commonly used
    where heavy tails,
    skewness,
    or outliers
    reduce usefulness of mean

MedianRegression :=
    QuantileRegression
    at τ=0.5

QuantileRegressionObjective :=
    τ=0.5
    ⇒
    MinimiseAbsoluteLoss

ConditionalMedian :=
    m(x)
    satisfying
    P(Y≤m(x)|X=x)≥1/2
    ∧
    P(Y≥m(x)|X=x)≥1/2

MedianConstraint :=
    ConstraintOn(
        Orderability,
        SampleSize,
        MedianConvention,
        Missingness,
        Weights,
        MeasurementSemantics
    )

MedianConsistencyState :=
    OrderedValues
    ∧ MedianPosition
    ∧ Convention
    ∧ MissingnessRule
    ∧ WeightingRule
    jointly_compatible

InvalidMedian :=
    EmptyEffectiveDataset
    ∨ NonOrderableNominalValues
    ∨ InvalidWeights
    ∨ UndocumentedEvenSampleConvention
    ∨ UndocumentedMissingnessTreatment

MedianValidation :=
    ResolveVariable
    → ResolveVariableType
    → ValidateOrderability
    → ResolveObservations
    → ResolveMissingness
    → ResolveWeights
    → SortOrResolveOrderStatistics
    → SelectMedianConvention
    → ComputeMedian
    → ValidateResult

MedianState := {
    Variable,
    Observations,
    EffectiveCount,
    OrderedValues,
    MedianConvention,
    Weights,
    MissingnessRule,
    MedianValue,
    PopulationOrSampleContext,
    Evidence,
    Confidence,
    Provenance
}

SEMANTIC_EQUIVALENCE(MedianA,MedianB) :=
    same(DataScope)
    ∧ same(VariableSemantics)
    ∧ same(Ordering)
    ∧ same(MedianConvention)
    ∧ same(WeightingRule)
    ∧ same(MissingnessRule)

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

CoreClasses := {
    Median,
    SampleMedian,
    PopulationMedian,
    WeightedMedian,
    GroupedMedian,
    ConditionalMedian,
    MedianAbsoluteDeviation,
    Quantile,
    OrderStatistic,
    StatisticalVariable,
    StatisticalObservation,
    Dataset,
    Sample,
    Population,
    MedianConstraint
}

CoreRelations := {
    computedFrom,
    summarises,
    estimates,
    equalsQuantile,
    hasOrderPosition,
    hasWeight,
    minimises,
    conditionedOn,
    derivedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    Median --computedFrom--> OrderedObservations
    Median --summarises--> StatisticalVariable
    SampleMedian --estimates--> PopulationMedian
    Median --equalsQuantile--> Quantile0_5
    Median --hasOrderPosition--> CentralPosition
    WeightedMedian --hasWeight--> Weight
    Median --minimises--> AbsoluteDeviationLoss
    ConditionalMedian --conditionedOn--> VariableOrInformation
    MedianAbsoluteDeviation --derivedFrom--> Median
    Median --tracesTo--> Provenance

InferenceRules := {
    OddCount(n)
        ⇒
        Median=x_((n+1)/2),

    EvenCount(n)
        ∧ NumericConvention
        ⇒
        Median=
        [x_(n/2)+x_(n/2+1)]/2,

    Median
        ⇒
        Quantile(0.5),

    Median
        ⇒
        MinimisesSumAbsoluteDeviations,

    OrdinalVariable
        ⇒
        MedianEligible,

    NominalVariable
        ⇒
        FlagMedianAsSemanticallyInvalid,

    StrictlyIncreasing(g)
        ⇒
        Median(g(X))
        =
        g(Median(X))
        under compatible convention,

    OutlierMagnitudeIncrease
        ↛
        NecessarilyChangeMedian
}

CanonicalMedianRepresentation :=
    ParseMedianRequest
    → ResolveVariable
    → ResolveDataScope
    → ResolveVariableTypeAndOrdering
    → ResolveObservations
    → ResolveMissingness
    → ResolveWeights
    → ResolveMedianConvention
    → ComputeOrderStatistics
    → ComputeMedian
    → ResolvePopulationOrSamplingRelationIfRequired
    → ValidateMedian

MedianGraph :=
    G=(V,E)

V := {
    Medians,
    SampleMedians,
    PopulationMedians,
    WeightedMedians,
    ConditionalMedians,
    Quantiles,
    OrderStatistics,
    Variables,
    Observations,
    Datasets,
    Samples,
    Populations,
    Weights,
    Evidence,
    ProvenanceNodes
}

E := {
    computedFrom,
    summarises,
    estimates,
    equalsQuantile,
    hasOrderPosition,
    hasWeight,
    minimises,
    conditionedOn,
    derivedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(MedianResolution) :=
    weighted_mean(
        VariableResolution,
        DataScopeResolution,
        OrderingValidity,
        MedianConventionResolution,
        MissingnessHandling,
        WeightingValidity,
        CalculationValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectMedianIntent
    → IdentifyVariableAndDataScope
    → ResolveOrderingAndVariableType
    → IdentifyWeightedGroupedConditionalOrOrdinaryMedian
    → ResolveMissingnessAndConvention

AI_REASONING_FLOW :=
    Query
    → ParseMedianProblem
    → ResolveDatasetSampleOrPopulation
    → ResolveVariable
    → ValidateOrderability
    → ResolveObservations
    → ResolveMissingValues
    → ResolveWeightsIfPresent
    → SortObservationsOrResolveCumulativeWeights
    → SelectMedianConvention
    → ComputeMedian
    → ComputeRelatedQuantileOrMADIfRequested
    → ResolveSamplingPropertiesIfRequested
    → ValidateMedianResult
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseMedianEntities,
    ParseTypedRelations,
    ResolveVariables,
    ResolveObservations,
    ResolveDatasets,
    ResolveSamples,
    ResolvePopulations,
    ValidateVariableOrdering,
    ResolveMissingness,
    ResolveWeights,
    ComputeOrderStatistics,
    ComputeSampleMedians,
    ComputePopulationMedians,
    ComputeWeightedMedians,
    ComputeGroupedMedians,
    ComputeConditionalMedians,
    ComputeMedianAbsoluteDeviations,
    ResolveQuantileRelations,
    ResolveAsymptoticMedianProperties,
    ValidateMedianSemantics,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewObservationWeightConventionOrScope
    → ValidateInput
    → IdentifyAffectedMedianClaims
    → UpdateMedianState
    → RecomputeEffectiveObservationSet
    → RecomputeOrdering
    → RecomputeMedian
    → RecomputeRelatedRobustStatistics
    → RevalidateConstraints
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ObservationUpdate :=
    AddedRemovedOrCorrectedObservation
    ⇒ recompute(
        EffectiveCount,
        OrderStatistics,
        MedianValue
    )

WeightUpdate :=
    ChangedWeight
    ⇒ recompute(
        CumulativeWeights,
        WeightedMedian
    )

ConventionUpdate :=
    ChangedEvenSampleOrQuantileConvention
    ⇒ recompute(
        MedianValue,
        SemanticEquivalence
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        Median,
        MedianValidation,
        MedianConstraint,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    MedianEntityResolution,
    Variable,
    DataScope,
    VariableType,
    Ordering,
    ObservationCount,
    EffectiveObservationCount,
    MedianConvention,
    Weights,
    MissingnessRule,
    MedianValue,
    QuantileRelation,
    RobustnessRelation,
    SamplingProperties,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA