tokenfabrikker/tests/test_terskler.py
Kjell Tore Guttormsen 1da369daa4
feat(terskler): demonstrated effect, the halves of rho_D and the conditions taken together (clarification 115)
A threshold counts when the quantity has a source, its first-order index
for the condition is above the chi-square limit, and, for rho_N, the target
holds under the condition in each half of the draws by rho_D. For a solution
whose conditions can be named, the share of the draws that meets the chosen
conditions together is given, and the share of them in which M1 to M4 hold.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-13 19:39:36 +01:00

362 lines
16 KiB
Python

"""Thresholds and Sobol indices (chapter 16, clarifications 105 to 111).
Invented values and outcomes only, with the answers computed by hand. Nothing here says
anything about the hypothesis.
"""
from __future__ import annotations
import math
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import sobol, terskler
from tokenfabrikker.terskler import Pristerskel, Retning, Rute, Terskel
if TYPE_CHECKING:
from collections.abc import Callable
X10 = [float(v) for v in range(1, 11)]
"""Ten draws of one quantity: the 10th percentile is 1.9 and the 90th 9.1."""
# ------------------------------------------------------------ the price threshold
def _teller(f: Callable[[float], float]) -> tuple[Callable[[float], float], list[float]]:
kall: list[float] = []
def g(k: float) -> float:
kall.append(k)
return float(f(k))
return g, kall
@pytest.mark.parametrize(
("f", "rot"),
[
(lambda k: 10.0 * k - 25.0, 2.5),
(lambda k: 3.0 * k - 0.9, 0.3),
(lambda k: min(k - 0.3, 0.1 * (k - 0.3)), 0.3),
(lambda k: -1.0 if k < 3.7 else 1.0, 3.7),
(lambda k: k**3 - 50.0, 50.0 ** (1 / 3)),
(lambda k: k - 99.5, 99.5),
],
)
def test_pristerskelen_er_laveste_faktor_med_median_som_ikke_er_negativ(
f: Callable[[float], float], rot: float
) -> None:
g, kall = _teller(f)
funnet = terskler.pristerskel(g)
assert funnet.k is not None
assert not funnet.over_maks
assert not funnet.uten_median
assert rot <= funnet.k <= rot + terskler.K_TOLERANSE
assert f(funnet.k) >= 0
assert f(funnet.k - terskler.K_TOLERANSE) < 0
# never more than two runs per halving of the bracket
assert len(kall) <= 60
def test_pristerskelen_finner_en_rett_linje_paa_faa_kjoringer() -> None:
g, kall = _teller(lambda k: 10.0 * k - 25.0)
terskler.pristerskel(g)
# 1, 2 and 4 bracket it; the line and the point just below close the bracket
assert kall[:3] == [1.0, 2.0, 4.0]
assert len(kall) == 5
def test_pristerskelen_ved_flat_median_er_det_laveste_punktet() -> None:
"""The median is zero from 2 and up: the threshold is the lowest such factor."""
funnet = terskler.pristerskel(lambda k: min(0.0, k - 2.0))
assert funnet.k is not None
assert 2.0 <= funnet.k <= 2.0 + terskler.K_TOLERANSE
def test_pristerskelen_er_null_naar_medianen_ikke_er_negativ_uten_inntekt() -> None:
assert terskler.pristerskel(lambda k: k) == Pristerskel(k=0.0)
assert terskler.pristerskel(lambda _k: 5.0) == Pristerskel(k=0.0)
def test_pristerskelen_har_ingen_verdi_over_hundre_eller_uten_median() -> None:
assert terskler.pristerskel(lambda k: k - 100.5) == Pristerskel(k=None, over_maks=True)
assert terskler.pristerskel(lambda _k: -math.inf) == Pristerskel(k=None, uten_median=True)
# exactly at the upper end it is found
funnet = terskler.pristerskel(lambda k: -1.0 if k < 100.0 else 0.0)
assert funnet.k == 100.0
def test_kontrollen_mot_kontraktsprisene_bruker_medianen() -> None:
"""The median cost is 20 and the highest contract price 50: k may be at most 2.5."""
lcoc = [10.0, 30.0, 20.0]
assert terskler.innenfor_kontraktsprisene(2.5, lcoc, 50.0) == (True, 2 / 3)
assert terskler.innenfor_kontraktsprisene(2.6, lcoc, 50.0) == (False, 1 / 3)
assert terskler.innenfor_kontraktsprisene(0.0, lcoc, 50.0) == (True, 1.0)
# ----------------------------------------------------- a threshold in one quantity
def test_terskelen_er_den_minst_strenge_betingelsen_innenfor_spennet() -> None:
"""The target is met where x <= 6. At most 9: 6 of 9. At most 8: 6 of 8. At most 7: 6 of 7."""
oppfylt: list[bool | None] = [v <= 6 for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (7.0, 0.7, 6 / 7)
# at least 2 covers 5 of 9, and it only gets worse
assert terskler.terskel(X10, oppfylt, Retning.MINST) is None
def test_terskelen_naar_andelen_svinger() -> None:
"""Met everywhere but at 1 and 6. At most 5 gives exactly 4 of 5; at least 2 gives 8 of 9."""
oppfylt: list[bool | None] = [v not in (1.0, 6.0) for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (5.0, 0.5, 0.8)
assert terskler.terskel(X10, oppfylt, Retning.MINST) == (2.0, 0.9, 8 / 9)
def test_terskelen_ligger_aldri_utenfor_10_og_90_persentilen() -> None:
"""Met only at 1: «at most 1» would hold, but 1 is below the 10th percentile, 1.9."""
oppfylt: list[bool | None] = [v == 1.0 for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) is None
# met everywhere but at 10: «at most 9» is the least strict candidate, not «at most 10»
oppfylt = [v != 10.0 for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (9.0, 0.9, 1.0)
def test_en_bane_som_ikke_lar_seg_bygge_oppfyller_ikke_vilkaaret() -> None:
"""Not buildable at 7: at most 7 is then 6 of 7 with the draw in the denominator."""
oppfylt: list[bool | None] = [True, True, True, True, True, True, None, False, False, False]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (7.0, 0.7, 6 / 7)
oppfylt = [True, True, True, True, True, None, None, False, False, False]
# at most 7: 5 of 7; at most 6: 5 of 6
assert terskler.terskel(X10, oppfylt, Retning.HOYST) == (6.0, 0.6, 5 / 6)
def test_like_verdier_er_en_kandidat() -> None:
"""Three draws at 1, three at 2 and four at 3: the percentiles are 1 and 3."""
x = [1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0]
oppfylt: list[bool | None] = [True, True, True, True, True, False, False, False, False, False]
assert terskler.terskel(x, oppfylt, Retning.HOYST) == (2.0, 0.6, 5 / 6)
assert terskler.terskel(x, oppfylt, Retning.MINST) is None
# a quantity with the same value in every draw has one candidate, which covers all
assert terskler.terskel([5.0] * 10, oppfylt, Retning.HOYST) is None
assert terskler.terskel([5.0] * 10, [True] * 8 + [False] * 2, Retning.MINST) == (5.0, 1.0, 0.8)
def test_grensen_i_M7_er_halvparten() -> None:
"""Met at 2, 4, 6 and 8: never 80 % of the draws up to a candidate; half of them up to 8."""
oppfylt: list[bool | None] = [v in (2.0, 4.0, 6.0, 8.0) for v in X10]
assert terskler.terskel(X10, oppfylt, Retning.HOYST) is None
assert terskler.terskel(X10, oppfylt, Retning.HOYST, grense=0.5) == (8.0, 0.8, 0.5)
def test_terskelen_trenger_en_verdi_per_trekning() -> None:
with pytest.raises(ValueError, match="one value and one outcome per draw"):
terskler.terskel([1.0, 2.0], [True], Retning.HOYST)
with pytest.raises(ValueError, match="at least one draw"):
terskler.terskel([], [], Retning.HOYST)
def _kjerne(t: Terskel) -> tuple[object, ...]:
"""A threshold without its index, which is compared for itself."""
return (
t.storrelse,
t.retning,
t.verdi,
t.sannsynlighet,
t.andel_oppfylt,
t.teller,
t.kilde,
t.paavist,
t.begge_halvdeler,
)
def test_med_ti_trekninger_kan_ingen_virkning_paavises() -> None:
"""Two classes of five: the index is 2/3, and the limit is 10.83 / 10, above one."""
oppfylt: list[bool | None] = [v <= 6 for v in X10]
storrelser = {"a": X10, "b": [11.0 - v for v in X10], "c": [1.0] * 10}
status = {"a": "kilde", "b": "åpen forutsetning", "c": "kilde"}
a, b = terskler.terskler_for_maal(storrelser, status, oppfylt)
assert _kjerne(a) == ("a", Retning.HOYST, 7.0, 0.7, 6 / 7, False, True, False, None)
assert _kjerne(b) == ("b", Retning.MINST, 4.0, 0.7, 6 / 7, False, False, False, None)
# between the classes 5 * 0.4^2 + 5 * 0.4^2 = 1.6, over all the draws 10 * 0.6 * 0.4 = 2.4
assert a.indeks == pytest.approx(2 / 3)
assert b.indeks == pytest.approx(2 / 3)
X40 = [float(v) for v in range(1, 41)]
"""Forty draws: the 10th percentile is 4.9, the 90th 36.1, and the classes hold 14, 13 and 13."""
Z40 = [
float(v)
for v in (
*(*range(1, 12), *range(15, 24), *range(28, 36)), # the 28 draws that meet the condition
*(12, 13, 14, 24, 25, 26, 27, 36, 37, 38, 39, 40), # the 12 that do not
)
]
"""A quantity the outcome below hardly depends on: 3, 4 and 5 misses in its three classes."""
def test_grensen_for_paavist_virkning_er_kjikvadratpersentilen_over_antall_trekninger() -> None:
"""With two degrees of freedom the 99.9th percentile is -2 ln 0.001 = 13.8155."""
assert terskler.grense_paavist(40, 3) == pytest.approx(-2 * math.log(0.001) / 40)
assert terskler.grense_paavist(10, 2) == pytest.approx(10.8276 / 10, abs=1e-5)
assert terskler.grense_paavist(10_000, 50) == pytest.approx(0.0085, abs=5e-5)
assert terskler.grense_paavist(10, 1) is None
def test_en_terskel_teller_bare_naar_virkningen_er_paavist() -> None:
"""Met where x <= 28, 70 % of forty draws. The limit for three classes is 0.3454.
x: «at most 35» gives 28 of 35. Its classes have the averages 1, 1 and 1/13, so the
index is (27 * 0.3^2 + 13 * (1/13 - 0.7)^2) / (40 * 0.7 * 0.3) = 0.890: demonstrated.
z: the misses lie at 12-14, 24-27 and 36-40, so «at most 35» again gives 28 of 35. Its
classes have the averages 11/14, 9/13 and 8/13 and the index 0.023: not demonstrated.
"""
oppfylt: list[bool | None] = [v <= 28 for v in X40]
status = {"x": "kilde", "z": "kilde", "aapen": "åpen forutsetning"}
x, z, aapen = terskler.terskler_for_maal({"x": X40, "z": Z40, "aapen": X40}, status, oppfylt)
assert _kjerne(x) == ("x", Retning.HOYST, 35.0, 0.875, 0.8, True, True, True, None)
assert _kjerne(z) == ("z", Retning.HOYST, 35.0, 0.875, 0.8, False, True, False, None)
assert _kjerne(aapen) == ("aapen", Retning.HOYST, 35.0, 0.875, 0.8, False, False, True, None)
assert x.indeks == pytest.approx((27 * 0.09 + 13 * (1 / 13 - 0.7) ** 2) / 8.4)
assert z.indeks == pytest.approx(
(14 * (11 / 14 - 0.7) ** 2 + 13 * (9 / 13 - 0.7) ** 2 + 13 * (8 / 13 - 0.7) ** 2) / 8.4
)
assert terskler.virkning(X40, oppfylt) == (x.indeks, True)
# the same outcome in every draw: the index has no value and nothing is demonstrated
assert terskler.virkning(X40, [True] * 40) == (None, False)
# a quantity with one value has one class and no degree of freedom
assert terskler.virkning([1.0] * 40, oppfylt) == (0.0, False)
def test_en_terskel_i_rho_N_maa_holde_i_begge_halvdeler_av_rho_D() -> None:
"""Met where rho_N <= 30: «at most 36» gives 30 of 36.
With rho_D alternating, each half has 18 draws under the condition and 15 that meet
it. With rho_D equal to rho_N the upper half (21 to 40) has 16 draws under it and 10
that meet it, 62.5 %: the threshold then carries the effect of rho_D and does not count.
"""
oppfylt: list[bool | None] = [v <= 30 for v in X40]
status = {"rho_N": "kilde", "rho_D": "åpen forutsetning"}
veksler = [float(j % 2) for j in range(40)]
(t,) = terskler.terskler_for_maal({"rho_N": X40, "rho_D": veksler}, status, oppfylt)
assert _kjerne(t) == ("rho_N", Retning.HOYST, 36.0, 0.9, 30 / 36, True, True, True, True)
assert terskler.holder_i_begge_halvdeler(X40, veksler, oppfylt, Retning.HOYST, 36.0)
n, d = terskler.terskler_for_maal({"rho_N": X40, "rho_D": X40}, status, oppfylt)
assert _kjerne(n) == ("rho_N", Retning.HOYST, 36.0, 0.9, 30 / 36, False, True, True, False)
# the assumption itself has a threshold that does not count, and no halves to hold in
assert _kjerne(d) == ("rho_D", Retning.HOYST, 36.0, 0.9, 30 / 36, False, False, True, None)
# exactly 80 % in each half is enough: at most 25 is 20 of 20 below and 4 of 5 above
tett: list[bool | None] = [v != 25.0 for v in X40]
assert terskler.holder_i_begge_halvdeler(X40, X40, tett, Retning.HOYST, 25.0)
# a half the condition covers no draw in does not hold: at most 20 leaves the upper half empty
assert not terskler.holder_i_begge_halvdeler(X40, X40, [True] * 40, Retning.HOYST, 20.0)
# at least 21 covers only the upper half
assert not terskler.holder_i_begge_halvdeler(X40, X40, [True] * 40, Retning.MINST, 21.0)
assert terskler.holder_i_begge_halvdeler(X40, veksler, [True] * 40, Retning.MINST, 21.0)
def test_en_terskel_i_rho_N_trenger_trekningene_av_rho_D() -> None:
oppfylt: list[bool | None] = [v <= 30 for v in X40]
with pytest.raises(ValueError, match="needs the drawn values of rho_D"):
terskler.terskler_for_maal({"rho_N": X40}, {"rho_N": "kilde"}, oppfylt)
with pytest.raises(ValueError, match="for the same draws"):
terskler.holder_i_begge_halvdeler(X40, X10, oppfylt, Retning.HOYST, 36.0)
# another pairing can be passed in; without any, no quantity has halves to hold in
(t,) = terskler.terskler_for_maal({"rho_N": X40}, {"rho_N": "kilde"}, oppfylt, partnere={})
assert (t.teller, t.begge_halvdeler) == (True, None)
# ------------------------------------------------------------ the threshold surfaces
def test_flaten_gir_antall_andel_og_median_per_rute() -> None:
"""Two classes per axis: draws 1 and 2 in the first cell, 3 and 4 in the last."""
x = [1.0, 2.0, 3.0, 4.0]
y = [10.0, 10.0, 20.0, 20.0]
flate = terskler.flate(x, y, [5.0, None, -1.0, 3.0], Q=2)
tom = Rute(antall=0, andel_positiv=None, median=None)
assert flate == (
(Rute(antall=2, andel_positiv=0.5, median=-math.inf), tom),
(tom, Rute(antall=2, andel_positiv=0.5, median=1.0)),
)
with pytest.raises(ValueError, match="the same draws"):
terskler.flate(x, y, [1.0])
def test_flaten_har_fem_klasser_per_akse() -> None:
x = [float(j % 5) for j in range(25)]
y = [float(j // 5) for j in range(25)]
flate = terskler.flate(x, y, [1.0] * 25)
assert len(flate) == 5
assert all(
rute == Rute(antall=1, andel_positiv=1.0, median=1.0) for rad in flate for rute in rad
)
# ----------------------------------------------------------------- the Sobol indices
def test_antall_klasser_er_halve_kvadratroten() -> None:
assert [sobol.antall_klasser(N) for N in (1, 16, 35, 36, 100, 9999, 10000)] == [
2,
2,
2,
3,
5,
49,
50,
]
def test_klassen_folger_antall_trekninger_med_lavere_verdi() -> None:
assert sobol.klasser([5.0, 1.0, 3.0, 1.0], 2) == [1, 0, 1, 0]
assert sobol.klasser([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 3) == [0, 0, 1, 1, 2, 2]
# equal values share a class; 30 % zeros and 70 % ones get a class each with ten classes
x = [0.0] * 3 + [1.0] * 7
assert sobol.klasser(x, 10) == [0] * 3 + [3] * 7
assert sobol.klasser([7.0] * 4, 2) == [0] * 4
def test_indeksen_er_variansen_mellom_klassene_over_variansen() -> None:
x = [1.0, 2.0, 3.0, 4.0]
assert sobol.indeks(x, [0.0, 0.0, 1.0, 1.0]) == 1.0
assert sobol.indeks(x, [0.0, 1.0, 0.0, 1.0]) == 0.0
# averages 1.5 and 4.5 around 3: 2 * 2.25 + 2 * 2.25 = 9, over 4 + 1 + 0 + 9 = 14
assert sobol.indeks(x, [1.0, 2.0, 3.0, 6.0]) == pytest.approx(9 / 14)
# the order of the draws does not matter
assert sobol.indeks([4.0, 1.0, 3.0, 2.0], [6.0, 1.0, 3.0, 2.0]) == pytest.approx(9 / 14)
def test_indeksen_har_ingen_verdi_naar_utfallet_er_likt_i_alle_trekningene() -> None:
assert sobol.indeks([1.0, 2.0, 3.0], [0.1, 0.1, 0.1]) is None
with pytest.raises(ValueError, match="one value and one outcome per draw"):
sobol.indeks([1.0], [])
def test_indeksene_gis_blant_trekningene_som_har_utfallet() -> None:
"""The third draw has no outcome: the index is that of the other four."""
storrelser = {"a": [1.0, 2.0, 9.0, 3.0, 4.0], "b": [1.0, 1.0, 1.0, 1.0, 1.0]}
y = [1.0, 2.0, None, 3.0, 6.0]
assert sobol.indekser(storrelser, y) == {"a": pytest.approx(9 / 14), "b": 0.0}
assert sobol.indekser(storrelser, [None] * 5) == {"a": None, "b": None}
def test_forventningen_uten_virkning_er_om_lag_M_minus_1_over_N_minus_1() -> None:
"""300 invented quantities without any effect on an invented outcome, 400 draws each."""
assert sobol.forventning_uten_virkning(10_000) == 49 / 9999
rng = np.random.default_rng(7)
N = 400
y = rng.normal(size=N).tolist()
indekser = [sobol.indeks(rng.normal(size=N).tolist(), y) for _ in range(300)]
snitt = math.fsum(i for i in indekser if i is not None) / 300
assert sobol.forventning_uten_virkning(N) == 9 / 399
# a quantity with few values has fewer classes with draws, and a lower expectation
x = [0.0] * 100 + [1.0] * 100 + [2.0] * 200
assert sobol.klasser_med_trekninger(x) == 3
assert sobol.klasser_med_trekninger(rng.normal(size=N).tolist()) == 10
assert sobol.forventning_uten_virkning(N, 3) == 2 / 399
assert snitt == pytest.approx(9 / 399, abs=0.002)