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>
This commit is contained in:
parent
0508114bdd
commit
1da369daa4
5 changed files with 455 additions and 40 deletions
|
|
@ -2037,8 +2037,9 @@ presisering 17 i forhåndsregistreringen på ett punkt (M6) og er prosjekteiers
|
|||
når andelen ligger nær 80 % fra før, vil noen størrelser gi en terskel av tilfeldighet. Derfor står
|
||||
sannsynligheten og andelen ved siden av, og Sobol-indeksen for samme vilkår (avklaring 110) viser om
|
||||
størrelsen betyr noe.
|
||||
109. *Betingelsene i del I (presisering 12 og 17, avklaring 59, 93 og 103 g). Valg; fyller ut presisering 17
|
||||
og er prosjekteiers å godkjenne.* For en løsning som ikke er felt, kan betingelsene navngis når hvert av
|
||||
109. *Betingelsene i del I (presisering 12 og 17, avklaring 59, 93 og 103 g). Valg, godkjent av prosjekteier
|
||||
2026-11-13 (presisering 21 i forhåndsregistreringen); hva som teller som terskel, er skjerpet i avklaring
|
||||
115.* For en løsning som ikke er felt, kan betingelsene navngis når hvert av
|
||||
M1 til M5 som er «holder under betingelser» for den, har en betingelse som kan navngis: for M1 til M4 minst
|
||||
én terskel som teller (avklaring 108), for M5 betingelsen i avklaring 93 (b). M6 er unntatt: en løsning
|
||||
trenger ingen terskel for M6. Grunn: forhåndsregistreringen sier at M6 ikke alene kan felle at en satsing
|
||||
|
|
@ -2193,6 +2194,42 @@ presisering 17 i forhåndsregistreringen på ett punkt (M6) og er prosjekteiers
|
|||
målet holder under hver strengere verdi, og rapporten skal ikke skrive det slik. $d^{*} = 1$ i (S52) betyr
|
||||
at medianen ikke er negativ selv om hele etterspørselen faller bort (det kan skje når
|
||||
$\varepsilon_d < 1$), ikke at den er null der.
|
||||
115. *Prosjekteiers svar på avklaring 114 (a) til (c), og samtidigheten i (d). Godkjent av prosjekteier
|
||||
2026-11-13 (presisering 21 til 23 i forhåndsregistreringen), før noe er regnet.* Der dette avviker fra
|
||||
avklaring 108 og 109, gjelder dette.
|
||||
(a) *M6 i betingelsene.* Avklaring 109 gjelder som den står: en løsning trenger ingen terskel for M6
|
||||
(presisering 21).
|
||||
(b) *Virkningen må være påvist (presisering 22).* For en terskel i størrelsen $X$ for et mål settes
|
||||
$y_\omega = 1$ når vilkåret for «holder» i målet er oppfylt i trekning $\omega$, og $0$ ellers, over alle
|
||||
de $N$ trekningene (en trekning der banen ikke lar seg bygge, er 0; i M7 også en trekning der A ikke lar
|
||||
seg bygge). $\hat S$ er indeksen i avklaring 110 for $X$ og $y$, med
|
||||
$M = \max(2, \lfloor \sqrt{N}/2 \rfloor)$ klasser, og $K$ er antall klasser som har trekninger. Virkningen
|
||||
er *påvist* når $\hat S$ har en verdi, $K \ge 2$ og
|
||||
$$\hat S > \frac{\chi^2_{K-1;\,0{,}999}}{N},$$
|
||||
der $\chi^2_{K-1;\,0{,}999}$ er 99,9-persentilen i kjikvadratfordelingen med $K - 1$ frihetsgrader. For et
|
||||
utfall som er 1 eller 0, er $N \hat S$ Pearsons observator for uavhengighet mellom klasse og vilkår, så
|
||||
prøven er kjikvadratprøven på 0,1 %-nivå. Prøven avhenger ikke av retningen og gjøres for hver terskel
|
||||
etter avklaring 108, også tersklene for M6 og M7, som vises. En terskel *teller* når størrelsen har status
|
||||
«kilde», virkningen er påvist, og (c) er oppfylt der den gjelder. For hver terskel står indeksen og om
|
||||
virkningen er påvist; en terskel i en størrelse med kilde som ikke består prøven, vises med «virkning
|
||||
ikke påvist». Følge: med få trekninger kan ingen terskel telle (med $N = 10$ er grensen $10{,}83/10 > 1$,
|
||||
og indeksen er høyst 1). Det gjelder bare prøver på oppdiktede tall; med 10 000 trekninger og 50 klasser
|
||||
er grensen 0,0085. Persentilen regnes med et bibliotek (scipy); to regnemåter kan avvike i siste siffer,
|
||||
og en indeks nøyaktig på grensen er ikke ventet.
|
||||
(c) *En terskel i $\rho_N$ (presisering 23).* $m$ er medianen av $\rho_D$ over alle trekningene (formelen
|
||||
i avklaring 99). Nedre halvdel er trekningene med $\rho_D \le m$, øvre dem med $\rho_D > m$. En terskel
|
||||
$c$ i $\rho_N$ teller bare når vilkåret, i hver av de to halvdelene, er oppfylt i minst 80 % (50 % i M7)
|
||||
av trekningene i halvdelen som betingelsen gjelder ($\rho_N \le c$ i retningen «høyst», $\rho_N \ge c$ i
|
||||
«minst»). En halvdel der betingelsen ikke gjelder noen trekning, holder ikke. Terskelens verdi søkes som
|
||||
før (avklaring 108): halvdelene avgjør bare om den teller, og det står ved terskelen om de holder.
|
||||
Regelen gjelder bare $\rho_N$; de tre andre korrelerte parene har kilde på begge sider.
|
||||
(d) *Betingelser samtidig (avklaring 114 d).* For en løsning som ikke er felt, som har betingelser som
|
||||
kan navngis, og som har minst ett av M1 til M4 «holder under betingelser»: for hvert slikt mål velges
|
||||
terskelen som teller med høyest sannsynlighet; ved likhet den første i rekkefølgen (størrelsene i
|
||||
parameterfilas rekkefølge, «høyst» før «minst»). Det oppgis hvor stor andel av alle trekningene som
|
||||
oppfyller alle de valgte betingelsene, og blant dem andelen der vilkårene for «holder» i M1, M2, M3 og M4
|
||||
alle er oppfylt i samme trekning; den siste har ingen verdi når ingen trekning oppfyller betingelsene. M5
|
||||
har ikke noe vilkår per trekning og inngår ikke. Tallene endrer ingen dom.
|
||||
|
||||
## 17. Tillegget til retningen (2026-11-12)
|
||||
|
||||
|
|
|
|||
|
|
@ -376,6 +376,23 @@ class Losningsdommer:
|
|||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Samtidig:
|
||||
"""The conditions of one solution taken together (clarifications 114 d and 115 d).
|
||||
|
||||
Attributes:
|
||||
valgt: per target among M1 to M4 that holds under conditions, the threshold that
|
||||
counts with the highest probability; the first of them when several are equal.
|
||||
sannsynlighet: the share of all the draws that meets every chosen condition.
|
||||
andel_oppfylt: among those draws, the share in which the conditions for «holder»
|
||||
in M1, M2, M3 and M4 are all met; None when no draw meets the chosen conditions.
|
||||
"""
|
||||
|
||||
valgt: Mapping[str, Terskel]
|
||||
sannsynlighet: float
|
||||
andel_oppfylt: float | None
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Betingelser:
|
||||
"""The conditions behind «holder under betingelser» for one solution (clarification 109).
|
||||
|
|
@ -386,13 +403,16 @@ class Betingelser:
|
|||
kan_navngis: True when each of them has a condition that can be named: a threshold
|
||||
that counts for M1 to M4, and by definition for M5.
|
||||
terskler: the thresholds per target that holds under conditions, also M6, which
|
||||
needs none; those that count and those in quantities without a source.
|
||||
needs none; those that count and those that do not.
|
||||
samtidig: the conditions taken together, for a solution that is not felled, whose
|
||||
conditions can be named and that has one of M1 to M4 under conditions; else None.
|
||||
"""
|
||||
|
||||
felt: bool
|
||||
maal: tuple[str, ...]
|
||||
kan_navngis: bool
|
||||
terskler: Mapping[str, tuple[Terskel, ...]]
|
||||
samtidig: Samtidig | None = None
|
||||
|
||||
@property
|
||||
def bare_skalaen_mangler(self) -> bool:
|
||||
|
|
@ -570,11 +590,49 @@ def betingelser_for_losning(
|
|||
if dom.maal[m].dom is Dom.BETINGELSER
|
||||
}
|
||||
har_terskel = {m: any(t.teller for t in rad) for m, rad in funnet.items()}
|
||||
maal = dommer.maal_under_betingelser(dom.dommer)
|
||||
kan_navngis = dommer.kan_navngis(dom.dommer, har_terskel)
|
||||
valgt = {
|
||||
# max keeps the first of several with the same probability
|
||||
m: max((t for t in funnet[m] if t.teller), key=lambda t: t.sannsynlighet)
|
||||
for m in maal
|
||||
if m in MAAL_SAMTIDIG and har_terskel.get(m, False)
|
||||
}
|
||||
return Betingelser(
|
||||
felt=dom.felt,
|
||||
maal=dommer.maal_under_betingelser(dom.dommer),
|
||||
kan_navngis=dommer.kan_navngis(dom.dommer, har_terskel),
|
||||
maal=maal,
|
||||
kan_navngis=kan_navngis,
|
||||
terskler=funnet,
|
||||
samtidig=_samtidig(valgt, holder, storrelser)
|
||||
if valgt and kan_navngis and not dom.felt
|
||||
else None,
|
||||
)
|
||||
|
||||
|
||||
MAAL_SAMTIDIG: Final = ("M1", "M2", "M3", "M4")
|
||||
"""The targets whose conditions are taken together (clarification 115 d)."""
|
||||
|
||||
|
||||
def _samtidig(
|
||||
valgt: Mapping[str, Terskel],
|
||||
holder: Mapping[str, Sequence[bool | None]],
|
||||
storrelser: Mapping[str, Sequence[float]],
|
||||
) -> Samtidig:
|
||||
N = len(holder["M1"])
|
||||
gjelder = [
|
||||
all(
|
||||
storrelser[t.storrelse][j] <= t.verdi
|
||||
if t.retning is terskler.Retning.HOYST
|
||||
else storrelser[t.storrelse][j] >= t.verdi
|
||||
for t in valgt.values()
|
||||
)
|
||||
for j in range(N)
|
||||
]
|
||||
oppfylt = [all(holder[m][j] is True for m in MAAL_SAMTIDIG) for j in range(N) if gjelder[j]]
|
||||
return Samtidig(
|
||||
valgt=valgt,
|
||||
sannsynlighet=lg.s37_andel(gjelder),
|
||||
andel_oppfylt=lg.s37_andel(oppfylt) if oppfylt else None,
|
||||
)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,13 @@ with a median that is not negative; it is found to within ``K_TOLERANSE``.
|
|||
A threshold in one drawn quantity is the least strict condition on that
|
||||
quantity, between its 10th and 90th percentile, under which a target that
|
||||
holds under conditions holds. It counts as a condition only for a quantity
|
||||
with the status «kilde» (pre-registration, clarification 5).
|
||||
with the status «kilde» (pre-registration, clarification 5), and only when the
|
||||
quantity demonstrably affects the outcome: the condition for «holder» and the
|
||||
quantity must not be independent in the draws, tested at the 0.1 % level
|
||||
(pre-registration, clarification 22; chapter 16, clarification 115 b). A
|
||||
threshold in the required return for power must also hold in each half of the
|
||||
draws by the required return for compute, an assumption without a source it
|
||||
is correlated with (clarification 23; 115 c).
|
||||
|
||||
A threshold surface is the net present value over classes of two quantities.
|
||||
|
||||
|
|
@ -27,6 +33,8 @@ import math
|
|||
from dataclasses import dataclass
|
||||
from typing import TYPE_CHECKING, Final
|
||||
|
||||
from scipy import stats
|
||||
|
||||
from tokenfabrikker import dommer, sobol
|
||||
from tokenfabrikker import ligninger as lg
|
||||
|
||||
|
|
@ -45,6 +53,12 @@ SPENN: Final = (0.1, 0.9)
|
|||
STATUS_KILDE: Final = "kilde"
|
||||
"""The status in the parameter file a quantity must have for its threshold to count."""
|
||||
|
||||
NIVAA_PAAVIST: Final = 0.999
|
||||
"""The percentile of the chi-square distribution an effect must pass (clarification 115 b)."""
|
||||
|
||||
KORRELERT_MED_FORUTSETNING: Final[Mapping[str, str]] = {"rho_N": "rho_D"}
|
||||
"""A quantity with a source that is correlated with an assumption without one (115 c)."""
|
||||
|
||||
KLASSER_FLATE: Final = 5
|
||||
"""The classes per axis of a threshold surface (clarification 111)."""
|
||||
|
||||
|
|
@ -165,8 +179,17 @@ class Terskel:
|
|||
verdi: the threshold, in the unit the draws are passed in.
|
||||
sannsynlighet: the share of all the draws the condition covers.
|
||||
andel_oppfylt: the share that meets the condition for «holder» among them.
|
||||
teller: True when the quantity has the status «kilde», so that the threshold counts
|
||||
as a condition; otherwise it «depends on an assumption without a source».
|
||||
teller: True when the threshold counts as a condition: the quantity has a source,
|
||||
the effect is demonstrated, and the two halves hold where that rule applies.
|
||||
kilde: True when the quantity has the status «kilde»; otherwise the threshold
|
||||
«depends on an assumption without a source».
|
||||
indeks: the first-order index of the quantity for the condition for «holder», over
|
||||
all the draws; None when every draw has the same outcome.
|
||||
paavist: True when the index is above the limit of the chi-square test
|
||||
(clarification 115 b): the quantity demonstrably affects the outcome.
|
||||
begge_halvdeler: for a quantity correlated with an assumption without a source,
|
||||
whether the target holds under the condition in each half of the draws by that
|
||||
assumption (clarification 115 c); None for every other quantity.
|
||||
"""
|
||||
|
||||
storrelse: str
|
||||
|
|
@ -175,6 +198,10 @@ class Terskel:
|
|||
sannsynlighet: float
|
||||
andel_oppfylt: float
|
||||
teller: bool
|
||||
kilde: bool
|
||||
indeks: float | None
|
||||
paavist: bool
|
||||
begge_halvdeler: bool | None = None
|
||||
|
||||
|
||||
def terskel(
|
||||
|
|
@ -219,35 +246,115 @@ def terskel(
|
|||
return None
|
||||
|
||||
|
||||
def grense_paavist(N: int, K: int) -> float | None:
|
||||
"""The limit the index must be above for an effect to be demonstrated (115 b).
|
||||
|
||||
The 99.9th percentile of the chi-square distribution with K - 1 degrees of
|
||||
freedom, over N: for an outcome that is 1 or 0, N times the index is
|
||||
Pearson's statistic for independence between class and outcome. None with
|
||||
fewer than two classes, where nothing can be demonstrated.
|
||||
"""
|
||||
if K < 2: # noqa: PLR2004 - one class leaves no degree of freedom
|
||||
return None
|
||||
return float(stats.chi2.ppf(NIVAA_PAAVIST, K - 1)) / N
|
||||
|
||||
|
||||
def virkning(x: Sequence[float], oppfylt: Sequence[bool | None]) -> tuple[float | None, bool]:
|
||||
"""The index of a quantity for the condition for «holder», and whether it is demonstrated.
|
||||
|
||||
The outcome is 1 where the condition is met and 0 elsewhere, also where
|
||||
the path cannot be built, over all the draws (clarification 115 b).
|
||||
"""
|
||||
indeks = sobol.indeks(x, [1.0 if o is True else 0.0 for o in oppfylt])
|
||||
grense = grense_paavist(len(x), sobol.klasser_med_trekninger(x))
|
||||
return indeks, indeks is not None and grense is not None and indeks > grense
|
||||
|
||||
|
||||
def holder_i_begge_halvdeler(
|
||||
x: Sequence[float],
|
||||
partner: Sequence[float],
|
||||
oppfylt: Sequence[bool | None],
|
||||
retning: Retning,
|
||||
verdi: float,
|
||||
*,
|
||||
grense: float = dommer.ANDEL_HOLDER,
|
||||
) -> bool:
|
||||
"""Whether a target holds under one condition in each half of the draws by ``partner``.
|
||||
|
||||
The lower half is the draws with the partner at most at its median over
|
||||
all the draws, the upper half those above it. In each half the condition
|
||||
for «holder» must be met in at least ``grense`` of the draws the condition
|
||||
on ``x`` covers; a half in which it covers no draw does not hold
|
||||
(clarification 115 c).
|
||||
"""
|
||||
if not len(x) == len(partner) == len(oppfylt):
|
||||
msg = "the halves need the quantity, its partner and the outcome for the same draws"
|
||||
raise ValueError(msg)
|
||||
median = dommer.persentil(partner, 0.5)
|
||||
for nedre in (True, False):
|
||||
gjelder = [
|
||||
o is True
|
||||
for v, q, o in zip(x, partner, oppfylt, strict=True)
|
||||
if (q <= median) is nedre and (v <= verdi if retning is Retning.HOYST else v >= verdi)
|
||||
]
|
||||
if not gjelder or sum(gjelder) / len(gjelder) < grense:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def terskler_for_maal(
|
||||
storrelser: Mapping[str, Sequence[float]],
|
||||
status: Mapping[str, str],
|
||||
oppfylt: Sequence[bool | None],
|
||||
*,
|
||||
grense: float = dommer.ANDEL_HOLDER,
|
||||
partnere: Mapping[str, str] = KORRELERT_MED_FORUTSETNING,
|
||||
) -> tuple[Terskel, ...]:
|
||||
"""Every threshold for one target of one solution, over the drawn quantities.
|
||||
|
||||
``storrelser`` holds the drawn values per quantity and ``status`` its
|
||||
status in the parameter file. The thresholds come in the order of the
|
||||
quantities, at most before at least.
|
||||
quantities, at most before at least. A threshold counts when the quantity
|
||||
has a source, its effect is demonstrated and, for a quantity in
|
||||
``partnere``, the target holds under the condition in each half of the
|
||||
draws by its partner, which must then be among the quantities
|
||||
(clarification 115).
|
||||
"""
|
||||
ut = []
|
||||
for navn, x in storrelser.items():
|
||||
for retning in Retning:
|
||||
funnet = terskel(x, oppfylt, retning, grense=grense)
|
||||
if funnet is not None:
|
||||
verdi, sannsynlighet, andel_oppfylt = funnet
|
||||
ut.append(
|
||||
Terskel(
|
||||
storrelse=navn,
|
||||
retning=retning,
|
||||
verdi=verdi,
|
||||
sannsynlighet=sannsynlighet,
|
||||
andel_oppfylt=andel_oppfylt,
|
||||
teller=status[navn] == STATUS_KILDE,
|
||||
)
|
||||
funnet = {retning: terskel(x, oppfylt, retning, grense=grense) for retning in Retning}
|
||||
if all(f is None for f in funnet.values()):
|
||||
continue
|
||||
kilde = status[navn] == STATUS_KILDE
|
||||
indeks, paavist = virkning(x, oppfylt)
|
||||
if navn in partnere and partnere[navn] not in storrelser:
|
||||
msg = f"a threshold in {navn} needs the drawn values of {partnere[navn]}"
|
||||
raise ValueError(msg)
|
||||
for retning, f in funnet.items():
|
||||
if f is None:
|
||||
continue
|
||||
verdi, sannsynlighet, andel_oppfylt = f
|
||||
halvdeler = (
|
||||
holder_i_begge_halvdeler(
|
||||
x, storrelser[partnere[navn]], oppfylt, retning, verdi, grense=grense
|
||||
)
|
||||
if navn in partnere
|
||||
else None
|
||||
)
|
||||
ut.append(
|
||||
Terskel(
|
||||
storrelse=navn,
|
||||
retning=retning,
|
||||
verdi=verdi,
|
||||
sannsynlighet=sannsynlighet,
|
||||
andel_oppfylt=andel_oppfylt,
|
||||
teller=kilde and paavist and halvdeler is not False,
|
||||
kilde=kilde,
|
||||
indeks=indeks,
|
||||
paavist=paavist,
|
||||
begge_halvdeler=halvdeler,
|
||||
)
|
||||
)
|
||||
return tuple(ut)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -539,22 +539,41 @@ def test_de_seks_scenarioene_og_stigen_er_de_forhaandsregistrerte() -> None:
|
|||
X10 = [float(v) for v in range(1, 11)]
|
||||
"""An invented quantity over ten draws: its 10th percentile is 1.9 and its 90th 9.1."""
|
||||
|
||||
X40 = [float(v) for v in range(1, 41)]
|
||||
"""An invented quantity over forty draws: its 10th percentile is 4.9 and its 90th 36.1."""
|
||||
|
||||
def _ti_trekninger_der_A_er_positiv_til_og_med(grense: int) -> Kjoring:
|
||||
"""Ten draws of A on step 5: net present value positive in the first ``grense`` of them."""
|
||||
return _kjoring([{(Losning.A, 5): _alle(_u(1.0 if j < grense else -1.0))} for j in range(10)])
|
||||
Z40 = [
|
||||
float(v)
|
||||
for v in (
|
||||
*(*range(1, 12), *range(15, 24), *range(28, 36)), # the draws 1 to 28
|
||||
*(12, 13, 14, 24, 25, 26, 27, 36, 37, 38, 39, 40), # the draws 29 to 40
|
||||
)
|
||||
]
|
||||
"""A quantity that says next to nothing about an outcome that turns at draw 28."""
|
||||
|
||||
|
||||
def _trekninger_der_A_er_positiv_til_og_med(grense: int, antall: int = 40) -> Kjoring:
|
||||
"""Draws of A on step 5: net present value positive in the first ``grense`` of them."""
|
||||
return _kjoring(
|
||||
[{(Losning.A, 5): _alle(_u(1.0 if j < grense else -1.0))} for j in range(antall)]
|
||||
)
|
||||
|
||||
|
||||
def _kjerne(t: Terskel) -> tuple[object, ...]:
|
||||
"""A threshold without its index, which is tested in ``test_terskler.py``."""
|
||||
return (t.storrelse, t.retning, t.verdi, t.sannsynlighet, t.andel_oppfylt, t.teller)
|
||||
|
||||
|
||||
def test_del_I_avgjores_med_tersklene() -> None:
|
||||
"""M1 is positive in 7 of 10 draws: at most 8 of the quantity gives 7 of 8."""
|
||||
kjoring = _ti_trekninger_der_A_er_positiv_til_og_med(7)
|
||||
"""M1 is positive in 28 of 40 draws: at most 35 of the quantity gives 28 of 35."""
|
||||
kjoring = _trekninger_der_A_er_positiv_til_og_med(28)
|
||||
M5 = {Losning.A: Dom.HOLDER}
|
||||
uten = kj.sett_dommer(kjoring, M5)
|
||||
assert uten.del_I is Dom.BETINGELSER
|
||||
assert uten.scenarioer[NORM.navn].betingelser is None
|
||||
assert not uten.scenarioer[NORM.navn].del_I_avgjort
|
||||
|
||||
storrelser = {"x": X10, "z": [11.0 - v for v in X10]}
|
||||
storrelser = {"x": X40, "z": [41.0 - v for v in X40]}
|
||||
d = kj.sett_dommer(
|
||||
kjoring, M5, storrelser=storrelser, status={"x": "kilde", "z": "åpen forutsetning"}
|
||||
)
|
||||
|
|
@ -564,12 +583,17 @@ def test_del_I_avgjores_med_tersklene() -> None:
|
|||
assert norm.betingelser is not None
|
||||
b = norm.betingelser[Losning.A]
|
||||
assert (b.felt, b.maal, b.kan_navngis, b.bare_skalaen_mangler) == (False, ("M1",), True, False)
|
||||
assert b.terskler == {
|
||||
"M1": (
|
||||
Terskel("x", Retning.HOYST, 8.0, 0.8, 0.875, teller=True),
|
||||
Terskel("z", Retning.MINST, 3.0, 0.8, 0.875, teller=False),
|
||||
)
|
||||
assert {m: [_kjerne(t) for t in rad] for m, rad in b.terskler.items()} == {
|
||||
"M1": [
|
||||
("x", Retning.HOYST, 35.0, 0.875, 0.8, True),
|
||||
("z", Retning.MINST, 6.0, 0.875, 0.8, False),
|
||||
]
|
||||
}
|
||||
assert [(t.kilde, t.paavist) for t in b.terskler["M1"]] == [(True, True), (False, True)]
|
||||
# one target under conditions: taken together it is that one condition
|
||||
assert b.samtidig is not None
|
||||
assert b.samtidig.valgt == {"M1": b.terskler["M1"][0]}
|
||||
assert (b.samtidig.sannsynlighet, b.samtidig.andel_oppfylt) == (0.875, 0.8)
|
||||
# the same threshold in a quantity without a source does not count: part I does not hold
|
||||
d = kj.sett_dommer(
|
||||
kjoring,
|
||||
|
|
@ -581,15 +605,100 @@ def test_del_I_avgjores_med_tersklene() -> None:
|
|||
assert d.del_I is Dom.HOLDER_IKKE
|
||||
assert norm.betingelser is not None
|
||||
assert not norm.betingelser[Losning.A].kan_navngis
|
||||
assert norm.betingelser[Losning.A].samtidig is None
|
||||
assert [t.teller for t in norm.betingelser[Losning.A].terskler["M1"]] == [False, False]
|
||||
# and with a quantity that says nothing there is no threshold at all
|
||||
d = kj.sett_dommer(kjoring, M5, storrelser={"c": [1.0] * 10}, status={"c": "kilde"})
|
||||
d = kj.sett_dommer(kjoring, M5, storrelser={"c": [1.0] * 40}, status={"c": "kilde"})
|
||||
assert d.del_I is Dom.HOLDER_IKKE
|
||||
norm = d.scenarioer[NORM.navn]
|
||||
assert norm.betingelser is not None
|
||||
assert norm.betingelser[Losning.A].terskler == {"M1": ()}
|
||||
|
||||
|
||||
def test_en_terskel_uten_paavist_virkning_gir_ingen_betingelse() -> None:
|
||||
"""Pre-registration, clarification 22: «at most 35» of z holds, but z has no shown effect."""
|
||||
kjoring = _trekninger_der_A_er_positiv_til_og_med(28)
|
||||
d = kj.sett_dommer(
|
||||
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"z": Z40}, status={"z": "kilde"}
|
||||
)
|
||||
norm = d.scenarioer[NORM.navn]
|
||||
assert norm.betingelser is not None
|
||||
b = norm.betingelser[Losning.A]
|
||||
(t,) = b.terskler["M1"]
|
||||
assert _kjerne(t) == ("z", Retning.HOYST, 35.0, 0.875, 0.8, False)
|
||||
assert (t.kilde, t.paavist) == (True, False)
|
||||
assert (b.kan_navngis, b.samtidig, d.del_I) == (False, None, Dom.HOLDER_IKKE)
|
||||
# with ten draws no effect can be shown, whatever the quantity
|
||||
faa = _trekninger_der_A_er_positiv_til_og_med(7, antall=10)
|
||||
d = kj.sett_dommer(faa, {Losning.A: Dom.HOLDER}, storrelser={"x": X10}, status={"x": "kilde"})
|
||||
assert d.del_I is Dom.HOLDER_IKKE
|
||||
|
||||
|
||||
def test_en_terskel_i_rho_N_teller_ikke_naar_den_baerer_virkningen_av_rho_D() -> None:
|
||||
"""Pre-registration, clarification 23, through the run."""
|
||||
kjoring = _trekninger_der_A_er_positiv_til_og_med(30)
|
||||
M5 = {Losning.A: Dom.HOLDER}
|
||||
status = {"rho_N": "kilde", "rho_D": "åpen forutsetning"}
|
||||
veksler = [float(j % 2) for j in range(40)]
|
||||
d = kj.sett_dommer(kjoring, M5, storrelser={"rho_N": X40, "rho_D": veksler}, status=status)
|
||||
assert d.del_I is Dom.BETINGELSER
|
||||
d = kj.sett_dommer(kjoring, M5, storrelser={"rho_N": X40, "rho_D": X40}, status=status)
|
||||
assert d.del_I is Dom.HOLDER_IKKE
|
||||
b = d.scenarioer[NORM.navn].betingelser
|
||||
assert b is not None
|
||||
assert [(t.storrelse, t.begge_halvdeler) for t in b[Losning.A].terskler["M1"]] == [
|
||||
("rho_N", False),
|
||||
("rho_D", None),
|
||||
]
|
||||
|
||||
|
||||
def test_betingelsene_samtidig() -> None:
|
||||
"""Clarification 115 d: M1 fails where x is above 28, M3 where it is below 13.
|
||||
|
||||
«At most 35» for M1 and «at least 6» for M3 each cover 35 of 40 draws. Together they
|
||||
cover the 30 draws from 6 to 35, and M1 to M4 are all met in the 16 from 13 to 28.
|
||||
"""
|
||||
|
||||
def trekning(x: float) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
|
||||
return {(Losning.A, 5): _alle(_u(1.0 if x <= 28 else -1.0, M3=0.0 if x >= 13 else 0.1))}
|
||||
|
||||
kjoring = _kjoring([trekning(x) for x in X40])
|
||||
d = kj.sett_dommer(
|
||||
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"x": X40}, status={"x": "kilde"}
|
||||
)
|
||||
b = d.scenarioer[NORM.navn].betingelser
|
||||
assert b is not None
|
||||
a = b[Losning.A]
|
||||
assert (a.maal, a.kan_navngis, d.del_I) == (("M1", "M3"), True, Dom.BETINGELSER)
|
||||
assert a.samtidig is not None
|
||||
assert {m: _kjerne(t) for m, t in a.samtidig.valgt.items()} == {
|
||||
"M1": ("x", Retning.HOYST, 35.0, 0.875, 0.8, True),
|
||||
"M3": ("x", Retning.MINST, 6.0, 0.875, 0.8, True),
|
||||
}
|
||||
assert (a.samtidig.sannsynlighet, a.samtidig.andel_oppfylt) == (0.75, 16 / 30)
|
||||
|
||||
|
||||
def test_betingelser_som_utelukker_hverandre_har_ingen_andel() -> None:
|
||||
"""M2 is met up to 14 («at most 17») and M3 from 27 («at least 24»): no draw meets both."""
|
||||
|
||||
def trekning(x: float) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
|
||||
return {(Losning.A, 5): _alle(_u(S42=1.0 if x <= 14 else -1.0, M3=0.0 if x >= 27 else 0.1))}
|
||||
|
||||
kjoring = _kjoring([trekning(x) for x in X40])
|
||||
d = kj.sett_dommer(
|
||||
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"x": X40}, status={"x": "kilde"}
|
||||
)
|
||||
b = d.scenarioer[NORM.navn].betingelser
|
||||
assert b is not None
|
||||
a = b[Losning.A]
|
||||
assert a.samtidig is not None
|
||||
assert {m: (t.retning, t.verdi) for m, t in a.samtidig.valgt.items()} == {
|
||||
"M2": (Retning.HOYST, 17.0),
|
||||
"M3": (Retning.MINST, 24.0),
|
||||
}
|
||||
assert (a.samtidig.sannsynlighet, a.samtidig.andel_oppfylt) == (0.0, None)
|
||||
|
||||
|
||||
def test_M5_under_betingelser_er_navngitt_og_M6_trenger_ingen_terskel() -> None:
|
||||
"""Clarifications 93 and 109: A has M5 and M6 under conditions and no threshold anywhere."""
|
||||
kjoring = _kjoring([{(Losning.A, 5): _alle(_u(M6=0.1))} for _ in range(10)])
|
||||
|
|
@ -627,13 +736,14 @@ def test_tersklene_for_M7_vises_og_endrer_ingenting() -> None:
|
|||
d = kj.sett_dommer(kjoring, M5, storrelser={"x": X10}, status={"x": "åpen forutsetning"})
|
||||
norm = d.scenarioer[NORM.navn]
|
||||
assert norm.M7[5].dom is Dom.BETINGELSER
|
||||
assert norm.terskler_M7 == (Terskel("x", Retning.HOYST, 8.0, 0.8, 0.5, teller=False),)
|
||||
(t,) = norm.terskler_M7
|
||||
assert _kjerne(t) == ("x", Retning.HOYST, 8.0, 0.8, 0.5, False)
|
||||
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
|
||||
assert kj.sett_dommer(kjoring, M5).scenarioer[NORM.navn].terskler_M7 == ()
|
||||
|
||||
|
||||
def test_tersklene_trenger_verdier_og_status_for_hver_trekning() -> None:
|
||||
kjoring = _ti_trekninger_der_A_er_positiv_til_og_med(7)
|
||||
kjoring = _trekninger_der_A_er_positiv_til_og_med(7, antall=10)
|
||||
M5 = {Losning.A: Dom.HOLDER}
|
||||
with pytest.raises(ValueError, match="both the drawn values and the status"):
|
||||
kj.sett_dommer(kjoring, M5, storrelser={"x": X10})
|
||||
|
|
|
|||
|
|
@ -157,14 +157,117 @@ def test_terskelen_trenger_en_verdi_per_trekning() -> None:
|
|||
terskler.terskel([], [], Retning.HOYST)
|
||||
|
||||
|
||||
def test_terskler_for_et_maal_teller_bare_for_storrelser_med_kilde() -> None:
|
||||
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"}
|
||||
assert terskler.terskler_for_maal(storrelser, status, oppfylt) == (
|
||||
Terskel("a", Retning.HOYST, 7.0, 0.7, 6 / 7, teller=True),
|
||||
Terskel("b", Retning.MINST, 4.0, 0.7, 6 / 7, teller=False),
|
||||
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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue