Uniform Distribution Ontology

FULL EXECUTABLE FLOW ALGEBRA — UNIFORM DISTRIBUTION ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/probability-distributions/uniform-distribution-ontology.html

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

BEGIN_FLOW

UniformDistribution :=
    ProbabilityDistribution
    ∧ EqualProbabilityStructure
    over specified support

UniformDistributionType := {
    DiscreteUniformDistribution,
    ContinuousUniformDistribution
}

ProbabilitySpace :=
    (Ω,F,P)

RandomVariable :=
    X:Ω→S

DiscreteUniformDistribution :=
    FiniteSupport
    ∧ EqualMassForEachSupportValue

DiscreteSupport :=
    S={x_1,...,x_n}

DiscreteUniformPMF :=
    P(X=x_i)
    =
    1/n
    for i=1,...,n

DiscreteUniformNormalisation :=
    Σ_{i=1..n}1/n
    =
    1

DiscreteUniformEventProbability :=
    A⊆S
    ⇒
    P(X∈A)
    =
    |A|/|S|

DiscreteUniformMean :=
    E[X]
    =
    (1/n)Σ_i x_i

ConsecutiveIntegerUniform :=
    X~DiscreteUniform({a,a+1,...,b})

ConsecutiveIntegerCount :=
    n=b-a+1

ConsecutiveIntegerPMF :=
    P(X=k)
    =
    1/(b-a+1)
    for k∈{a,...,b}

ConsecutiveIntegerMean :=
    (a+b)/2

ConsecutiveIntegerVariance :=
    [(b-a+1)^2-1]/12

ContinuousUniformDistribution :=
    X~Uniform(a,b)

ParameterConstraints :=
    a<b

ContinuousSupport :=
    [a,b]

UniformPDF :=
    f_X(x)
    =
    {
        1/(b-a) if a≤x≤b,
        0 otherwise
    }

PDFNormalisation :=
    Integral_a^b
    1/(b-a) dx
    =
    1

UniformCDF :=
    F_X(x)
    =
    {
        0                       if x<a,
        (x-a)/(b-a)             if a≤x≤b,
        1                       if x>b
    }

UniformSurvivalFunction :=
    S_X(x)
    =
    1-F_X(x)

IntervalProbability :=
    a≤c≤d≤b
    ⇒
    P(c≤X≤d)
    =
    (d-c)/(b-a)

SubintervalProbability :=
    Probability
    proportional_to
    subinterval length

LengthRatioRule :=
    P(X∈[c,d])
    =
    Length([c,d])
    /
    Length([a,b])
    for [c,d]⊆[a,b]

PointProbability :=
    ContinuousUniform(X)
    ⇒
    P(X=x)=0

ContinuousUniformMean :=
    E[X]
    =
    (a+b)/2

ContinuousUniformVariance :=
    Var(X)
    =
    (b-a)^2/12

ContinuousUniformStandardDeviation :=
    (b-a)/sqrt(12)

ContinuousUniformMedian :=
    (a+b)/2

ContinuousUniformQuantile :=
    Q(p)
    =
    a+p(b-a)
    for 0≤p≤1

UniformMoment :=
    E[X^k]
    =
    [b^(k+1)-a^(k+1)]
    /
    [(k+1)(b-a)]
    for integer k≥0

UniformMGF :=
    M_X(t)
    =
    (e^(tb)-e^(ta))
    /
    [t(b-a)]
    for t≠0

UniformMGFAtZero :=
    M_X(0)=1

UniformCharacteristicFunction :=
    φ_X(t)
    =
    [e^(itb)-e^(ita)]
    /
    [it(b-a)]
    for t≠0

StandardUniform :=
    U~Uniform(0,1)

StandardUniformPDF :=
    f_U(u)=1
    for 0≤u≤1

StandardUniformCDF :=
    F_U(u)=u
    for 0≤u≤1

StandardUniformMean :=
    1/2

StandardUniformVariance :=
    1/12

AffineTransformation :=
    X
    =
    a+(b-a)U

UniformGeneration :=
    U~Uniform(0,1)
    → X=a+(b-a)U
    → X~Uniform(a,b)

UniformStandardisation :=
    U
    =
    (X-a)/(b-a)

InverseTransformSampling :=
    U~Uniform(0,1)
    ∧ TargetCDF F
    → X=F^{-1}(U)

ProbabilityIntegralTransform :=
    ContinuousCDF F_X
    ∧ X~F_X
    ⇒
    F_X(X)~Uniform(0,1)
    under standard continuity conditions

RandomNumberGeneration :=
    PseudoOrPhysicalUniformSource
    → StandardUniformVariate
    → TransformToTargetDistribution

MaximumEntropyBoundedSupport :=
    Uniform(a,b)
    maximises
    differential entropy
    among continuous distributions
    supported on [a,b]
    under standard conditions

UniformDifferentialEntropy :=
    h(X)
    =
    log(b-a)

DiscreteUniformEntropy :=
    H(X)
    =
    log(n)

Symmetry :=
    Uniform(a,b)
    symmetric_about
    (a+b)/2

LocationScaleProperty :=
    U~Uniform(0,1)
    ⇒
    a+(b-a)U~Uniform(a,b)

ShiftProperty :=
    X~Uniform(a,b)
    ⇒
    X+c~Uniform(a+c,b+c)

PositiveScaleProperty :=
    X~Uniform(a,b)
    ∧ c>0
    ⇒
    cX~Uniform(ca,cb)

NegativeScaleProperty :=
    X~Uniform(a,b)
    ∧ c<0
    ⇒
    cX~Uniform(cb,ca)

MinimumOfUniformSample :=
    X_1,...,X_n iid Uniform(0,1)
    ⇒
    F_min(x)
    =
    1-(1-x)^n
    for 0≤x≤1

MaximumOfUniformSample :=
    X_1,...,X_n iid Uniform(0,1)
    ⇒
    F_max(x)
    =
    x^n
    for 0≤x≤1

OrderStatisticUniform :=
    X_(k)
    from iid Uniform(0,1)
    follows
    Beta(k,n+1-k)

UniformJointDistribution :=
    ConstantDensity
    over specified multidimensional region
    when uniform measure exists

RectangularUniform :=
    (X,Y)
    uniform_on
    [a,b]×[c,d]

RectangularUniformJointPDF :=
    f_(X,Y)(x,y)
    =
    1/[(b-a)(d-c)]
    within rectangle

RectangularMarginals :=
    X~Uniform(a,b)
    ∧ Y~Uniform(c,d)

RectangularIndependence :=
    ConstantRectangularJointDensity
    factorises
    ⇒ X⟂Y

UniformOnFiniteSet :=
    P(X=x)
    =
    1/|S|
    for every x∈S

UniformOnRegion :=
    Probability(A)
    =
    Measure(A)
    /
    Measure(S)
    for measurable A⊆S
    when 0<Measure(S)<∞

GeometricProbability :=
    UniformMeasureOnRegion
    → Probability
    proportional_to
    geometric measure

UniformAngle :=
    Θ~Uniform(0,2π)

UniformRandomDirection :=
    Requires
    appropriate invariant measure
    not generally uniform in arbitrary coordinate parameters

UniformPrior :=
    PriorDistribution
    assigning constant density_or_mass
    over specified bounded support

ImproperUniformPrior :=
    Constant density over unbounded domain
    that does_not_normalise
    and is not a probability distribution

UniformLikelihoodModel :=
    Data
    assumed iid
    from Uniform(a,b)

UniformSample :=
    X_1,...,X_n iid Uniform(a,b)

UniformLikelihoodKnownBounds :=
    L
    =
    (1/(b-a))^n
    if all observations within [a,b]
    else 0

UniformOrderStatistics :=
    X_(1)=min sample
    ∧ X_(n)=max sample

UniformParameterEstimation :=
    Sample
    → EstimateBounds
    using order statistics
    under model assumptions

UniformGoodnessOfFit :=
    ObservedData
    → CompareAgainstUniformModel

DiscreteUniformGoodnessOfFit :=
    CategoryCounts
    compared_to
    equal expected frequencies

ContinuousUniformGoodnessOfFit :=
    EmpiricalCDF
    compared_to
    linear UniformCDF

UniformConstraint :=
    EqualProbabilityOrConstantDensity
    over declared support

DiscreteUniformConstraint :=
    ∀x∈S:
        p(x)=1/|S|

ContinuousUniformConstraint :=
    ∀x∈[a,b]:
        f(x)=1/(b-a)

SupportConstraint :=
    ProbabilityOutsideSupport=0

UniformNormalisationConstraint :=
    TotalProbability=1

UniformConsistency :=
    Support
    ∧ EqualProbabilityStructure
    ∧ Normalisation
    ∧ Parameters
    jointly_compatible

InvalidUniformDistribution :=
    Violates(
        EqualProbabilityStructure
        ∨ ParameterConstraints
        ∨ SupportConstraint
        ∨ Normalisation
    )

UniformDistributionValidation :=
    DetermineDiscreteOrContinuous
    → ResolveSupport
    → ResolveParameters
    → CheckEqualMassOrConstantDensity
    → CheckNormalisation
    → ValidateMoments

UniformDistributionState := {
    DistributionType,
    RandomVariable,
    Support,
    Parameters,
    PMFOrPDF,
    CDF,
    Moments,
    Evidence,
    Confidence,
    Provenance
}

UniformEvidence :=
    ModelDefinition
    ∨ SampleData
    ∨ SymmetryAssumption
    ∨ EqualLikelihoodAssumption

UniformDistributionUpdate :=
    NewDataSupportOrParameterEvidence
    → UpdateUniformState
    → RecomputeProbabilityFunction
    → RecomputeCDF
    → Revalidate

SEMANTIC_EQUIVALENCE(UniformA,UniformB) :=
    same(UniformProbabilityMeasure)
    on semantically equivalent support
    under specified query scope

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

CoreClasses := {
    UniformDistribution,
    DiscreteUniformDistribution,
    ContinuousUniformDistribution,
    StandardUniform,
    RandomVariable,
    Support,
    PMF,
    PDF,
    CDF,
    Parameter,
    Expectation,
    Variance,
    Quantile,
    UniformSample,
    UniformConstraint
}

CoreRelations := {
    distributionOf,
    hasSupport,
    hasPMF,
    hasPDF,
    hasCDF,
    hasParameter,
    hasExpectation,
    hasVariance,
    transformedFrom,
    sampledFrom,
    constrainedBy,
    estimatedFrom,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    UniformDistribution --distributionOf--> RandomVariable
    UniformDistribution --hasSupport--> Support
    DiscreteUniformDistribution --hasPMF--> PMF
    ContinuousUniformDistribution --hasPDF--> PDF
    UniformDistribution --hasCDF--> CDF
    UniformDistribution --hasParameter--> Parameter
    UniformDistribution --hasExpectation--> ExpectedValue
    UniformDistribution --hasVariance--> Variance
    UniformDistribution --transformedFrom--> StandardUniform
    UniformSample --sampledFrom--> UniformDistribution
    UniformDistribution --tracesTo--> Provenance

InferenceRules := {
    DiscreteUniform(S)
        ⇒
        ∀x∈S:
            P(X=x)=1/|S|,

    ContinuousUniform(a,b)
        ⇒
        f_X(x)=1/(b-a)
        for a≤x≤b,

    ContinuousUniform(a,b)
        ⇒
        F_X(x)=(x-a)/(b-a)
        for a≤x≤b,

    U~Uniform(0,1)
        ⇒
        a+(b-a)U~Uniform(a,b),

    X~Uniform(a,b)
        ⇒
        E[X]=(a+b)/2,

    X~Uniform(a,b)
        ⇒
        Var(X)=(b-a)^2/12,

    UniformFiniteSet(S)
        ⇒
        P(A)=|A|/|S|
        for A⊆S,

    ChangedSupport
        ⇒ recompute(
            ProbabilityFunction,
            CDF,
            Moments
        )
}

CanonicalUniformRepresentation :=
    ParseUniformDistribution
    → DetermineDiscreteOrContinuous
    → ResolveSupport
    → ResolveParameters
    → ConstructPMFOrPDF
    → ConstructCDF
    → ComputeMoments
    → ValidateUniformity

UniformDistributionGraph :=
    G=(V,E)

V := {
    UniformDistributions,
    RandomVariables,
    Supports,
    Parameters,
    PMFs,
    PDFs,
    CDFs,
    Moments,
    Quantiles,
    Samples,
    Transformations,
    Evidence,
    ProvenanceNodes
}

E := {
    distributionOf,
    hasSupport,
    hasPMF,
    hasPDF,
    hasCDF,
    hasParameter,
    hasExpectation,
    hasVariance,
    transformedFrom,
    sampledFrom,
    constrainedBy,
    estimatedFrom,
    equivalentTo,
    tracesTo
}

CONFIDENCE(UniformDistributionResolution) :=
    weighted_mean(
        DistributionTypeResolution,
        SupportResolution,
        ParameterQuality,
        EqualProbabilityValidation,
        NormalisationValidity,
        CDFConsistency,
        MomentConsistency,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectUniformDistributionIntent
    → DetermineDiscreteOrContinuous
    → IdentifySupport
    → ResolveParameters
    → IdentifyRequestedProbabilityOrProperty

AI_REASONING_FLOW :=
    Query
    → ParseUniformDistributionProblem
    → ResolveProbabilitySpace
    → ResolveRandomVariable
    → DetermineDiscreteOrContinuousUniform
    → ResolveSupport
    → ResolveParameters
    → ConstructPMFOrPDF
    → ConstructCDF
    → ComputeRequestedProbability
    → ComputeExpectationVarianceOrQuantileIfRequired
    → ApplyAffineTransformationIfRequired
    → ValidateUniformDistribution
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseUniformDistributionEntities,
    ParseTypedRelations,
    ResolveUniformDistributionType,
    ResolveSupports,
    ResolveParameters,
    EvaluateUniformPMFs,
    EvaluateUniformPDFs,
    EvaluateUniformCDFs,
    ComputeIntervalProbabilities,
    ComputeExpectations,
    ComputeVariances,
    ComputeQuantiles,
    ApplyAffineTransformations,
    GenerateUniformSamples,
    ValidateUniformDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewDataSupportParameterOrConstraint
    → ValidateInput
    → IdentifyAffectedUniformClaims
    → UpdateUniformState
    → RecomputePMFOrPDF
    → RecomputeCDF
    → RecomputeMoments
    → RevalidateUniformity
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

SupportUpdate :=
    ChangedSupport
    ⇒ recompute(
        EqualProbabilityValueOrDensity,
        CDF,
        Moments
    )

ParameterUpdate :=
    ChangedBoundsOrSupportSize
    ⇒ recompute(
        PMFOrPDF,
        CDF,
        Mean,
        Variance
    )

DataUpdate :=
    NewSampleData
    ⇒ reevaluate(
        UniformModelFit,
        ParameterEstimates
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        UniformDistribution,
        DiscreteUniformDistribution,
        ContinuousUniformDistribution,
        UniformDistributionValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    UniformDistributionEntityResolution,
    ProbabilitySpace,
    RandomVariable,
    DistributionType,
    Support,
    Parameters,
    PMFOrPDF,
    CDF,
    RequestedProbability,
    Mean,
    Variance,
    Quantile,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA