kshana 0.27.2

Open, reproducible PNT-resilience simulator with quantum-sensor performance models
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#!/usr/bin/env python3
"""Independent numpy oracle for the TIB scorer machinery (InternalConsistency).

Builds a fixed synthetic (true_error, pl) sample set, classifies each epoch by
the Stanford integrity-diagram four-region rule, counts the regions, and emits
tests/fixtures/tib/reference.json. This checks the Rust scorer's *counting*, not
any accuracy claim: the benchmark is honesty-immune and makes no accuracy claim.
Run: python3 scripts/gen_tib_scorer_reference.py
"""
import json
import pathlib
import numpy as np

AL = 10.0
STATED_IR = 1e-2

rng = np.random.default_rng(20260708)
# A deterministic spread across all four regions.
true_errors = np.concatenate([
    rng.uniform(0.0, 3.0, 40),     # mostly Nominal against a ~5 PL
    rng.uniform(6.0, 9.0, 20),     # MI region against a ~5 PL, still < AL
    rng.uniform(11.0, 20.0, 10),   # HMI region: > AL
    rng.uniform(0.0, 2.0, 10),     # Unavailable epochs (PL > AL below)
])
pls = np.concatenate([
    np.full(40, 5.0),
    np.full(20, 5.0),
    np.full(10, 5.0),
    np.full(10, 12.0),             # PL > AL => Unavailable
])

def classify(e, pl, al):
    e = abs(e)
    if pl > al:
        return "unavailable"
    if e <= pl:
        return "nominal"
    if e <= al:
        return "mi"
    return "hmi"

counts = {"nominal": 0, "unavailable": 0, "mi": 0, "hmi": 0}
for e, pl in zip(true_errors, pls):
    counts[classify(e, pl, AL)] += 1

n = int(len(true_errors))
hmi_rate = counts["hmi"] / n
mi_rate = counts["mi"] / n
# Stanford/WAAS availability: fraction with PL <= AL (i.e. 1 - unavailable-frac);
# nominal, MI and HMI epochs are all "available" in this continuity sense.
availability = 1.0 - counts["unavailable"] / n
# Tightness signal, distinct from availability: the Nominal fraction.
nominal_rate = counts["nominal"] / n
coverage_ok = bool(hmi_rate <= STATED_IR)

out = {
    "al": AL,
    "stated_ir": STATED_IR,
    "true_errors": [float(x) for x in true_errors],
    "pls": [float(x) for x in pls],
    "n": n,
    "n_nominal": counts["nominal"],
    "n_unavailable": counts["unavailable"],
    "n_mi": counts["mi"],
    "n_hmi": counts["hmi"],
    "hmi_rate": hmi_rate,
    "mi_rate": mi_rate,
    "availability": availability,
    "nominal_rate": nominal_rate,
    "coverage_ok": coverage_ok,
}
path = pathlib.Path(__file__).resolve().parents[1] / "tests" / "fixtures" / "tib" / "reference.json"
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps(out, indent=2) + "\n")
print(f"wrote {path}: n={n} nominal={counts['nominal']} mi={counts['mi']} "
      f"hmi={counts['hmi']} unavailable={counts['unavailable']}")