Неопределенный

Вы знаете, что не так с людьми? Они слишком уверены в себе.

Лучше ошибаться и владеть им, чем быть правым с предостережением. В наши дни трудно построить личный бренд из нюанса. Людей привлекают уверенность – как бы ни были неуместны.

Но можете ли вы их винить? (Люди, то есть), работая в программном обеспечении, самая раздражающая часть достижения старшего уровня должна сказать “это зависит” все время. Гораздо веселее сказать
«Давайте отправим его и перечислите» как персонал или
«Это не масштабируется» как директор.

Тем не менее, несмотря на все наше интеллектуальное смирение, почему мы писать Подобный код атмосфера?

if currentLocation.distance(to: target) < 100 {
    print("You've arrived!") // But have you, really? 🤨
}

Координаты GPS не точны. Они шумные. Они приблизительны. Они вероятностными. Что horizontalAccuracy собственность спрятана в вашем CLLocation Объект пытается рассказать вам что -то важное: вы вероятно В этом радиусе.
Вероятно.

А Boolтем временем, может быть только true или falseПолем Что if Заявление должно сделать выбор так или иначе, но подобный код не отражает неопределенность ситуации. Если истина является светом, то современные модели программирования разрушают волновую функцию слишком рано.

Выбор правильной абстракции

В 2014 году исследователи из Вашингтонского университета и Microsoft Research предложили радикальную идею: что, если неопределенность была закодирована непосредственно в систему типов? Их бумага,
Неопределенность: Тип первого порядка для неопределенных данных

представил вероятностный подход программирования, который является математически строгим и удивительно практичным.

Как и следовало ожидать от Microsoft в 2010 -х годах, газета реализована в C#. Но концепции прекрасно переводятся на Свифт.

Вы можете найти Мой порт на GitHub:

import Uncertain
import CoreLocation

let uncertainLocation = Uncertain<CLLocation>.from(currentLocation)
let nearbyEvidence = uncertainLocation.distance(to: target) < 100
if nearbyEvidence.probability(exceeds: 0.95) {
    print("You've arrived!") // With 2σ confidence 🤓
}

Когда вы сравниваете два Uncertain Значения, вы не получите окончательного true или falseПолем Вы получаете Uncertain это представляет вероятность о сравнении trueПолем

То же самое верно и для других операторов:

// How fast did we run around the track?
let distance: Double = 400 // meters
let time: Uncertain<Double> = .normal(mean: 60, standardDeviation: 5.0) // seconds
let runningSpeed = distance / time // Uncertain

// How much air resistance?
let airDensity: Uncertain<Double> = .normal(mean: 1.225, standardDeviation: 0.1) // kg/m³
let dragCoefficient: Uncertain<Double> = .kumaraswamy(alpha: 9, beta: 3) // slightly right-skewed distribution
let frontalArea: Uncertain<Double> = .normal(mean: 0.45, standardDeviation: 0.05) // m²
let airResistance = 0.5 * airDensity * frontalArea * dragCoefficient * (runningSpeed * runningSpeed)

Этот код создает график вычисления, отбирая выборку только при просьбе конкретных результатов. Библиотека использует
Тестирование последовательного соотношения вероятности (SPRT)
Чтобы эффективно определить, сколько выборок необходимо – может быть, несколько десятков раз для простых сравнений, автоматически масштабируя для сложных расчетов.

// Sampling happens only when we need to evaluate
if ~(runningSpeed > 6.0) {
    print("Great pace for a 400m sprint!")
}
// SPRT might only need a dozen samples for this simple comparison

let sustainableFor5K = (runningSpeed < 6.0) && (airResistance < 50.0)
print("Can sustain for 5K: (sustainableFor5K.probability(exceeds: 0.9))")
// Might use 100+ samples for this compound condition

Используя абстракцию как Uncertain Заставляет вас справляться с неопределенностью как первоклассной концепции, а не притворяться, что ее не существует. И при этом вы получаете гораздо более умный код.

Цитировать Алан Кей:

Точка зрения стоит 80 точек IQ

Прежде чем углубиться в распределения вероятностей, давайте отправимся в Монако и поговорим о
Монте -Карло выборкаПолем

Метод Монте -Карло

enum SlotMachine {
    static func spin() -> Int {
        let symbols = [
            "◻️", "◻️", "◻️",  // blanks
            "🍒", "🍋", "🍊", "🍇", "💎"
        ]

        // Spin three reels independently
        let reel1 = symbols.randomElement()!
        let reel2 = symbols.randomElement()!
        let reel3 = symbols.randomElement()!

        switch (reel1, reel2, reel3) {
        case ("💎", "💎", "💎"): return 100  // Jackpot!
        case ("🍒", "🍒", "🍒"): return 10
        case ("🍇", "🍇", "🍇"): return 5
        case ("🍊", "🍊", "🍊"): return 3
        case ("🍋", "🍋", "🍋"): return 2
        case ("🍒", _, _), // Any cherry
             (_, "🍒", _),
             (_, _, "🍒"):
            return 1
        default:
            return 0  // Better luck next time
        }
    }
}

Теперь мы мог Выработайте эти вероятности аналитически – подсчет комбинаций, расчет условных вероятностей, возможно, даже разорвать некоторые комбинаторики.

Или мы могли бы просто позволить компьютеру потянуть рычаг кучу и посмотреть, что произойдет.

let expectedPayout = Uncertain<Int> {
    SlotMachine.spin()
}.expectedValue(sampleCount: 10_000)
print("Expected value per spin: $(expectedPayout)")
// Expected value per spin: ≈ $0.56

По крайней мере, мы знаем одну вещь наверняка:
Дом всегда побеждает.

Помимо простых распределений

Uncertain обеспечивает
богатый набор распределений вероятностей:

// Modeling sensor noise
let rawGyroData = 0.85  // rad/s
let gyroReading = Uncertain.normal(
    mean: rawGyroData,
    standardDeviation: 0.05  // Typical gyroscope noise in rad/s
)

// User behavior modeling
let userWillTapButton = Uncertain.bernoulli(probability: 0.3)

// Network latency with long tail
let apiResponseTime = Uncertain.exponential(rate: 0.1)

// Coffee shop visit times (bimodal: morning rush + afternoon break)
let morningRush = Uncertain.normal(mean: 8.5, standardDeviation: 0.5)  // 8:30 AM
let afternoonBreak = Uncertain.normal(mean: 15.0, standardDeviation: 0.8)  // 3:00 PM
let visitTime = Uncertain.mixture(
    of: [morningRush, afternoonBreak],
    weights: [0.6, 0.4]  // Slightly prefer morning coffee
)

Uncertain также предоставляет всеобъемлющее
статистические операции:

// Basic statistics
let temperature = Uncertain.normal(mean: 23.0, standardDeviation: 1.0)
let avgTemp = temperature.expectedValue() // about 23°C
let tempSpread = temperature.standardDeviation() // about 1°C

// Confidence intervals
let (lower, upper) = temperature.confidenceInterval(0.95)
print("95% of temperatures between (lower)°C and (upper)°C")

// Distribution shape analysis
let networkDelay = Uncertain.exponential(rate: 0.1)
let skew = networkDelay.skewness() // right skew
let kurt = networkDelay.kurtosis() // heavy tail

// Working with discrete distributions
let diceRoll = Uncertain.categorical([1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1])!
diceRoll.entropy()  // Randomness measure (~2.57)
(diceRoll + diceRoll).mode() // Most frequent outcome (7, perhaps?)

// Cumulative probability
if temperature.cdf(at: 25.0) < 0.2 {  // P(temp ≤ 25°C) < 20%
    print("Unlikely to be 25°C or cooler")
}

Статистика вычисляется с помощью выборки. Количество образцов настраивается, что позволяет обменивать время вычисления на точность.

Поставить теорию на практику

extension CLLocation {
    var uncertain: Uncertain<CLLocation> {
        Uncertain<CLLocation>.from(self)
    }
}

// Gradually migrate critical paths
let isNearby = (
    currentLocation.uncertain.distance(to: destination) < threshold
).probability(exceeds: 0.68)

// Fast approximation for UI updates
let quickEstimate = speed.probability(
    exceeds: walkingSpeed,
    maxSamples: 100
)

// High precision for critical decisions
let preciseResult = speed.probability(
    exceeds: walkingSpeed,
    confidenceLevel: 0.99,
    maxSamples: 10_000
)