feat(kjoring): thresholds, the conditions of part I, Sobol indices and threshold surfaces

Clarifications 105 to 111, on invented outcomes and made-up draws only. The price
threshold runs the model with the price multiplied by a factor; the thresholds in
a quantity, the indices and two of the surfaces are read from the outcomes per draw.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-13 17:57:52 +01:00
commit 8d13501653
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
10 changed files with 1561 additions and 79 deletions

View file

@ -1,4 +1,4 @@
"""The run over the draws (chapter 11; clarifications 95 to 103).
"""The run over the draws (chapter 11; clarifications 95 to 111).
Made-up draws only: variants of the made-up set of ``conftest.py``, and invented outcomes per
draw for the verdicts and the timeline. Nothing here says anything about the hypothesis.
@ -10,19 +10,21 @@ does not start within the final year 2060.
from __future__ import annotations
import dataclasses
import math
import statistics
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import dommer, eierskap, nivaaisert, skala
from tokenfabrikker import dommer, eierskap, nivaaisert, skala, terskler
from tokenfabrikker import kjoring as kj
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag
from tokenfabrikker.kjoring import Bane, Kjoring, Scenario, Utfall
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.miljo import Kildeverdier
from tokenfabrikker.terskler import Pristerskel, Retning, Rute, Terskel
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
@ -409,17 +411,17 @@ def test_dommene_paa_oppdiktede_trekninger_henger_sammen_med_utfallene(
def test_persentilen_er_lineaer_mellom_naboverdiene() -> None:
x = [4.0, 1.0, 3.0, 2.0]
# h = 1 + 3 p: 1.3 gives 1 + 0.3 (2 - 1); 3.7 gives 3 + 0.7 (4 - 3)
assert kj.persentil(x, 0.1) == pytest.approx(1.3)
assert kj.persentil(x, 0.9) == pytest.approx(3.7)
assert kj.persentil(x, 0.5) == statistics.median(x) == 2.5
assert (kj.persentil(x, 0.0), kj.persentil(x, 1.0)) == (1.0, 4.0)
assert dommer.persentil(x, 0.1) == pytest.approx(1.3)
assert dommer.persentil(x, 0.9) == pytest.approx(3.7)
assert dommer.persentil(x, 0.5) == statistics.median(x) == 2.5
assert (dommer.persentil(x, 0.0), dommer.persentil(x, 1.0)) == (1.0, 4.0)
# a whole h is the value itself: five values, p = 0.25 gives the second
assert kj.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.25) == 20.0
assert kj.persentil([7.0], 0.1) == kj.persentil([7.0], 0.9) == 7.0
assert dommer.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.25) == 20.0
assert dommer.persentil([7.0], 0.1) == dommer.persentil([7.0], 0.9) == 7.0
with pytest.raises(ValueError, match="at least one value"):
kj.persentil([], 0.5)
dommer.persentil([], 0.5)
with pytest.raises(ValueError, match="between 0 and 1"):
kj.persentil([1.0], 10.0)
dommer.persentil([1.0], 10.0)
def test_tidslinjen_over_trekningene_har_med_baner_som_ikke_lar_seg_bygge() -> None:
@ -529,3 +531,326 @@ def test_de_seks_scenarioene_og_stigen_er_de_forhaandsregistrerte() -> None:
]
assert [s.teller for s in kj.SCENARIOER] == [False, True, False, False, False, False]
assert len({s.navn for s in kj.SCENARIOER}) == 6
# ------------------------------ thresholds, conditions and indices over the draws
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."""
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)])
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)
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]}
d = kj.sett_dommer(
kjoring, M5, storrelser=storrelser, status={"x": "kilde", "z": "åpen forutsetning"}
)
norm = d.scenarioer[NORM.navn]
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_25)
assert (d.del_I, norm.del_I_avgjort) == (Dom.BETINGELSER, True)
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),
)
}
# the same threshold in a quantity without a source does not count: part I does not hold
d = kj.sett_dommer(
kjoring,
M5,
storrelser=storrelser,
status={"x": "modellvalg", "z": "åpen forutsetning"},
)
norm = d.scenarioer[NORM.navn]
assert d.del_I is Dom.HOLDER_IKKE
assert norm.betingelser is not None
assert not norm.betingelser[Losning.A].kan_navngis
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"})
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_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)])
d = kj.sett_dommer(
kjoring, {Losning.A: Dom.BETINGELSER}, storrelser={"x": X10}, status={"x": "kilde"}
)
norm = d.scenarioer[NORM.navn]
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_5)
assert norm.per_trinn[5][Losning.A].maal["M6"].dom is Dom.BETINGELSER
assert d.del_I is Dom.BETINGELSER
assert norm.betingelser is not None
b = norm.betingelser[Losning.A]
assert (b.maal, b.kan_navngis, b.terskler) == (("M5",), True, {"M6": ()})
# with M5 holding only the scale is missing (clarification 103 g)
d = kj.sett_dommer(
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"x": X10}, status={"x": "kilde"}
)
norm = d.scenarioer[NORM.navn]
assert d.del_I is Dom.BETINGELSER
assert norm.betingelser is not None
assert norm.betingelser[Losning.A].bare_skalaen_mangler
def test_tersklene_for_M7_vises_og_endrer_ingenting() -> None:
"""A is best in the first 4 of 10 draws: at most 8 of the quantity gives 4 of 8."""
def trekning(j: int) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
return {
(Losning.A, 5): _alle(_u(1.0 if j < 4 else 0.2)),
(Losning.C, 5): _alle(_u(0.5)),
}
kjoring = _kjoring([trekning(j) for j in range(10)])
M5 = dict.fromkeys((Losning.A, Losning.C), Dom.HOLDER)
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),)
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)
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})
with pytest.raises(ValueError, match="one value per draw"):
kj.sett_dommer(kjoring, M5, storrelser={"x": [1.0]}, status={"x": "kilde"})
def test_tallene_ved_siden_av_M6_over_trekningene_som_har_verdi() -> None:
"""Clarification 103 c. One draw cannot be built, one has no year of stable operation."""
utfall: list[Utfall | None] = [
None,
_u(M6=None),
dataclasses.replace(_u(M6=0.1), M6_2050=0.2),
dataclasses.replace(_u(M6=0.3), M6_2050=0.4),
]
side = kj.ved_siden_av_m6(utfall)
assert side["snitt"] == side["median av ti aar"]
assert side["snitt"].antall == 2
assert side["snitt"].median == pytest.approx(0.2)
assert side["snitt"].persentiler == pytest.approx((0.12, 0.28))
assert side["2050"].antall == 2
assert side["2050"].median == pytest.approx(0.3)
assert side["2050"].persentiler == pytest.approx((0.22, 0.38))
# the peak year has a value for every path that can be built: 0, 0.1 and 0.3
assert (side["toppaar"].antall, side["toppaar"].median) == (3, 0.1)
assert side["toppaar"].persentiler == pytest.approx((0.02, 0.26))
ingen = kj.ved_siden_av_m6([None, None])
assert all(x == kj.Sidetall(antall=0, median=None, persentiler=None) for x in ingen.values())
def test_utfallene_indeksene_gis_for() -> None:
"""Four draws of A and C on step 5; A cannot be built in the last."""
a: list[Utfall | None] = [_u(2.0), _u(1.0, M3=0.2, M6=0.01), _u(-1.0, S42=-1.0, M4=False), None]
kjoring = _kjoring(
[
{(Losning.A, 5): None if u is None else _alle(u), (Losning.C, 5): _alle(_u(1.5))}
for u in a
]
)
y = kj.utfall_for_indeksene(kjoring, Losning.A, 5)
assert y == {
"NNV": [2.0, 1.0, -1.0, None],
"byggbar": [1.0, 1.0, 1.0, 0.0],
"M1 holder": [1.0, 1.0, 0.0, 0.0],
"M2 holder": [1.0, 1.0, 0.0, 0.0],
"M3 holder": [1.0, 0.0, 1.0, 0.0],
"M4 holder": [1.0, 1.0, 0.0, 0.0],
"M6 holder": [1.0, 0.0, 1.0, 0.0],
"M3 holder ikke": [0.0, 1.0, 0.0, 0.0],
"M4 holder ikke": [0.0, 0.0, 1.0, 0.0],
# a path that cannot be built counts as under 5 % in M6
"M6 holder ikke": [0.0, 1.0, 0.0, 1.0],
"M7": [1.0, 0.0, 0.0, 0.0],
}
assert "M7" not in kj.utfall_for_indeksene(kjoring, Losning.C, 5)
indekser = kj.sobol_indekser(kjoring, {"x": [1.0, 2.0, 3.0, 4.0]}, Losning.A, 5)
assert set(indekser) == set(y)
# two classes of two draws: M1 follows the class exactly, M3 not at all
assert indekser["M1 holder"] == {"x": 1.0}
assert indekser["M3 holder"] == {"x": 0.0}
# the net present value among the three draws that can be built. With three draws and
# two classes the class is floor(2 r / 3): {2, 1} with the average 1.5, and {-1}
snitt = 2.0 / 3.0
mellom = 2 * (1.5 - snitt) ** 2 + (-1.0 - snitt) ** 2
total = (2.0 - snitt) ** 2 + (1.0 - snitt) ** 2 + (-1.0 - snitt) ** 2
assert indekser["NNV"]["x"] == pytest.approx(mellom / total)
assert kj.sobol_indekser(kjoring, {"x": [1.0, 2.0, 3.0, 4.0]}, Losning.C, 5)["M1 holder"] == {
"x": None
}
def test_flatene_leses_av_utfallene() -> None:
"""Four draws; A cannot be built in the second. Two of the 25 cells are filled per pair."""
a: list[Utfall | None] = [
dataclasses.replace(_u(2.0), c_snitt=300.0),
None,
dataclasses.replace(_u(-1.0), c_snitt=500.0),
dataclasses.replace(_u(4.0), c_snitt=400.0),
]
kjoring = _kjoring([{(Losning.A, 5): None if u is None else _alle(u)} for u in a])
rho = [0.05, 0.05, 0.09, 0.09]
kost = [100.0, 100.0, 200.0, 200.0]
flate = kj.flate_over_trekningene(kjoring, rho, kost, Losning.A, 5)
assert flate[0][0] == Rute(antall=2, andel_positiv=0.5, median=-math.inf)
assert flate[2][2] == Rute(antall=2, andel_positiv=0.5, median=1.5)
assert sum(rute.antall for rad in flate for rute in rad) == 4
# the competitor's price against the Norwegian cost, among the three that can be built:
# classes 0, 1 and 3 of five for both, since class is floor(5 r / 3)
antall, flate = kj.kraftprisflate(kjoring, [800.0, 850.0, 900.0, 950.0], Losning.A, 5)
assert antall == 3
assert flate[0][0] == Rute(antall=1, andel_positiv=1.0, median=2.0)
assert flate[1][3] == Rute(antall=1, andel_positiv=0.0, median=-1.0)
assert flate[3][1] == Rute(antall=1, andel_positiv=1.0, median=4.0)
uten_kost = _kjoring([{(Losning.A, 5): _alle(_u())}])
with pytest.raises(ValueError, match="cost of Norwegian power"):
kj.kraftprisflate(uten_kost, [800.0], Losning.A, 5)
# ------------------------------------------------ the price threshold, through the model
def test_prisfaktoren_en_gir_de_samme_tallene_til_siste_siffer(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
for losning in Losning:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
uten = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim)
med = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, prisfaktor=1.0)
assert med.NNV == uten.NNV
assert kj.nnv_med_prisfaktor(
inn, losning=losning, trinn=2, knapphet=Knapphet.VARER, k=1.0
) == (uten.NNV)
with pytest.raises(ValueError, match="cannot be negative"):
ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, prisfaktor=-0.1)
def test_netto_naaverdi_avtar_ikke_med_prisen_og_faktoren_er_som_et_bortfall(
oppdiktet: LagInndata,
) -> None:
"""17.3: a loss d for every vintage is the price times 1 - eps_d d. Here eps_d is one."""
inn = oppdiktet()
for losning in Losning:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
def nnv(k: float, losning: Losning = losning) -> float:
verdi = kj.nnv_med_prisfaktor(
inn, losning=losning, trinn=2, knapphet=Knapphet.NORMALISERING, k=k
)
assert verdi is not None
return verdi
rekke = [nnv(k) for k in (0.0, 0.5, 0.8, 1.0, 1.3, 2.0, 5.0)]
assert rekke == sorted(rekke)
assert rekke[0] < rekke[-1]
med_bortfall = ks.regn_program(
inn, losning, plan, Knapphet.NORMALISERING, dim=dim, bortfall=ks.fast_bortfall(0.2)
)
assert nnv(0.8) == pytest.approx(med_bortfall.NNV, rel=1e-12)
# the avoided emissions follow the capacity sold, not the price
dobbel = ks.regn_program(
inn, losning, plan, Knapphet.NORMALISERING, dim=dim, prisfaktor=2.0
)
assert dobbel.mu_d.andel(2040) == 1.0
assert dobbel.mu_d(2040) == 2.0
def test_pristerskelen_gjennom_modellen(oppdiktet: LagInndata) -> None:
"""Four made-up draws; the median at the threshold is not negative, and negative just below."""
trekninger = _trekninger(oppdiktet)
for losning in (Losning.A, Losning.C, Losning.T_F):
funnet = kj.pristerskel_for_losning(trekninger, losning, 1, NORM)
assert funnet.k is not None
def median(k: float, losning: Losning = losning) -> float:
return dommer.median(
[
kj.nnv_med_prisfaktor(
inn, losning=losning, trinn=1, knapphet=Knapphet.NORMALISERING, k=k
)
for inn in trekninger
]
)
assert median(funnet.k) >= 0
assert funnet.k == 0.0 or median(funnet.k - terskler.K_TOLERANSE) < 0
# shared out over processes the same factors are tried, and the answer is the same
en = kj.pristerskel_for_losning(trekninger, Losning.C, 1, NORM)
assert kj.pristerskel_for_losning(trekninger, Losning.C, 1, NORM, prosesser=2) == en
with pytest.raises(ValueError, match="price scenarios on the main path"):
kj.pristerskel_for_losning(trekninger, Losning.C, 1, LAVT)
with pytest.raises(ValueError, match="at least one draw"):
kj.pristerskel_for_losning([], Losning.C, 1, NORM)
def test_pristerskelen_finnes_ikke_naar_halvparten_ikke_lar_seg_bygge(
oppdiktet: LagInndata,
) -> None:
"""Step 3 of the slow nuclear path cannot be built; with two of four such draws: no median."""
trekninger = [oppdiktet(), oppdiktet(p_v=3000.0), *[oppdiktet(n_reaktor=100.0)] * 2]
assert kj.pristerskel_for_losning(trekninger, Losning.A, 3, NORM) == Pristerskel(
k=None, uten_median=True
)
def test_prisflaten_gir_terskelen_per_klasse_av_reaktorkostnaden(oppdiktet: LagInndata) -> None:
"""Ten made-up draws in five classes of two; each class has the threshold of its own draws."""
kost = [80e6, 90e6, 100e6, 110e6, 120e6, 130e6, 140e6, 150e6, 160e6, 170e6]
trekninger = [oppdiktet(c_N_ref=c) for c in kost]
flate = kj.prisflate(trekninger, kost, Losning.A, 1, NORM)
assert [None if p is None else (p.antall, p.c_N_ref) for p in flate] == [
(2, 85e6),
(2, 105e6),
(2, 125e6),
(2, 145e6),
(2, 165e6),
]
forste = kj.pristerskel_for_losning(trekninger[:2], Losning.A, 1, NORM)
assert flate[0] is not None
assert flate[0].terskel == forste
terskel = [p.terskel.k for p in flate if p is not None]
assert all(k is not None for k in terskel)
# a dearer reactor needs a higher price
assert terskel == sorted(terskel) # type: ignore[type-var]
with pytest.raises(ValueError, match="reactor cost of every draw"):
kj.prisflate(trekninger, kost[:3], Losning.A, 1, NORM)
def test_kraftkostnaden_i_utfallet_er_snittet_over_aargangsleddene(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
bane = kj.regn_bane(inn, Losning.C, 2, (NORM,))
dim = ks.dimensjoner(inn, Losning.C)
plan = ks.lag_plan(inn, Losning.C, dim, N_anlegg=2)
res = ks.regn_program(inn, Losning.C, plan, Knapphet.NORMALISERING, dim=dim)
ledd = nivaaisert.kraftkostnad(inn, res, bedrift=True).aarganger
vekter = [(1.0 + inn["rho_D"]) ** -(a.t_v - plan.T_0) for a in ledd]
snitt = sum(w * a.c_a for w, a in zip(vekter, ledd, strict=True)) / sum(vekter)
assert bane.utfall[NORM.navn].c_snitt == pytest.approx(snitt, rel=1e-12)
assert min(a.c_a for a in ledd) <= snitt <= max(a.c_a for a in ledd)
assert kj.lcoc_v_2025(inn) == ks.regnekraftpris(inn, Knapphet.VARER, 2040).lcoc_v(2025)