eyeling 1.19.5 → 1.20.0

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

package/examples/extra/output/path-discovery.txt

@@ -0,0 +1,28 @@
+=== Answer ===
+The path-discovery case finds every simple route from Ostend-Bruges International Airport to Václav Havel Airport Prague with at most two stopovers.
+
+=== Reason Why ===
+The program builds adjacency lists from the full airport graph, then runs a depth-limited DFS that never revisits an airport.
+airports      : 7698
+flights       : 37274
+source        : Ostend-Bruges International Airport
+destination   : Václav Havel Airport Prague
+max stopovers : 2
+
+Route #1
+  Stopovers : 2
+  Airports  : Ostend-Bruges International Airport -> Liège Airport -> Heraklion International Nikos Kazantzakis Airport -> Václav Havel Airport Prague
+
+Route #2
+  Stopovers : 2
+  Airports  : Ostend-Bruges International Airport -> Liège Airport -> Diagoras Airport -> Václav Havel Airport Prague
+
+Route #3
+  Stopovers : 2
+  Airports  : Ostend-Bruges International Airport -> Liège Airport -> Palma De Mallorca Airport -> Václav Havel Airport Prague
+
+=== Check ===
+all routes within stopover bound : yes
+all routes are simple paths      : yes
+all routes match endpoints       : yes
+route set matches known answer   : yes

package/examples/extra/output/pn-junction-tunneling.txt

@@ -0,0 +1,15 @@
+=== Answer ===
+In this toy PN-junction tunneling model, heavy doping narrows the depletion region enough for a tunneling window that rises to a peak and then falls.
+
+=== Reason Why ===
+We count exact state overlap while forward bias shifts the empty P-side levels.
+bias -> overlap current proxy : 0->2, 1->3, 2->4, 3->3, 4->2, 5->1, 6->0
+peak point                    : 2 -> 4
+high-bias point               : 6 -> 0
+
+=== Check ===
+heavily doped barrier is narrower : yes
+peak occurs before overlap closes : yes
+negative differential region      : yes
+high-bias overlap closes          : yes
+peak equals full overlap          : yes

package/examples/extra/output/polynomial.txt

@@ -0,0 +1,20 @@
+=== Answer ===
+Both polynomial examples are solved consistently: the computed roots satisfy the source polynomials and reconstruct the original coefficients.
+
+=== Reason Why ===
+For each quartic, the program solves for the roots numerically, substitutes them back, and rebuilds the polynomial from those roots.
+
+Example #1 (real quartic)
+roots               : 4, 3, 2, 1
+residuals           : 0, 0, 0, 0
+reconstruction ok   : yes
+roots valid         : yes
+
+Example #2 (complex quartic)
+roots               : 3 + 2i, 1i, 1 + 1i, 5 + 1i
+residuals           : 0, 0, 0, 0
+reconstruction ok   : yes
+roots valid         : yes
+
+=== Check ===
+all examples valid  : yes

package/examples/extra/output/sudoku.txt

@@ -0,0 +1,47 @@
+=== Answer ===
+The puzzle is solved, and the completed grid is the unique valid Sudoku solution.
+
+Puzzle
+1 . . | . . 7 | . 9 . 
+. 3 . | . 2 . | . . 8 
+. . 9 | 6 . . | 5 . . 
+
+. . 5 | 3 . . | 9 . . 
+. 1 . | . 8 . | . . 2 
+6 . . | . . 4 | . . . 
+
+3 . . | . . . | . 1 . 
+. 4 . | . . . | . . 7 
+. . 7 | . . . | 3 . . 
+
+Completed grid
+1 6 2 | 8 5 7 | 4 9 3 
+5 3 4 | 1 2 9 | 6 7 8 
+7 8 9 | 6 4 3 | 5 2 1 
+
+4 7 5 | 3 1 2 | 9 8 6 
+9 1 3 | 5 8 6 | 7 4 2 
+6 2 8 | 7 9 4 | 1 3 5 
+
+3 5 6 | 4 7 8 | 2 1 9 
+2 4 1 | 9 3 5 | 8 6 7 
+8 9 7 | 2 6 1 | 3 5 4 
+
+=== Reason Why ===
+The solver combines constraint propagation with depth-first search. It fills forced singles immediately and branches on the blank cell with the fewest candidates.
+givens             : 23
+blanks             : 58
+forced placements  : 213
+guesses            : 22
+search nodes       : 23
+backtracks         : 12
+solution unique    : yes
+
+=== Check ===
+solver found solution           : yes
+givens preserved                : yes
+rows complete                   : yes
+columns complete                : yes
+boxes complete                  : yes
+recorded placements replay legally: yes
+uniqueness check                : yes

package/examples/extra/output/transistor-switch.txt

@@ -0,0 +1,16 @@
+=== Answer ===
+In this toy transistor-switch model, a low input leaves the transistor OFF and a high input drives it ON in saturation.
+
+=== Reason Why ===
+low input state   : cutoff / OFF
+high input state  : saturation / ON
+high base current : 430 uA
+high collector Ic : 4800 uA
+load-limited Ic   : 4800 uA
+
+=== Check ===
+low input cutoff                : yes
+high input saturation           : yes
+switching states differ         : yes
+on-state current is load-limited: yes
+load voltage matches Ohm's law  : yes