eyeling 1.19.4 → 1.19.6

package/examples/extra/kaprekar-6174.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Kaprekar 6174 exploration over all admissible four-digit starts.
+ * The script records traces, a convergence histogram, and a few representative witnesses.
+ */
+
+function digits4(n) {
+  return [Math.floor(n / 1000) % 10, Math.floor(n / 100) % 10, Math.floor(n / 10) % 10, n % 10];
+}
+
+function sort4(digits, descending) {
+  digits.sort((a, b) => (descending ? b - a : a - b));
+}
+
+function build4(d) {
+  return d[0] * 1000 + d[1] * 100 + d[2] * 10 + d[3];
+}
+
+function hasTwoDistinctDigits(n) {
+  const d = digits4(n);
+  for (let i = 1; i < 4; i += 1) if (d[i] !== d[0]) return true;
+  return false;
+}
+
+function kaprekarStep(n) {
+  const hi = digits4(n);
+  const lo = [...hi];
+  sort4(hi, true);
+  sort4(lo, false);
+  return build4(hi) - build4(lo);
+}
+
+function kaprekarTrace(start, cap) {
+  const out = [];
+  let cur = start;
+  while (out.length < cap) {
+    out.push(cur);
+    if (cur === 6174) break;
+    cur = kaprekarStep(cur);
+  }
+  return out;
+}
+
+function fmt4(n) {
+  return String(n).padStart(4, '0');
+}
+
+// Explore the full start space and then print a compact convergence summary.
+function main() {
+  let validStarts = 0;
+  let repdigits = 0;
+  let maxIterations = 0;
+  let worstCaseStarts = 0;
+  const hist = new Array(8).fill(0);
+  let worstTrace = [];
+  const leadingTrace = kaprekarTrace(2111, 16);
+  let allReach = true;
+  let boundOk = true;
+
+  for (let start = 0; start <= 9999; start += 1) {
+    if (!hasTwoDistinctDigits(start)) {
+      repdigits += 1;
+      continue;
+    }
+    const trace = kaprekarTrace(start, 16);
+    const steps = trace.length ? trace.length - 1 : 0;
+    validStarts += 1;
+    if (trace[trace.length - 1] !== 6174) allReach = false;
+    if (steps > 7) boundOk = false;
+    if (steps < 8) hist[steps] += 1;
+    if (steps > maxIterations) {
+      maxIterations = steps;
+      worstCaseStarts = 1;
+      worstTrace = trace.slice();
+    } else if (steps === maxIterations) {
+      worstCaseStarts += 1;
+    }
+  }
+
+  const fixedPointOk = kaprekarStep(6174) === 6174;
+  const histTotal = hist.reduce((sum, n) => sum + n, 0);
+  const histogramOk = histTotal === validStarts;
+  const ok = fixedPointOk && allReach && boundOk && histogramOk;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push('Every valid four-digit start tested reaches 6174, and all of them do so within seven iterations.');
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    "The program applies Kaprekar's routine to every non-repdigit start, records the iteration count, and keeps witness traces.",
+  );
+  lines.push(`valid starts checked: ${validStarts}`);
+  lines.push(`repdigits excluded  : ${repdigits}`);
+  lines.push(`max iterations      : ${maxIterations}`);
+  lines.push(`worst-case starts   : ${worstCaseStarts}`);
+  lines.push(`worst trace         : ${worstTrace.map(fmt4).join(' -> ')}`);
+  lines.push(`leading-zero trace  : ${leadingTrace.map(fmt4).join(' -> ')}`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`6174 fixed point    : ${fixedPointOk ? 'yes' : 'no'}`);
+  lines.push(`all starts reach it : ${allReach ? 'yes' : 'no'}`);
+  lines.push(`bound <= 7 verified : ${boundOk ? 'yes' : 'no'}`);
+  lines.push(`histogram total ok  : ${histogramOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/matrix-mechanics.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Toy matrix-mechanics example over 2x2 matrices.
+ * It highlights spectrum, involution, and a non-zero commutator in a compact exact model.
+ */
+
+function m2(a11, a12, a21, a22) {
+  return { a11, a12, a21, a22 };
+}
+
+function mul(a, b) {
+  return m2(
+    a.a11 * b.a11 + a.a12 * b.a21,
+    a.a11 * b.a12 + a.a12 * b.a22,
+    a.a21 * b.a11 + a.a22 * b.a21,
+    a.a21 * b.a12 + a.a22 * b.a22,
+  );
+}
+
+function sub(a, b) {
+  return m2(a.a11 - b.a11, a.a12 - b.a12, a.a21 - b.a21, a.a22 - b.a22);
+}
+
+function trace(a) {
+  return a.a11 + a.a22;
+}
+
+function det(a) {
+  return a.a11 * a.a22 - a.a12 * a.a21;
+}
+
+// Evaluate the tiny model exactly, then verify the expected algebraic properties.
+function main() {
+  const H = m2(1, 0, 0, 2);
+  const X = m2(0, 1, 1, 0);
+  const HX = mul(H, X);
+  const XH = mul(X, H);
+  const C = sub(HX, XH);
+  const commutatorNonzero = !!(C.a11 || C.a12 || C.a21 || C.a22);
+  const spectrumOk = trace(H) === 3 && det(H) === 2;
+  const XX = mul(X, X);
+  const involution = XX.a11 === 1 && XX.a12 === 0 && XX.a21 === 0 && XX.a22 === 1;
+  const ok = spectrumOk && involution && commutatorNonzero;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'In this toy matrix-mechanics model, the Hamiltonian has two discrete energy levels and does not commute with a second observable.',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(`H  = [[${H.a11},${H.a12}],[${H.a21},${H.a22}]]`);
+  lines.push(`X  = [[${X.a11},${X.a12}],[${X.a21},${X.a22}]]`);
+  lines.push(`HX = [[${HX.a11},${HX.a12}],[${HX.a21},${HX.a22}]]`);
+  lines.push(`XH = [[${XH.a11},${XH.a12}],[${XH.a21},${XH.a22}]]`);
+  lines.push(`[H,X] = [[${C.a11},${C.a12}],[${C.a21},${C.a22}]]`);
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`trace/determinant match energy levels: ${spectrumOk ? 'yes' : 'no'}`);
+  lines.push(`X^2 = I                           : ${involution ? 'yes' : 'no'}`);
+  lines.push(`[H,X] != 0                        : ${commutatorNonzero ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/odrl-dpv-ehds-risk-ranked.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Specialized EHDS risk-ranking case with concrete permissions, needs, and scoring rules.
+ * Instead of generic policy reasoning, the file evaluates the fixed rule set directly and explains the ranking.
+ */
+
+const ACTION = {
+  PROVIDE_SECONDARY_USE_DATA: 0,
+  DOWNLOAD: 1,
+  REMOVE_DIRECT_IDENTIFIERS: 2,
+  PROCESS_ONLY_IN_SECURE_ENVIRONMENT: 3,
+};
+
+const CONSTRAINT_KEY = {
+  PURPOSE: 0,
+  HAS_DATA_PERMIT: 1,
+  RESPECT_OPT_OUT_SECONDARY_USE: 2,
+  STATISTICALLY_ANONYMISED: 3,
+};
+
+function actionName(a) {
+  switch (a) {
+    case ACTION.PROVIDE_SECONDARY_USE_DATA:
+      return 'provideSecondaryUseData';
+    case ACTION.DOWNLOAD:
+      return 'download';
+    case ACTION.REMOVE_DIRECT_IDENTIFIERS:
+      return 'removeDirectIdentifiers';
+    case ACTION.PROCESS_ONLY_IN_SECURE_ENVIRONMENT:
+      return 'processOnlyInSecureEnvironment';
+    default:
+      return '?';
+  }
+}
+
+const NEEDS = [
+  {
+    id: 'Need_RequireDataPermit',
+    importance: 20,
+    description: 'Secondary use should be authorised via an EHDS Data Permit.',
+  },
+  {
+    id: 'Need_RespectOptOutSecondaryUse',
+    importance: 25,
+    description: 'Respect the EHDS right to opt out from secondary use.',
+  },
+  {
+    id: 'Need_SecureProcessingEnvironment',
+    importance: 18,
+    description: 'Secondary-use processing must occur within a secure processing environment.',
+  },
+  {
+    id: 'Need_StatisticallyAnonymisedSecondaryUse',
+    importance: 15,
+    description: 'Secondary use should use statistically anonymised data.',
+  },
+];
+
+const P1_C = [{ key: CONSTRAINT_KEY.PURPOSE, value: 'HealthcareScientificResearch' }];
+const P2_C = [{ key: CONSTRAINT_KEY.PURPOSE, value: 'TrainTestAndEvaluateHealthAlgorithms' }];
+const P4_D = [{ action: ACTION.REMOVE_DIRECT_IDENTIFIERS }];
+
+const PERMISSIONS = [
+  {
+    id: 'PermSecondaryUseDUA',
+    clauseId: 'H1',
+    action: ACTION.PROVIDE_SECONDARY_USE_DATA,
+    constraints: P1_C,
+    duties: [],
+  },
+  {
+    id: 'PermSecondaryUseAllPatients',
+    clauseId: 'H2',
+    action: ACTION.PROVIDE_SECONDARY_USE_DATA,
+    constraints: P2_C,
+    duties: [],
+  },
+  { id: 'PermDownloadLocalCopy', clauseId: 'H3', action: ACTION.DOWNLOAD, constraints: [], duties: [] },
+  {
+    id: 'PermProvidePseudonymisedData',
+    clauseId: 'H4',
+    action: ACTION.PROVIDE_SECONDARY_USE_DATA,
+    constraints: [],
+    duties: P4_D,
+  },
+];
+
+const MISSING = {
+  MISSING_DATA_PERMIT: 0,
+  MISSING_OPT_OUT: 1,
+  MISSING_SECURE_ENV: 2,
+  MISSING_STAT_ANON: 3,
+};
+
+// Risk rules combine a base severity with the importance of the unmet need.
+const RULES = [
+  {
+    ruleId: 'R1',
+    permissionId: 'PermSecondaryUseDUA',
+    clauseId: 'H1',
+    needId: 'Need_RequireDataPermit',
+    baseScore: 80,
+    riskSource: 'Secondary use permitted without EHDS Data Permit.',
+    mitigation: 'Require an EHDS Data Permit before secondary use.',
+    missing: MISSING.MISSING_DATA_PERMIT,
+  },
+  {
+    ruleId: 'R2',
+    permissionId: 'PermSecondaryUseAllPatients',
+    clauseId: 'H2',
+    needId: 'Need_RespectOptOutSecondaryUse',
+    baseScore: 75,
+    riskSource: 'Opt-out from secondary use not explicitly respected.',
+    mitigation: 'Exclude records of persons who exercised the EHDS opt-out.',
+    missing: MISSING.MISSING_OPT_OUT,
+  },
+  {
+    ruleId: 'R3',
+    permissionId: 'PermDownloadLocalCopy',
+    clauseId: 'H3',
+    needId: 'Need_SecureProcessingEnvironment',
+    baseScore: 70,
+    riskSource: 'Local download permitted; secure processing environment not required.',
+    mitigation: 'Require processing only within a secure processing environment.',
+    missing: MISSING.MISSING_SECURE_ENV,
+  },
+  {
+    ruleId: 'R4',
+    permissionId: 'PermProvidePseudonymisedData',
+    clauseId: 'H4',
+    needId: 'Need_StatisticallyAnonymisedSecondaryUse',
+    baseScore: 65,
+    riskSource: 'Statistical anonymisation safeguard missing for secondary use.',
+    mitigation: 'Require statistically anonymised data for secondary use.',
+    missing: MISSING.MISSING_STAT_ANON,
+  },
+];
+
+function findNeed(id) {
+  return NEEDS.find((need) => need.id === id) || null;
+}
+
+function findPerm(id) {
+  return PERMISSIONS.find((permission) => permission.id === id) || null;
+}
+
+function hasConstraint(permission, key) {
+  return permission.constraints.some((constraint) => constraint.key === key);
+}
+
+function hasDuty(permission, action) {
+  return permission.duties.some((duty) => duty.action === action);
+}
+
+function missing(permission, kind) {
+  switch (kind) {
+    case MISSING.MISSING_DATA_PERMIT:
+      return !hasConstraint(permission, CONSTRAINT_KEY.HAS_DATA_PERMIT);
+    case MISSING.MISSING_OPT_OUT:
+      return !hasConstraint(permission, CONSTRAINT_KEY.RESPECT_OPT_OUT_SECONDARY_USE);
+    case MISSING.MISSING_SECURE_ENV:
+      return !hasDuty(permission, ACTION.PROCESS_ONLY_IN_SECURE_ENVIRONMENT);
+    case MISSING.MISSING_STAT_ANON:
+      return !hasConstraint(permission, CONSTRAINT_KEY.STATISTICALLY_ANONYMISED);
+    default:
+      return false;
+  }
+}
+
+// Materialize the ranked risk list and verify the ordering and scores.
+function main() {
+  const risks = [];
+  for (const rule of RULES) {
+    const permission = findPerm(rule.permissionId);
+    const need = findNeed(rule.needId);
+    if (permission && need && missing(permission, rule.missing)) {
+      const raw = rule.baseScore + need.importance;
+      const score = raw > 100 ? 100 : raw;
+      risks.push({
+        clauseId: rule.clauseId,
+        permissionId: rule.permissionId,
+        needId: rule.needId,
+        action: permission.action,
+        needImportance: need.importance,
+        scoreRaw: raw,
+        score,
+        riskSource: rule.riskSource,
+        mitigation: rule.mitigation,
+      });
+    }
+  }
+
+  risks.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.clauseId.localeCompare(b.clauseId);
+  });
+
+  let scoreFormulaOk = true;
+  let sortedOk = true;
+  let mitigationsOk = true;
+  for (let i = 0; i < risks.length; i += 1) {
+    const rule = RULES[i];
+    const need = findNeed(rule.needId);
+    const expected = Math.min(rule.baseScore + need.importance, 100);
+    if (risks.length > 0 && risks[i].score !== expected) scoreFormulaOk = false;
+    if (!risks[i].mitigation) mitigationsOk = false;
+    if (i + 1 < risks.length && risks[i].score < risks[i + 1].score) sortedOk = false;
+  }
+
+  const topPairOk =
+    risks.length >= 2 &&
+    risks[0].clauseId === 'H1' &&
+    risks[0].score === 100 &&
+    risks[1].clauseId === 'H2' &&
+    risks[1].score === 100;
+
+  const ok = risks.length === 4 && scoreFormulaOk && sortedOk && topPairOk && mitigationsOk;
+
+  const lines = [];
+  lines.push('=== Answer ===');
+  lines.push(
+    'The EHDS secondary-use agreement yields four ranked risks; H1 and H2 normalize to score 100, followed by H3 at 88 and H4 at 80.',
+  );
+  lines.push('');
+  lines.push('=== Reason Why ===');
+  lines.push(
+    'The agreement instantiates concrete clauses, permissions, patient needs, and rule applications. A risk appears when a permission is missing a required safeguard.',
+  );
+  for (let i = 0; i < risks.length; i += 1) {
+    const risk = risks[i];
+    lines.push(`Risk #${i + 1}`);
+    lines.push(`  clause        : ${risk.clauseId}`);
+    lines.push(`  permission    : ${risk.permissionId}`);
+    lines.push(`  action        : ${actionName(risk.action)}`);
+    lines.push(`  violated need : ${risk.needId}`);
+    lines.push(`  score raw     : ${risk.scoreRaw}`);
+    lines.push(`  score         : ${risk.score}`);
+    lines.push(`  source        : ${risk.riskSource}`);
+    lines.push(`  mitigation    : ${risk.mitigation}`);
+  }
+  lines.push('');
+  lines.push('=== Check ===');
+  lines.push(`risk count = 4          : ${risks.length === 4 ? 'yes' : 'no'}`);
+  lines.push(`score formula recomputes: ${scoreFormulaOk ? 'yes' : 'no'}`);
+  lines.push(`ranking sorted desc     : ${sortedOk ? 'yes' : 'no'}`);
+  lines.push(`expected top pair       : ${topPairOk ? 'yes' : 'no'}`);
+  lines.push(`every risk has mitigation: ${mitigationsOk ? 'yes' : 'no'}`);
+
+  process.stdout.write(`${lines.join('\n')}\n`);
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/examples/extra/output/collatz-1000.txt

@@ -0,0 +1,18 @@
+=== Answer ===
+For starts 1..=10000, every tested value reaches 1 under the Collatz map.
+
+=== Reason Why ===
+The program applies the standard Collatz rule, memoizes stopping times, and tracks the hardest witnesses.
+starts checked      : 10000
+max steps           : 261
+max-steps start     : 6171
+highest peak        : 27114424
+peak start          : 9663
+trace(27) steps     : 111
+trace(27) peak      : 9232
+
+=== Check ===
+all reach 1         : yes
+trace(27) valid     : yes
+max-steps witness ok: yes
+peak witness ok     : yes

package/examples/extra/output/control-system.txt

@@ -0,0 +1,14 @@
+=== Answer ===
+The control query is satisfied: the source facts derive concrete outputs for actuator1 and actuator2.
+
+=== Reason Why ===
+The helper rule measurement10(input1) is derived first, then both control rules are evaluated from the available facts.
+measurement10(input1): 2.236068
+actuator1            : 39.273462
+actuator2            : 26.080000
+
+=== Check ===
+query satisfied      : yes
+unique actuators     : yes
+actuator1 formula ok : yes
+actuator2 formula ok : yes

package/examples/extra/output/deep-taxonomy-100000.txt

@@ -0,0 +1,15 @@
+=== Answer ===
+The deep taxonomy chain reaches the goal from the seed fact after deriving the full class ladder up to N(100000).
+
+=== Reason Why ===
+Starting from Ind:N(0), each N(i) derives N(i+1), I(i+1), and J(i+1); N(100000) then derives A2 and the goal.
+seed facts    : 1
+rules         : 100002
+derived facts : 300003
+type facts    : 300002
+
+=== Check ===
+goal reached  : yes
+N(100000) seen: yes
+A2 derived    : yes
+count formula : yes

package/examples/extra/output/delfour.txt

@@ -0,0 +1,20 @@
+=== Answer ===
+The scanner is allowed to use a neutral shopping insight and recommends Low-Sugar Tea Biscuits instead of Classic Tea Biscuits.
+
+=== Reason Why ===
+The phone desensitizes a diabetes-related household condition into a scoped low-sugar need, wraps it in an expiring Insight+Policy envelope, and signs it.
+scanned product      : Classic Tea Biscuits
+suggested alternative: Low-Sugar Tea Biscuits
+payload SHA-256      : e1ad69852c98ca7697a164dbc6f0ca28f873508a6676865dba37b81faa66ebcb
+HMAC-SHA256          : 518a84185e2975928c6c935dae6e251a071766078c6e9e70d6f583a1147728db
+
+=== Check ===
+signature verifies             : yes
+payload hash matches           : yes
+minimization strips sensitive terms: yes
+scope complete                 : yes
+authorization allowed          : yes
+high-sugar banner              : yes
+alternative lowers sugar       : yes
+duty timing consistent         : yes
+marketing prohibited           : yes

package/examples/extra/output/euler-identity.txt

@@ -0,0 +1,12 @@
+=== Answer ===
+Euler's identity holds exactly in this exact-arithmetic model: exp(i*pi) + 1 = 0.
+
+=== Reason Why ===
+exp(i*pi) is represented as (-1, 0) and adding (1, 0) gives the exact zero complex number.
+exp(i*pi)   : (-1, 0)
+exp(i*pi)+1 : (0, 0)
+|exp(i*pi)|^2: 1
+
+=== Check ===
+identity exact: yes
+unit circle   : yes

package/examples/extra/output/fibonacci.txt

@@ -0,0 +1,21 @@
+=== Answer ===
+The requested Fibonacci values are computed exactly, up to F(10000).
+
+=== Reason Why ===
+The main computation uses the defining recurrence F(n+1)=F(n)+F(n-1), and the results are cross-checked with fast doubling.
+value[0]          : F(0) = 0
+value[1]          : F(1) = 1
+value[2]          : F(10) = 55
+value[3]          : F(100) = 354224848179261915075
+value[4]          : F(1000) = 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
+value[5]          : F(10000) = 33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875
+digits in F(1000)   : 209
+digits in F(10000)  : 2090
+
+=== Check ===
+F(10) = 55            : yes
+fast doubling agrees  : yes
+Cassini at n=100      : yes
+F(1000) has 209 digits: yes
+F(10000) has 2090 digits: yes
+F(10000) ends in 875  : yes

package/examples/extra/output/goldbach-1000.txt

@@ -0,0 +1,17 @@
+=== Answer ===
+Every even integer from 4 through 1000 has at least one Goldbach decomposition in the tested range.
+
+=== Reason Why ===
+The program builds a prime table, enumerates unordered pairs p+q=n for each even target, and summarizes sparse and rich cases.
+even targets checked : 499
+total decompositions : 8222
+fewest decompositions: 1
+hardest targets      : 4, 6, 8, 12
+most decompositions  : 52
+richest target       : 990
+balanced pair(1000)  : 491 + 509
+
+=== Check ===
+all represented      : yes
+prime count known    : yes
+balanced pair valid  : yes

package/examples/extra/output/gps.txt

@@ -0,0 +1,33 @@
+=== Answer ===
+The GPS case finds all goal routes from Gent to Oostende that satisfy the route constraints.
+case      : gps
+routes    : 2
+
+=== Reason Why ===
+Routes are built compositionally from direct descriptions, with duration and cost added and belief and comfort combined multiplicatively.
+Route #1
+ Steps    : 2
+ Duration : 2400 s (≤ 5000)
+ Cost     : 0.010 (≤ 5.0)
+ Belief   : 0.941 (≥ 0.2)
+ Comfort  : 0.990 (≥ 0.4)
+ Stages   : 1 (≤ 1)
+   1. drive_gent_brugge
+   2. drive_brugge_oostende
+
+Route #2
+ Steps    : 3
+ Duration : 4100 s (≤ 5000)
+ Cost     : 0.018 (≤ 5.0)
+ Belief   : 0.903 (≥ 0.2)
+ Comfort  : 0.980 (≥ 0.4)
+ Stages   : 1 (≤ 1)
+   1. drive_gent_kortrijk
+   2. drive_kortrijk_brugge
+   3. drive_brugge_oostende
+
+=== Check ===
+all routes satisfy constraints : yes
+all routes hit goal endpoints  : yes
+metrics recompute from steps   : yes
+expected route count (= 2)     : yes

package/examples/extra/output/kaprekar-6174.txt

@@ -0,0 +1,17 @@
+=== Answer ===
+Every valid four-digit start tested reaches 6174, and all of them do so within seven iterations.
+
+=== Reason Why ===
+The program applies Kaprekar's routine to every non-repdigit start, records the iteration count, and keeps witness traces.
+valid starts checked: 9990
+repdigits excluded  : 10
+max iterations      : 7
+worst-case starts   : 2184
+worst trace         : 0014 -> 4086 -> 8172 -> 7443 -> 3996 -> 6264 -> 4176 -> 6174
+leading-zero trace  : 2111 -> 0999 -> 8991 -> 8082 -> 8532 -> 6174
+
+=== Check ===
+6174 fixed point    : yes
+all starts reach it : yes
+bound <= 7 verified : yes
+histogram total ok  : yes

package/examples/extra/output/matrix-mechanics.txt

@@ -0,0 +1,14 @@
+=== Answer ===
+In this toy matrix-mechanics model, the Hamiltonian has two discrete energy levels and does not commute with a second observable.
+
+=== Reason Why ===
+H  = [[1,0],[0,2]]
+X  = [[0,1],[1,0]]
+HX = [[0,1],[2,0]]
+XH = [[0,2],[1,0]]
+[H,X] = [[0,-1],[1,0]]
+
+=== Check ===
+trace/determinant match energy levels: yes
+X^2 = I                           : yes
+[H,X] != 0                        : yes

package/examples/extra/output/odrl-dpv-ehds-risk-ranked.txt

@@ -0,0 +1,48 @@
+=== Answer ===
+The EHDS secondary-use agreement yields four ranked risks; H1 and H2 normalize to score 100, followed by H3 at 88 and H4 at 80.
+
+=== Reason Why ===
+The agreement instantiates concrete clauses, permissions, patient needs, and rule applications. A risk appears when a permission is missing a required safeguard.
+Risk #1
+  clause        : H1
+  permission    : PermSecondaryUseDUA
+  action        : provideSecondaryUseData
+  violated need : Need_RequireDataPermit
+  score raw     : 100
+  score         : 100
+  source        : Secondary use permitted without EHDS Data Permit.
+  mitigation    : Require an EHDS Data Permit before secondary use.
+Risk #2
+  clause        : H2
+  permission    : PermSecondaryUseAllPatients
+  action        : provideSecondaryUseData
+  violated need : Need_RespectOptOutSecondaryUse
+  score raw     : 100
+  score         : 100
+  source        : Opt-out from secondary use not explicitly respected.
+  mitigation    : Exclude records of persons who exercised the EHDS opt-out.
+Risk #3
+  clause        : H3
+  permission    : PermDownloadLocalCopy
+  action        : download
+  violated need : Need_SecureProcessingEnvironment
+  score raw     : 88
+  score         : 88
+  source        : Local download permitted; secure processing environment not required.
+  mitigation    : Require processing only within a secure processing environment.
+Risk #4
+  clause        : H4
+  permission    : PermProvidePseudonymisedData
+  action        : provideSecondaryUseData
+  violated need : Need_StatisticallyAnonymisedSecondaryUse
+  score raw     : 80
+  score         : 80
+  source        : Statistical anonymisation safeguard missing for secondary use.
+  mitigation    : Require statistically anonymised data for secondary use.
+
+=== Check ===
+risk count = 4          : yes
+score formula recomputes: yes
+ranking sorted desc     : yes
+expected top pair       : yes
+every risk has mitigation: yes