Randomness Ontology

FULL EXECUTABLE FLOW ALGEBRA — RANDOMNESS ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/foundations-of-probability/randomness-ontology.html

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

BEGIN_FLOW

Randomness :=
    Unpredictability
    ∧ OutcomeVariability
    ∧ ProbabilityStructure
    ∧ AbsenceOfDeterministicPredictability
    under specified information and model

RandomPhenomenon :=
    Process
    ∧ MultiplePossibleOutcomes
    ∧ OutcomeNotKnownWithCertaintyBeforeObservation

RandomExperiment :=
    Procedure
    → Outcome ∈ SampleSpace

Outcome := ω

SampleSpace :=
    Ω := SetOfPossibleOutcomes

Event :=
    A ⊆ Ω

ProbabilitySpace :=
    (Ω,F,P)

RandomnessModel :=
    RandomProcess
    ∧ ProbabilitySpace
    ∧ DependenceStructure
    ∧ InformationState

Determinism :=
    State
    ∧ Rules
    uniquely_determine
    FutureState

Stochasticity :=
    FutureOutcome
    represented_by
    ProbabilityDistribution

DeterministicVsRandom :=
    DeterministicModel
    ≠ StochasticModel

EpistemicUnpredictability :=
    Unpredictability
    caused_by
    IncompleteKnowledge

AleatoricRandomness :=
    IrreducibleVariation
    represented_with
    ProbabilityModel

PseudoRandomness :=
    DeterministicAlgorithm
    → Sequence
    appearing_statistically_random

TrueRandomness :=
    Randomness
    attributed_to
    NondeterministicPhysicalOrFormalSource

PseudoRandomNumberGenerator :=
    PRNG

PRNG :=
    Seed
    ∧ DeterministicStateTransition
    → PseudoRandomSequence

Seed :=
    InitialInternalState

PRNGState :=
    S_n

PRNGTransition :=
    S_(n+1)=F(S_n)

PRNGOutput :=
    X_n=G(S_n)

SameSeedProperty :=
    SameSeed
    ∧ SameAlgorithm
    ⇒ SameSequence

Period :=
    SmallestPositive p
    such_that
    S_(n+p)=S_n
    for repeating state sequence

CryptographicRandomness :=
    ComputationalUnpredictability
    ∧ ResistanceToStateRecovery
    ∧ SuitableEntropySource
    under security assumptions

EntropySource :=
    PhysicalOrComputationalSource
    providing
    UncertainInput

RandomBit :=
    X ∈ {0,1}

FairRandomBit :=
    P(X=0)=P(X=1)=1/2

BiasedRandomBit :=
    P(X=1)=p
    where p≠1/2

RandomSequence :=
    X_1,X_2,...,X_n,...

FiniteRandomSequence :=
    (X_1,...,X_n)

InfiniteRandomSequence :=
    (X_1,X_2,...)

IndependentSequence :=
    {X_n}
    ∧ mutually_independent

IIDSequence :=
    Independent
    ∧ IdenticallyDistributed

IdenticallyDistributed :=
    Distribution(X_i)=Distribution(X_j)
    for all relevant i,j

RandomVariable :=
    X : Ω→R
    ∧ Measurable(X)

RandomVector :=
    X : Ω→R^n

RandomProcess :=
    {X_t | t∈T}

StochasticProcess :=
    RandomProcess

DiscreteTimeRandomProcess :=
    T = {0,1,2,...}

ContinuousTimeRandomProcess :=
    T ⊆ R

RandomWalk :=
    S_n
    =
    S_0 + Σ_{i=1..n} X_i

SimpleSymmetricRandomWalk :=
    P(X_i=1)=1/2
    ∧ P(X_i=-1)=1/2

RandomPermutation :=
    Permutation
    sampled_from
    ProbabilityDistributionOverPermutations

RandomSample :=
    Observations
    generated_under
    SamplingMechanism

SimpleRandomSample :=
    X_1,...,X_n
    IID
    from PopulationDistribution

RandomSelection :=
    CandidateSet
    → RandomMechanism
    → SelectedElementOrSubset

UniformRandomness :=
    Outcomes
    have
    EqualProbability
    over finite admissible set

UniformFiniteModel :=
    P(ω)=1/|Ω|
    for every ω∈Ω

NonUniformRandomness :=
    OutcomeProbabilities
    not_all_equal

RandomnessDoesNotRequireUniformity :=
    Random
    ↛ Uniform

Independence :=
    P(A∩B)=P(A)P(B)

Dependence :=
    JointDistribution
    not_factorising
    according_to relevant independence condition

Correlation :=
    StatisticalAssociation
    ∧ does_not_define_randomness

RandomnessVsIndependence :=
    RandomVariable
    may_be_random
    while dependent_on
    other random variables

RandomnessVsNoise :=
    Noise
    may_be_modelled_as
    RandomProcess

Noise :=
    UnwantedOrUnmodelledVariation

WhiteNoise :=
    Process
    with specified
    zero-mean_and_uncorrelated_or_independent_properties
    depending on definition

RandomnessMeasure :=
    QuantitativeOrAlgorithmicDescriptor
    of unpredictability_or_information

Entropy :=
    UncertaintyMeasure

ShannonEntropy :=
    H(X)
    =
    -Σ_x p(x) log p(x)

ContinuousEntropy :=
    DifferentialEntropy
    =
    -Integral f(x)log f(x)dx
    where defined

JointEntropy :=
    H(X,Y)

ConditionalEntropy :=
    H(X|Y)

MutualInformation :=
    I(X;Y)
    =
    H(X)-H(X|Y)

EntropyRelation :=
    Independence(X,Y)
    ⇒ I(X;Y)=0
    under standard discrete information theory

MaximumEntropyFiniteUniform :=
    UniformDistribution
    maximises
    ShannonEntropy
    over finite support

MinEntropy :=
    H_inf(X)
    =
    -log(max_x P(X=x))

EntropyRate :=
    lim_{n→∞}
    (1/n)H(X_1,...,X_n)
    where limit exists

AlgorithmicRandomness :=
    Sequence
    lacking
    effective_compressible_pattern
    under specified formalism

KolmogorovComplexity :=
    K(x)
    :=
    LengthOfShortestProgramProducing(x)
    relative_to universal machine

Incompressibility :=
    K(x)
    approximately
    Length(x)

MartinLofRandomness :=
    InfiniteSequence
    passes
    all_effective_statistical_tests
    in Martin-Löf framework

ComputableSequence :=
    Sequence
    generated_by
    ComputableFunction

AlgorithmicRandomSequence :=
    not_effectively_predictable_or_compressible
    according_to selected formal definition

StatisticalRandomness :=
    Sequence
    exhibits
    ExpectedDistributionalProperties

RandomnessTest :=
    Sequence
    → TestStatistic
    → CompareWithReferenceDistribution

StatisticalTestSuite := {
    FrequencyTest,
    RunsTest,
    SerialTest,
    AutocorrelationTest,
    DistributionTest,
    SpectralTest
}

FrequencyTest :=
    CompareObservedSymbolFrequencies
    with ExpectedFrequencies

RunsTest :=
    AnalyseLengthsAndCounts
    of consecutive symbol runs

AutocorrelationTest :=
    EvaluateDependence
    between lagged sequence values

SerialTest :=
    EvaluateDistribution
    of consecutive tuples

RandomnessTestResult := {
    CompatibleWithRandomModel,
    EvidenceAgainstSpecifiedRandomModel,
    Inconclusive
}

PassingRandomnessTests :=
    does_not_prove
    true randomness

FailingRandomnessTest :=
    provides_evidence_against
    specified_random_model

RandomnessHypothesis :=
    DataGeneratedBy(SpecifiedRandomProcess)

NullRandomnessModel :=
    H0 := SpecifiedRandomGeneratorOrDistribution

RandomnessAssessment :=
    ObservedSequence
    → DefineNullModel
    → SelectTests
    → ComputeStatistics
    → EvaluateEvidence
    → ReportLimitations

Predictability :=
    AbilityToForecastOutcome
    from available information

PerfectPredictability :=
    ConditionalDistribution
    degenerates_at
    one outcome

StatisticalPredictability :=
    ConditionalDistribution
    differs_from
    unconditional distribution
    in useful way

Unpredictability :=
    NoAvailablePredictor
    achieves specified predictive advantage
    under defined model and information

RandomnessRelativeToInformation :=
    RandomnessAssessment
    depends_on
    ObserverInformation
    ∧ ModelClass

ConditionalRandomness :=
    UncertaintyRemaining
    after conditioning_on
    Information

ConditionalEntropyRelation :=
    H(X|Y)
    quantifies
    residual uncertainty
    in information-theoretic context

RandomnessGeneration :=
    Source
    → SamplingOrExtraction
    → RandomOutput

RandomnessExtraction :=
    WeakRandomSource
    ∧ Extractor
    → OutputCloserToTargetRandomness
    under extractor assumptions

RandomnessExtractor :=
    Function
    transforming
    imperfect random source
    into higher-quality random bits
    under formal conditions

Sampling :=
    ProbabilityDistribution
    → RandomOutcome

InverseTransformSampling :=
    U~Uniform(0,1)
    → X=F^{-1}(U)
    under suitable CDF conditions

RejectionSampling :=
    ProposalDistribution
    ∧ AcceptanceRule
    → TargetDistributionSamples

MonteCarlo :=
    RandomSampling
    → NumericalEstimation

MonteCarloEstimator :=
    θ_hat
    based_on
    RandomSamples

MonteCarloError :=
    SamplingVariability
    in numerical estimate

Randomisation :=
    DeliberateUseOfRandomMechanism

RandomisedAlgorithm :=
    Algorithm
    ∧ RandomInputOrChoices

RandomisedDecision :=
    Input
    ∧ RandomBits
    → Output

LasVegasAlgorithm :=
    RandomRuntime
    ∧ CorrectOutputWhenTerminates
    under standard classification

MonteCarloAlgorithm :=
    BoundedOrControlledRuntime
    ∧ NonzeroErrorProbability
    under standard classification

RandomisedExperimentDesign :=
    Units
    → RandomAssignment
    → TreatmentGroups

RandomAssignment :=
    AssignmentMechanism
    governed_by
    KnownProbabilityDistribution

RandomisationInference :=
    RandomAssignmentDistribution
    → ReferenceDistribution
    → StatisticalInference

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

CoreClasses := {
    Randomness,
    RandomPhenomenon,
    RandomExperiment,
    Outcome,
    SampleSpace,
    ProbabilitySpace,
    RandomVariable,
    RandomSequence,
    StochasticProcess,
    RandomSample,
    PseudoRandomness,
    TrueRandomness,
    Entropy,
    AlgorithmicRandomness,
    RandomnessTest,
    RandomGenerator,
    RandomisedAlgorithm,
    Uncertainty
}

CoreRelations := {
    generates,
    sampledFrom,
    distributedAs,
    independentOf,
    dependsOn,
    conditionedOn,
    hasEntropy,
    seededBy,
    produces,
    testedBy,
    predicts,
    derivedFrom,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    RandomExperiment --generates--> Outcome
    RandomVariable --distributedAs--> Distribution
    RandomSample --sampledFrom--> PopulationOrDistribution
    RandomVariable --independentOf--> RandomVariable
    ConditionalRandomness --conditionedOn--> Information
    RandomVariable --hasEntropy--> EntropyValue
    PRNG --seededBy--> Seed
    RandomGenerator --produces--> RandomSequence
    RandomSequence --testedBy--> RandomnessTest
    RandomnessAssessment --tracesTo--> Evidence

InferenceRules := {
    IID(X_1,...,X_n)
        ⇒ Independent(X_i,X_j)
        for i≠j,

    UniformFinite(X)
        ⇒ P(X=x)=1/|Support(X)|,

    Independent(X,Y)
        ⇒ P(X,Y)=P(X)P(Y),

    SameSeed(PRNG_A,PRNG_B)
        ∧ SameAlgorithm(PRNG_A,PRNG_B)
        ⇒ SamePseudoRandomSequence,

    PassesStatisticalTests(Sequence)
        ↛ ProvenTrueRandomness,

    DeterministicGenerator
        ∧ HiddenSeed
        may_produce
        ApparentlyRandomSequence,

    RandomVariable(X)
        does_not_imply
        Independent(X,Y),

    NewEvidence
        ⇒ Update(RandomnessAssessment)
}

SEMANTIC_EQUIVALENCE(RandomModelA,RandomModelB) :=
    same(RelevantOutcomeDistribution)
    ∧ same(DependenceStructure)
    ∧ same(InformationContext)
    under specified query scope

CanonicalRandomnessRepresentation :=
    ParsePhenomenon
    → IdentifyRandomExperiment
    → ResolveOutcomeSpace
    → ResolveProbabilityModel
    → ResolveDependenceStructure
    → ResolveGeneratorType
    → ResolveInformationContext
    → BuildRandomnessGraph

RandomnessGraph :=
    G=(V,E)

V := {
    RandomExperiments,
    Outcomes,
    SampleSpaces,
    RandomVariables,
    Distributions,
    RandomSequences,
    Generators,
    Seeds,
    EntropyMeasures,
    RandomnessTests,
    Evidence
}

E := {
    generates,
    sampledFrom,
    distributedAs,
    independentOf,
    dependsOn,
    conditionedOn,
    hasEntropy,
    seededBy,
    produces,
    testedBy,
    predicts,
    tracesTo
}

CONFIDENCE(RandomnessAssessment) :=
    weighted_mean(
        ModelSpecificationQuality,
        DistributionFit,
        DependenceAnalysis,
        TestCoverage,
        EntropyEvidence,
        GeneratorKnowledge,
        InformationContextQuality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectRandomnessConcept
    → IdentifyProcessOrSequence
    → ResolveProbabilityModel
    → ResolveGeneratorType
    → ResolveDependenceAndInformationContext
    → IdentifyRequestedRandomnessAssessment

AI_REASONING_FLOW :=
    Query
    → ParseRandomnessProblem
    → IdentifyRandomPhenomenon
    → ResolveSampleSpace
    → ResolveRandomVariablesOrSequence
    → ResolveDistribution
    → AnalyseDependence
    → IdentifyDeterministicOrStochasticGenerator
    → EvaluateEntropyWhereRelevant
    → SelectRandomnessTestsWhereRelevant
    → EvaluatePredictability
    → DistinguishStatisticalFromAlgorithmicRandomness
    → CheckModelAssumptions
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseRandomnessEntities,
    ParseTypedRelations,
    ResolveRandomExperiments,
    ResolveRandomVariables,
    ResolveDistributions,
    AnalyseRandomSequences,
    EvaluateIndependence,
    EvaluateEntropy,
    IdentifyPseudoRandomGenerators,
    EvaluateRandomnessTests,
    AnalysePredictability,
    DistinguishRandomnessTypes,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewSequenceEvidenceGeneratorInfoOrModel
    → ValidateInput
    → IdentifyAffectedRandomnessClaims
    → UpdateDistributionEvidence
    → ReevaluateDependence
    → ReevaluateEntropy
    → RerunRelevantRandomnessTests
    → ReassessPredictability
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

SequenceUpdate :=
    AddedOrChangedObservations
    ⇒ recompute(
        FrequencyStatistics,
        DependenceStatistics,
        RandomnessTestResults
    )

GeneratorUpdate :=
    NewGeneratorOrSeedInformation
    ⇒ reevaluate(
        PseudoRandomness,
        Predictability,
        GeneratorClassification
    )

ModelUpdate :=
    ChangedProbabilityModel
    ⇒ reevaluate(
        RandomnessAssessment,
        TestInterpretation,
        Confidence
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        RandomnessModel,
        RandomSequence,
        Entropy,
        AlgorithmicRandomness,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    RandomnessEntityResolution,
    RandomPhenomenon,
    SampleSpace,
    RandomVariables,
    Distribution,
    DependenceStructure,
    GeneratorClassification,
    EntropyAssessment,
    RandomnessTestStatus,
    PredictabilityAssessment,
    RandomnessClassification,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA