tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (252) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +56 -56
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +49 -44
  20. package/dist/transfer.js +48 -43
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +14 -2
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +516 -280
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +18 -4
  33. package/src/cli/tlc.ts +18 -12
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +190 -1
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +123 -38
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +370 -99
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +135 -11
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +179 -60
  49. package/src/liveness.ts +51 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  67. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  68. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  69. package/src/prover/smt/solver/ast-lt.ts +1 -1
  70. package/src/prover/smt/solver/ast.ts +66 -14
  71. package/src/prover/smt/solver/auf-solver.ts +23 -12
  72. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  73. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  74. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  75. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  76. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  77. package/src/prover/smt/solver/card2bv.ts +35 -18
  78. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  79. package/src/prover/smt/solver/context.ts +84 -15
  80. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  81. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  82. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  83. package/src/prover/smt/solver/diff-neq.ts +1 -2
  84. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  85. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  86. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  87. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  88. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  89. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  90. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  91. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  92. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  93. package/src/prover/smt/solver/euf/mam.ts +1 -5
  94. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  95. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  96. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  97. package/src/prover/smt/solver/factor.ts +36 -14
  98. package/src/prover/smt/solver/fd-solver.ts +608 -139
  99. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  100. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  101. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  102. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  103. package/src/prover/smt/solver/goal.ts +6 -3
  104. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  105. package/src/prover/smt/solver/hashtable.ts +4 -0
  106. package/src/prover/smt/solver/internalizer.ts +1 -1
  107. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  108. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  109. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  110. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  111. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  112. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  113. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  114. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  115. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  116. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  117. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  118. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  119. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  120. package/src/prover/smt/solver/maxcore.ts +2 -1
  121. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  122. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  123. package/src/prover/smt/solver/model-checker.ts +1 -1
  124. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  125. package/src/prover/smt/solver/model-generator.ts +85 -43
  126. package/src/prover/smt/solver/mpf.ts +2 -4
  127. package/src/prover/smt/solver/mus.ts +2 -3
  128. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  129. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  130. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  131. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  132. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  133. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  134. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  135. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  136. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  137. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  138. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  139. package/src/prover/smt/solver/nlqsat.ts +1 -1
  140. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  141. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  142. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  143. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  144. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  145. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  146. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  147. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  148. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  149. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  150. package/src/prover/smt/solver/nnf.ts +6 -2
  151. package/src/prover/smt/solver/opt-context.ts +21 -7
  152. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  153. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  154. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  155. package/src/prover/smt/solver/opt-solver.ts +10 -6
  156. package/src/prover/smt/solver/optsmt.ts +1 -1
  157. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  158. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  159. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  160. package/src/prover/smt/solver/probes.ts +88 -23
  161. package/src/prover/smt/solver/proto-model.ts +8 -8
  162. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  163. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  164. package/src/prover/smt/solver/qe-lite.ts +2 -2
  165. package/src/prover/smt/solver/qe.ts +3 -2
  166. package/src/prover/smt/solver/qsat.ts +23 -8
  167. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  168. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  169. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  170. package/src/prover/smt/solver/rewriter.ts +31 -25
  171. package/src/prover/smt/solver/rlimit.ts +7 -3
  172. package/src/prover/smt/solver/sat/config.ts +1 -1
  173. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  174. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  175. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  176. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  177. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  178. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  179. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  180. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  181. package/src/prover/smt/solver/sat/solver.ts +27 -47
  182. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  183. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  184. package/src/prover/smt/solver/seq-derive.ts +2 -2
  185. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  186. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  187. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  188. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  189. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  190. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  191. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  192. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  193. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  194. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  195. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  196. package/src/prover/smt/solver/smt-setup.ts +106 -13
  197. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  198. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  199. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  200. package/src/prover/smt/solver/solver.ts +18 -3
  201. package/src/prover/smt/solver/tactic.ts +350 -195
  202. package/src/prover/smt/solver/theory-bv.ts +13 -3
  203. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  204. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  205. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  206. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  207. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  208. package/src/prover/smt/solver/theory-lra.ts +1 -1
  209. package/src/prover/smt/solver/theory-pb.ts +24 -7
  210. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  211. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  212. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  213. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  214. package/src/prover/tlapm/cache.ts +8 -8
  215. package/src/prover/zenon/index-table.ts +5 -2
  216. package/src/prover/zenon/isar-case.ts +1 -1
  217. package/src/prover/zenon/isar.ts +2 -2
  218. package/src/prover/zenon/phrase.ts +1 -1
  219. package/src/resolve.ts +1274 -257
  220. package/src/runtime.ts +7 -1
  221. package/src/sany/builtins.ts +10 -10
  222. package/src/sany/generation.ts +5 -15
  223. package/src/sany/generator-def-entries.ts +123 -36
  224. package/src/sany/generator-definitions.ts +5 -3
  225. package/src/sany/generator-expressions.ts +60 -37
  226. package/src/sany/generator-proofs.ts +18 -12
  227. package/src/sany/generator.ts +12 -6
  228. package/src/sany/lexer.ts +15 -7
  229. package/src/sany/modules.ts +4 -2
  230. package/src/sany/nodes.ts +1 -1
  231. package/src/sany/selectors.ts +11 -6
  232. package/src/sany/xml.ts +2 -3
  233. package/src/search.ts +319 -135
  234. package/src/simulate.ts +235 -182
  235. package/src/spec-description.ts +8 -6
  236. package/src/standard-definitions.ts +1 -0
  237. package/src/standard-modules.ts +56 -22
  238. package/src/subexpressions.ts +564 -138
  239. package/src/successors.ts +37 -13
  240. package/src/symmetry.ts +2 -1
  241. package/src/tlc/jar-data.ts +10 -0
  242. package/src/tlc/messages.ts +3 -3
  243. package/src/tlc/order.ts +14 -3
  244. package/src/tlc/random.ts +2 -1
  245. package/src/tlc/replay.ts +67 -43
  246. package/src/tlc/tlc-operators.ts +10 -8
  247. package/src/tlc/tlcext-operators.ts +44 -15
  248. package/src/tlc/trace-spec.ts +9 -22
  249. package/src/trace-liveness.ts +529 -0
  250. package/src/typed-tier.ts +52 -31
  251. package/src/typescript/types.ts +2 -2
  252. package/src/values.ts +150 -79
@@ -0,0 +1,529 @@
1
+ import { isSameState } from "./fingerprints";
2
+ import { evaluateLive, type LiveAtoms } from "./liveness";
3
+ import { isFulfilling, type LiveExpression, type Solution } from "./tableau";
4
+ import type { Value } from "./values";
5
+
6
+ interface GraphNode {
7
+ fingerprint: bigint;
8
+ tableau: number;
9
+ position: number;
10
+ stateChecks: boolean[];
11
+ successors: GraphNode[];
12
+ actionChecks: boolean[][];
13
+ stepPositions: number[];
14
+ number: number;
15
+ }
16
+
17
+ interface TraceChecks {
18
+ getStates: (position: number) => boolean[];
19
+ getSteps: (position: number) => boolean[];
20
+ getStutters: (position: number) => boolean[];
21
+ isConsistent: (tableauNode: number, position: number) => boolean;
22
+ }
23
+
24
+ interface BehaviorGraph {
25
+ initial: GraphNode[];
26
+ isPartial: boolean;
27
+ }
28
+
29
+ export interface TraceLasso {
30
+ positions: number[];
31
+ cyclePosition: number;
32
+ backPosition: number | undefined;
33
+ }
34
+
35
+ const MAX_FIRST = 2 ** 50;
36
+ const MAX_SECOND = 2 ** 51;
37
+
38
+ const createNode = (
39
+ fingerprint: bigint,
40
+ tableau: number,
41
+ position: number,
42
+ stateChecks: boolean[],
43
+ ): GraphNode => ({
44
+ fingerprint,
45
+ tableau,
46
+ position,
47
+ stateChecks,
48
+ successors: [],
49
+ actionChecks: [],
50
+ stepPositions: [],
51
+ number: 0,
52
+ });
53
+
54
+ const addTransition = (
55
+ source: GraphNode,
56
+ target: GraphNode,
57
+ actionChecks: boolean[],
58
+ position: number,
59
+ ) => {
60
+ source.successors.push(target);
61
+ source.actionChecks.push(actionChecks);
62
+ source.stepPositions.push(position);
63
+ };
64
+
65
+ const getStepTo = (source: GraphNode, target: GraphNode) =>
66
+ source.stepPositions[source.successors.indexOf(target)];
67
+
68
+ const pop = (nodes: GraphNode[]) => {
69
+ const top = nodes[nodes.length - 1];
70
+ nodes.length -= 1;
71
+ return top;
72
+ };
73
+
74
+ const createGraph = (
75
+ fingerprints: bigint[],
76
+ solution: Solution,
77
+ checks: TraceChecks,
78
+ isComplete: boolean,
79
+ ): BehaviorGraph => {
80
+ const graph: BehaviorGraph = { initial: [], isPartial: false };
81
+ const tableau = solution.tableau;
82
+ if (!tableau) {
83
+ const nodes = new Map<bigint, GraphNode>();
84
+ let source = createNode(fingerprints[0], -1, 0, checks.getStates(0));
85
+ addTransition(source, source, checks.getStutters(0), 0);
86
+ nodes.set(fingerprints[0], source);
87
+ graph.initial.push(source);
88
+ for (let position = 1; position < fingerprints.length; position++) {
89
+ const existing = nodes.get(fingerprints[position]);
90
+ if (existing === undefined) {
91
+ const target = createNode(fingerprints[position], -1, position, checks.getStates(position));
92
+ addTransition(target, target, checks.getStutters(position), position);
93
+ addTransition(source, target, checks.getSteps(position), position);
94
+ nodes.set(fingerprints[position], target);
95
+ source = target;
96
+ continue;
97
+ }
98
+ if (!source.successors.includes(existing)) {
99
+ addTransition(source, existing, checks.getSteps(position), position);
100
+ }
101
+ source = existing;
102
+ }
103
+ return graph;
104
+ }
105
+ const rows = new Map<bigint, GraphNode[]>();
106
+ const getRow = (fingerprint: bigint) => {
107
+ const row = rows.get(fingerprint) ?? [];
108
+ rows.set(fingerprint, row);
109
+ return row;
110
+ };
111
+ const extend = (
112
+ sources: GraphNode[],
113
+ targets: GraphNode[],
114
+ row: GraphNode[],
115
+ position: number,
116
+ stateChecks: boolean[],
117
+ actionChecks: boolean[],
118
+ ) => {
119
+ for (let index = 0; index < sources.length; index++) {
120
+ const source = sources[index];
121
+ const successors = tableau.nodes[source.tableau].successors;
122
+ for (let successor = 0; successor < successors.length; successor++) {
123
+ const tableauNode = successors[successor];
124
+ const existing = row[tableauNode];
125
+ if (existing === undefined) {
126
+ if (!checks.isConsistent(tableauNode, position)) continue;
127
+ const target = createNode(fingerprints[position], tableauNode, position, stateChecks);
128
+ addTransition(source, target, actionChecks, position);
129
+ targets.push(target);
130
+ row[tableauNode] = target;
131
+ continue;
132
+ }
133
+ if (!source.successors.includes(existing)) {
134
+ addTransition(source, existing, actionChecks, position);
135
+ }
136
+ if (existing.position === position) continue;
137
+ graph.isPartial = true;
138
+ if (isComplete && !targets.includes(existing)) targets.push(existing);
139
+ }
140
+ }
141
+ };
142
+ const initialRow = getRow(fingerprints[0]);
143
+ const initialChecks = checks.getStates(0);
144
+ const initialStutters = checks.getStutters(0);
145
+ for (let tableauNode = 0; tableauNode < tableau.initialCount; tableauNode++) {
146
+ if (!checks.isConsistent(tableauNode, 0)) continue;
147
+ const node = createNode(fingerprints[0], tableauNode, 0, initialChecks);
148
+ graph.initial.push(node);
149
+ initialRow[tableauNode] = node;
150
+ }
151
+ for (const source of graph.initial) {
152
+ for (const tableauNode of tableau.nodes[source.tableau].successors) {
153
+ const target = initialRow[tableauNode];
154
+ if (!target) {
155
+ graph.isPartial = true;
156
+ continue;
157
+ }
158
+ addTransition(source, target, initialStutters, 0);
159
+ }
160
+ }
161
+ let sources = [...graph.initial];
162
+ if (isComplete) extend(sources, sources, initialRow, 0, initialChecks, initialStutters);
163
+ for (let position = 1; position < fingerprints.length; position++) {
164
+ const row = getRow(fingerprints[position]);
165
+ const stateChecks = checks.getStates(position);
166
+ const targets: GraphNode[] = [];
167
+ extend(sources, targets, row, position, stateChecks, checks.getSteps(position));
168
+ extend(targets, targets, row, position, stateChecks, checks.getStutters(position));
169
+ sources = targets;
170
+ }
171
+ return graph;
172
+ };
173
+
174
+ const findLasso = (
175
+ fingerprints: bigint[],
176
+ solution: Solution,
177
+ initial: GraphNode[],
178
+ ): TraceLasso | undefined => {
179
+ const promises = solution.promises;
180
+ const tableauNodes = solution.tableau?.nodes ?? [];
181
+ const stack: GraphNode[] = [];
182
+ let firstNumber = 1;
183
+ let secondNumber = MAX_FIRST + 1;
184
+ let thirdNumber = MAX_SECOND + 1;
185
+ let startSecondNumber = secondNumber;
186
+ let startThirdNumber = thirdNumber;
187
+ let firstComponentNumber = secondNumber;
188
+ let secondComponentNumber = thirdNumber;
189
+ let model = solution.models[0];
190
+ let lasso: TraceLasso | undefined;
191
+
192
+ const isEventuallyAlways = (node: GraphNode, transition: number) => {
193
+ const actionChecks = node.actionChecks[transition];
194
+ const checks = model.eventuallyAlways;
195
+ for (let index = 0; index < checks.length; index++) {
196
+ if (!actionChecks[checks[index]]) return false;
197
+ }
198
+ return true;
199
+ };
200
+ const getLasso = (node: GraphNode): TraceLasso => {
201
+ const cycle: GraphNode[] = [];
202
+ const lowNumber = thirdNumber - 1;
203
+ const states = model.infinitelyOftenStates;
204
+ const actions = model.infinitelyOftenActions;
205
+ const isStateFound = states.map(() => false);
206
+ const isActionFound = actions.map(() => false);
207
+ const isPromiseFound = promises.map(() => false);
208
+ let count = states.length + actions.length + promises.length;
209
+ let current = node;
210
+ while (count > 0) {
211
+ current.number = thirdNumber;
212
+ const countBefore = count;
213
+ search: while (true) {
214
+ for (let index = 0; index < states.length; index++) {
215
+ if (!isStateFound[index] && current.stateChecks[states[index]]) {
216
+ isStateFound[index] = true;
217
+ count--;
218
+ }
219
+ }
220
+ for (let index = 0; index < promises.length; index++) {
221
+ if (
222
+ !isPromiseFound[index] &&
223
+ isFulfilling(tableauNodes[current.tableau].particle, promises[index])
224
+ ) {
225
+ isPromiseFound[index] = true;
226
+ count--;
227
+ }
228
+ }
229
+ if (count <= 0) break;
230
+ let inComponent: GraphNode | undefined;
231
+ let unvisited: GraphNode | undefined;
232
+ const countBeforeActions = count;
233
+ for (let index = 0; index < current.successors.length; index++) {
234
+ const target = current.successors[index];
235
+ const targetNumber = target.number;
236
+ if (lowNumber <= targetNumber && targetNumber <= thirdNumber) {
237
+ inComponent = target;
238
+ for (let action = 0; action < actions.length; action++) {
239
+ if (!isActionFound[action] && current.actionChecks[index][actions[action]]) {
240
+ isActionFound[action] = true;
241
+ count--;
242
+ }
243
+ }
244
+ }
245
+ if (count < countBeforeActions) {
246
+ cycle.push(current);
247
+ current = target;
248
+ thirdNumber++;
249
+ break search;
250
+ }
251
+ if (lowNumber <= targetNumber && targetNumber < thirdNumber) unvisited = target;
252
+ }
253
+ if (count < countBefore && inComponent) {
254
+ cycle.push(current);
255
+ current = inComponent;
256
+ thirdNumber++;
257
+ break;
258
+ }
259
+ while (unvisited === undefined) {
260
+ current = pop(cycle);
261
+ for (let index = 0; index < current.successors.length; index++) {
262
+ const target = current.successors[index];
263
+ if (lowNumber <= target.number && target.number < thirdNumber) {
264
+ cycle.push(current);
265
+ unvisited = target;
266
+ break;
267
+ }
268
+ }
269
+ }
270
+ cycle.push(current);
271
+ current = unvisited;
272
+ current.number = thirdNumber;
273
+ }
274
+ }
275
+ thirdNumber++;
276
+ current.number = thirdNumber;
277
+ close: while (current !== node) {
278
+ let isFound = false;
279
+ for (let index = 0; index < current.successors.length; index++) {
280
+ const target = current.successors[index];
281
+ if (lowNumber <= target.number && target.number < thirdNumber) {
282
+ cycle.push(current);
283
+ if (target === node) break close;
284
+ isFound = true;
285
+ current = target;
286
+ current.number = thirdNumber;
287
+ break;
288
+ }
289
+ }
290
+ if (!isFound) current = pop(cycle);
291
+ }
292
+ if (cycle.length === 0) cycle.push(current);
293
+ // Deviation from TLC: LiveCheck1#printErrorTrace shows the behavior's states in order, not those of the lasso it found, which differ once the behavior revisits a state.
294
+ const positions: number[] = [];
295
+ for (let position = 0; position <= node.position; position++) {
296
+ if (position === 0 || fingerprints[position] !== fingerprints[position - 1]) {
297
+ positions.push(position);
298
+ }
299
+ }
300
+ const cyclePosition = positions.length;
301
+ for (let index = 1; index < cycle.length; index++) {
302
+ if (cycle[index].fingerprint !== cycle[index - 1].fingerprint) {
303
+ positions.push(getStepTo(cycle[index - 1], cycle[index]));
304
+ }
305
+ }
306
+ const last = cycle[cycle.length - 1];
307
+ return {
308
+ positions,
309
+ cyclePosition,
310
+ backPosition: last.fingerprint === node.fingerprint ? undefined : getStepTo(last, node),
311
+ };
312
+ };
313
+ const checkSubcomponent = (node: GraphNode) => {
314
+ const states = model.infinitelyOftenStates;
315
+ const actions = model.infinitelyOftenActions;
316
+ const isStateFound = states.map(() => false);
317
+ const isActionFound = actions.map(() => false);
318
+ const isPromiseFound = promises.map(() => false);
319
+ const pending = [node];
320
+ node.number++;
321
+ while (pending.length > 0) {
322
+ const current = pop(pending);
323
+ for (let index = 0; index < states.length; index++) {
324
+ if (!isStateFound[index]) isStateFound[index] = current.stateChecks[states[index]];
325
+ }
326
+ for (let index = 0; index < current.successors.length; index++) {
327
+ const target = current.successors[index];
328
+ const targetNumber = target.number;
329
+ if (targetNumber >= thirdNumber) {
330
+ for (let action = 0; action < actions.length; action++) {
331
+ if (!isActionFound[action]) {
332
+ isActionFound[action] = current.actionChecks[index][actions[action]];
333
+ }
334
+ }
335
+ }
336
+ if (targetNumber === thirdNumber) {
337
+ target.number++;
338
+ pending.push(target);
339
+ }
340
+ }
341
+ for (let index = 0; index < promises.length; index++) {
342
+ if (isFulfilling(tableauNodes[current.tableau].particle, promises[index])) {
343
+ isPromiseFound[index] = true;
344
+ }
345
+ }
346
+ }
347
+ thirdNumber += 2;
348
+ if (
349
+ lasso === undefined &&
350
+ !isStateFound.includes(false) &&
351
+ !isActionFound.includes(false) &&
352
+ !isPromiseFound.includes(false)
353
+ ) {
354
+ lasso = getLasso(node);
355
+ }
356
+ };
357
+ const canStutter = (node: GraphNode) => {
358
+ const stutter = node.successors.indexOf(node);
359
+ return (
360
+ stutter !== -1 && firstComponentNumber <= node.number && isEventuallyAlways(node, stutter)
361
+ );
362
+ };
363
+ const extractSubcomponent = (node: GraphNode) => {
364
+ let popped = pop(stack);
365
+ if (popped === node && !canStutter(node)) {
366
+ node.number = thirdNumber++;
367
+ return false;
368
+ }
369
+ popped.number = thirdNumber;
370
+ while (popped !== node) {
371
+ popped = pop(stack);
372
+ popped.number = thirdNumber;
373
+ }
374
+ return true;
375
+ };
376
+ const checkSubcomponents = (node: GraphNode): number => {
377
+ let lowlink = secondNumber++;
378
+ node.number = lowlink;
379
+ stack.push(node);
380
+ for (let index = 0; index < node.successors.length; index++) {
381
+ const target = node.successors[index];
382
+ let targetNumber = target.number;
383
+ if (firstComponentNumber <= targetNumber && isEventuallyAlways(node, index)) {
384
+ if (
385
+ targetNumber < startSecondNumber ||
386
+ (secondComponentNumber <= targetNumber && targetNumber < startThirdNumber)
387
+ ) {
388
+ targetNumber = checkSubcomponents(target);
389
+ }
390
+ if (targetNumber < lowlink) lowlink = targetNumber;
391
+ }
392
+ }
393
+ if (lowlink === node.number && extractSubcomponent(node)) checkSubcomponent(node);
394
+ return lowlink;
395
+ };
396
+ const extractComponent = (node: GraphNode) => {
397
+ let popped = pop(stack);
398
+ if (popped === node && !node.successors.includes(node)) {
399
+ node.number = MAX_FIRST;
400
+ return undefined;
401
+ }
402
+ const nodes: GraphNode[] = [];
403
+ firstComponentNumber = secondNumber++;
404
+ secondComponentNumber = thirdNumber;
405
+ popped.number = firstComponentNumber;
406
+ nodes.push(popped);
407
+ while (popped !== node) {
408
+ popped = pop(stack);
409
+ popped.number = firstComponentNumber;
410
+ nodes.push(popped);
411
+ }
412
+ return nodes;
413
+ };
414
+ const checkComponent = (node: GraphNode) => {
415
+ const nodes = extractComponent(node);
416
+ if (!nodes) return;
417
+ for (const errorModel of solution.models) {
418
+ model = errorModel;
419
+ startSecondNumber = secondNumber;
420
+ startThirdNumber = thirdNumber;
421
+ for (let index = nodes.length - 1; index >= 0; index--) {
422
+ if (nodes[index].number < startThirdNumber) checkSubcomponents(nodes[index]);
423
+ }
424
+ }
425
+ };
426
+ const checkComponents = (node: GraphNode): number => {
427
+ let lowlink = firstNumber++;
428
+ node.number = lowlink;
429
+ stack.push(node);
430
+ for (let index = 0; index < node.successors.length; index++) {
431
+ const target = node.successors[index];
432
+ const targetNumber = target.number === 0 ? checkComponents(target) : target.number;
433
+ if (targetNumber < lowlink) lowlink = targetNumber;
434
+ }
435
+ if (lowlink === node.number) checkComponent(node);
436
+ return lowlink;
437
+ };
438
+ for (const node of initial) {
439
+ if (node.number === 0) checkComponents(node);
440
+ if (lasso) return lasso;
441
+ }
442
+ return undefined;
443
+ };
444
+
445
+ export const findTraceLasso = (
446
+ trace: Value[][],
447
+ fingerprints: bigint[],
448
+ solutions: Solution[],
449
+ atoms: LiveAtoms<Value[]>,
450
+ isShared: boolean,
451
+ ): TraceLasso | undefined => {
452
+ const stateCache = new Map<LiveExpression, boolean>();
453
+ const holds = (check: LiveExpression, position: number, next: number | undefined) => {
454
+ stateCache.clear();
455
+ return evaluateLive(
456
+ check,
457
+ trace[position],
458
+ next === undefined ? undefined : trace[next],
459
+ atoms,
460
+ stateCache,
461
+ );
462
+ };
463
+ const statePositions = trace.map((_state, position) => position);
464
+ const stepPositions = trace.map((_state, position) => position);
465
+ if (isShared) {
466
+ const firstStates = new Map<bigint, number>();
467
+ const firstSteps = new Map<number, number>();
468
+ for (let position = 0; position < trace.length; position++) {
469
+ const first = firstStates.get(fingerprints[position]) ?? position;
470
+ firstStates.set(fingerprints[position], first);
471
+ if (isSameState(trace[first], trace[position])) statePositions[position] = first;
472
+ if (position === 0) continue;
473
+ const key = statePositions[position - 1] * trace.length + statePositions[position];
474
+ stepPositions[position] = firstSteps.get(key) ?? position;
475
+ firstSteps.set(key, stepPositions[position]);
476
+ }
477
+ }
478
+ const solutionChecks = solutions.map((solution): TraceChecks => {
479
+ const states: boolean[][] = [];
480
+ const steps: boolean[][] = [];
481
+ const stutters: boolean[][] = [];
482
+ const consistent: boolean[][] = [];
483
+ const statePredicates = solution.tableau?.nodes.map((node) => node.statePredicates) ?? [];
484
+ return {
485
+ getStates: (position) => {
486
+ const first = statePositions[position];
487
+ return (states[first] ??= solution.stateChecks.map((check) =>
488
+ holds(check, first, undefined),
489
+ ));
490
+ },
491
+ getSteps: (position) => {
492
+ const first = stepPositions[position];
493
+ return (steps[first] ??= solution.actionChecks.map((check) =>
494
+ holds(check, first - 1, first),
495
+ ));
496
+ },
497
+ getStutters: (position) => {
498
+ const first = statePositions[position];
499
+ return (stutters[first] ??= solution.actionChecks.map((check) =>
500
+ holds(check, first, first),
501
+ ));
502
+ },
503
+ isConsistent: (tableauNode, position) => {
504
+ const first = statePositions[position];
505
+ const row = (consistent[first] ??= []);
506
+ const known = isShared ? row[tableauNode] : undefined;
507
+ if (known !== undefined) return known;
508
+ row[tableauNode] = statePredicates[tableauNode].every((predicate) =>
509
+ holds(predicate, first, undefined),
510
+ );
511
+ return row[tableauNode];
512
+ },
513
+ };
514
+ });
515
+ const partial: number[] = [];
516
+ for (let index = 0; index < solutions.length; index++) {
517
+ const graph = createGraph(fingerprints, solutions[index], solutionChecks[index], false);
518
+ const lasso = findLasso(fingerprints, solutions[index], graph.initial);
519
+ if (lasso) return lasso;
520
+ if (graph.isPartial) partial.push(index);
521
+ }
522
+ // Deviation from TLC: LiveCheck1#constructBEGraph gives the initial state no stuttering step to a tableau node that isn't initial and goes on from no node a revisited state reaches, so it misses a violation past them.
523
+ for (const index of partial) {
524
+ const graph = createGraph(fingerprints, solutions[index], solutionChecks[index], true);
525
+ const lasso = findLasso(fingerprints, solutions[index], graph.initial);
526
+ if (lasso) return lasso;
527
+ }
528
+ return undefined;
529
+ };