docs(rapport): appendices with the parameters and the change list, the reference list, and the two-page summary

Appendix B, appendix C and the reference list are generated from the frozen
parameter file, the pre-registration and the source bank. Citations link to
their item in the list. The two-page summary states only what the summary in
the report states. Draft PDFs of the report and the summary are in pdf/.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-14 21:24:36 +01:00
commit f271f11715
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
12 changed files with 2105 additions and 67 deletions

BIN
pdf/Tokenfabrikker.pdf Normal file

Binary file not shown.

Binary file not shown.

View file

@ -5,8 +5,9 @@
#
# Every LaTeX run has a hard time limit (TIDSGRENSE seconds, default 120): one pdflatex run has
# been seen to hang. The limit is set with perl's alarm, since macOS has no timeout command.
# The script first writes vedlegg_kart.tex with lag_vedlegg.py and generert/ (chapter 6) with
# lag_resultater.py. It exits non-zero when the
# The script first writes vedlegg_kart.tex with lag_vedlegg.py, generert/ (chapter 6) with
# lag_resultater.py, the appendices with the parameters and the change list, and the reference
# list (lag_vedlegg_parametere.py, lag_vedlegg_endringer.py, lag_referanser.py). It exits non-zero when the
# generator fails, a LaTeX run fails or times out, or the last run reports undefined references.
# Bash 3.2 and ASCII only. Build output stays in rapport/ and is ignored by git.
@ -84,6 +85,10 @@ fi
python3 lag_vedlegg.py || { echo "FEIL: lag_vedlegg.py" >&2; exit 1; }
python3 lag_resultater.py || { echo "FEIL: lag_resultater.py" >&2; exit 1; }
python3 lag_vedlegg_parametere.py || { echo "FEIL: lag_vedlegg_parametere.py" >&2; exit 1; }
python3 lag_vedlegg_endringer.py || { echo "FEIL: lag_vedlegg_endringer.py" >&2; exit 1; }
# Last: the reference list also reads the generated appendices.
python3 lag_referanser.py || { echo "FEIL: lag_referanser.py" >&2; exit 1; }
feil=0
for maal in "$@"; do

View file

@ -16,4 +16,4 @@ Ideen om et eget kjernekraftverk for hvert datasenter er inspirert av Sadhguru,
tall eller noen påstand her.
Teksten er lisensiert under CC BY 4.0, koden og dataene under MIT-lisensen. Modellen, kildebanken og
dataene ligger på \kommer{lenke til repoet}.
dataene ligger på \url{https://git.fromaitochitta.com/open/tokenfabrikker}.

View file

@ -83,9 +83,9 @@ de beste utfallene, slik de to funnene over sier at den kan bli dyrere i de dår
avvik fra frysen og føres med dato og grunn (spesifikasjonen kapittel~15).
\item \emph{Område 27 hviler mest på språkmodeller.} Av de 90 postene om hva fagmiljøene sier, hviler
85 på forsker og kontrollør, som begge er språkmodeller; prosjektet har selv funnet sitatene i fem
bærende poster (K27-001, K27-007, K27-017, K27-138 og K27-142). Fire studier av læring i kjernekraft
bærende poster \kilde{K27-001, K27-007, K27-017, K27-138, K27-142}. Fire studier av læring i kjernekraft
er lest i arbeidsnotat, instituttutgave eller manus, ikke i den publiserte tidsskriftsversjonen, og én
av dem bare i sammendrag (K27-008 til K27-011). Ett tall står som «Ikke verifisert» (K27-038). Runden
av dem bare i sammendrag \kilde{K27-008 til K27-011}. Ett tall står som «Ikke verifisert» \kilde{K27-038}. Runden
var én dag (fagfelleloggen del~19). Ingen parameter bygger på område 27.
\end{itemize}

668
rapport/lag_referanser.py Normal file
View file

@ -0,0 +1,668 @@
# ruff: noqa: INP001
r"""Write the reference list of the report: the entries of the source bank it cites.
The report cites entries in the source bank (``kilder/*.md``) with ``\kilde{K03-020}``,
``\kilde{K03-044, K03-045}`` or ``\kilde{K27-007 til K27-011}``. This script collects
the cited ids from three places:
(a) every ``\kilde{...}`` in the hand-written ``rapport/*.tex`` (LaTeX comments are
skipped);
(b) every ``poster`` list in ``modell/parametere.json`` (the parameter appendix cites
them);
(c) every ``\kilde{...}`` in ``rapport/generert/vedlegg-*.tex``, when such files exist.
For each cited id it looks up the entry (``### K03-020 Title`` and its bullet fields)
and writes ``rapport/generert/referanser.tex``: a short lead-in with the counts, then
one item per entry, sorted by id in natural order, with the id as label (the look of
``\kilde``), a hyperlink target named ``kilde:<id>``, the entry's title and its
``Kilde`` field as the entry gives it. Nothing is paraphrased: the text is the
entry's own, escaped for LaTeX; URLs become ``\url{...}``, Markdown italics
``\emph{...}`` and code spans ``\fil{...}``.
The rule of the project: no reference is written in unless the entry's ``Kontroll``
line confirms it. The line is classified from what it says (see ``klasse``). An
entry whose class is not in ``TILLATT`` stops the script, unless its id stands in
``UNNTAK`` with the operator's decision.
Standard library only. Same input, same bytes. The script stops with an error, and
writes nothing, when a cited id has no entry, when a citation or an entry does not
have the expected form, when a cited entry is not confirmed, or when the text holds
a character or a Markdown construct the script does not know.
Run from anywhere: ``python3 rapport/lag_referanser.py``. With ``--sjekk`` it writes
nothing and prints everything it found: the ids per origin, every problem at once,
the classes of the Kontroll lines with the entries outside the plain classes and
where they are cited, and the ids the report mentions outside ``\kilde{}``.
"""
from __future__ import annotations
import json
import re
import sys
from collections import Counter
from dataclasses import dataclass
from pathlib import Path
from urllib.parse import quote
ROT = Path(__file__).resolve().parent.parent
KILDER = ROT / "kilder"
RAPPORT = ROT / "rapport"
GENERERT = RAPPORT / "generert"
PARAMETERE = ROT / "modell" / "parametere.json"
UT = GENERERT / "referanser.tex"
# Cited entries whose Kontroll class is not in TILLATT, let through by the operator's
# decision. Key: the id. Value: the date and the reason, as the operator gave them.
# Empty: no exception has been decided.
UNNTAK: dict[str, str] = {}
BEKREFTET = "bekreftet"
FORBEHOLD = "bekreftet med forbehold"
RETTET = "rettet"
LAGT_TIL = "lagt til av kontrolløren"
IKKE_BEKREFTET = "ikke bekreftet"
MANGLER = "mangler"
ANNET = "annen ordlyd"
KLASSER = (BEKREFTET, FORBEHOLD, RETTET, LAGT_TIL, IKKE_BEKREFTET, MANGLER, ANNET)
TILLATT = frozenset({BEKREFTET, FORBEHOLD, RETTET, LAGT_TIL})
ID = r"K\d{2}[a-z]?-[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*"
ER_ID = re.compile(ID)
I_TEKST = re.compile(r"(?<![A-Za-z0-9-])" + ID + r"(?![A-Za-z0-9])")
OMRAADE = re.compile(r"^K(\d{2})([a-z]?)-")
INTERVALL = re.compile(r"^(" + ID + r")\s+til\s+(" + ID + r")$")
NUMMERERT = re.compile(r"^(K\d{2}[a-z]?-)(\d+)$")
OVERSKRIFT = re.compile(r"^### (Ikke verifisert: )?(" + ID + r") (\S.*)$")
ID_OVERSKRIFT = re.compile(r"^#+ (?:Ikke verifisert: )?" + ID + r"\b")
FELT = re.compile(r"^- \*\*([^*]+?):\*\*(?: (.*))?$")
# A citation is \kilde{ with no space: a definition such as \RenewDocumentCommand \kilde { m }
# is not one.
KILDE_START = re.compile(r"\\kilde\{")
# A code span, a URL (it ends at white space, a guillemet, a backtick or an ellipsis) or
# Markdown italics (the star opens before a word and closes after one, as in CommonMark).
DEL = re.compile(
r"`(?P<kode>[^`]*)`"
r"|(?P<url>https?://[^\s\u00ab\u00bb`\u2026]+)"
r"|(?<![\w*])\*(?=[^\s*])(?P<kursiv>[^*]+?)(?<=[^\s*])\*(?![\w*])"
)
TRYGG_KODE = re.compile(r"^[A-Za-z0-9._/-]+$")
# Printable ASCII but the characters \url cannot take (" is a shorthand in babel norsk).
TRYGG_URL = re.compile(r"^[!#-\[\]_a-z|~]+$")
SLUTT_URL = ".,;:!?"
# LaTeX for the ASCII characters that need it in running text.
ASCII_TEX = {
"\\": r"\textbackslash{}",
"{": r"\{",
"}": r"\}",
"$": r"\$",
"&": r"\&",
"%": r"\%",
"#": r"\#",
"_": r"\_",
"^": r"\textasciicircum{}",
"~": r"\textasciitilde{}",
"<": r"\textless{}",
">": r"\textgreater{}",
"|": r"\textbar{}",
'"': r"\textquotedbl{}",
}
# Every non-ASCII character the entries hold, and how it is written. A letter the
# T1 encoding has is written as itself (inputenc reads it); the rest as a command.
# A character that is not here stops the script.
UNICODE_TEX = {
"\u00e5": "\u00e5", # a with ring
"\u00c5": "\u00c5",
"\u00f8": "\u00f8", # o with stroke
"\u00d8": "\u00d8",
"\u00e6": "\u00e6", # ae
"\u00c6": "\u00c6",
"\u00e4": "\u00e4", # a with diaeresis
"\u00c4": "\u00c4",
"\u00f6": "\u00f6", # o with diaeresis
"\u00d6": "\u00d6",
"\u00fc": "\u00fc", # u with diaeresis
"\u00e9": "\u00e9", # e with acute
"\u00c9": "\u00c9",
"\u00e8": "\u00e8", # e with grave
"\u00ea": "\u00ea", # e with circumflex
"\u00e7": "\u00e7", # c with cedilla
"\u00e0": "\u00e0", # a with grave
"\u00e1": "\u00e1", # a with acute
"\u00fb": "\u00fb", # u with circumflex
"\u00da": "\u00da", # U with acute
"\u00ed": "\u00ed", # i with acute
"\u00f3": "\u00f3", # o with acute
"\u00ab": r"\guillemotleft{}",
"\u00bb": r"\guillemotright{}",
"\u2013": r"\textendash{}",
"\u2014": r"\textemdash{}",
"\u2026": r"\textellipsis{}",
"\u2018": r"\textquoteleft{}",
"\u2019": r"\textquoteright{}",
"\u201c": r"\textquotedblleft{}",
"\u201d": r"\textquotedblright{}",
"\u00a7": r"\S{}",
"\u00b6": r"\P{}",
"\u2212": r"\textminus{}",
"\u2192": r"\textrightarrow{}",
"\u20ac": r"\texteuro{}",
"\u00a3": r"\pounds{}",
"\u00b3": r"\textthreesuperior{}",
"\u00b2": r"\texttwosuperior{}",
"\u00d7": r"\texttimes{}",
"\u00b0": r"\textdegree{}",
"\u00b1": r"\textpm{}",
"\u2265": r"\ensuremath{\geq}",
"\u2264": r"\ensuremath{\leq}",
"\u2248": r"\ensuremath{\approx}",
"\u2082": r"\textsubscript{2}",
"\u00a0": "~", # no-break space
}
LISTE = (
r"\begin{itemize}[label={},leftmargin=1.6em,itemindent=-1.6em,labelwidth=0pt,"
r"labelsep=0pt,align=left,itemsep=0.6pt plus 0.4pt,parsep=0pt,topsep=4pt]"
)
# URLs may break after any letter or digit too (with a penalty), so that a long
# path never runs into the margin. Set inside the group of the list only.
BRUDD = "".join(
rf"\do\{c}" for c in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-"
)
class ReferanseError(Exception):
"""The input does not have the expected form."""
@dataclass(frozen=True)
class Post:
"""One entry of the source bank, as far as the reference list needs it."""
id: str
tittel: str
kilde: str
kontroll: str | None
merket: bool # the heading says "Ikke verifisert:"
sted: str # file and line of the heading
# ---------------------------------------------------------------------------
# The source bank
def les_poster(navn: str, tekst: str, feil: list[str]) -> list[Post]:
"""Return the entries of one file of the source bank; append problems to ``feil``."""
linjer = tekst.splitlines()
poster: list[Post] = []
i = 0
while i < len(linjer):
m = OVERSKRIFT.match(linjer[i])
if not m:
if ID_OVERSKRIFT.match(linjer[i]):
feil.append(
f"{navn}:{i + 1}: heading with an id that is not an entry: {linjer[i]!r}"
)
i += 1
continue
sted = f"kilder/{navn}:{i + 1}"
felt: list[tuple[str, list[str]]] = []
i += 1
while i < len(linjer):
linje = linjer[i]
if linje.startswith("#"):
break
f = FELT.match(linje)
if f:
felt.append((f.group(1), [f.group(2) or ""]))
elif not linje.strip() or linje.startswith((" ", "\t")):
if felt:
felt[-1][1].append(linje.strip())
elif linje.strip():
feil.append(f"{sted}: indented line before the first field")
else:
break # text after the entry (a section heading in bold, a table)
i += 1
poster.append(lag_post(m, felt, sted, feil))
return poster
def lag_post(
m: re.Match[str], felt: list[tuple[str, list[str]]], sted: str, feil: list[str]
) -> Post:
"""Put one entry together from its heading and fields."""
kilder = [deler for navn, deler in felt if navn == "Kilde"]
kontroller = [deler for navn, deler in felt if navn == "Kontroll"]
kilde = ""
if len(kilder) != 1:
feil.append(f"{sted}: {m.group(2)} has {len(kilder)} Kilde fields, not one")
else:
deler = kilder[0]
while deler and not deler[-1]:
deler = deler[:-1]
if any(d.startswith(("- ", "* ", "|")) for d in deler[1:]):
feil.append(f"{sted}: {m.group(2)}: a list or table inside the Kilde field")
kilde = " ".join(d for d in deler if d)
if not kilde:
feil.append(f"{sted}: {m.group(2)}: empty Kilde field")
kontroll: str | None = None
if len(kontroller) > 1:
feil.append(f"{sted}: {m.group(2)} has {len(kontroller)} Kontroll fields")
elif kontroller:
kontroll = " ".join(d for d in kontroller[0] if d)
return Post(m.group(2), m.group(3).strip(), kilde, kontroll, bool(m.group(1)), sted)
def les_banken(feil: list[str]) -> dict[str, Post]:
"""Return every entry of the source bank by id."""
poster: dict[str, Post] = {}
filer = sorted(p for p in KILDER.glob("*.md") if p.name != "README.md")
if not filer:
msg = f"no files in {KILDER}"
raise ReferanseError(msg)
for fil in filer:
for post in les_poster(fil.name, fil.read_text(encoding="utf-8"), feil):
if post.id in poster:
feil.append(f"{post.sted}: {post.id} also stands at {poster[post.id].sted}")
continue
poster[post.id] = post
return poster
def klasse(post: Post) -> str:
"""Classify the entry's Kontroll line from what it says.
The line's first words decide: «ikke bekreftet»; «bekreftet som …» or
«bekreftet for …» (confirmed as a news item, as a rendering, for one edition
or some years: «bekreftet med forbehold»); «bekreftet» (also «bekreftet ved ny
kontroll»); «rettet»; «ny post …» or «lagt til …» (added by the controller,
who read the primary source). No line is «mangler»; anything else, or a
heading that still says «Ikke verifisert:», is «annen ordlyd».
"""
if post.kontroll is None:
return MANGLER
t = post.kontroll.strip()
if re.match(r"ikke bekreftet\b", t):
klasse_ = IKKE_BEKREFTET
elif re.match(r"bekreftet (som|for)\b", t):
klasse_ = FORBEHOLD
elif re.match(r"bekreftet\b", t):
klasse_ = BEKREFTET
elif re.match(r"rettet\b", t):
klasse_ = RETTET
elif re.match(r"(ny post|lagt til)\b", t):
klasse_ = LAGT_TIL
else:
klasse_ = ANNET
if post.merket and klasse_ in TILLATT:
return ANNET # the heading still says "Ikke verifisert:"
return klasse_
# ---------------------------------------------------------------------------
# Where the report cites
def uten_kommentarer(tekst: str) -> str:
"""Remove LaTeX comments, keeping the line breaks."""
return "\n".join(re.sub(r"(?<!\\)%.*", "", linje) for linje in tekst.split("\n"))
def utvid(del_: str) -> list[str] | None:
"""Return the ids of one part of a citation (an id, or 'A til B'), or None."""
if ER_ID.fullmatch(del_):
return [del_]
m = INTERVALL.match(del_)
if not m:
return None
a, b = NUMMERERT.match(m.group(1)), NUMMERERT.match(m.group(2))
if not a or not b or a.group(1) != b.group(1) or len(a.group(2)) != len(b.group(2)):
return None
fra, til = int(a.group(2)), int(b.group(2))
if fra >= til:
return None
bredde = len(a.group(2))
return [f"{a.group(1)}{n:0{bredde}d}" for n in range(fra, til + 1)]
def les_henvisninger(navn: str, tekst: str, feil: list[str]) -> list[tuple[str, str]]:
r"""Return (id, file:line) for every id inside a \kilde{...} of a .tex file."""
ren = uten_kommentarer(tekst)
funnet: list[tuple[str, str]] = []
for m in KILDE_START.finditer(ren):
linje = ren.count("\n", 0, m.start()) + 1
sted = f"{navn}:{linje}"
slutt = ren.find("}", m.end())
innhold = ren[m.end() : slutt] if slutt >= 0 else ""
if slutt < 0 or "{" in innhold or "\\" in innhold:
feil.append(f"{sted}: a \\kilde{{...}} that is not a plain list of ids")
continue
for del_ in innhold.split(","):
del_ = " ".join(del_.split()) # noqa: PLW2901
ider = utvid(del_)
if ider is None:
feil.append(f"{sted}: not an id or a range of ids: {del_!r}")
continue
funnet += [(i, sted) for i in ider]
return funnet
def les_parameterposter(data: object, sti: str = "") -> list[tuple[str, str]]:
"""Return (id, place) for every id in a ``poster`` list of the parameter file."""
funnet: list[tuple[str, str]] = []
if isinstance(data, dict):
navn = data.get("id")
sted = f"modell/parametere.json: {navn}" if isinstance(navn, str) else sti
for nokkel, verdi in data.items():
if nokkel == "poster":
if not isinstance(verdi, list) or not all(isinstance(v, str) for v in verdi):
msg = f"{sted or 'modell/parametere.json'}: poster is not a list of ids"
raise ReferanseError(msg)
funnet += [(v, sted or f"modell/parametere.json: {sti}") for v in verdi]
else:
funnet += les_parameterposter(verdi, f"{sti}/{nokkel}")
elif isinstance(data, list):
for n, verdi in enumerate(data):
funnet += les_parameterposter(verdi, f"{sti}[{n}]")
return funnet
def tex_filer() -> tuple[list[Path], list[Path]]:
"""Return the hand-written .tex files of the report and the generated appendix files."""
hand = sorted(RAPPORT.glob("*.tex"))
generert = sorted(GENERERT.glob("vedlegg-*.tex"))
return hand, generert
def les_alle_henvisninger(feil: list[str]) -> dict[str, list[tuple[str, str]]]:
"""Return the citations per origin: 'a' hand-written, 'b' parameter file, 'c' generated."""
hand, generert = tex_filer()
a: list[tuple[str, str]] = []
for fil in hand:
a += les_henvisninger(f"rapport/{fil.name}", fil.read_text(encoding="utf-8"), feil)
c: list[tuple[str, str]] = []
for fil in generert:
c += les_henvisninger(f"rapport/generert/{fil.name}", fil.read_text(encoding="utf-8"), feil)
b = les_parameterposter(json.loads(PARAMETERE.read_text(encoding="utf-8")))
for i, sted in b:
if not ER_ID.fullmatch(i):
feil.append(f"{sted}: not an id: {i!r}")
return {"a": a, "b": [(i, s) for i, s in b if ER_ID.fullmatch(i)], "c": c}
def utenfor_kilde() -> list[tuple[str, str]]:
r"""Return (id, file:line) for ids the hand-written report text holds outside \kilde{}."""
funnet: list[tuple[str, str]] = []
hand, _ = tex_filer()
for fil in hand:
ren = uten_kommentarer(fil.read_text(encoding="utf-8"))
ren = re.sub(r"\\kilde\{[^{}]*\}", lambda m: "\n" * m.group(0).count("\n"), ren)
for m in I_TEKST.finditer(ren):
linje = ren.count("\n", 0, m.start()) + 1
funnet.append((m.group(0), f"rapport/{fil.name}:{linje}"))
return funnet
# ---------------------------------------------------------------------------
# LaTeX
def sorteringsnokkel(post_id: str) -> tuple[tuple[int, int | str], ...]:
"""Natural order: area, then the rest with numbers as numbers (001 before K01)."""
deler = re.split(r"(\d+)", post_id)
return tuple((0, int(d)) if d.isdigit() else (1, d) for d in deler if d)
def etter_ord(tekst: str, k: int) -> bool:
"""True when the character at k follows a word and no word follows it."""
return k > 0 and tekst[k - 1].isalnum() and not (k + 1 < len(tekst) and tekst[k + 1].isalnum())
def tex_tegn(tekst: str, sted: str) -> str:
"""Escape plain running text (no URLs, code spans or italics) for LaTeX."""
ut: list[str] = []
for k, tegn in enumerate(tekst):
if tegn in ASCII_TEX:
ut.append(ASCII_TEX[tegn])
elif tegn == "*" and etter_ord(tekst, k):
ut.append("*") # a mark after a word, like «1y*»: not Markdown
elif tegn in "*`":
msg = f"{sted}: a lone {tegn!r} (unpaired Markdown) in {tekst!r}"
raise ReferanseError(msg)
elif ord(tegn) < 128: # noqa: PLR2004
if not tegn.isprintable():
msg = f"{sted}: control character {tegn!r}"
raise ReferanseError(msg)
ut.append(tegn)
elif tegn in UNICODE_TEX:
ut.append(UNICODE_TEX[tegn])
else:
msg = f"{sted}: unknown character {tegn!r} (U+{ord(tegn):04X}); add it to UNICODE_TEX"
raise ReferanseError(msg)
tex = "".join(ut)
# Keep the T1 ligatures out: -- (dash), '' (quote), ,, (low quote).
for par in ("--", "''", ",,"):
while par in tex:
tex = tex.replace(par, par[0] + "{}" + par[1])
return tex
def tex_url(url: str, sted: str) -> str:
r"""A URL as \url{...}, with % and # escaped (hyperref removes the backslash).
A URL with a letter outside ASCII (``§36-4``, ``inngår``, a template such as
``ÅÅÅÅ-MM-DD``) cannot go through \url under pdflatex. It is written as
\href with the letters percent-encoded as UTF-8 in the link, and shown as it
stands in the entry, in the typewriter font of \url, with break points.
"""
if TRYGG_URL.match(url):
return r"\url{" + url.replace("%", r"\%").replace("#", r"\#") + "}"
ascii_ = "".join(c if ord(c) < 128 else quote(c, safe="") for c in url) # noqa: PLR2004
if not TRYGG_URL.match(ascii_):
msg = f"{sted}: URL with a character \\url cannot take: {url!r}"
raise ReferanseError(msg)
lenke = ascii_.replace("%", r"\%").replace("#", r"\#")
vist = "".join(tex_tegn(c, sted) + (r"\allowbreak{}" if c in "/.-=&?" else "") for c in url)
return r"\href{" + lenke + r"}{\texttt{" + vist + "}}"
def klipp_url(url: str) -> str:
"""Strip the punctuation that ends the sentence, not the URL."""
while True:
siste = url[-1]
aapen = {")": "(", "]": "["}.get(siste)
if siste in SLUTT_URL or (aapen and url.count(aapen) < url.count(siste)):
url = url[:-1]
else:
return url
def tex_tekst(tekst: str, sted: str, *, kursiv: bool = True) -> str:
"""Escape a field with Markdown code spans, URLs and italics for LaTeX."""
ut: list[str] = []
pos = 0
while True:
m = DEL.search(tekst, pos)
if not m:
ut.append(tex_tegn(tekst[pos:], sted))
return "".join(ut)
ut.append(tex_tegn(tekst[pos : m.start()], sted))
if m.group("kode") is not None:
kode = m.group("kode")
if not TRYGG_KODE.match(kode):
msg = f"{sted}: code span with characters \\fil cannot take: {kode!r}"
raise ReferanseError(msg)
ut.append(r"\fil{" + kode + "}")
pos = m.end()
elif m.group("url") is not None:
url = klipp_url(m.group("url"))
ut.append(tex_url(url, sted))
pos = m.start() + len(url)
else:
if not kursiv:
msg = f"{sted}: italics inside italics in {tekst!r}"
raise ReferanseError(msg)
ut.append(r"\emph{" + tex_tekst(m.group("kursiv"), sted, kursiv=False) + "}")
pos = m.end()
def tex_post(post: Post) -> str:
"""One item of the list: target, label, title, the Kilde field."""
tittel = tex_tekst(post.tittel, post.sted)
skille = " " if post.tittel.rstrip("*")[-1:] in ".?!" else ". "
return (
rf"\item \hypertarget{{kilde:{post.id}}}{{}}{{\color{{accent}}\textsf{{[{post.id}]}}}}"
rf"\enskip {tittel}{skille}{tex_tekst(post.kilde, post.sted)}"
)
def omraade(post_id: str) -> str:
"""The area of an id: its two digits (and letter, if any)."""
m = OMRAADE.match(post_id)
if not m:
msg = f"no area in {post_id!r}"
raise ReferanseError(msg)
return m.group(1) + m.group(2)
def lag(poster: list[Post], i_tekst: int, i_vedlegg: int, alle_omraader: int) -> str:
"""Return the LaTeX of the reference list."""
omraader = len({omraade(p.id) for p in poster})
innledning = (
rf"\noindent Lista har de {len(poster)} postene i kildebanken som rapporten viser til,"
rf" fra {omraader} av de {alle_omraader} områdene i \fil{{kilder/}}: {i_tekst} i teksten"
rf" og {i_vedlegg} i parametertabellen i \cref{{app:parametere}} (noen begge steder)."
r" Hver post står med tittel og med kildefeltet slik posten gir det: kilde, sted i kilden"
r" og lenke. Posten i \fil{kilder/} har i tillegg påstanden, tallene, et ordrett sitat og"
r" kontrollen mot primærkilden. Lista er laget av \fil{rapport/lag_referanser.py} og"
r" rettes ikke for hånd."
)
ut = [
"% Laget av rapport/lag_referanser.py fra kilder/*.md, rapport/*.tex og",
"% modell/parametere.json. Rettes ikke for hånd: kjør skriptet på nytt.",
innledning,
"",
r"\begingroup",
r"\fontsize{9}{10.5}\selectfont",
r"\raggedright",
r"\expandafter\def\expandafter\UrlBreaks\expandafter{\UrlBreaks" + BRUDD + "}",
LISTE,
]
ut += [tex_post(p) for p in poster]
ut += [r"\end{itemize}", r"\endgroup", ""]
return "\n".join(ut)
# ---------------------------------------------------------------------------
# Running
@dataclass
class Funn:
"""Everything the script found, before anything is written."""
bank: dict[str, Post]
henvisninger: dict[str, list[tuple[str, str]]]
feil: list[str]
def steder(self) -> dict[str, list[str]]:
"""Where each cited id is cited, in the order found."""
steder: dict[str, list[str]] = {}
for opphav in ("a", "b", "c"):
for i, sted in self.henvisninger[opphav]:
steder.setdefault(i, []).append(sted)
return steder
def finn() -> Funn:
"""Read the source bank and the citations; collect every problem."""
feil: list[str] = []
bank = les_banken(feil)
henvisninger = les_alle_henvisninger(feil)
funn = Funn(bank, henvisninger, feil)
alle = funn.steder()
for i in sorted(alle, key=sorteringsnokkel):
hvor = ", ".join(alle[i])
if i not in bank:
feil.append(f"{i} has no entry in kilder/ (cited at {hvor})")
continue
k = klasse(bank[i])
if k not in TILLATT and i not in UNNTAK:
feil.append(
f"{i} ({bank[i].sted}) is not confirmed: Kontroll is '{k}' (cited at {hvor})"
)
try:
tex_post(bank[i])
except ReferanseError as e:
feil.append(str(e))
feil.extend(f"{i} stands in UNNTAK but is not cited" for i in sorted(set(UNNTAK) - set(alle)))
return funn
def sjekk(funn: Funn) -> int:
"""Print what was found; write nothing."""
s = sys.stdout.write
steder = funn.steder()
for opphav, navn in (("a", "rapport/*.tex"), ("b", "parametere.json"), ("c", "generert")):
s(f"ids {opphav} ({navn}): {len({i for i, _ in funn.henvisninger[opphav]})}\n")
s(f"ids in all: {len(steder)}\n")
s(f"entries in the bank: {len(funn.bank)}\n\n")
teller: Counter[str] = Counter()
for i in steder:
if i in funn.bank:
teller[klasse(funn.bank[i])] += 1
s("Kontroll classes of the cited entries:\n")
for k in KLASSER:
s(f" {k}: {teller[k]}\n")
s("\nCited entries outside the classes bekreftet, rettet and lagt til:\n")
for i in sorted(steder, key=sorteringsnokkel):
if i in funn.bank and klasse(funn.bank[i]) not in {BEKREFTET, RETTET, LAGT_TIL}:
post = funn.bank[i]
s(f" {i} [{klasse(post)}] {post.sted}\n Kontroll: {(post.kontroll or '')[:200]}\n")
s(f" cited at: {', '.join(steder[i])}\n")
s("\nIds mentioned outside \\kilde{} in rapport/*.tex:\n")
for i, sted in utenfor_kilde():
s(f" {i} at {sted}\n")
s(f"\nProblems ({len(funn.feil)}):\n")
for f in funn.feil:
s(f" {f}\n")
return 1 if funn.feil else 0
def main(argv: list[str]) -> int:
"""Write the reference list; return 0, or 1 with a message on error."""
if argv not in ([], ["--sjekk"]):
sys.stderr.write("bruk: lag_referanser.py [--sjekk]\n")
return 2
try:
funn = finn()
except (ReferanseError, OSError, json.JSONDecodeError) as e:
sys.stderr.write(f"lag_referanser: {e}\n")
return 1
if argv == ["--sjekk"]:
return sjekk(funn)
if funn.feil:
sys.stderr.write("lag_referanser: the reference list is not written:\n")
sys.stderr.writelines(f" {f}\n" for f in funn.feil)
return 1
steder = funn.steder()
poster = [funn.bank[i] for i in sorted(steder, key=sorteringsnokkel)]
i_tekst = len({i for i, _ in funn.henvisninger["a"]})
i_vedlegg = len({i for i, _ in funn.henvisninger["b"] + funn.henvisninger["c"]})
alle_omraader = len({omraade(i) for i in funn.bank})
try:
tekst = lag(poster, i_tekst, i_vedlegg, alle_omraader)
except ReferanseError as e:
sys.stderr.write(f"lag_referanser: {e}\n")
return 1
GENERERT.mkdir(exist_ok=True)
UT.write_text(tekst, encoding="utf-8", newline="\n")
sys.stdout.write(f"lag_referanser: skrev {UT.relative_to(ROT)} ({len(poster)} poster)\n")
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))

View file

@ -0,0 +1,503 @@
# ruff: noqa: INP001
r"""Write appendix C of the report: the list «Endringer» of the pre-registration, word for word.
Reads ``FORHANDSREGISTRERING.md`` from the heading ``## Endringer`` to the end of the file and
writes ``rapport/generert/vedlegg-endringer.tex``: a lead-in line (the number of dated entries and
the SHA-256 of the file it was read from) and the list itself in ``\small``. Only the layout
changes: the date of an entry is set in bold, inline code in ``\texttt`` with break points,
``**bold**`` in ``\textbf`` and ``*italic*`` in ``\emph``. The words, numbers and punctuation are
those of the source, in the same order.
The converter knows exactly the Markdown the section uses, read by its indentation:
* an entry: ``- YYYY-MM-DD: text`` at the margin, continued on lines indented by two spaces;
* a numbered point inside an entry: `` N. text`` (indented by two), continued on lines indented
to the text of the point; the numbers of one list run on without a gap;
* a new paragraph of the entry: a line indented by two after a numbered list or after a blank
line;
* inline: code spans, ``**bold**`` and ``*italic*`` (properly nested, closed in the paragraph),
the backslash escape of CommonMark, and a fixed table of characters.
Anything else stops the script with the line number, and nothing is written: another heading,
a block quote, a table row, a code fence, a bullet inside an entry, a numbered point inside a
point, a blank line inside a point, trailing whitespace, a tab, a link or HTML (``[``, ``]``,
``<``), an underscore or tilde that could be emphasis or strike-through, and every character
not in the table.
Standard library only. The output depends only on the input file: same input, same bytes.
Run from anywhere: ``python3 rapport/lag_vedlegg_endringer.py``.
"""
from __future__ import annotations
import hashlib
import re
import sys
from dataclasses import dataclass, field
from pathlib import Path
ROT = Path(__file__).resolve().parent.parent
KILDE = ROT / "FORHANDSREGISTRERING.md"
UT = ROT / "rapport" / "generert" / "vedlegg-endringer.tex"
OVERSKRIFT = "## Endringer"
INNRYKK = 2
OPPDELING = 8 # a long hex string (a checksum, a commit) can break after every eighth character
ENTRY = re.compile(r"^- (\d{4}-\d{2}-\d{2}): (\S.*)$")
PUNKT = re.compile(r"^ (\d+)\. (\S.*)$")
LISTEMERKE = re.compile(r"^(?:[-*+] |\d+[.)] )")
BLOKKMERKE = re.compile(r"^(?:#|>|\||```|~~~)")
HEKS = re.compile(r"[0-9a-f]{16,}")
# ASCII punctuation that is typeset as it stands. A character that forms a ligature with the next
# one under T1 (-- , ,, '' !` ?`) gets an empty group after it when such a pair occurs.
VANLIG = frozenset(".,;:()/-+='!?@")
LIGATUR = {"-": "-", ",": ",", "'": "'", "!": "`", "?": "`"}
# ASCII characters that are special to LaTeX and have a plain meaning in the Markdown read here.
SPESIELL = {
"%": r"\%",
"&": r"\&",
"#": r"\#",
"$": r"\$",
"{": r"\{",
"}": r"\}",
"^": r"\textasciicircum{}",
"|": r"\textbar{}",
">": r"\textgreater{}",
'"': r"\textquotedbl{}",
}
# Characters that inputenc (utf8) and T1 set directly, by code point so that the table is ASCII.
DIREKTE = frozenset(
{
0x00E6, # latin small letter ae
0x00F8, # latin small letter o with stroke
0x00E5, # latin small letter a with ring above
0x00C6, # latin capital letter ae
0x00D8, # latin capital letter o with stroke
0x00C5, # latin capital letter a with ring above
0x00E9, # latin small letter e with acute
0x00E8, # latin small letter e with grave
0x00EA, # latin small letter e with circumflex
0x00E4, # latin small letter a with diaeresis
0x00F6, # latin small letter o with diaeresis
0x00FC, # latin small letter u with diaeresis
0x00C4, # latin capital letter a with diaeresis
0x00D6, # latin capital letter o with diaeresis
0x00DC, # latin capital letter u with diaeresis
0x00AB, # left-pointing double angle quotation mark (T1 has the glyph)
0x00BB, # right-pointing double angle quotation mark
}
)
# Every other non-ASCII character the converter accepts, by code point, and how it is set under
# pdflatex with inputenc utf8 and T1.
UNICODE = {
# Punctuation and symbols.
0x2013: r"\textendash{}", # en dash
0x2014: r"\textemdash{}", # em dash
0x2026: r"\textellipsis{}", # horizontal ellipsis
0x201C: r"\textquotedblleft{}", # left double quotation mark
0x201D: r"\textquotedblright{}", # right double quotation mark
0x2018: r"\textquoteleft{}", # left single quotation mark
0x2019: r"\textquoteright{}", # right single quotation mark
0x201E: r"\quotedblbase{}", # double low-9 quotation mark
0x00A0: "~", # no-break space
0x00B7: r"\textperiodcentered{}", # middle dot
0x00D7: r"\texttimes{}", # multiplication sign
0x2212: r"\textminus{}", # minus sign
0x2032: r"\ensuremath{{}^{\prime}}", # prime
0x2192: r"\textrightarrow{}", # rightwards arrow
0x2265: r"\ensuremath{\geq}", # greater-than or equal to
0x2264: r"\ensuremath{\leq}", # less-than or equal to
0x2248: r"\ensuremath{\approx}", # almost equal to
0x00B1: r"\textpm{}", # plus-minus sign
0x00B0: r"\textdegree{}", # degree sign
0x00BD: r"\textonehalf{}", # vulgar fraction one half
0x00BC: r"\textonequarter{}", # vulgar fraction one quarter
0x00B9: r"\textonesuperior{}", # superscript one
0x00B2: r"\texttwosuperior{}", # superscript two
0x00B3: r"\textthreesuperior{}", # superscript three
0x00A7: r"\S{}", # section sign
0x20AC: r"\texteuro{}", # euro sign
# Greek letters as they stand in the specification.
0x03B1: r"\ensuremath{\alpha}", # greek small letter alpha
0x03B2: r"\ensuremath{\beta}", # greek small letter beta
0x03B3: r"\ensuremath{\gamma}", # greek small letter gamma
0x03B4: r"\ensuremath{\delta}", # greek small letter delta
0x03B5: r"\ensuremath{\varepsilon}", # greek small letter epsilon
0x03B7: r"\ensuremath{\eta}", # greek small letter eta
0x03B8: r"\ensuremath{\theta}", # greek small letter theta
0x03BA: r"\ensuremath{\kappa}", # greek small letter kappa
0x03BB: r"\ensuremath{\lambda}", # greek small letter lamda
0x03BC: r"\ensuremath{\mu}", # greek small letter mu
0x03C0: r"\ensuremath{\pi}", # greek small letter pi
0x03C1: r"\ensuremath{\rho}", # greek small letter rho
0x03C3: r"\ensuremath{\sigma}", # greek small letter sigma
0x03C4: r"\ensuremath{\tau}", # greek small letter tau
0x03C6: r"\ensuremath{\varphi}", # greek small letter phi
0x03C7: r"\ensuremath{\chi}", # greek small letter chi
0x03C8: r"\ensuremath{\psi}", # greek small letter psi
0x03C9: r"\ensuremath{\omega}", # greek small letter omega
0x0394: r"\ensuremath{\Delta}", # greek capital letter delta
0x03A3: r"\ensuremath{\Sigma}", # greek capital letter sigma
0x03A9: r"\ensuremath{\Omega}", # greek capital letter omega
}
# Characters that may follow a backslash as a CommonMark escape.
ASCII_TEGN = frozenset("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~")
# Characters that mean something in Markdown, set as themselves (after a backslash, in code).
BOKSTAVELIG = {
"\\": r"\textbackslash{}",
"~": r"\textasciitilde{}",
"_": r"\_",
"<": r"\textless{}",
"[": "[",
"]": "]",
"*": "*",
"`": r"\textasciigrave{}",
}
# Characters after which a code span may break.
KODEBRUDD = {
"/": r"/\allowbreak{}",
".": r".\allowbreak{}",
"-": r"-{}\allowbreak{}",
"_": r"\_\allowbreak{}",
}
class EndringerError(Exception):
"""The input does not have the expected form."""
@dataclass
class Avsnitt:
"""A paragraph of an entry: its source lines without indentation, and the first line number."""
linjer: list[str]
nr: int
@dataclass
class Punkt:
"""A numbered point: its number, source lines without indentation, first line number."""
nummer: int
linjer: list[str]
nr: int
@dataclass
class Liste:
"""A numbered list inside an entry."""
punkter: list[Punkt] = field(default_factory=list)
@dataclass
class Oppforing:
"""A dated entry: the date and its blocks in order."""
dato: str
blokker: list[Avsnitt | Liste]
def feil(nr: int, hva: str, linje: str) -> EndringerError:
"""An error that names the line of the pre-registration it stands on."""
return EndringerError(f"FORHANDSREGISTRERING.md:{nr}: {hva}: {linje!r}")
def sjekk_innhold(innhold: str, nr: int, linje: str) -> None:
"""Stop on a block construct the converter does not know, at the start of a line's text."""
if BLOKKMERKE.match(innhold):
msg = "heading, block quote, table row or code fence"
raise feil(nr, msg, linje)
if LISTEMERKE.match(innhold):
msg = "list marker where only text is expected"
raise feil(nr, msg, linje)
def les_seksjon(tekst: str) -> tuple[list[tuple[int, str]], int]:
"""Return the lines after the heading with their numbers, and the heading's line number."""
linjer = tekst.split("\n")
treff = [i for i, linje in enumerate(linjer) if linje == OVERSKRIFT]
if len(treff) != 1:
msg = f"the heading {OVERSKRIFT!r} stands {len(treff)} times, not once"
raise EndringerError(msg)
start = treff[0]
resten = linjer[start + 1 :]
if resten and resten[-1] == "":
resten = resten[:-1] # the newline that ends the file
else:
msg = "the file does not end with a newline"
raise EndringerError(msg)
return [(start + 2 + i, linje) for i, linje in enumerate(resten)], start + 1
def les_oppforinger(linjer: list[tuple[int, str]]) -> list[Oppforing]: # noqa: C901, PLR0912, PLR0915
"""Read the entries by the indentation of their lines."""
oppforinger: list[Oppforing] = []
tom_foran = True # a blank line (or the heading) stands before this line
for nr, linje in linjer:
if "\t" in linje or "\r" in linje:
raise feil(nr, "tab or carriage return", linje)
if linje != linje.rstrip(" "):
raise feil(nr, "trailing whitespace (a hard line break in Markdown)", linje)
if not linje:
if not oppforinger and not tom_foran:
raise feil(nr, "blank line before the first entry", linje)
tom_foran = True
continue
if linje.startswith("- "):
m = ENTRY.match(linje)
if not m:
raise feil(nr, "an entry does not start with a date and a colon", linje)
sjekk_innhold(m.group(2), nr, linje)
oppforinger.append(Oppforing(m.group(1), [Avsnitt([m.group(2)], nr)]))
tom_foran = False
continue
if not oppforinger:
raise feil(nr, "text before the first entry", linje)
blokker = oppforinger[-1].blokker
siste = blokker[-1]
m = PUNKT.match(linje)
if m:
nummer = int(m.group(1))
sjekk_innhold(m.group(2), nr, linje)
punkt = Punkt(nummer, [m.group(2)], nr)
if isinstance(siste, Liste):
if tom_foran:
raise feil(nr, "blank line inside a numbered list", linje)
if nummer != siste.punkter[-1].nummer + 1:
raise feil(nr, "the numbers of a list do not run on", linje)
siste.punkter.append(punkt)
else:
blokker.append(Liste([punkt]))
tom_foran = False
continue
innrykk = len(linje) - len(linje.lstrip(" "))
innhold = linje[innrykk:]
sjekk_innhold(innhold, nr, linje)
if innrykk == INNRYKK:
if isinstance(siste, Avsnitt) and not tom_foran:
siste.linjer.append(innhold)
else:
blokker.append(Avsnitt([innhold], nr))
elif isinstance(siste, Liste) and not tom_foran:
punkt = siste.punkter[-1]
if innrykk != INNRYKK + len(f"{punkt.nummer}. "):
raise feil(nr, "indentation that continues neither the entry nor the point", linje)
punkt.linjer.append(innhold)
else:
raise feil(nr, "indentation the converter does not know", linje)
tom_foran = False
if not oppforinger:
msg = "the section has no entries"
raise EndringerError(msg)
return oppforinger
def ukjent(nr: int, hva: str) -> EndringerError:
"""An error in a paragraph that starts on line ``nr`` of the pre-registration."""
return EndringerError(f"FORHANDSREGISTRERING.md:{nr}: {hva}")
def tegn(c: str, neste: str, nr: int) -> str:
"""One character of running text in LaTeX (not one of the Markdown characters)."""
if c.isascii() and (c.isalnum() or c in " \n"):
return c
if c in VANLIG:
return c + "{}" if LIGATUR.get(c) == neste else c
if c in SPESIELL:
return SPESIELL[c]
if ord(c) in DIREKTE:
return c
if ord(c) in UNICODE:
return UNICODE[ord(c)]
msg = f"a character the converter does not know: {c!r} (U+{ord(c):04X})"
raise ukjent(nr, msg)
def bokstavelig(c: str, nr: int) -> str:
"""A character that means something in Markdown, set as the character itself."""
if c in BOKSTAVELIG:
return BOKSTAVELIG[c]
return tegn(c, "", nr)
def kode(innhold: str, nr: int) -> str:
r"""A code span in \texttt, with break points after / . _ - and inside long hex strings."""
if not innhold or innhold != innhold.strip(" ") or "\n" in innhold:
msg = "a code span that is empty, padded or broken over lines"
raise ukjent(nr, msg)
ut: list[str] = []
pos = 0
for m in HEKS.finditer(innhold):
ut.extend(kodetegn(c, nr) for c in innhold[pos : m.start()])
heks = m.group(0)
ut.append(
r"\allowbreak{}".join(heks[k : k + OPPDELING] for k in range(0, len(heks), OPPDELING))
)
pos = m.end()
ut.extend(kodetegn(c, nr) for c in innhold[pos:])
return r"\texttt{" + "".join(ut) + "}"
def kodetegn(c: str, nr: int) -> str:
"""One character of a code span."""
if c.isascii() and c.isalnum():
return c
if c in KODEBRUDD:
return KODEBRUDD[c]
return bokstavelig(c, nr)
def kodespenn(tekst: str, i: int, nr: int) -> tuple[str, int]:
"""The code span that opens at ``i``, and the position after it."""
slutt = tekst.find("`", i + 1)
if slutt < 0 or tekst.startswith("``", i):
msg = "an unclosed or double code span"
raise ukjent(nr, msg)
return kode(tekst[i + 1 : slutt], nr), slutt + 1
def stjerne(tekst: str, i: int, apne: list[str], nr: int) -> tuple[str, int]:
"""Open or close the emphasis at ``i``; return its LaTeX and the position after the marker."""
if tekst.startswith("***", i):
msg = "three asterisks in a row"
raise ukjent(nr, msg)
merke = "**" if tekst.startswith("**", i) else "*"
foran = tekst[i - 1] if i > 0 else " "
etter = tekst[i + len(merke)] if i + len(merke) < len(tekst) else " "
if apne and apne[-1] == merke and not foran.isspace():
apne.pop()
return "}", i + len(merke)
if merke not in apne and not etter.isspace():
apne.append(merke)
return (r"\textbf{" if merke == "**" else r"\emph{"), i + len(merke)
msg = "an asterisk that neither opens nor closes emphasis"
raise ukjent(nr, msg)
def vanlig(tekst: str, i: int, nr: int) -> str:
"""One character of running text that is not a code span, an asterisk or a backslash."""
c = tekst[i]
neste = tekst[i + 1] if i + 1 < len(tekst) else ""
if c == "_":
if not (i > 0 and tekst[i - 1].isalnum() and neste.isalnum()):
msg = "an underscore that could be emphasis"
raise ukjent(nr, msg)
return r"\_"
if c == "~":
if neste == "~" or (i > 0 and tekst[i - 1] == "~"):
msg = "a double tilde (strike-through)"
raise ukjent(nr, msg)
return r"\textasciitilde{}"
if c in "<[]":
msg = f"a link or HTML ({c!r})"
raise ukjent(nr, msg)
if c == " " and neste == "%":
return "~" # no line break between a number and its per cent sign
return tegn(c, neste, nr)
def inline(tekst: str, nr: int) -> str:
"""Convert the inline Markdown of one paragraph (lines joined by newlines) to LaTeX."""
ut: list[str] = []
apne: list[str] = []
i = 0
while i < len(tekst):
c = tekst[i]
if c == "`":
bit, i = kodespenn(tekst, i, nr)
elif c == "*":
bit, i = stjerne(tekst, i, apne, nr)
elif c == "\\":
neste = tekst[i + 1] if i + 1 < len(tekst) else ""
if neste not in ASCII_TEGN:
msg = "a backslash that is not a Markdown escape"
raise ukjent(nr, msg)
bit, i = bokstavelig(neste, nr), i + 2
else:
bit, i = vanlig(tekst, i, nr), i + 1
ut.append(bit)
if apne:
msg = f"emphasis not closed in the paragraph: {apne}"
raise ukjent(nr, msg)
return "".join(ut)
def lag_liste(liste: Liste) -> list[str]:
"""The LaTeX of a numbered list inside an entry."""
forste = liste.punkter[0].nummer
storste = liste.punkter[-1].nummer
ut = [
(
rf"\begin{{enumerate}}[label=\arabic*.,start={forste},widest={storste},leftmargin=*,"
r"topsep=0.3ex,itemsep=0.15ex,parsep=0pt]"
)
]
ut += [r"\item " + inline("\n".join(p.linjer), p.nr) for p in liste.punkter]
ut.append(r"\end{enumerate}")
return ut
def lag(tekst: str, sjekksum: str) -> tuple[str, int]:
"""Return the LaTeX of the appendix and the number of dated entries."""
linjer, _ = les_seksjon(tekst)
oppforinger = les_oppforinger(linjer)
antall = len(oppforinger)
sum_tex = kode(sjekksum, 0)
innledning = (
r"\noindent Lista under gjengir avsnittet «Endringer» i \fil{FORHANDSREGISTRERING.md}"
rf" ordrett og i sin helhet: {antall} daterte punkter, i den rekkefølgen de står der."
r" Bare oppsettet er endret: datoen i hvert punkt står med fet skrift, og filnavn og"
r" sjekksummer med skrivemaskinskrift. Lista er laget av"
r" \fil{rapport/lag_vedlegg_endringer.py} fra fila med SHA-256 " + sum_tex + "."
)
ut = [
"% Laget av rapport/lag_vedlegg_endringer.py fra FORHANDSREGISTRERING.md.",
"% Rettes ikke for hånd: kjør skriptet på nytt.",
innledning,
"",
r"{\small",
(
r"\begin{itemize}[leftmargin=1.1em,label=\textbullet,topsep=1ex,itemsep=0.7ex,"
r"parsep=0.5ex,listparindent=0pt]"
),
]
for opp in oppforinger:
for i, blokk in enumerate(opp.blokker):
if isinstance(blokk, Liste):
ut += lag_liste(blokk)
continue
avsnitt = inline("\n".join(blokk.linjer), blokk.nr)
if i == 0:
ut.append(rf"\item \textbf{{{opp.dato}:}} " + avsnitt)
else:
ut += ["", avsnitt]
ut += [r"\end{itemize}", "}", ""]
return "\n".join(ut), antall
def main() -> int:
"""Write the appendix; return 0, or 1 with a message on error."""
try:
data = KILDE.read_bytes()
tekst, antall = lag(data.decode("utf-8"), hashlib.sha256(data).hexdigest())
UT.parent.mkdir(exist_ok=True)
except (EndringerError, OSError, UnicodeDecodeError) as e:
sys.stderr.write(f"lag_vedlegg_endringer: {e}\n")
return 1
UT.write_text(tekst, encoding="utf-8", newline="\n")
sys.stdout.write(f"lag_vedlegg_endringer: skrev {UT.relative_to(ROT)} ({antall} punkter)\n")
return 0
if __name__ == "__main__":
sys.exit(main())

View file

@ -0,0 +1,711 @@
# ruff: noqa: INP001
r"""Write appendix B of the report: the frozen parameters.
Reads ``modell/parametere.json`` and writes ``rapport/generert/vedlegg-parametere.tex``: a
short lead-in (the version, the number of parameters per status, the SHA-256 of the file), one
table row per parameter in the file's order, and the frozen sensitivity list verbatim.
A parameter row holds the symbol and the id, the name with the unit and where it is used, the
distribution with every number it has in the file, the status and the source-bank entries as
``\kilde{...}``. A line under the row, across the table, holds the source value, the remark and
a fixed value that is a table, when the file has them.
Numbers follow one rule (``tall``): the shortest decimal string that gives back the same value
(Python's ``repr``), without a trailing ``.0``; a decimal comma; a thin space between groups of
three digits when the integer part has five digits or more; a minus sign for negative values;
and a power of ten when the shortest string has an exponent. No digit is dropped.
Free text goes through ``tekst``: every character LaTeX treats specially is escaped, and every
non-ASCII character must be one of those listed in ``TEGN``. A symbol is set in math mode when
it uses only the commands in ``KOMMANDOER`` and plain letters, digits and signs. Anything else
stops the script.
Standard library only. The output depends only on the parameter file and the pre-registration:
same input, same bytes. The script stops with an error, and writes nothing, when the file does
not have the expected form, when a character or a symbol cannot be rendered, or when the
checksum of the file is not the last one stated under «Parameterfrys» in the pre-registration.
Run from anywhere: ``python3 rapport/lag_vedlegg_parametere.py``.
"""
from __future__ import annotations
import hashlib
import json
import math
import re
import sys
from pathlib import Path
ROT = Path(__file__).resolve().parent.parent
PARAMETERE = ROT / "modell" / "parametere.json"
FORHAANDSREG = ROT / "FORHANDSREGISTRERING.md"
UT = ROT / "rapport" / "generert" / "vedlegg-parametere.tex"
ANTALL = 137
ANTALL_FOELSOMHETER = 37
MAKS_DYBDE = 2
FELT = (
"id",
"symbol",
"navn",
"enhet",
"fordeling",
"poster",
"status",
"ligninger",
"kildeverdi",
"merknad",
)
TEKSTFELT = ("id", "symbol", "navn", "enhet", "status", "ligninger", "kildeverdi", "merknad")
FORDELINGSFELT = {
"fast": ("type", "verdi"),
"jevn": ("type", "lav", "hoy"),
"logjevn": ("type", "lav", "hoy"),
"pert": ("type", "lav", "modus", "hoy", "form"),
"lognormal": ("type", "median", "sigma", "min", "maks", "avkorting"),
"diskret": ("type", "verdier", "vekter"),
}
SAMMENSATT = "sammensatt"
INGEN = "\u2013" # the file's en dash for "no symbol" and "no unit"
ID = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$")
POST = re.compile(r"^K\d{2}-(?:\d{3}|K\d{2}|Ka\d{2})$")
SJEKKSUM = re.compile(r"SHA-256: `([0-9a-f]{64})`")
# Characters LaTeX treats specially, written so that they print as themselves.
SPESIELLE = {
"\\": r"\textbackslash{}",
"{": r"\{",
"}": r"\}",
"$": r"\$",
"&": r"\&",
"#": r"\#",
"%": r"\%",
"_": r"\_",
"^": r"\textasciicircum{}",
"~": r"\textasciitilde{}",
"<": r"\textless{}",
">": r"\textgreater{}",
"|": r"\textbar{}",
'"': r"\textquotedbl{}", # an active shorthand under babel norsk
"`": r"\textasciigrave{}",
}
# Every non-ASCII character the text may hold, and how it is written for pdflatex with
# inputenc utf8 and T1. Letters and guillemets are left to inputenc; the rest are named.
TEGN = {
"\u00e6": "\u00e6", # ae
"\u00f8": "\u00f8", # o with stroke
"\u00e5": "\u00e5", # a with ring
"\u00c6": "\u00c6", # AE
"\u00d8": "\u00d8", # O with stroke
"\u00c5": "\u00c5", # A with ring
"\u00e9": "\u00e9", # e with acute
"\u00ab": "\u00ab", # left guillemet
"\u00bb": "\u00bb", # right guillemet
"\u00b0": r"\textdegree{}",
"\u00b2": r"\textsuperscript{2}",
"\u00b3": r"\textsuperscript{3}",
"\u00b7": r"\textperiodcentered{}",
"\u00d7": r"\texttimes{}",
"\u2013": r"\textendash{}",
"\u2212": r"\textminus{}",
"\u2192": r"\textrightarrow{}",
"\u2264": r"\ensuremath{\leq}",
"\u2265": r"\ensuremath{\geq}",
}
# Letters allowed inside \text{...} of a symbol, besides ASCII letters, digits, comma and space.
TEKST_I_SYMBOL = frozenset("\u00e6\u00f8\u00e5\u00c6\u00d8\u00c5")
KOMMANDOER = frozenset(
{
"alpha",
"bar",
"beta",
"chi",
"Delta",
"delta",
"ell",
"epsilon",
"eta",
"Gamma",
"gamma",
"iota",
"kappa",
"lambda",
"mathcal",
"mathit",
"min",
"mu",
"nu",
"omega",
"phi",
"pi",
"psi",
"rho",
"sigma",
"tau",
"theta",
"varepsilon",
"varphi",
"xi",
}
)
SYMBOLTEGN = frozenset("_^{}(),*- ")
TEKSTGRUPPE = re.compile(r"\\text\{([^{}\\]*)\}")
KOMMANDO = re.compile(r"\\([A-Za-z]+)")
STRIPE = r"\textendash{}"
HODE = r"Symbol og id & Størrelse & Fordeling & Status & Poster \\"
SYMBOLBREDDE = "19mm"
KOLONNER = rf"@{{}}P{{{SYMBOLBREDDE}}}LP{{36mm}}P{{17mm}}P{{17mm}}@{{}}"
UNDERLINJE = (
rf"\multicolumn{{4}}{{>{{\raggedright\arraybackslash}}"
rf"p{{\dimexpr\linewidth-{SYMBOLBREDDE}-2\tabcolsep\relax}}@{{}}}}"
)
class ParameterError(Exception):
"""The input does not have the expected form, or something in it cannot be rendered."""
def tekst(s: str) -> str:
"""Free text from the file as LaTeX: special characters escaped, non-ASCII from TEGN."""
ut: list[str] = []
forrige = ""
for c in s:
if c in SPESIELLE:
ut.append(SPESIELLE[c])
elif c in TEGN:
ut.append(TEGN[c])
elif " " <= c <= "~":
# Break the T1 ligatures "--" (dash) and ",," (low quotes) by an empty group.
if c == forrige and c in "-,":
ut.append("{}")
ut.append(c)
else:
msg = f"character {c!r} (U+{ord(c):04X}) has no rendering in TEGN: {s!r}"
raise ParameterError(msg)
forrige = c
return "".join(ut)
def _grupper(siffer: str) -> str:
r"""Digits with \, between groups of three when there are five digits or more."""
if len(siffer) < 5: # noqa: PLR2004 - four-digit numbers are not grouped in Norwegian
return siffer
hode = len(siffer) % 3 or 3
grupper = [siffer[:hode]] + [siffer[i : i + 3] for i in range(hode, len(siffer), 3)]
return r"\,".join(grupper)
def _desimal(s: str) -> str:
"""A decimal string without exponent (as repr writes it) in the Norwegian form."""
minus = s.startswith("-")
s = s.removeprefix("-")
heltall, _, brok = s.partition(".")
if not heltall.isdigit() or (brok and not brok.isdigit()):
msg = f"not a decimal number: {s!r}"
raise ParameterError(msg)
if brok == "0":
brok = ""
ut = _grupper(heltall) + ("," + brok if brok else "")
return (r"\textminus{}" if minus else "") + ut
def tall(x: float) -> str:
"""A number from the file, with every digit it has there (see the module docstring)."""
if isinstance(x, bool):
msg = f"a truth value where a number is expected: {x!r}"
raise ParameterError(msg)
if isinstance(x, int):
return _desimal(str(x))
if not math.isfinite(x):
msg = f"not a finite number: {x!r}"
raise ParameterError(msg)
r = repr(x)
if "e" not in r:
return _desimal(r)
mantisse, _, eksponent = r.partition("e")
e = int(eksponent)
potens = (r"\textminus{}" if e < 0 else "") + str(abs(e))
return _desimal(mantisse) + r"\,\textperiodcentered\,10\textsuperscript{" + potens + "}"
def er_tall(x: object) -> bool:
"""Whether x is a JSON number (not a truth value)."""
return isinstance(x, (int, float)) and not isinstance(x, bool)
def skalar(x: object) -> str:
"""One value inside a fixed value: a number, a text, a truth value or null."""
if x is None:
return "ingen"
if isinstance(x, bool):
return "ja" if x else "nei"
if isinstance(x, (int, float)):
return tall(x)
if isinstance(x, str):
return tekst(x)
msg = f"not a single value: {x!r}"
raise ParameterError(msg)
def er_skalar(x: object) -> bool:
"""Whether x is a single value (not a list or an object)."""
return x is None or isinstance(x, (bool, int, float, str))
def nokkel(k: str) -> str:
r"""A key of a fixed value, as it stands in the file, in \texttt."""
return r"\texttt{" + tekst(k) + "}"
def _liste(v: list[object]) -> str:
if not v or not all(er_skalar(x) for x in v):
msg = f"a list that is empty or not of single values: {v!r}"
raise ParameterError(msg)
return "; ".join(skalar(x) for x in v)
def _indre(v: object) -> str:
"""The second level of a table: a single value, a list, or an object of single values."""
if er_skalar(v):
return skalar(v)
if isinstance(v, list):
return _liste(v)
if isinstance(v, dict):
if not v or not all(er_skalar(x) for x in v.values()):
msg = f"a table deeper than {MAKS_DYBDE} levels: {v!r}"
raise ParameterError(msg)
return "; ".join(f"{nokkel(k)} = {skalar(x)}" for k, x in v.items())
msg = f"unexpected value: {v!r}"
raise ParameterError(msg)
def fast_verdi(v: object) -> tuple[str, list[str]]:
"""The cell text for a fixed value, and the lines under the row when it is a table."""
if er_tall(v):
return "fast " + skalar(v), []
if isinstance(v, list) and all(er_skalar(x) for x in v):
return "fast " + _liste(v), []
if isinstance(v, dict) and v and all(er_skalar(x) for x in v.values()):
celle = "".join(rf"\newline {nokkel(k)}: {skalar(x)}" for k, x in v.items())
return "fast" + celle, []
if isinstance(v, list) and v:
return "fast, tabell (verdiene står under)", [_indre(x) for x in v]
if isinstance(v, dict) and v:
linjer = [f"{nokkel(k)}: {_indre(x)}" for k, x in v.items()]
return "fast, tabell (verdiene står under)", linjer
msg = f"unexpected fixed value: {v!r}"
raise ParameterError(msg)
def _felt(f: dict[str, object], navn: str) -> float:
x = f[navn]
if not isinstance(x, (int, float)) or isinstance(x, bool):
msg = f"field {navn!r} is not a number: {x!r}"
raise ParameterError(msg)
return x
def _talliste(f: dict[str, object], navn: str) -> list[float]:
x = f[navn]
if not isinstance(x, list) or not x:
msg = f"field {navn!r} is not a list of numbers: {x!r}"
raise ParameterError(msg)
ut: list[float] = []
for v in x:
if not isinstance(v, (int, float)) or isinstance(v, bool):
msg = f"field {navn!r} is not a list of numbers: {x!r}"
raise ParameterError(msg)
ut.append(v)
return ut
def _jevn(f: dict[str, object], _pert_form: int) -> str:
return f"jevn {tall(_felt(f, 'lav'))} {STRIPE} {tall(_felt(f, 'hoy'))}"
def _logjevn(f: dict[str, object], _pert_form: int) -> str:
return f"jevn i logaritmen {tall(_felt(f, 'lav'))} {STRIPE} {tall(_felt(f, 'hoy'))}"
def _pert(f: dict[str, object], pert_form: int) -> str:
"""PERT low / mode / high; the form only when it is not the file's common one."""
punkter = " / ".join(tall(_felt(f, k)) for k in ("lav", "modus", "hoy"))
form = _felt(f, "form")
tillegg = "" if form == pert_form else f", form {tall(form)}"
return f"PERT {punkter}{tillegg}"
def _diskret(f: dict[str, object], _pert_form: int) -> str:
verdier = _talliste(f, "verdier")
vekter = _talliste(f, "vekter")
if len(verdier) != len(vekter):
msg = f"{len(verdier)} values but {len(vekter)} weights"
raise ParameterError(msg)
tekst_verdier = "; ".join(tall(v) for v in verdier)
tekst_vekter = "; ".join(tall(v) for v in vekter)
return f"diskret {tekst_verdier}" + r"\newline " + f"vekter {tekst_vekter}"
def _lognormal(f: dict[str, object], _pert_form: int) -> str:
avkorting = f["avkorting"]
if not isinstance(avkorting, str):
msg = f"the truncation of a lognormal distribution is not a text: {avkorting!r}"
raise ParameterError(msg)
return (
f"lognormal, median {tall(_felt(f, 'median'))}, sigma {tall(_felt(f, 'sigma'))}, "
f"minst {tall(_felt(f, 'min'))}, høyst {tall(_felt(f, 'maks'))}, "
f"avkorting: {tekst(avkorting)}"
)
SKRIV = {
"jevn": _jevn,
"logjevn": _logjevn,
"pert": _pert,
"diskret": _diskret,
"lognormal": _lognormal,
}
def _sammensatt(f: dict[str, object], pert_form: int) -> str:
"""One line per part: the name of the part and its distribution (never a table)."""
deler = [k for k in f if k != "type"]
if not deler:
msg = "a composite distribution with no parts"
raise ParameterError(msg)
linjer = []
for k in deler:
celle, under = fordeling(f[k], pert_form, indre=True)
if under:
msg = f"part {k!r} of a composite distribution is a table"
raise ParameterError(msg)
linjer.append(f"{tekst(k)}: {celle}")
return r"\newline ".join(linjer)
def fordeling(f: object, pert_form: int, *, indre: bool = False) -> tuple[str, list[str]]:
"""The cell text for a distribution, and the lines under the row (for a table value)."""
if not isinstance(f, dict):
msg = f"a distribution is not an object: {f!r}"
raise ParameterError(msg)
t = f.get("type")
if t == SAMMENSATT and not indre:
return _sammensatt(f, pert_form), []
if not isinstance(t, str) or t not in FORDELINGSFELT:
msg = f"unknown distribution type {t!r}"
raise ParameterError(msg)
if tuple(f) != FORDELINGSFELT[t]:
msg = f"distribution {t!r} has the fields {tuple(f)}, expected {FORDELINGSFELT[t]}"
raise ParameterError(msg)
if t == "fast":
return fast_verdi(f["verdi"])
return SKRIV[t](f, pert_form), []
def _sjekk_tekstgrupper(s: str) -> None:
r"""Every \text{...} in a symbol holds only letters, digits, commas and spaces."""
for innhold in TEKSTGRUPPE.findall(s):
if not innhold or not all(
(c.isascii() and (c.isalnum() or c in ", ")) or c in TEKST_I_SYMBOL for c in innhold
):
msg = f"symbol {s!r}: \\text{{{innhold}}} holds a character that is not allowed"
raise ParameterError(msg)
def _sjekk_resten(s: str, rest: str) -> None:
"""What is left of a symbol: allowed characters, scripts with an argument, balanced braces."""
dybde = 0
for i, c in enumerate(rest):
if not (c.isascii() and c.isalnum()) and c not in SYMBOLTEGN:
msg = f"symbol {s!r}: character {c!r} is not allowed in a symbol"
raise ParameterError(msg)
if c in "_^" and (i + 1 == len(rest) or rest[i + 1] in "_^} "):
msg = f"symbol {s!r}: {c!r} without an argument"
raise ParameterError(msg)
dybde += {"{": 1, "}": -1}.get(c, 0)
if dybde < 0:
break
if dybde != 0:
msg = f"symbol {s!r}: unbalanced braces"
raise ParameterError(msg)
def tex_symbol(s: str) -> str:
"""The symbol in math mode, or a dash for none; stops on anything not known to be safe."""
if s == INGEN:
return STRIPE
if not s or s.strip() != s:
msg = f"empty symbol or symbol with spaces at the ends: {s!r}"
raise ParameterError(msg)
_sjekk_tekstgrupper(s)
rest = TEKSTGRUPPE.sub("x", s)
for kommando in KOMMANDO.findall(rest):
if kommando not in KOMMANDOER:
msg = f"symbol {s!r}: command \\{kommando} is not in KOMMANDOER"
raise ParameterError(msg)
_sjekk_resten(s, KOMMANDO.sub("x", rest))
return "$" + s + "$"
def tex_id(pid: str) -> str:
r"""The parameter id in \texttt, with break points after underscores."""
if not ID.match(pid):
msg = f"not a plain id: {pid!r}"
raise ParameterError(msg)
return r"\texttt{" + pid.replace("_", r"\_\allowbreak{}") + "}"
def tex_poster(poster: list[str]) -> str:
r"""The source-bank entries, each in \kilde, or a dash when there are none."""
for p in poster:
if not POST.match(p):
msg = f"not a source-bank entry: {p!r}"
raise ParameterError(msg)
if not poster:
return STRIPE
# \leavevmode first: the colour in \kilde would otherwise start the cell in vertical mode
# and push its first line below the first line of the other cells.
return r"\leavevmode " + " ".join(r"\kilde{" + p + "}" for p in poster)
def les_parameter(p: object, statuser: dict[str, str]) -> dict[str, object]:
"""Check one parameter object and return it."""
if not isinstance(p, dict) or tuple(p) != FELT:
msg = f"a parameter does not have exactly the fields {FELT}: {p!r}"
raise ParameterError(msg)
for k in TEKSTFELT:
if not isinstance(p[k], str):
msg = f"{p.get('id')!r}: field {k!r} is not a text"
raise ParameterError(msg)
for k in ("id", "symbol", "navn", "enhet", "status"):
if not p[k]:
msg = f"{p.get('id')!r}: field {k!r} is empty"
raise ParameterError(msg)
poster = p["poster"]
if not isinstance(poster, list) or not all(isinstance(x, str) for x in poster):
msg = f"{p['id']!r}: the entries are not a list of texts"
raise ParameterError(msg)
if p["status"] not in statuser:
msg = f"{p['id']!r}: unknown status {p['status']!r}"
raise ParameterError(msg)
return p
def rad(p: dict[str, object], pert_form: int) -> list[str]:
"""The table lines for one parameter: the row, and the line under it when there is one."""
pid, symbol, navn, enhet = str(p["id"]), str(p["symbol"]), str(p["navn"]), str(p["enhet"])
status, ligninger = str(p["status"]), str(p["ligninger"])
kildeverdi, merknad = str(p["kildeverdi"]), str(p["merknad"])
poster = p["poster"]
assert isinstance(poster, list) # noqa: S101 - checked in les_parameter
celle, tabell = fordeling(p["fordeling"], pert_form)
navnecelle = tekst(navn) + r"\newline \textit{Enhet:} " + tekst(enhet)
if ligninger:
navnecelle += r". \textit{Brukes i:} " + tekst(ligninger)
celler = [
tex_symbol(symbol) + r"\newline " + tex_id(pid),
navnecelle,
celle,
tekst(status),
tex_poster(poster),
]
deler = []
if kildeverdi:
deler.append(r"\textit{Kildeverdi:} " + tekst(kildeverdi))
if merknad:
deler.append(r"\textit{Merknad:} " + tekst(merknad))
if tabell:
deler.append(r"\textit{Verdi:}\newline " + tabell[0])
if not deler:
return [" & ".join(celler) + r" \\", r"\addlinespace[3pt]"]
# The row and the first line under it stay on one page; the rest of a table value has one
# table row per line, so that a long table can break across pages.
return [
" & ".join(celler) + r" \\*",
"& " + UNDERLINJE + "{" + r"\newline ".join(deler) + r"} \\",
*("& " + UNDERLINJE + "{" + linje + r"} \\" for linje in tabell[1:]),
r"\addlinespace[3pt]",
]
def sjekksum_registrert(forhaandsreg: str) -> str:
"""The last SHA-256 stated under «Parameterfrys» in the pre-registration."""
_, funnet, etter = forhaandsreg.partition("\n## Parameterfrys\n")
if not funnet:
msg = "the pre-registration has no section «Parameterfrys»"
raise ParameterError(msg)
seksjon = etter.split("\n## ", 1)[0]
summer = SJEKKSUM.findall(seksjon)
if not summer:
msg = "no SHA-256 under «Parameterfrys» in the pre-registration"
raise ParameterError(msg)
return str(summer[-1])
def _uten_dubletter(par: list[tuple[str, object]]) -> dict[str, object]:
"""A JSON object, refusing a key that stands twice (json would keep the last silently)."""
d: dict[str, object] = {}
for k, v in par:
if k in d:
msg = f"the key {k!r} stands twice in one object"
raise ParameterError(msg)
d[k] = v
return d
def _hent(d: dict[str, object], k: str) -> object:
if k not in d:
msg = f"the file has no field {k!r}"
raise ParameterError(msg)
return d[k]
def lag(raa: bytes, forhaandsreg: str) -> str:
"""Return the LaTeX of the appendix."""
sjekksum = hashlib.sha256(raa).hexdigest()
registrert = sjekksum_registrert(forhaandsreg)
if sjekksum != registrert:
msg = (
f"the checksum of the file ({sjekksum}) is not the one the pre-registration "
f"states under «Parameterfrys» ({registrert})"
)
raise ParameterError(msg)
d = json.loads(raa.decode("utf-8"), object_pairs_hook=_uten_dubletter)
if not isinstance(d, dict):
msg = "the file is not a JSON object"
raise ParameterError(msg)
versjon = _hent(d, "versjon")
statuser = _hent(d, "status")
monte_carlo = _hent(d, "monte_carlo")
foelsomheter = _hent(d, "foelsomheter")
parametere = _hent(d, "parametere")
if not isinstance(versjon, str) or not versjon:
msg = f"the version is not a text: {versjon!r}"
raise ParameterError(msg)
if not isinstance(statuser, dict) or not all(
isinstance(k, str) and isinstance(v, str) for k, v in statuser.items()
):
msg = "the field 'status' is not an object of texts"
raise ParameterError(msg)
if not isinstance(monte_carlo, dict) or not isinstance(monte_carlo.get("pert_form"), int):
msg = "monte_carlo.pert_form is not a whole number"
raise ParameterError(msg)
pert_form = int(monte_carlo["pert_form"])
if not isinstance(parametere, list) or len(parametere) != ANTALL:
msg = f"the file does not hold exactly {ANTALL} parameters"
raise ParameterError(msg)
if (
not isinstance(foelsomheter, list)
or len(foelsomheter) != ANTALL_FOELSOMHETER
or not all(isinstance(s, str) and s for s in foelsomheter)
):
msg = f"the sensitivity list is not {ANTALL_FOELSOMHETER} non-empty texts"
raise ParameterError(msg)
rader = [les_parameter(p, statuser) for p in parametere]
ider = [str(p["id"]) for p in rader]
if len(set(ider)) != len(ider):
msg = "an id stands twice"
raise ParameterError(msg)
antall = {s: sum(1 for p in rader if p["status"] == s) for s in statuser}
deler = [f"{n} med status «{tekst(s)}» ({tekst(statuser[s])})" for s, n in antall.items() if n]
opptelling = "; ".join(deler[:-1]) + " og " + deler[-1] if len(deler) > 1 else deler[0]
sum_tekst = r"\allowbreak{}".join(sjekksum[i : i + 16] for i in range(0, len(sjekksum), 16))
innledning = [
(
rf"\noindent Fila er versjon {tekst(versjon)} og har {len(rader)} parametere, som"
rf" står i tabellen i samme rekkefølge som i fila: {opptelling}. Sjekksummen (SHA-256)"
rf" av fila er \texttt{{{sum_tekst}}}, den samme som forhåndsregistreringen oppgir"
r" under «Parameterfrys» for fila som gjelder nå."
),
"",
(
r"Fordelingen skrives som i kapittel~14 i spesifikasjonen: «fast» med verdien,"
r" «jevn lav \textendash{} høy», «jevn i logaritmen lav \textendash{} høy»,"
rf" «PERT lav / modus / høy» (beta-PERT med formparameter {tall(pert_form)}),"
r" «diskret» med verdiene og vektene, og «lognormal» med median, sigma og grensene den"
r" avkortes ved. En sammensatt parameter har én linje per størrelse. Tall står med alle"
r" sifrene de har i fila, med desimalkomma og tynt mellomrom mellom tusener når"
r" heltallsdelen har fem sifre eller flere; flere verdier skilles med semikolon. Id-er"
r" og nøkler står i skrivemaskinskrift slik de står i fila. Under raden står"
r" kildeverdien (kildens tall i kildens egen enhet), merknaden og en fast verdi som er"
r" en tabell, når fila har dem."
r" En strek for symbol eller poster betyr at fila ikke har noe der; som enhet betyr den"
r" at størrelsen er uten enhet."
),
]
ut = [
"% Laget av rapport/lag_vedlegg_parametere.py fra modell/parametere.json.",
"% Rettes ikke for hånd: kjør skriptet på nytt.",
*innledning,
"",
r"{\footnotesize",
r"\setlength{\tabcolsep}{4pt}",
r"\renewcommand{\arraystretch}{1.12}",
r"\begin{xltabular}{\linewidth}{" + KOLONNER + "}",
r"\caption{Parameterne i parameterfila, versjon " + tekst(versjon) + r". Kildeverdien,"
r" merknaden og verdier som er tabeller, står i linja under parameteren.}"
r"\label{tab:parametere}\\",
r"\toprule",
HODE,
r"\midrule",
r"\endfirsthead",
r"\toprule",
HODE,
r"\midrule",
r"\endhead",
r"\bottomrule",
r"\endfoot",
]
for p in rader:
ut += rad(p, pert_form)
ut += [r"\end{xltabular}", "}", ""]
ut += [
(
r"\noindent Parameterfila låser også lista over følsomheter."
rf" \Cref{{tab:folsomhetsliste}} gjengir den ordrett, {len(foelsomheter)} linjer,"
r" nummerert i den rekkefølgen de står i fila."
),
"",
r"{\footnotesize",
r"\setlength{\tabcolsep}{4pt}",
r"\renewcommand{\arraystretch}{1.12}",
r"\begin{xltabular}{\linewidth}{@{}P{8mm}L@{}}",
(
r"\caption{Den frosne følsomhetslista i parameterfila, ordrett.}"
r"\label{tab:folsomhetsliste}\\"
),
r"\toprule",
r"Linje & Følsomhet \\",
r"\midrule",
r"\endfirsthead",
r"\toprule",
r"Linje & Følsomhet \\",
r"\midrule",
r"\endhead",
r"\bottomrule",
r"\endfoot",
]
ut += [f"{i} & {tekst(s)} \\\\" for i, s in enumerate(foelsomheter, start=1)]
ut += [r"\end{xltabular}", "}", ""]
return "\n".join(ut)
def main() -> int:
"""Write the appendix; return 0, or 1 with a message on error."""
try:
tekst_ut = lag(PARAMETERE.read_bytes(), FORHAANDSREG.read_text(encoding="utf-8"))
except (ParameterError, OSError, ValueError) as e:
sys.stderr.write(f"lag_vedlegg_parametere: {e}\n")
return 1
UT.parent.mkdir(exist_ok=True)
UT.write_text(tekst_ut, encoding="utf-8", newline="\n")
sys.stdout.write(f"lag_vedlegg_parametere: skrev {UT.relative_to(ROT)}\n")
return 0
if __name__ == "__main__":
sys.exit(main())

View file

@ -1,5 +1,7 @@
\documentclass[11pt,a4paper]{article}
\input{preamble}
\usepackage{xstring}
\usepackage{pgfplotstable}
\geometry{top=12mm,bottom=12mm,left=18mm,right=18mm}
\hypersetup{pdftitle={Tokenfabrikker: sammendrag for beslutningstakere},pdfauthor={Kjell Tore Guttormsen},pdflang={nb-NO}}
\pagestyle{fancy}
@ -11,8 +13,19 @@
\fancypagestyle{plain}{\fancyhf{}\fancyfoot[C]{\small\thepage}\renewcommand{\headrulewidth}{0pt}}
\setlist{itemsep=0.6pt,topsep=1.5pt}
\titlespacing*{\section}{0pt}{1.1ex plus .2ex}{0.5ex}
\titlespacing*{\paragraph}{0pt}{0.5ex plus .2ex}{0.5em}
% Skjelett: bare overskrifter og plassholdere. Må holde seg på to sider når det fylles ut.
% Tall fra resultatfilene, skrevet av lag_resultater.py (bygg.sh)
\input{generert/tall}
% The note states only what the summary in the report (sammendrag.tex) states; the method is explained
% from chapters 1 to 3. Every measured number and verdict word is a key of tall.json.
% A \tall value ("3,14") as a number pgfplots can read ("3.14"); only for placing bars and labels.
\newcommand{\tallsomtall}[2]{\fullexpandarg\StrSubstitute{\tall{#1}}{,}{.}[#2]}
% The share "best alone" of one solution on the step with one facility, from generert/dommer-m7.dat
% (row 0 is the step with one facility; checked below), in per cent.
\newcommand{\hentalene}[2]{\pgfplotstablegetelem{0}{#1}\of\mseven\pgfmathsetmacro#2{100*\pgfplotsretval}}
\begin{document}
\thispagestyle{plain}
@ -25,52 +38,178 @@
\begin{tcolorbox}[enhanced,colback=boxbg,colframe=accent,boxrule=0.6pt,arc=1.5pt,left=7pt,right=7pt,top=4pt,bottom=4pt]
\small
\textbf{Kjernebudskap.} \begin{kommerblokk}
hypotesen ordrett og den samlede dommen i én til to setninger
\end{kommerblokk}
\textbf{Kjernebudskap.} Hypotesen er at «statlig eide tokenfabrikker i stor skala lønner seg for Norge og
oppfyller vilkårene for strøm og miljø, med den beste av kraftløsningene». Dommen er
\textbf{«\tall{dommer.del1}»}. Netto nåverdi for Norge har negativ median for alle fem kraftløsningene, og
skalaen nås ikke.
\end{tcolorbox}
\section{Spørsmålet}
\begin{kommerblokk}
hypotesen ordrett, og at den ble endret av prosjekteier før noe var regnet
\end{kommerblokk}
Rapporten prøver om AI-datasentre som i prinsippet eies av staten, kan bli en inntektskilde for Norge slik
oljen har vært. Slike datasentre kalles tokenfabrikker: datasentre som eksporterer ferdig prosessert
regnekraft. Hypotesen står ordrett i rammen over. Prøven er ærlig ment: alle alternativer og
alle resultater rapporteres, også de som går imot hypotesen.
Prosjekteier, som har godkjent kriteriene og hver endring av dem, endret ordlyden i hypotesen 13.~november
2026, før noe var regnet. Før endringen hadde hypotesen en egen del om at ett dedikert kjernekraftverk per
datasenter er den beste måten å gjøre det på. Nå er det én av fem kraftløsninger som sammenlignes på like vilkår, og ingen løsning har
særstilling. Målene og tersklene ble ikke endret.
\section{Slik er det prøvd}
\begin{kommerblokk}
forhåndsregistreringen, målene M1--M6, sammenligningen M7 uten dom, de fem kraftløsningene,
trekningene og prisscenarioene
\end{kommerblokk}
\paragraph{Bestemt på forhånd}
Målene, tersklene og reglene for dommen ble skrevet ned og godkjent før noe ble regnet. Dette kalles
forhåndsregistreringen. Parameterne ble også frosset før noe ble regnet: 137 parametere, hver med verdi,
spenn og fordeling.
\paragraph{Fem kraftløsninger}
\textbf{A}: ett dedikert kjernekraftverk per datasenter, som verken tar kraft fra nettet eller gir kraft til det.
\textbf{B}: kjernekraft koblet til strømnettet. \textbf{C}: ny fornybar kraft (vind, vann) med lagring og
fleksibilitet. \textbf{T-F}: trinnvis utbygging med fornybar kraft, i moduler på nettet, der de første
modulene kobles til nettet som finnes, og ny fornybar kraft bygges for hver modul. \textbf{T-K}: som T-F, men modulene som settes i drift når
kjernekraft tidligst kan komme, får kjernekraft koblet til nettet. Alle måles mot et nullalternativ uten
statlig satsing.
\paragraph{Seks mål}
\textbf{M1} er netto nåverdi for Norge: alle gevinster minus alle kostnader for samfunnet over tid, regnet
om til verdien i ett år og målt mot nullalternativet. \textbf{M2} er bedriftsøkonomien: kostnaden per
levert enhet regnekraft mot prisen på regnekraft. \textbf{M3} er strømprisen for husholdninger og
virksomheter. \textbf{M4} er forsyningssikkerheten for resten av landet. \textbf{M5} er miljøet: blant annet utslipp
og naturinngrep fra krafta. \textbf{M6} er skalaen, «den nye oljen»: hva satsingen netto tilfører Norges
inntekt per år utover vanlig avkastning på kapitalen, målt mot statens netto kontantstrøm fra petroleum. Hvert mål får én av tre dommer:
«holder», «holder under betingelser» eller «holder ikke». M1 holder når netto nåverdi er positiv i minst
80~\% av trekningene og medianen er positiv. M6 holder ikke når bidraget er under 5~\% av den.
\paragraph{Dommen over hypotesen}
En kraftløsning er \emph{felt} når minst ett av M1 til M5 «holder ikke», eller når medianen i M1 er
negativ. Er alle løsningene felt, holder ikke hypotesen. M6 kan ikke alene felle en løsning. Men er M6
under 5~\%, holder ikke hypotesen i den formen den er stilt. Ved siden av dommen står en sammenligning av
kraftløsningene (M7): hvor ofte hver løsning har høyest netto nåverdi. Den har ingen terskler og gir ingen
dom.
\paragraph{Usikkerheten}
Mye er usikkert, så modellen regnes \tall{dommer.antall} ganger. Hver gang kalles en \emph{trekning}: da
trekkes én verdi for hver usikker størrelse fra den frosne fordelingen. Medianen er verdien som halvparten
av trekningene ligger under. Prisen på regnekraft kan ingen kilde forutsi. Den legges inn som tre
prisscenarioer uten sannsynligheter: «knapphet varer», «normalisering» (knapphetspåslaget i prisen er
borte før første anlegg er i drift) og «overkapasitet». Dommen som teller, er dommen i «normalisering».
Hver løsning regnes for 1, 5, 10, 20 og 40 anlegg på 1\,000~MW IT-last hvert (strømmen datautstyret
bruker). Hvilket av disse trinnene
dommene leses av på, følger av faste regler for skalaen (M6).
\section{Hva modellen finner}
\begin{kommerblokk}
dommen per mål i «normalisering» på trinnet dommene leses av på, og den samlede dommen
\end{kommerblokk}
Dommen som teller, er dommen i prisscenarioet «\tall{dommer.teller}», regnet over \tall{dommer.antall}
trekninger. M6, skalaen, er under 5~\% i \tall{dommer.normalisering.t1.A.m6.andel-ikke}~\% av trekningene
for alle fem løsningene på alle trinn. Med fem anlegg eller flere har ingen av dem et år med stabil drift
(alle anleggene i drift) i minst 80~\% av trekningene. Dommene leses derfor av på trinnet med
\tall{dommer.trinn} anlegg på 1\,000~MW IT-last, og skalaen nås ikke.
\begin{kommerblokk}
Én figur fra datafilene: sammenligningen av kraftløsningene eller tidslinjen.
\end{kommerblokk}
\begin{center}
\small
\setlength{\tabcolsep}{4pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabularx}{\linewidth}{@{}>{\raggedright\arraybackslash}p{40mm}*{5}{>{\raggedright\arraybackslash}X}@{}}
\toprule
Mål & A & B & C & T-F & T-K \\
\midrule
M1 netto nåverdi for Norge & \tall{dommer.normalisering.t1.A.m1.dom} & \tall{dommer.normalisering.t1.B.m1.dom}
& \tall{dommer.normalisering.t1.C.m1.dom} & \tall{dommer.normalisering.t1.TF.m1.dom}
& \tall{dommer.normalisering.t1.TK.m1.dom} \\
M2 bedriftsøkonomi & \tall{dommer.normalisering.t1.A.m2.dom} & \tall{dommer.normalisering.t1.B.m2.dom}
& \tall{dommer.normalisering.t1.C.m2.dom} & \tall{dommer.normalisering.t1.TF.m2.dom}
& \tall{dommer.normalisering.t1.TK.m2.dom} \\
M3 strømpris & \tall{dommer.normalisering.t1.A.m3.dom} & \tall{dommer.normalisering.t1.B.m3.dom}
& \tall{dommer.normalisering.t1.C.m3.dom} & \tall{dommer.normalisering.t1.TF.m3.dom}
& \tall{dommer.normalisering.t1.TK.m3.dom} \\
M4 forsyningssikkerhet & \tall{dommer.normalisering.t1.A.m4.dom} & \tall{dommer.normalisering.t1.B.m4.dom}
& \tall{dommer.normalisering.t1.C.m4.dom} & \tall{dommer.normalisering.t1.TF.m4.dom}
& \tall{dommer.normalisering.t1.TK.m4.dom} \\
M5 miljø & \tall{dommer.normalisering.t1.A.m5} & \tall{dommer.normalisering.t1.B.m5}
& \tall{dommer.normalisering.t1.C.m5} & \tall{dommer.normalisering.t1.TF.m5}
& \tall{dommer.normalisering.t1.TK.m5} \\
M6 skala & \tall{dommer.normalisering.t1.A.m6.dom} & \tall{dommer.normalisering.t1.B.m6.dom}
& \tall{dommer.normalisering.t1.C.m6.dom} & \tall{dommer.normalisering.t1.TF.m6.dom}
& \tall{dommer.normalisering.t1.TK.m6.dom} \\[2pt]
Median M1, mrd.~kr & \tall{dommer.normalisering.t1.A.nnv-median} & \tall{dommer.normalisering.t1.B.nnv-median}
& \tall{dommer.normalisering.t1.C.nnv-median} & \tall{dommer.normalisering.t1.TF.nnv-median}
& \tall{dommer.normalisering.t1.TK.nnv-median} \\
\midrule
\multicolumn{6}{@{}l}{\emph{Sammenligningen M7, uten dom, i prosent av trekningene}} \\
Best alene & \tall{dommer.m7.normalisering.t1.A.alene} & \tall{dommer.m7.normalisering.t1.B.alene}
& \tall{dommer.m7.normalisering.t1.C.alene} & \tall{dommer.m7.normalisering.t1.TF.alene}
& \tall{dommer.m7.normalisering.t1.TK.alene} \\
Deler plassen & \tall{dommer.m7.normalisering.t1.A.deler} & \tall{dommer.m7.normalisering.t1.B.deler}
& \tall{dommer.m7.normalisering.t1.C.deler} & \tall{dommer.m7.normalisering.t1.TF.deler}
& \tall{dommer.m7.normalisering.t1.TK.deler} \\
\bottomrule
\end{tabularx}
\end{center}
\section{Betingelsene}
\begin{kommerblokk}
betingelsene som kan navngis, med sannsynligheten for hver, eller hvorfor de ikke kan det
\end{kommerblokk}
Netto nåverdi for Norge er positiv i høyst \tall{dommer.normalisering.t1.C.m1.andel}~\% av trekningene
(C), og medianen er negativ for alle fem (2025-kroner, nåverdi i 2027). Hypotesen er
«\tall{dommer.del1}» fordi målene ikke nås: alle fem er felt av M1 og den negative medianen, A og B også av
M2. Fordi M6 er under 5~\%, holder hypotesen heller ikke i den formen den er stilt (stor skala, «den nye
oljen»). Med ett anlegg kunne den høyst blitt «holder under betingelser», men det er M1 og medianen som
feller løsningene, ikke trinnet. De andre scenarioene, trinnene og følsomhetene står i kapittel~6 i
rapporten.
\section{Kraftløsningene og eierformene}
\begin{kommerblokk}
hvor ofte hver løsning kommer best ut, og hva sammenligningen av eierformene viser
\end{kommerblokk}
\section{Hvilken kraftløsning kommer best ut}
M7 viser hvor ofte hver løsning har høyest netto nåverdi, alene eller delt med en annen med nøyaktig samme
verdi. Med ett anlegg lar alle fem seg bygge i alle trekningene. C er best alene i
\tall{dommer.m7.normalisering.t1.C.alene}~\% av trekningene. T-F og T-K deler plassen i
\tall{dommer.m7.normalisering.t1.par.TF-TK}~\%; de er samme utbygging når ingen modul får kjernekraft. At
en løsning er best, betyr ikke at den lønner seg.
\section{Hva modellen er, og hva den ikke er}
\begin{kommerblokk}
de viktigste kjente begrensningene og hva modellen ikke gjør
\end{kommerblokk}
\pgfplotstableread{generert/dommer-m7.dat}\mseven
\pgfplotstablegetelem{0}{trinn}\of\mseven
\ifnum\pgfplotsretval=1 \else\errmessage{dommer-m7.dat: rad 0 er ikke trinnet med ett anlegg}\fi
\hentalene{A}{\aA}\hentalene{B}{\aB}\hentalene{C}{\aC}\hentalene{TF}{\aTF}\hentalene{TK}{\aTK}%
\tallsomtall{dommer.m7.normalisering.t1.A.deler}{\dA}\tallsomtall{dommer.m7.normalisering.t1.B.deler}{\dB}%
\tallsomtall{dommer.m7.normalisering.t1.C.deler}{\dC}\tallsomtall{dommer.m7.normalisering.t1.TF.deler}{\dTF}%
\tallsomtall{dommer.m7.normalisering.t1.TK.deler}{\dTK}%
\newcommand{\mlabel}[2]{\node[anchor=west,font=\small] at (axis cs:101,#1)
{\tall{dommer.m7.normalisering.t1.#2.alene}~\% alene, \tall{dommer.m7.normalisering.t1.#2.deler}~\% deler};}
\begin{center}
\captionsetup{hypcap=false}
\begin{tikzpicture}
\begin{axis}[xbar stacked, width=118mm, height=36mm, scale only axis=false,
bar width=5.5pt, ymin=0.4, ymax=5.6, ytick={1,...,5}, yticklabels={T-K,T-F,C,B,A},
xmin=0, xmax=100, xtick={0,20,...,100}, xlabel={Andel av trekningene, \%},
xmajorgrids, grid style={black!12}, clip=false, axis y line*=left, axis x line*=bottom,
tick label style={font=\small}, label style={font=\small},
legend style={font=\small, at={(0.5,1.03)}, anchor=south, legend columns=2, draw=none},
legend cell align=left, reverse legend=false,
/pgf/number format/.cd, use comma, 1000 sep={\,}]
\addplot[fill=accent, draw=none] coordinates {(\aA,5) (\aB,4) (\aC,3) (\aTF,2) (\aTK,1)};
\addlegendentry{best alene}
\addplot[fill=cB, draw=none] coordinates {(\dA,5) (\dB,4) (\dC,3) (\dTF,2) (\dTK,1)};
\addlegendentry{deler plassen med en annen}
\mlabel{5}{A}\mlabel{4}{B}\mlabel{3}{C}\mlabel{2}{TF}\mlabel{1}{TK}
\end{axis}
\end{tikzpicture}
\captionof{figure}{Sammenligningen av kraftløsningene (M7) i «normalisering» med ett anlegg: andelen av
trekningene der hver løsning har høyest netto nåverdi alene, og der den deler plassen med en annen. M7
gir ingen dom. At en løsning er best, betyr ikke at den lønner seg: medianen er negativ for alle fem.}
\end{center}
\section{De viktigste kjente begrensningene}
De seks resultatfilene fra hovedkjøringen er laget på nytt på samme maskin og ble like ned til siste
byte, men det er ikke gjort på en annen maskin ennå. 40 av de 137 parameterne er åpne forutsetninger uten kilde som gir verdien, og en
terskel i en slik forutsetning teller ikke som betingelse. To funn fra fagmiljøene er ikke dekket av
spennene i modellen. Én kilde gir større sjanse for svært store kostnadsoverskridelser for kjernekraft enn
fordelingen modellen bruker. Og modellen har ikke noe påslag for å tilpasse et utenlandsk reaktordesign
til norsk regelverk. Begge kan gjøre kjernekraft dyrere enn modellen regner med i de dårligste utfallene
(A, B og T-K). To observasjoner i de samme kildene trekker motsatt vei, mot raskere bygging og mer læring i
de beste utfallene. Fagfellene som har vurdert arbeidet, er språkmodeller (KI). Den uavhengige
kontrollkoden er skrevet ut fra samme tekst som modellen, så en feil begge leser likt, oppdages ikke. Se
kapittel~7 til~9 i rapporten.
\begin{tcolorbox}[enhanced,colback=boxbg,colframe=accent,boxrule=0.6pt,arc=1.5pt,left=7pt,right=7pt,top=2.5pt,bottom=2.5pt,before skip=5pt,after skip=5pt]
\small
\textbf{Rapport, modell og kode:} \kommer{lenke til repoet}
\textbf{Rapport, modell, kilder og kode:} \url{https://git.fromaitochitta.com/open/tokenfabrikker}
\end{tcolorbox}
\noindent{\small\textbf{Kilder:} \kommer{kildene}
\noindent{\small\textbf{Kilder:} Kildene, med side og ordrett sitat for hver, står i referanselista i
rapporten og i kildebanken.
\textit{Utarbeidet med omfattende bruk av KI (Claude, Anthropic). Ansvar for innholdet: forfatteren.}}
\end{document}

View file

@ -77,9 +77,32 @@
\Crefname{enumi}{Punkt}{Punktene}
% ---------- makroer for rapporten ----------
% Post i kildebanken (kilder/). En senere runde gjør id-ene om til fulle referanser.
% Post i kildebanken (kilder/), med full referanse i lista «Kilder» (refs.tex).
% Bruk: \kilde{K27-138} eller \kilde{K03-044, K03-045}.
\newcommand{\kilde}[1]{{\color{accent}\textsf{\small[#1]}}}
% Hver id blir en lenke til posten i referanselista (\hypertarget{kilde:<id>} i generert/referanser.tex);
% «A til B» lenker begge ender. Mellomrommet foran klammen i definisjonen er med vilje:
% lag_referanser.py leser «\kilde» fulgt rett av klamme som en henvisning.
\ExplSyntaxOn
\tl_new:N \l__kilde_tl
\seq_new:N \l__kilde_del_seq
\cs_new_protected:Npn \__kilde_post:n #1
{
\seq_set_split:Nnn \l__kilde_del_seq { til } { #1 }
\seq_set_map:NNn \l__kilde_del_seq \l__kilde_del_seq
{ \exp_not:n { \hyperlink { kilde: ##1 } { ##1 } } }
\tl_if_empty:NF \l__kilde_tl { \tl_put_right:Nn \l__kilde_tl { , ~ } }
\tl_put_right:Nx \l__kilde_tl
{ \seq_use:Nn \l__kilde_del_seq { \c_space_tl til \c_space_tl } }
}
\NewDocumentCommand \kilde { m }
{
\group_begin:
\tl_clear:N \l__kilde_tl
\clist_map_function:nN { #1 } \__kilde_post:n
{ \color { accent } \textsf { \small [ \tl_use:N \l__kilde_tl ] } }
\group_end:
}
\ExplSyntaxOff
% Fil eller kommando i repoet, skrevet som den står (understrek uten \_), med linjeskift etter / og .
\DeclareUrlCommand\fil{\urlstyle{tt}}
\setlength{\emergencystretch}{2.5em}

View file

@ -1,21 +1,11 @@
% =================================================================
% Kilder. Tom struktur: teksten viser foreløpig til poster i kildebanken med \kilde{K..-...}.
% En senere runde gjør id-ene om til fulle referanser (\bibitem) her, med kilde, side og lenke
% slik posten i kilder/ oppgir dem. Ingen referanse skrives inn uten at posten har en bekreftet
% Kontroll-linje.
% Kilder. Lista lages av lag_referanser.py (bygg.sh) fra postene i kilder/ som rapporten viser til
% med \kilde{K..-...}: postens tittel og feltet Kilde, slik posten oppgir dem. En post uten bekreftet
% Kontroll-linje stanser skriptet.
% =================================================================
\section*{Kilder}\addcontentsline{toc}{section}{Kilder}\label{sec:kilder}
Henvisninger i hakeparentes, som \kilde{K27-138}, viser til poster i kildebanken (\fil{kilder/}), der
hver post har påstand, tall, spenn, kilde med side, ordrett sitat, kvalitet og kontroll mot
primærkilden.
Henvisninger i hakeparentes, som \kilde{K27-138}, viser til poster i kildebanken (\fil{kilder/}). I
PDF-en er hver henvisning en lenke til posten i lista under.
\begin{kommerblokk}
Litteraturlisten, laget fra postene rapporten viser til.
\end{kommerblokk}
% \begin{thebibliography}{99}
% \small
% \setlength{\itemsep}{0pt}
% \bibitem[Forfatter(år)]{nøkkel} ...
% \end{thebibliography}
\input{generert/referanser}

View file

@ -22,14 +22,12 @@ Funksjonene ligger i \fil{src/tokenfabrikker/}.
% -----------------------------------------------------------------
\section{Parameterne}\label{app:parametere}
Parameterne står i \fil{modell/parametere.json} (versjon~1.1, SHA-256
\texttt{\small 4b8809bc\dots f16}; \cref{sec:frys}): verdi, spenn, fordeling, status og poster i
kildebanken for hver av de 137 parameterne.
Tabellen viser de frosne parameterne slik de står i \fil{modell/parametere.json} (\cref{sec:frys}).
Den er laget av \fil{rapport/lag_vedlegg_parametere.py} fra fila, som tabellen i kapittel~14 i
spesifikasjonen, og rettes ikke for hånd. Henvisningene i hakeparentes er poster i kildebanken
(se «Kilder» foran vedleggene).
\begin{kommerblokk}
Tabellen lages fra \fil{modell/parametere.json} av et skript, som tabellen i kapittel 14 i
spesifikasjonen, og skrives ikke for hånd.
\end{kommerblokk}
\input{generert/vedlegg-parametere}
% -----------------------------------------------------------------
\section{Avvik fra forhåndsregistreringen og endringer}\label{app:endringer}
@ -37,10 +35,11 @@ spesifikasjonen, og skrives ikke for hånd.
Alle endringer i kriteriene og i parameterfila står med dato og grunn under «Endringer» i
\fil{FORHANDSREGISTRERING.md}. Det er gjort ett avvik fra parameterfrysen, 12.~november 2026 (versjon~1.1),
før noe var regnet. Hypotesen ble endret av prosjekteier 13.~november 2026, og den nye ordlyden ført inn
14.~november 2026, før noe var regnet (\cref{sec:endringen}).
14.~november 2026, før noe var regnet (\cref{sec:endringen}). Ett avvik er ført etter at resultatene
forelå, 14.~november 2026: rangeringen av eierformene er ikke vist for andre vektinger og grenser
(siste punkt i lista og \cref{sec:begrensninger}).
\begin{kommerblokk}
Lista «Endringer» gjengitt i sin helhet, med dato, hva som ble endret, grunnen, og om endringen gjør
testen strengere eller mildere. Etter hovedkjøringen: eventuelle feil som stanset kjøringen og ble rettet
(avklaring 140~(d)).
\end{kommerblokk}
Hovedkjøringen på de frosne tallene og kjøringen som laget de to ekstra datafilene, gikk uten feil
(fagfelleloggen del~22 og~23), så ingen feil som stanset en kjøring, er rettet.
\input{generert/vedlegg-endringer}