Logistic Distribution Ontology

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

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

BEGIN_FLOW

LogisticDistribution :=
    ContinuousProbabilityDistribution
    ∧ RealLineSupport
    ∧ LocationParameter
    ∧ PositiveScaleParameter
    ∧ SymmetricDistribution
    ∧ ClosedFormCDF
    ∧ LogisticFunctionRelation

ProbabilitySpace := (Ω,F,P)

LogisticRandomVariable :=
    X~Logistic(μ,s)

LocationParameter :=
    μ

ScaleParameter :=
    s

ParameterConstraints :=
    μ∈R
    ∧ s>0

Support :=
    R

StandardLogistic :=
    Z~Logistic(0,1)

LogisticCDF :=
    F_X(x)
    =
    1
    /
    [
        1+exp(-(x-μ)/s)
    ]

EquivalentCDF :=
    F_X(x)
    =
    exp((x-μ)/s)
    /
    [
        1+exp((x-μ)/s)
    ]

LogisticFunction :=
    logistic(z)
    =
    1/(1+e^(-z))

CDFLogisticRelation :=
    F_X(x)
    =
    logistic(
        (x-μ)/s
    )

LogOddsCDF :=
    log(
        F_X(x)/(1-F_X(x))
    )
    =
    (x-μ)/s

LogitFunction :=
    logit(p)
    =
    log(p/(1-p))

InverseCDF :=
    Q(p)
    =
    μ
    +
    s log(
        p/(1-p)
    )

QuantileFunction :=
    Q(p)
    =
    μ+s logit(p)
    for 0<p<1

LogisticPDF :=
    f_X(x)
    =
    exp(-(x-μ)/s)
    /
    [
        s(
            1+exp(-(x-μ)/s)
        )²
    ]

EquivalentPDF :=
    f_X(x)
    =
    F_X(x)
    [
        1-F_X(x)
    ]
    /
    s

HyperbolicSecantForm :=
    f_X(x)
    =
    1/(4s)
    sech²(
        (x-μ)/(2s)
    )

PDFNonnegativity :=
    f_X(x)>0
    for all x∈R

PDFNormalisation :=
    Integral_{-∞}^{∞}
    f_X(x)dx
    =
    1

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

SurvivalClosedForm :=
    S_X(x)
    =
    1/
    [
        1+exp((x-μ)/s)
    ]

HazardFunction :=
    h_X(x)
    =
    f_X(x)/S_X(x)

LogisticHazard :=
    h_X(x)
    =
    F_X(x)/s

CumulativeHazard :=
    H_X(x)
    =
    -log(S_X(x))

Expectation :=
    E[X]
    =
    μ

Median :=
    μ

Mode :=
    μ

MeanMedianModeEquality :=
    Mean=Median=Mode=μ

Variance :=
    Var(X)
    =
    π²s²/3

StandardDeviation :=
    πs/sqrt(3)

Skewness :=
    0

ExcessKurtosis :=
    6/5

Kurtosis :=
    21/5

Symmetry :=
    f_X(μ-d)
    =
    f_X(μ+d)

CDFSymmetry :=
    F_X(μ-d)
    =
    1-F_X(μ+d)

MomentGeneratingFunction :=
    M_X(t)
    =
    e^(μt)
    ×
    [πst/sin(πst)]
    for |t|<1/s

CharacteristicFunction :=
    φ_X(t)
    =
    e^(iμt)
    ×
    [πst/sinh(πst)]

Entropy :=
    h(X)
    =
    ln(s)+2
    in natural-log units

LocationScaleRepresentation :=
    X
    =
    μ+sZ
    where Z~Logistic(0,1)

AffineTransformation :=
    X~Logistic(μ,s)
    ∧ a>0
    ⇒
    aX+b
    ~
    Logistic(
        aμ+b,
        as
    )

NegativeAffineTransformation :=
    a<0
    ⇒
    aX+b
    ~
    Logistic(
        aμ+b,
        |a|s
    )

Standardisation :=
    Z
    =
    (X-μ)/s

InverseTransformSampling :=
    U~Uniform(0,1)
    ⇒
    X
    =
    μ
    +
    s log(
        U/(1-U)
    )
    ~
    Logistic(μ,s)

UniformLogitRelation :=
    U~Uniform(0,1)
    ⇒
    logit(U)
    ~
    Logistic(0,1)

LogisticVsNormal :=
    Both
    symmetric bell-shaped distributions
    but
    LogisticDistribution
    has heavier tails

VarianceMatchedNormalScale :=
    LogisticScale s
    corresponds_to
    NormalStandardDeviation
    πs/sqrt(3)
    when matching variances

TailBehaviour :=
    LogisticTails
    decay exponentially

NormalTailContrast :=
    GaussianTails
    decay faster
    than logistic tails

LogisticRegressionRelation :=
    BinaryOutcomeProbability
    modelled_by
    logistic function

BernoulliResponse :=
    Y∈{0,1}

SuccessProbability :=
    p(x)

LogisticRegressionModel :=
    logit(
        P(Y=1|X=x)
    )
    =
    β0
    +
    β^Tx

InverseLink :=
    P(Y=1|x)
    =
    logistic(
        β0+β^Tx
    )

LogisticDistributionVsLogisticRegression :=
    LogisticDistribution
    is continuous distribution
    whereas
    logistic regression
    models Bernoulli probability
    using logistic link

LatentVariableLogitModel :=
    Y=1
    iff
    Y* > 0

LatentVariable :=
    Y*
    =
    x^Tβ
    +
    ε

LogisticError :=
    ε~Logistic(0,1)

LatentLogisticProbability :=
    P(Y=1|x)
    =
    logistic(x^Tβ)

Odds :=
    p/(1-p)

LogOdds :=
    log(Odds)

OddsRatio :=
    exp(β_j)
    for unit change in predictor
    under logistic regression interpretation

ProportionalOddsRelation :=
    OrderedLogisticModels
    use
    cumulative logits
    with logistic error structure

LogLogisticRelation :=
    If
    Y=exp(X)
    and
    X~Logistic(μ,s),
    then
    Y
    follows
    LogLogisticDistribution
    under parameter mapping

LogLogisticCDF :=
    P(Y≤y)
    =
    logistic(
        (ln y-μ)/s
    )
    for y>0

ExtremeValueDifferenceRelation :=
    DifferenceOfTwoIndependent
    identically scaled
    GumbelVariables
    can produce
    LogisticDistribution

RandomUtilityRelation :=
    LogisticChoiceProbabilities
    arise from
    Gumbel-distributed utility errors
    under standard discrete-choice assumptions

SoftmaxRelation :=
    MultinomialChoiceProbabilities
    generalise binary logistic choice
    under Gumbel error models

LogisticLikelihood :=
    X_1,...,X_n
    iid Logistic(μ,s)

LogLikelihood :=
    ℓ(μ,s)
    =
    Σ_i log f_X(x_i|μ,s)

ParameterEstimation :=
    Data
    → Estimate(
        μ,
        s
    )

MaximumLikelihoodEstimation :=
    UsuallyRequires
    numerical optimisation
    for both unknown μ and s

LocationEstimator :=
    SampleMedian
    provides
    natural robust location summary
    though not generally identical to MLE

ScaleFromVariance :=
    s
    =
    sqrt(3 Var(X))/π

ScaleFromStandardDeviation :=
    s
    =
    SD(X)sqrt(3)/π

InterquartileRange :=
    Q(0.75)-Q(0.25)

LogisticIQR :=
    2s ln3

ScaleFromIQR :=
    s
    =
    IQR/(2ln3)

RobustnessRelation :=
    HeavierTails
    can provide
    alternative error model
    to Gaussian assumptions

LogisticDistributionConstraint :=
    ConstraintOn(
        Location,
        Scale,
        Support,
        PDF,
        CDF,
        Moments
    )

LocationConstraint :=
    μ∈R

ScaleConstraint :=
    s>0

SupportConstraint :=
    X∈R

NormalisationConstraint :=
    Integral_{-∞}^{∞}
    f_X(x)dx
    =
    1

LogisticConsistency :=
    Location
    ∧ Scale
    ∧ PDF
    ∧ CDF
    ∧ Quantiles
    ∧ Moments
    jointly_compatible

InvalidLogisticDistribution :=
    s≤0
    ∨ PDFNormalisationFailure
    ∨ CDFMismatch
    ∨ MomentConflict

LogisticValidation :=
    ResolveLocation
    → ResolveScale
    → ValidateScale
    → ResolveSupport
    → ConstructCDF
    → DifferentiateOrConstructPDF
    → ValidateNormalisation
    → ValidateMoments

LogisticDistributionState := {
    RandomVariable,
    Location,
    Scale,
    Support,
    PDF,
    CDF,
    SurvivalFunction,
    QuantileFunction,
    Mean,
    Variance,
    RegressionRelations,
    Evidence,
    Confidence,
    Provenance
}

LogisticEvidence :=
    ContinuousData
    ∨ LocationScaleModel
    ∨ LatentVariableModel
    ∨ LogisticRegressionContext
    ∨ TheoreticalDerivation

LogisticUpdate :=
    NewDataLocationScaleOrModelEvidence
    → UpdateLogisticState
    → RecomputePDF
    → RecomputeCDF
    → RecomputeQuantiles
    → RecomputeMoments
    → Revalidate

SEMANTIC_EQUIVALENCE(LogisticA,LogisticB) :=
    same(Location)
    ∧ same(Scale)
    ⇒
    same(LogisticProbabilityMeasure)

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

CoreClasses := {
    LogisticDistribution,
    ContinuousDistribution,
    LogisticRandomVariable,
    LocationParameter,
    ScaleParameter,
    LogisticPDF,
    LogisticCDF,
    LogisticFunction,
    LogitFunction,
    QuantileFunction,
    SurvivalFunction,
    LogisticRegression,
    BernoulliResponse,
    LogLogisticDistribution,
    LogisticConstraint
}

CoreRelations := {
    distributionOf,
    hasLocation,
    hasScale,
    hasSupport,
    hasPDF,
    hasCDF,
    hasQuantile,
    transformedFrom,
    relatedTo,
    usedBy,
    modelsErrorFor,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

TypedRelations :=
    LogisticDistribution --distributionOf--> LogisticRandomVariable
    LogisticDistribution --hasLocation--> LocationParameter
    LogisticDistribution --hasScale--> ScaleParameter
    LogisticDistribution --hasSupport--> Support
    LogisticDistribution --hasPDF--> LogisticPDF
    LogisticDistribution --hasCDF--> LogisticCDF
    LogisticDistribution --hasQuantile--> QuantileFunction
    LogisticRandomVariable --transformedFrom--> UniformRandomVariable
    LogisticDistribution --relatedTo--> LogLogisticDistribution
    LogisticDistribution --modelsErrorFor--> LatentLogitModel
    LogisticFunction --usedBy--> LogisticRegression
    LogisticDistribution --tracesTo--> Provenance

InferenceRules := {
    X~Logistic(μ,s)
        ⇒
        F_X(x)
        =
        1/[1+exp(-(x-μ)/s)],

    X~Logistic(μ,s)
        ⇒
        E[X]=μ,

    X~Logistic(μ,s)
        ⇒
        Var(X)=π²s²/3,

    U~Uniform(0,1)
        ⇒
        μ+slog(U/(1-U))
        ~
        Logistic(μ,s),

    X~Logistic(μ,s)
        ⇒
        logit(F_X(x))
        =
        (x-μ)/s,

    s≤0
        ⇒
        InvalidLogisticDistribution
}

CanonicalLogisticRepresentation :=
    ParseLogisticModel
    → ResolveRandomVariable
    → ResolveLocation
    → ResolveScale
    → ValidateScale
    → ResolveSupport
    → ConstructCDF
    → ConstructPDF
    → ConstructQuantileFunction
    → ComputeMoments
    → ResolveRegressionOrTransformationRelations
    → ValidateLogisticDistribution

LogisticDistributionGraph :=
    G=(V,E)

V := {
    LogisticDistributions,
    LogisticRandomVariables,
    LocationParameters,
    ScaleParameters,
    PDFs,
    CDFs,
    Quantiles,
    SurvivalFunctions,
    LogisticFunctions,
    LogitFunctions,
    LogisticRegressionModels,
    LatentVariables,
    LogLogisticDistributions,
    Evidence,
    ProvenanceNodes
}

E := {
    distributionOf,
    hasLocation,
    hasScale,
    hasSupport,
    hasPDF,
    hasCDF,
    hasQuantile,
    transformedFrom,
    relatedTo,
    usedBy,
    modelsErrorFor,
    estimatedFrom,
    constrainedBy,
    equivalentTo,
    tracesTo
}

CONFIDENCE(LogisticDistributionResolution) :=
    weighted_mean(
        RandomVariableResolution,
        LocationResolution,
        ScaleResolution,
        SupportValidity,
        PDFConsistency,
        CDFConsistency,
        RegressionRelationValidity,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectLogisticDistributionIntent
    → IdentifyContinuousRandomVariable
    → ResolveLocation
    → ResolveScale
    → IdentifyRequestedProbabilityQuantileOrProperty
    → ResolveLogisticRegressionContextIfPresent

AI_REASONING_FLOW :=
    Query
    → ParseLogisticDistributionProblem
    → ResolveProbabilitySpace
    → ResolveLogisticRandomVariable
    → ResolveLocation
    → ResolveScale
    → ValidateScale
    → ConstructLogisticCDF
    → ConstructLogisticPDF
    → ComputeRequestedIntervalOrTailProbability
    → ComputeQuantileMeanVarianceOrIQRIfRequired
    → ResolveUniformLogitTransformationIfRelevant
    → ResolveLogisticRegressionOrLatentVariableRelationIfRelevant
    → ValidateLogisticModel
    → UpdateConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseLogisticDistributionEntities,
    ParseTypedRelations,
    ResolveLogisticRandomVariables,
    ResolveLocationParameters,
    ResolveScaleParameters,
    EvaluateLogisticPDFs,
    EvaluateLogisticCDFs,
    EvaluateSurvivalFunctions,
    ComputeIntervalProbabilities,
    ComputeTailProbabilities,
    ComputeQuantiles,
    ComputeMeans,
    ComputeVariances,
    ComputeIQRs,
    ApplyInverseTransformSampling,
    ResolveLogitRelations,
    ResolveLogisticRegressionRelations,
    ResolveLatentVariableModels,
    ResolveLogLogisticRelations,
    EstimateLogisticParameters,
    ValidateLogisticDistributions,
    CompareSemanticEquivalence,
    UpdateConfidence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewDataLocationScaleOrConstraint
    → ValidateInput
    → IdentifyAffectedLogisticClaims
    → UpdateLogisticState
    → RecomputePDF
    → RecomputeCDF
    → RecomputeQuantiles
    → RecomputeMoments
    → ReevaluateRegressionRelations
    → RevalidateConstraints
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

LocationUpdate :=
    ChangedLocation
    ⇒ recompute(
        PDFLocation,
        CDF,
        Quantiles,
        Mean
    )

ScaleUpdate :=
    ChangedScale
    ⇒ revalidate(s>0)
    → recompute(
        PDFScale,
        CDF,
        Quantiles,
        Variance,
        IQR
    )

DataUpdate :=
    NewContinuousOrLatentModelData
    ⇒ reevaluate(
        LocationEstimate,
        ScaleEstimate,
        ModelFit,
        Confidence
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        LogisticDistribution,
        LogisticCDF,
        LogisticPDF,
        LogisticValidation,
        SEMANTIC_EQUIVALENCE,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    LogisticDistributionEntityResolution,
    ProbabilitySpace,
    LogisticRandomVariable,
    Location,
    Scale,
    Support,
    PDF,
    CDF,
    SurvivalFunction,
    QuantileFunction,
    RequestedProbability,
    Mean,
    Variance,
    IQR,
    LogisticRegressionRelation,
    ValidationStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF FULL EXECUTABLE FLOW ALGEBRA