feat(dommer): the power solutions compared on equal terms, and the axes of the surfaces (clarifications 134, 135 and 137)

M7 gives, for each of the five solutions, the share of the draws in which it
is best alone and in which it shares the place, with no verdict on A; part II
and the thresholds for M7 are gone. T-F and T-K share the place where they
are the same path. The surfaces carry the classes along their axes, and
kontroll prints a line per file. The made-up reference files are
regenerated: everything outside the comparison is unchanged to the last
digit. Nothing is computed on the frozen parameters.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-13 23:03:05 +01:00
commit 5a54fba628
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
15 changed files with 8804 additions and 758 deletions

View file

@ -297,15 +297,20 @@ def test_trinnet_settes_i_normalisering_og_gjelder_alle_scenarioene() -> None:
d = kj.sett_dommer(_kjoring([trekning() for _ in range(5)]), M5)
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_25)
assert d.teller == NORM.navn
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.HOLDER_IKKE)
assert d.del_I is Dom.HOLDER
varer = d.scenarioer[VARER.navn]
assert (varer.del_I, varer.del_II) == (Dom.HOLDER, Dom.HOLDER_IKKE)
assert varer.del_I is Dom.HOLDER
assert varer.per_trinn[1][Losning.C].maal["M6"].dom is Dom.HOLDER
assert d.scenarioer[NORM.navn].per_trinn[1][Losning.C].maal["M6"].dom is Dom.BETINGELSER
assert set(varer.per_trinn[5]) == {Losning.A, Losning.C, Losning.R}
assert varer.per_trinn[5][Losning.R].maal["M6"].dom is Dom.HOLDER
# the comparison is on every step, among A and C; R is not part of it
assert set(varer.M7) == {1, 5}
assert varer.M7[5].andel_holder == 0.0
assert list(varer.M7[5].losninger) == [Losning.A, Losning.C]
assert varer.M7[5].losninger[Losning.A].best_alene == 0.0
assert (varer.M7[5].delt, varer.M7[5].ingen) == (0.0, 0.0)
assert varer.M7[5].losninger[Losning.C].best_alene == 1.0
assert varer.M7[5].par == {(Losning.A, Losning.C): 0.0}
def test_del_I_leses_paa_trinnet_fra_normalisering_ogsaa_naar_scenarioet_er_svakere() -> None:
@ -319,15 +324,18 @@ def test_del_I_leses_paa_trinnet_fra_normalisering_ogsaa_naar_scenarioet_er_svak
kjoring = _kjoring([trekning() for _ in range(4)], scenarioer=(LAVT, NORM))
d = kj.sett_dommer(kjoring, {Losning.A: Dom.HOLDER})
assert (d.valg.trinn, d.valg.grunnlag) == (2, Grunnlag.TRINN_25)
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.HOLDER)
assert d.del_I is Dom.HOLDER
lavt = d.scenarioer[LAVT.navn]
assert lavt.per_trinn[2][Losning.A].felt
# part II follows M7: A is alone in the run and is best wherever it can be built
assert (lavt.del_I, lavt.del_II) == (Dom.HOLDER_IKKE, Dom.HOLDER)
assert lavt.del_I is Dom.HOLDER_IKKE
# A is alone in the run and is best wherever it can be built, whatever its value
m7 = lavt.M7[2]
assert (m7.losninger[Losning.A].best_alene, m7.delt, m7.ingen, m7.par) == (1.0, 0.0, 0.0, {})
def test_M7_teller_A_mot_de_som_lar_seg_bygge_og_viser_tallene_for_A() -> None:
# A is best in draws 0, 2 (C cannot be built there) and 4; equal in 1; not built in 3
def test_M7_sammenligner_de_som_lar_seg_bygge_og_viser_tallene_for_hver() -> None:
# A is best alone in draws 0, 2 (C cannot be built there) and 4; the two share draw 1;
# C is best alone in 3
per_trekning: list[dict[tuple[Losning, int], dict[str, Utfall] | None]] = [
{(Losning.A, 1): _alle(_u(5.0)), (Losning.C, 1): _alle(_u(1.0))},
{(Losning.A, 1): _alle(_u(1.0)), (Losning.C, 1): _alle(_u(1.0))},
@ -338,16 +346,20 @@ def test_M7_teller_A_mot_de_som_lar_seg_bygge_og_viser_tallene_for_A() -> None:
M5 = {Losning.A: Dom.HOLDER, Losning.C: Dom.HOLDER}
d = kj.sett_dommer(_kjoring(per_trekning), M5)
m7 = d.scenarioer[NORM.navn].M7[1]
assert m7.andel_holder == 0.6
assert m7.dom is Dom.HOLDER
assert m7.andel_holder_ikke is None
assert m7.ikke_byggbar == 0.2
assert m7.oppfylt_blant_byggbare == 0.75
assert m7.losninger == {
Losning.A: kj.Bestandel(
best_alene=0.6, deler_plassen=0.2, ikke_byggbar=0.2, best_alene_blant_byggbare=0.75
),
Losning.C: kj.Bestandel(
best_alene=0.2, deler_plassen=0.2, ikke_byggbar=0.2, best_alene_blant_byggbare=0.25
),
}
assert (m7.delt, m7.par, m7.ingen) == (0.2, {(Losning.A, Losning.C): 0.2}, 0.0)
# step 1 holds 25 % but a single facility cannot give «holder» for part I
assert (d.valg.trinn, d.del_I, d.del_II) == (1, Dom.BETINGELSER, Dom.HOLDER)
assert (d.valg.trinn, d.del_I) == (1, Dom.BETINGELSER)
def test_uten_noe_trinn_holder_ikke_del_I_og_del_II_har_ingen_dom() -> None:
def test_uten_noe_trinn_holder_ikke_del_I_og_M7_vises_likevel() -> None:
# the path is built in half the draws on both steps: no step can be built in 80 %
per_trekning: list[dict[tuple[Losning, int], dict[str, Utfall] | None]] = [
{(Losning.A, 1): _alle(_u()), (Losning.A, 2): _alle(_u())},
@ -356,9 +368,173 @@ def test_uten_noe_trinn_holder_ikke_del_I_og_del_II_har_ingen_dom() -> None:
d = kj.sett_dommer(_kjoring(per_trekning), {Losning.A: Dom.HOLDER})
assert (d.valg.trinn, d.valg.grunnlag) == (None, Grunnlag.INGEN)
assert d.del_I is Dom.HOLDER_IKKE
assert d.del_II is None
# M7 is still shown on every step
assert d.scenarioer[NORM.navn].M7[2].andel_holder == 0.5
# the comparison is still shown on every step: A is best where it can be built
m7 = d.scenarioer[NORM.navn].M7[2]
assert (m7.losninger[Losning.A].best_alene, m7.delt, m7.ingen) == (0.5, 0.0, 0.5)
assert not hasattr(d, "del_II")
FEM = (Losning.A, Losning.B, Losning.C, Losning.T_F, Losning.T_K)
FEM_NNV: dict[Losning, list[float | None]] = {
# draw: 0 1 2 3 4 5 6 7 8 9
Losning.A: [9.0, 1.0, 1.0, 1.0, 1.0, None, None, 3.0, 1.0, None],
Losning.B: [1.0, 9.0, 1.0, 1.0, 1.0, None, None, None, 1.0, 5.0],
Losning.C: [1.0, 1.0, 9.0, 1.0, None, None, None, 3.0, 1.0, 5.0],
Losning.T_F: [1.0, 1.0, 1.0, 9.0, 1.0, None, None, 2.0, 4.0, 5.0],
Losning.T_K: [1.0, 1.0, 1.0, 1.0, 9.0, -5.0, None, 1.0, 4.0, 4.0],
}
"""Ten invented draws: A, B, C, T-F and T-K best alone in turn in 0 to 4; T-K alone (and
negative) in 5; nothing built in 6; A and C share in 7; T-F and T-K the same path in 8; B, C
and T-F share in 9, where A cannot be built."""
def _fem_kjoring(uten: tuple[Losning, ...] = ()) -> Kjoring:
"""The draws of ``FEM_NNV`` on step 1, with R and B' far above and not compared."""
def bane(a: Losning, j: int) -> dict[str, Utfall] | None:
v = FEM_NNV[a][j]
return None if v is None else _alle(_u(v))
return _kjoring(
[
{
**{(a, 1): bane(a, j) for a in FEM if a not in uten},
(Losning.R, 1): _alle(_u(100.0)),
(Losning.B_MERKET, 1): _alle(_u(100.0)),
}
for j in range(10)
]
)
def test_sammenligningen_av_de_fem_haandregnet() -> None:
"""Clarification 137 b on the ten draws of ``FEM_NNV``.
A: alone in 0, shares 7, not built in 5, 6, 9, alone in 1 of its 7. B: alone in 1, shares
9, not built in 5, 6, 7, 1 of 7. C: alone in 2, shares 7 and 9, not built in 4, 5, 6, 1 of
7. T-F: alone in 3, shares 8 and 9, not built in 5, 6, 1 of 8. T-K: alone in 4 and 5,
shares 8, not built in 6, 2 of 9. Shared in 7, 8, 9; none built in 6.
"""
m7 = kj.sammenligning(FEM_NNV)
assert list(m7.losninger) == list(FEM)
assert {a: dataclasses.astuple(b) for a, b in m7.losninger.items()} == {
Losning.A: (1 / 10, 1 / 10, 3 / 10, 1 / 7),
Losning.B: (1 / 10, 1 / 10, 3 / 10, 1 / 7),
Losning.C: (1 / 10, 2 / 10, 3 / 10, 1 / 7),
Losning.T_F: (1 / 10, 2 / 10, 2 / 10, 1 / 8),
Losning.T_K: (2 / 10, 1 / 10, 1 / 10, 2 / 9),
}
assert (m7.delt, m7.ingen) == (3 / 10, 1 / 10)
# every pair in the fixed order; the three sharing draw 9 count for each of their pairs
A, B, C, TF, TK = FEM
assert list(m7.par.items()) == [
((A, B), 0.0),
((A, C), 1 / 10),
((A, TF), 0.0),
((A, TK), 0.0),
((B, C), 1 / 10),
((B, TF), 1 / 10),
((B, TK), 0.0),
((C, TF), 1 / 10),
((C, TK), 0.0),
((TF, TK), 1 / 10),
]
# «best alene» of the five, «delt» and «ingen» sum to one (exactly in counts: 6 + 3 + 1)
summen = math.fsum([*(b.best_alene for b in m7.losninger.values()), m7.delt, m7.ingen])
assert summen == pytest.approx(1.0, rel=0.0, abs=1e-15)
# the order the solutions are passed in does not matter
assert kj.sammenligning({a: FEM_NNV[a] for a in reversed(FEM)}) == m7
def test_T_F_og_T_K_som_samme_bane_deler_plassen_og_er_ikke_ingen() -> None:
"""Clarification 137: where T-K gets no nuclear power it is T-F, and the two share the top."""
lik: list[float | None] = [7.0, 7.0, 7.0, 7.0]
nnv: dict[Losning, list[float | None]] = {
Losning.A: [1.0, 9.0, None, None],
Losning.B: [1.0, 1.0, None, None],
Losning.C: [None, 1.0, None, None],
Losning.T_F: lik,
Losning.T_K: [*lik[:3], 8.0],
}
m7 = kj.sammenligning(nnv)
assert (m7.delt, m7.ingen) == (0.5, 0.0)
assert m7.par[Losning.T_F, Losning.T_K] == 0.5
assert m7.losninger[Losning.T_F].deler_plassen == 0.5
assert m7.losninger[Losning.T_K].best_alene == 0.25
assert m7.losninger[Losning.A].best_alene == 0.25
def test_en_losning_som_ikke_lar_seg_bygge_er_aldri_best() -> None:
"""B is never built; under it the four others share the top, or nothing is built."""
nnv = {a: [None if a is Losning.B else 0.0, 5.0 if a is Losning.B else None] for a in FEM}
nnv[Losning.B] = [None, None]
m7 = kj.sammenligning(nnv)
b = m7.losninger[Losning.B]
assert dataclasses.astuple(b) == (0.0, 0.0, 1.0, None)
# draw 0: the four others share the top at zero; draw 1: nothing is built
assert (m7.delt, m7.ingen) == (0.5, 0.5)
assert all(x.best_alene == 0.0 for x in m7.losninger.values())
assert [a for a, x in m7.losninger.items() if x.deler_plassen == 0.5] == [
Losning.A,
Losning.C,
Losning.T_F,
Losning.T_K,
]
assert [p for p, x in m7.par.items() if x == 0.5] == [
(Losning.A, Losning.C),
(Losning.A, Losning.T_F),
(Losning.A, Losning.T_K),
(Losning.C, Losning.T_F),
(Losning.C, Losning.T_K),
(Losning.T_F, Losning.T_K),
]
def test_sammenligningen_gjennom_kjoringen_og_uten_A() -> None:
"""The run puts the comparison together from the outcomes; R and B' are left out of it."""
kjoring = _fem_kjoring()
d = kj.sett_dommer(kjoring, dict.fromkeys(kjoring.losninger, Dom.HOLDER))
for scenario in (NORM, VARER):
assert d.scenarioer[scenario.navn].M7[1] == kj.sammenligning(FEM_NNV)
# a run without A compares the four that are in it
uten_a = _fem_kjoring(uten=(Losning.A,))
m7 = (
kj.sett_dommer(uten_a, dict.fromkeys(uten_a.losninger, Dom.HOLDER))
.scenarioer[NORM.navn]
.M7[1]
)
assert list(m7.losninger) == [Losning.B, Losning.C, Losning.T_F, Losning.T_K]
assert m7 == kj.sammenligning({a: FEM_NNV[a] for a in FEM if a is not Losning.A})
# draw 0: the four share at 1; draw 7: C alone; shared in 0, 8 and 9, none built in 6
assert (m7.delt, m7.ingen) == (3 / 10, 1 / 10)
assert m7.losninger[Losning.C].best_alene == 2 / 10
assert m7.par[Losning.B, Losning.C] == 2 / 10
assert len(m7.par) == 6
# a run with none of the five has no comparison
bare_r = _kjoring([{(Losning.R, 1): _alle(_u())}])
assert kj.sett_dommer(bare_r, {Losning.R: Dom.HOLDER}).scenarioer[NORM.navn].M7 == {}
def test_sobol_utfallet_M7_er_blant_de_beste_alene_eller_delt() -> None:
"""Clarification 137 c: one where the solution is among the best, alone or shared."""
kjoring = _fem_kjoring()
best = {a: kj.utfall_for_indeksene(kjoring, a, 1)["M7"] for a in FEM}
assert best == {
Losning.A: [1.0, 0, 0, 0, 0, 0, 0, 1.0, 0, 0],
Losning.B: [0, 1.0, 0, 0, 0, 0, 0, 0, 0, 1.0],
Losning.C: [0, 0, 1.0, 0, 0, 0, 0, 1.0, 0, 1.0],
Losning.T_F: [0, 0, 0, 1.0, 0, 0, 0, 0, 1.0, 1.0],
Losning.T_K: [0, 0, 0, 0, 1.0, 1.0, 0, 0, 1.0, 0],
}
assert "M7" not in kj.utfall_for_indeksene(kjoring, Losning.R, 1)
x = [float(j) for j in range(10)]
indekser = kj.sobol_indekser(kjoring, {"x": x}, Losning.T_K, 1)
# two classes of five: T-K is among the best in 1 of the lower and 2 of the upper
snitt = 3 / 10
mellom = 5 * (0.2 - snitt) ** 2 + 5 * (0.4 - snitt) ** 2
total = 3 * (1 - snitt) ** 2 + 7 * (0 - snitt) ** 2
assert indekser["M7"]["x"] == pytest.approx(mellom / total)
def test_dommene_trenger_normalisering_paa_hovedforlopet_en_gang() -> None:
@ -722,8 +898,11 @@ def test_M5_under_betingelser_er_navngitt_og_M6_trenger_ingen_terskel() -> 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 test_ingen_terskel_soekes_for_M7() -> None:
"""Clarification 135 d: A is best in the first 4 of 10 draws, C in the other 6; no threshold.
Under the old rule this was M7 «holder under betingelser» with a threshold at most 8 of x.
"""
def trekning(j: int) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
return {
@ -735,11 +914,18 @@ def test_tersklene_for_M7_vises_og_endrer_ingenting() -> None:
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
(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 == ()
m7 = norm.M7[5]
assert [(a, b.best_alene) for a, b in m7.losninger.items()] == [
(Losning.A, 0.4),
(Losning.C, 0.6),
]
assert (m7.delt, m7.ingen) == (0.0, 0.0)
assert not hasattr(norm, "terskler_M7")
assert norm.betingelser is not None
assert all("M7" not in b.terskler for b in norm.betingelser.values())
# the comparison is the same with and without the drawn values
assert kj.sett_dommer(kjoring, M5).scenarioer[NORM.navn].M7 == norm.M7
assert d.del_I is Dom.HOLDER
def test_tersklene_trenger_verdier_og_status_for_hver_trekning() -> None:
@ -798,7 +984,8 @@ def test_utfallene_indeksene_gis_for() -> None:
"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)
# C is best where A is lower or cannot be built (clarification 135 d)
assert kj.utfall_for_indeksene(kjoring, Losning.C, 5)["M7"] == [0.0, 1.0, 1.0, 1.0]
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