tokenfabrikker/tests/test_dommer.py
Kjell Tore Guttormsen 6a51c4f4d2
feat(grunnlag): the approved EEA assessment as a fixed table, and M7 rejects a net present value that is not a number (clarifications 136 and 139)
fra_frys takes the assessment of clarification 136 («usikker» for all
four ownership forms) and has no guard any more; it is still not called
before part 6. beste_per_trekning raises on NaN, where the best would
depend on the order of the solutions.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-14 06:43:45 +01:00

365 lines
17 KiB
Python

"""The verdicts (chapter 11 and the pre-registration), tested on invented outcomes.
No array here comes from the model run on the frozen parameters: the outcomes per draw are
made up, and the two conditions that are read from the power system are computed on the
made-up set in ``conftest.py``. Nothing here says anything about the hypothesis.
"""
from __future__ import annotations
import math
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import dommer
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag, Trinnvalg
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
_UENDRET = Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False)
_EFFEKT_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=False)
_ENERGI_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=True)
def _utfall(*deler: tuple[float | None, int]) -> list[float | None]:
"""Invented outcomes: each value repeated the given number of draws."""
return [verdi for verdi, antall in deler for _ in range(antall)]
def _regn(inn: Inndata, losning: Losning, *, N_anlegg: int = 1) -> ks.Programresultat:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
return ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING, dim=dim)
# ------------------------------------------------------------------- shares
def test_s37_andel() -> None:
assert lg.s37_andel([True, False, True, True]) == 0.75
with pytest.raises(ValueError, match="at least one draw"):
lg.s37_andel([])
def test_trekning_uten_verdi_teller_i_nevneren() -> None:
utfall = _utfall((1.0, 6), (-1.0, 2), (None, 2))
assert dommer.andel_positiv(utfall) == 0.6
assert dommer.andel(utfall, 0.0, minst=True) == 0.6
assert dommer.andel(utfall, 0.0, minst=False) == 0.2
assert dommer.median(utfall) == 1.0
assert dommer.median(_utfall((1.0, 4), (None, 6))) == -math.inf
# -------------------------------------------------------------- M1, M2
@pytest.mark.parametrize(
("positive", "negative", "uten", "dom"),
[
(80, 20, 0, Dom.HOLDER),
(79, 21, 0, Dom.BETINGELSER),
(20, 80, 0, Dom.BETINGELSER),
(19, 81, 0, Dom.HOLDER_IKKE),
(80, 0, 20, Dom.HOLDER),
(79, 0, 21, Dom.BETINGELSER),
(19, 0, 81, Dom.HOLDER_IKKE),
],
)
def test_dom_m1(positive: int, negative: int, uten: int, dom: Dom) -> None:
"""Positive in at least 80 % of all draws holds; in under 20 % it does not."""
assert dommer.dom_m1(_utfall((5.0, positive), (-5.0, negative), (None, uten))) is dom
def test_dom_m2_teller_null_som_oppfylt() -> None:
"""S42 is an inequality with >=: a sum of exactly zero meets it."""
assert dommer.dom_m2(_utfall((0.0, 80), (-1.0, 20))) is Dom.HOLDER
assert dommer.dom_m2(_utfall((0.0, 50), (-1.0, 50))) is Dom.BETINGELSER
assert dommer.dom_m2(_utfall((1.0, 10), (-1.0, 50), (None, 40))) is Dom.HOLDER_IKKE
def test_m7_hvem_som_er_best_blant_a_b_og_c() -> None:
"""Clarification 137 a, one rule for each: the highest value among those that can be built.
Ten draws. 0-4: A highest. 5-7: B highest (A lower, C equal to A in 5-7). 8-9: A cannot
be built, B is negative and C cannot be built either: B is best alone. The two versions of
solution T are left out here; ``test_trinnvis_dommer.py`` has all five.
"""
A = _utfall((10.0, 5), (1.0, 3), (None, 2))
B = _utfall((5.0, 5), (2.0, 3), (-9.0, 2))
C = _utfall((None, 5), (1.0, 3), (None, 2))
beste = dommer.beste_per_trekning({Losning.A: A, Losning.B: B, Losning.C: C})
assert beste == [(Losning.A,)] * 5 + [(Losning.B,)] * 5
# equal values share the place, in the order A, B, C; none built leaves none
assert dommer.beste_per_trekning({Losning.A: [1.0], Losning.B: [1.0], Losning.C: [0.0]}) == [
(Losning.A, Losning.B)
]
assert dommer.beste_per_trekning({Losning.C: [3.0], Losning.B: [2.0], Losning.A: [3.0]}) == [
(Losning.A, Losning.C)
]
assert dommer.beste_per_trekning({Losning.A: [None], Losning.B: [None], Losning.C: [None]}) == [
()
]
# C can be best as A can, and a solution that cannot be built is never among the best
assert dommer.beste_per_trekning({Losning.A: [None], Losning.B: [-1.0], Losning.C: [0.0]}) == [
(Losning.C,)
]
# ------------------------------------------------------------------ M3 and M4
def test_M7_avviser_en_netto_naaverdi_som_ikke_er_et_tall() -> None:
"""Clarification 139: with NaN the best would depend on the order of the solutions."""
with pytest.raises(ValueError, match="not a number in draw 1"):
dommer.beste_per_trekning({Losning.A: [1.0, math.nan], Losning.B: [2.0, 0.0]})
with pytest.raises(ValueError, match="not a number in draw 0"):
dommer.beste_per_trekning({Losning.B: [0.0], Losning.C: [math.nan]})
assert dommer.beste_per_trekning({Losning.A: [-math.inf], Losning.B: [None]}) == [(Losning.A,)]
def test_m3_verste_prisvirkning_i_R(oppdiktet: LagInndata) -> None:
"""One facility in R takes 3.942 TWh from the balance: 39.42 kr/MWh on a price of 600.
In the dry year the effect is 1.2 times larger; the price level 1.5 is in both numerator
and denominator. The made-up lines are the same in all areas.
"""
inn = oppdiktet()
res = _regn(inn, Losning.R)
normal = 10e-6 * 0.5 * E_D / 600.0
assert dommer.m3_verste_prisvirkning(inn, res) == pytest.approx(1.2 * normal)
assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.A)) == 0.0
# B produces more than the data centres use: the price falls
assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.B)) < 0
def test_dom_m3() -> None:
assert dommer.dom_m3(_utfall((0.05, 80), (0.2, 20))) is Dom.HOLDER
assert dommer.dom_m3(_utfall((0.051, 80), (0.2, 20))) is Dom.BETINGELSER
assert dommer.dom_m3(_utfall((0.16, 80), (0.0, 20))) is Dom.HOLDER_IKKE
assert dommer.dom_m3(_utfall((0.15, 80), (0.0, 20))) is Dom.BETINGELSER
# a draw without a value meets neither condition
assert dommer.dom_m3(_utfall((0.16, 79), (None, 21))) is Dom.BETINGELSER
assert dommer.dom_m3(_utfall((0.0, 79), (None, 21))) is Dom.BETINGELSER
def test_m4_forsyning_i_de_fem_losningene(oppdiktet: LagInndata) -> None:
"""A changes nothing. R only takes power. B and one facility in C add more than they take.
With three facilities C has used up hydropower and wind on land; offshore wind counts
nothing in the scarcest hour, so capacity is missing, but energy is not.
"""
inn = oppdiktet()
assert dommer.m4_forsyning(inn, _regn(inn, Losning.A)) == _UENDRET
assert dommer.m4_forsyning(inn, _regn(inn, Losning.R)) == _ENERGI_MANGLER
assert dommer.m4_forsyning(inn, _regn(inn, Losning.B)) == _UENDRET
assert dommer.m4_forsyning(inn, _regn(inn, Losning.C)) == _UENDRET
tre = _regn(inn, Losning.C, N_anlegg=3)
assert dommer.m4_forsyning(inn, tre) == _EFFEKT_MANGLER
def test_m4_C_dekker_akkurat_forbruket_i_toerraaret(oppdiktet: LagInndata) -> None:
"""With nothing displaced in the grid queue, C's dry-year balance is zero, not weaker."""
inn = oppdiktet(delta_V=0.0, kappa_vind=1.0)
res = _regn(inn, Losning.C)
assert max(abs(rad.Delta_Q_tort) for rad in res.kraftaar) < 1.0
assert not dommer.m4_forsyning(inn, res).svakere_ogsaa_med_tiltak
def test_dom_m4() -> None:
ok, effekt, energi = _UENDRET, _EFFEKT_MANGLER, _ENERGI_MANGLER
assert dommer.dom_m4([ok] * 8 + [energi] * 2) is Dom.HOLDER
assert dommer.dom_m4([ok] * 7 + [effekt] * 3) is Dom.BETINGELSER
assert dommer.dom_m4([effekt] * 10) is Dom.BETINGELSER
assert dommer.dom_m4([energi] * 8 + [ok] * 2) is Dom.HOLDER_IKKE
assert dommer.dom_m4([energi] * 7 + [None] * 3) is Dom.BETINGELSER
# -------------------------------------------------------- M6 and the ladder
def test_dom_m6() -> None:
assert dommer.dom_m6(_utfall((0.25, 80), (0.0, 20))) is Dom.HOLDER
assert dommer.dom_m6(_utfall((0.24, 80), (0.0, 20))) is Dom.BETINGELSER
assert dommer.dom_m6(_utfall((0.049, 80), (0.3, 20))) is Dom.HOLDER_IKKE
assert dommer.dom_m6(_utfall((0.05, 80), (0.3, 20))) is Dom.BETINGELSER
# a path that cannot be built does not reach 5 %
assert dommer.dom_m6(_utfall((0.3, 20), (None, 80))) is Dom.HOLDER_IKKE
def _stige(**andel_per_trinn: tuple[float, int]) -> dict[int, dict[Losning, list[float | None]]]:
"""A made-up ladder: for A, M6 is the given value in the given number of 10 draws.
B can be built in the same draws and contributes nothing; R reaches 90 % everywhere.
"""
stige = {}
for navn, (verdi, antall) in andel_per_trinn.items():
trinn = int(navn.removeprefix("n"))
stige[trinn] = {
Losning.A: _utfall((verdi, antall), (None, 10 - antall)),
Losning.B: _utfall((0.0, antall), (None, 10 - antall)),
Losning.R: _utfall((0.9, 10)),
}
return stige
def test_dommene_leses_paa_det_laveste_trinnet_som_gir_25_prosent() -> None:
stige = _stige(n1=(0.03, 10), n5=(0.1, 10), n10=(0.3, 8), n20=(0.5, 10))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(10, Grunnlag.TRINN_25)
def test_trinnet_med_ett_anlegg_kan_ikke_vaere_25_prosent_trinnet() -> None:
"""Clarification 104: step 1 reaches 25 % and so does step 10; step 5 only reaches 5 %."""
stige = _stige(n1=(0.3, 10), n5=(0.1, 10), n10=(0.3, 8))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(10, Grunnlag.TRINN_25)
def test_naar_bare_ett_anlegg_naar_25_prosent_leses_dommene_paa_5_prosent_trinnet() -> None:
"""Clarification 104: there is no 25 % step, and step 1 is the lowest that reaches 5 %."""
stige = _stige(n1=(0.3, 10), n5=(0.1, 10), n10=(0.2, 10))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(1, Grunnlag.TRINN_5)
# the single facility reaches 25 % in too few draws to be the 5 % step: the next step is
stige = _stige(n1=(0.3, 7), n5=(0.1, 10))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.TRINN_5)
# a ladder with the single facility only
assert dommer.trinn_for_dommene(_stige(n1=(0.3, 10))) == Trinnvalg(1, Grunnlag.TRINN_5)
def test_regelen_for_trinnet_er_monoton_i_trinnet_med_ett_anlegg() -> None:
"""Clarification 104: a weaker single facility no longer gives another step (103 g)."""
sterk = _stige(n1=(0.3, 10), n5=(0.3, 10))
svak = _stige(n1=(0.03, 10), n5=(0.3, 10))
assert dommer.trinn_for_dommene(sterk) == Trinnvalg(5, Grunnlag.TRINN_25)
assert dommer.trinn_for_dommene(svak) == Trinnvalg(5, Grunnlag.TRINN_25)
def test_ellers_paa_trinnet_som_gir_5_prosent() -> None:
"""25 % is reached in only 7 of 10 draws on the top step; 5 % in 8 of 10 from step 5."""
stige = _stige(n1=(0.03, 10), n5=(0.1, 8), n10=(0.3, 7))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.TRINN_5)
def test_ellers_paa_hoyeste_trinn_som_lar_seg_bygge() -> None:
"""No step reaches 5 %. Step 10 can be built in 7 of 10 draws, step 5 in 9."""
stige = _stige(n1=(0.01, 10), n5=(0.03, 9), n10=(0.04, 7))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.HOYESTE)
def test_referansekjoringen_kan_ikke_gi_trinnet() -> None:
"""R reaches 90 % on every step here, but only A, B, C, T-F and T-K decide the step."""
stige = _stige(n1=(0.0, 10), n5=(0.0, 10))
assert dommer.trinn_for_dommene(stige).grunnlag is Grunnlag.HOYESTE
def test_ingen_trinn_lar_seg_bygge() -> None:
stige = {
1: {
Losning.A: _utfall((None, 10)),
Losning.B: _utfall((0.1, 7), (None, 3)),
}
}
assert dommer.trinn_for_dommene(stige) == Trinnvalg(None, Grunnlag.INGEN)
# ---------------------------------------------------------------- overall verdicts
def _dommer(**endringer: Dom) -> dict[str, Dom]:
alle = dict.fromkeys(dommer.MAAL_DEL_I, Dom.HOLDER)
alle.update(endringer)
return alle
def test_del_I_holder_naar_en_losning_holder_paa_alle_maal() -> None:
per_losning = {
Losning.A: _dommer(M1=Dom.HOLDER_IKKE),
Losning.B: _dommer(),
Losning.C: _dommer(M3=Dom.BETINGELSER),
}
median = {Losning.A: -1.0, Losning.B: 5.0, Losning.C: 5.0}
paa_25 = Trinnvalg(10, Grunnlag.TRINN_25)
assert dommer.del_I(per_losning, median, paa_25) is Dom.HOLDER
# on the 5 % step, or with a single facility, it can at most hold under conditions
assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_5)) is Dom.BETINGELSER
assert dommer.del_I(per_losning, median, Trinnvalg(1, Grunnlag.TRINN_25)) is Dom.BETINGELSER
def test_del_I_holder_ikke_naar_hver_losning_er_felt() -> None:
"""A fails M1, B has a negative median, C fails M4. M6 alone cannot fell a solution."""
per_losning = {
Losning.A: _dommer(M1=Dom.HOLDER_IKKE),
Losning.B: _dommer(M1=Dom.BETINGELSER),
Losning.C: _dommer(M4=Dom.HOLDER_IKKE),
}
median = {Losning.A: -1.0, Losning.B: -0.5, Losning.C: 5.0}
valg = Trinnvalg(10, Grunnlag.TRINN_25)
assert dommer.del_I(per_losning, median, valg) is Dom.HOLDER_IKKE
per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE)
assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER
# C has none of M1 to M5 under conditions: what is missing is the scale, and no
# threshold is needed (clarifications 103 g and 109)
assert dommer.del_I(per_losning, median, valg, har_terskel={}) is Dom.BETINGELSER
# without conditions that can be named within the range of the sources it does not hold
per_losning[Losning.C] = _dommer(M2=Dom.BETINGELSER, M6=Dom.HOLDER_IKKE)
assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER
assert dommer.del_I(per_losning, median, valg, har_terskel={}) is Dom.HOLDER_IKKE
uten = {Losning.C: {"M1": True, "M2": False}}
assert dommer.del_I(per_losning, median, valg, har_terskel=uten) is Dom.HOLDER_IKKE
med = {Losning.C: {"M2": True}}
assert dommer.del_I(per_losning, median, valg, har_terskel=med) is Dom.BETINGELSER
# a threshold for a solution that is felled does not help
feil = {Losning.A: {"M2": True}, Losning.B: {"M1": True}}
assert dommer.del_I(per_losning, median, valg, har_terskel=feil) is Dom.HOLDER_IKKE
per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE)
# the pre-registration says a negative median; a median of exactly zero does not fell
median[Losning.B] = 0.0
per_losning[Losning.C] = _dommer(M4=Dom.HOLDER_IKKE)
assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER
assert dommer.del_I(per_losning, median, Trinnvalg(None, Grunnlag.INGEN)) is Dom.HOLDER_IKKE
def test_del_I_ser_ikke_paa_referansekjoringen() -> None:
"""The reference run R holds on everything here; it cannot give «holder»."""
per_losning = {
Losning.A: _dommer(M2=Dom.HOLDER_IKKE),
Losning.R: _dommer(),
}
median = {Losning.A: 1.0, Losning.R: 9.0}
assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_25)) is Dom.HOLDER_IKKE
def test_hvor_mye_av_dommen_som_skyldes_baner_som_ikke_lar_seg_bygge() -> None:
"""Clarification 69: 2 of 8 draws cannot be built; 3 of the 6 others meet the condition."""
oppfylt = [True, None, False, True, None, False, True, False]
assert dommer.ved_siden_av_dommen(oppfylt) == pytest.approx((0.25, 0.5))
assert dommer.ved_siden_av_dommen([None, None]) == (1.0, None)
assert dommer.ved_siden_av_dommen([True, True]) == (0.0, 1.0)
def test_betingelsene_kan_navngis_naar_hvert_maal_har_en_terskel_som_teller() -> None:
"""Clarifications 93 and 109: every one of M1 to M5 under conditions; M5 by definition."""
d = _dommer(M1=Dom.BETINGELSER, M3=Dom.BETINGELSER, M5=Dom.BETINGELSER, M6=Dom.BETINGELSER)
assert dommer.maal_under_betingelser(d) == ("M1", "M3", "M5")
assert dommer.kan_navngis(d, {"M1": True, "M3": True})
assert not dommer.kan_navngis(d, {"M1": True, "M3": False})
assert not dommer.kan_navngis(d, {"M1": True})
# M5 alone is named by definition, and M6 needs no threshold
assert dommer.kan_navngis(_dommer(M5=Dom.BETINGELSER), {})
assert dommer.kan_navngis(_dommer(M6=Dom.BETINGELSER), {})
assert dommer.kan_navngis(_dommer(), {})
def test_felt_er_ett_av_M1_til_M5_som_ikke_holder_eller_negativ_median() -> None:
assert dommer.er_felt(_dommer(M5=Dom.HOLDER_IKKE), 1.0)
assert dommer.er_felt(_dommer(), -1.0)
assert not dommer.er_felt(_dommer(M6=Dom.HOLDER_IKKE), 0.0)