Range Ontology

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

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

BEGIN_FLOW

StatisticalRange :=
    MeasureOfDispersion
    ∧ ExtremeValueDifference
    ∧ MaximumMinusMinimum

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

SampleSize :=
    n

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

Minimum :=
    min_i x_i
    =
    x_(1)

Maximum :=
    max_i x_i
    =
    x_(n)

Range :=
    R
    =
    Maximum-Minimum

SampleRange :=
    R_n
    =
    X_(n)-X_(1)

PopulationRange :=
    SupremumOfSupport
    -
    InfimumOfSupport
    when finite

FinitePopulationRange :=
    max_iX_i
    -
    min_iX_i

RangeNonnegativity :=
    R≥0

ZeroRange :=
    R=0
    iff
    all observed values equal
    for nonempty finite dataset

PositiveRange :=
    AtLeastTwoDistinctValues
    ⇒
    R>0

RangeUnit :=
    SameMeasurementUnit
    as source quantitative variable

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

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

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

MonotonicTransformation :=
    For strictly increasing g:
        Range(g(X))
        =
        g(Max(X))-g(Min(X))

RangeDependsOnlyOnExtremes :=
    InteriorObservations
    do_not affect Range
    if MinimumAndMaximum unchanged

ExtremeSensitivity :=
    Range
    highly sensitive_to
    extreme observations

OutlierInfluence :=
    NewExtremeObservation
    may substantially increase Range

Robustness :=
    Range
    is nonrobust
    as dispersion measure

BreakdownBehaviour :=
    SingleExtremeContamination
    can make Range
    arbitrarily large
    for unbounded measurement domain

RangeVsIQR :=
    Range
    uses extreme values
    whereas
    IQR
    uses central 50 percent

RangeVsVariance :=
    Range
    uses only minimum_and_maximum
    whereas
    Variance
    uses all observations

RangeVsStandardDeviation :=
    Range
    measures total observed span
    whereas
    StandardDeviation
    measures typical deviation
    from mean

Midrange :=
    M
    =
    (Maximum+Minimum)/2

HalfRange :=
    H
    =
    Range/2

MidrangeRelation :=
    Minimum
    =
    Midrange-HalfRange
    ∧
    Maximum
    =
    Midrange+HalfRange

IntervalRepresentation :=
    ObservedDataSupportInterval
    =
    [Minimum,Maximum]

ObservedSpan :=
    Length(
        [Minimum,Maximum]
    )
    =
    Range

OrderStatisticRelation :=
    Range
    =
    X_(n)-X_(1)

MinimumOrderStatistic :=
    X_(1)

MaximumOrderStatistic :=
    X_(n)

RandomSample :=
    X_1,...,X_n
    iid from Distribution F

SampleRangeDistribution :=
    DistributionOf(
        X_(n)-X_(1)
    )

JointExtremeDistribution :=
    JointDistribution
    of
    Minimum
    and Maximum

ContinuousIIDJointExtremeDensity :=
    f_(min,max)(u,v)
    =
    n(n-1)
    [F(v)-F(u)]^(n-2)
    f(u)f(v)
    for u<v
    under regular continuous iid conditions

RangeDistributionDerivation :=
    JointExtremeDistribution
    → Transform(v-u)
    → SampleRangeDistribution

ExpectedSampleRange :=
    E[R_n]
    depends_on
    ParentDistribution
    and SampleSize

SampleSizeEffect :=
    LargerSampleSize
    generally increases
    expected observed range
    for many nondegenerate distributions

BoundedSupportRelation :=
    ParentSupport=[a,b]
    ⇒
    SampleRange≤b-a

UnboundedSupportRelation :=
    ParentDistribution
    unbounded
    ⇒
    SampleRange
    can grow with n

UniformDistributionRelation :=
    X_i iid Uniform(a,b)
    ⇒
    R_n/(b-a)
    has distribution
    determined_by sample size

UniformExpectedRange :=
    E[R_n]
    =
    (b-a)
    (n-1)/(n+1)
    for iid Uniform(a,b)

NormalDistributionRelation :=
    NormalSampleRange
    has no simple elementary distribution
    and depends_on n and σ

RangeRuleOfThumb :=
    StandardDeviation
    sometimes approximated
    from Range/d_n
    using sample-size-specific constants
    under normality assumptions

ProcessControlRange :=
    SubgroupRange
    used_in
    RCharts

RChart :=
    TimeOrderedSubgroupRanges
    → ProcessDispersionMonitoring

AverageRange :=
    R_bar
    =
    (1/k)
    Σ_jR_j

RangeControlLimits :=
    FunctionsOf(
        R_bar,
        SubgroupSize,
        ControlChartConstants
    )

MeasurementRange :=
    InstrumentOrVariable
    allowable interval
    [LowerBound,UpperBound]

MeasurementRangeWidth :=
    UpperBound-LowerBound

ObservedRangeVsPermittedRange :=
    ObservedRange
    may be subset_of
    MeasurementRange

DataValidationRange :=
    AllowedMinimum
    ∧ AllowedMaximum

RangeConstraint :=
    LowerBound≤Value≤UpperBound

RangeViolation :=
    Value<LowerBound
    ∨ Value>UpperBound

RangeCheck :=
    Observation
    → CompareWithAllowedBounds
    → ValidOrInvalid

DynamicRange :=
    RatioOrDifference
    between largest_and_smallest usable signal
    depending domain convention

StatisticalRangeNotDynamicRange :=
    StatisticalRange
    ≠
    DomainSpecificDynamicRange
    unless explicitly mapped

InterquartileRange :=
    IQR
    =
    Q3-Q1

SemiInterquartileRange :=
    IQR/2

PercentileRange :=
    Q(p_high)-Q(p_low)

CentralPercentileRange :=
    Q(1-α/2)-Q(α/2)

RobustRangeAlternative :=
    InterquartileRange
    ∨ PercentileRange

TrimmedRange :=
    UpperTrimmedExtreme
    -
    LowerTrimmedExtreme

WinsorisedRange :=
    WinsorisedMaximum
    -
    WinsorisedMinimum

GroupedDataRange :=
    ApproximateUpperBoundary
    -
    ApproximateLowerBoundary
    under grouped representation

ClassRange :=
    HighestClassBoundary
    -
    LowestClassBoundary

CategoricalRange :=
    Undefined
    for nominal categories

OrdinalRange :=
    MayRepresent
    difference in ordered positions
    but arithmetic range
    depends_on numeric coding semantics

QuantitativeRange :=
    Valid
    for numerical variables
    with meaningful differences

IntervalScaleRange :=
    Meaningful
    because differences are meaningful

RatioScaleRange :=
    Meaningful
    because differences are meaningful

NominalScaleConstraint :=
    NominalVariable
    ⇒
    ArithmeticRangeNotMeaningful

MissingDataRange :=
    Range
    computed_from
    selected nonmissing values
    under explicit missingness rule

MissingnessConstraint :=
    RangeResult
    must record
    effective observation set

MissingCodeRisk :=
    NumericMissingCode
    treated_as substantive value
    ⇒
    InvalidRangeRisk

EmptyDatasetRange :=
    Undefined

SingleObservationRange :=
    n=1
    ⇒
    Range=0

TwoObservationRange :=
    n=2
    ⇒
    Range=|x_1-x_2|

StreamingRange :=
    Maintain(
        CurrentMinimum,
        CurrentMaximum
    )

OnlineRangeUpdate :=
    NewValue x
    → NewMinimum=min(CurrentMinimum,x)
    → NewMaximum=max(CurrentMaximum,x)
    → NewRange=NewMaximum-NewMinimum

BatchRangeCombination :=
    DatasetA
    ∧ DatasetB
    ⇒
    CombinedMinimum
    =
    min(MinA,MinB)
    ∧
    CombinedMaximum
    =
    max(MaxA,MaxB)

CombinedRange :=
    max(MaxA,MaxB)
    -
    min(MinA,MinB)

RangeAggregationConstraint :=
    RangeOfCombinedData
    cannot generally be derived
    from individual ranges alone
    without minima_and_maxima

RangeEvidence :=
    ObservedValues
    ∨ OrderStatistics
    ∨ SummaryMinMax
    ∨ DistributionSupport

RangeState := {
    Variable,
    Observations,
    EffectiveCount,
    Minimum,
    Maximum,
    RangeValue,
    MeasurementUnit,
    MissingnessRule,
    PopulationOrSampleContext,
    Evidence,
    Confidence,
    Provenance
}

RangeConsistency :=
    Minimum
    ∧ Maximum
    ∧ RangeValue
    ∧ DataScope
    ∧ MeasurementSemantics
    jointly_compatible

InvalidRange :=
    EmptyEffectiveDataset
    ∨ Maximum<Minimum
    ∨ IncompatibleUnits
    ∨ NominalArithmeticRange
    ∨ UndocumentedMissingness
    ∨ RangeValueMismatch

RangeValidation :=
    ResolveVariable
    → ResolveVariableType
    → ResolveMeasurementScale
    → ResolveObservations
    → ResolveMissingness
    → ValidateUnits
    → ComputeMinimum
    → ComputeMaximum
    → ComputeRange
    → ValidateResult

SEMANTIC_EQUIVALENCE(RangeA,RangeB) :=
    same(DataScope)
    ∧ same(VariableSemantics)
    ∧ same(Minimum)
    ∧ same(Maximum)
    ∧ same(MissingnessRule)
    ∧ compatible(MeasurementUnit)

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

CoreClasses := {
    StatisticalRange,
    SampleRange,
    PopulationRange,
    Minimum,
    Maximum,
    Midrange,
    HalfRange,
    InterquartileRange,
    PercentileRange,
    OrderStatistic,
    StatisticalVariable,
    StatisticalObservation,
    Dataset,
    Sample,
    Population,
    RangeConstraint
}

CoreRelations := {
    computedFrom,
    summarises,
    hasMinimum,
    hasMaximum,
    hasWidth,
    derivedFrom,
    boundedBy,
    comparedWith,
    transformedBy,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    StatisticalRange --computedFrom--> Observations
    StatisticalRange --summarises--> StatisticalVariable
    StatisticalRange --hasMinimum--> Minimum
    StatisticalRange --hasMaximum--> Maximum
    StatisticalRange --hasWidth--> RangeValue
    StatisticalRange --derivedFrom--> OrderStatistics
    ObservedRange --boundedBy--> MeasurementRange
    StatisticalRange --comparedWith--> InterquartileRange
    StatisticalRange --transformedBy--> AffineTransformation
    StatisticalRange --tracesTo--> Provenance

InferenceRules := {
    NonemptyDataset
        ⇒
        Range=Maximum-Minimum,

    n=1
        ⇒
        Range=0,

    Range
        ⇒
        Range≥0,

    AllValuesEqual
        ⇒
        Range=0,

    AtLeastTwoDistinctValues
        ⇒
        Range>0,

    Range(X+c)
        =
        Range(X),

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

    NominalVariable
        ⇒
        FlagArithmeticRangeAsSemanticallyInvalid,

    NewValueWithinCurrentBounds
        ⇒
        RangeUnchanged,

    NewValueOutsideCurrentBounds
        ⇒
        RecomputeRange
}

CanonicalRangeRepresentation :=
    ParseRangeRequest
    → ResolveVariable
    → ResolveDataScope
    → ResolveVariableTypeAndScale
    → ResolveObservations
    → ResolveMissingness
    → ResolveMeasurementUnit
    → ComputeMinimum
    → ComputeMaximum
    → ComputeRange
    → ResolvePopulationOrSamplingContextIfRequired
    → ValidateRange

RangeGraph :=
    G=(V,E)

V := {
    Ranges,
    SampleRanges,
    PopulationRanges,
    Minima,
    Maxima,
    Midranges,
    HalfRanges,
    InterquartileRanges,
    PercentileRanges,
    Variables,
    Observations,
    Datasets,
    Samples,
    Populations,
    Units,
    Evidence,
    ProvenanceNodes
}

E := {
    computedFrom,
    summarises,
    hasMinimum,
    hasMaximum,
    hasWidth,
    derivedFrom,
    boundedBy,
    comparedWith,
    transformedBy,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(RangeResolution) :=
    weighted_mean(
        VariableResolution,
        DataScopeResolution,
        MeasurementScaleValidity,
        ObservationResolution,
        MissingnessHandling,
        UnitCompatibility,
        ExtremeValueValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectRangeIntent
    → IdentifyVariableAndDataScope
    → ResolveQuantitativeMeasurementSemantics
    → IdentifySamplePopulationObservedOrAllowedRange
    → ResolveMissingnessAndUnits

AI_REASONING_FLOW :=
    Query
    → ParseRangeProblem
    → ResolveDatasetSamplePopulationOrDistribution
    → ResolveVariable
    → ResolveVariableTypeAndMeasurementScale
    → ResolveObservations
    → ResolveMissingValues
    → ResolveMeasurementUnits
    → ComputeMinimum
    → ComputeMaximum
    → ComputeRange
    → CompareWithIQRPercentileRangeOrAllowedBoundsIfRequested
    → ResolveSamplingPropertiesIfRequested
    → ValidateRangeResult
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseRangeEntities,
    ParseTypedRelations,
    ResolveVariables,
    ResolveObservations,
    ResolveDatasets,
    ResolveSamples,
    ResolvePopulations,
    ResolveMeasurementScales,
    ResolveMeasurementUnits,
    ResolveMissingness,
    ComputeMinima,
    ComputeMaxima,
    ComputeSampleRanges,
    ComputePopulationRanges,
    ComputeMidranges,
    ComputeHalfRanges,
    ComputeInterquartileRanges,
    ComputePercentileRanges,
    ResolveOrderStatistics,
    EvaluateRangeConstraints,
    ResolveSampleRangeDistributions,
    ValidateRangeSemantics,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewObservationScopeConstraintOrDefinition
    → ValidateInput
    → IdentifyAffectedRangeClaims
    → UpdateRangeState
    → RecomputeEffectiveObservationSet
    → RecomputeMinimum
    → RecomputeMaximum
    → RecomputeRange
    → RevalidateConstraints
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ObservationUpdate :=
    AddedRemovedOrCorrectedObservation
    ⇒ recompute(
        Minimum,
        Maximum,
        RangeValue
    )

ScopeUpdate :=
    ChangedDataScope
    ⇒ recompute(
        EffectiveCount,
        Minimum,
        Maximum,
        RangeValue
    )

ConstraintUpdate :=
    ChangedAllowedBounds
    ⇒ reevaluate(
        RangeViolations,
        ObservedRangeVsPermittedRange
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        StatisticalRange,
        RangeValidation,
        RangeConstraint,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    RangeEntityResolution,
    Variable,
    DataScope,
    VariableType,
    MeasurementScale,
    ObservationCount,
    EffectiveObservationCount,
    Minimum,
    Maximum,
    RangeValue,
    MeasurementUnit,
    MissingnessRule,
    PopulationOrSampleContext,
    RobustRangeComparison,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA