tla-ts 0.0.10-dev.3a85c3a9e → 0.0.10-dev.45c0eaef5

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 (260) 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 +79 -79
  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 +97 -92
  20. package/dist/transfer.js +97 -92
  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 +31 -3
  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 +146 -107
  29. package/src/check.ts +535 -281
  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 +21 -7
  33. package/src/cli/tlc.ts +31 -11
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +255 -18
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +131 -41
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -13
  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 +204 -62
  49. package/src/liveness.ts +55 -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 -10
  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/containers.ts +7 -1
  109. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  110. package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
  111. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  112. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  113. package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
  114. package/src/prover/smt/solver/lp/nex.ts +2 -1
  115. package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
  116. package/src/prover/smt/solver/lp/nla-core.ts +26 -6
  117. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -81
  118. package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
  119. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  120. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  121. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  122. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  123. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  124. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  125. package/src/prover/smt/solver/maxcore.ts +2 -1
  126. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  127. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  128. package/src/prover/smt/solver/model-checker.ts +1 -1
  129. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  130. package/src/prover/smt/solver/model-generator.ts +85 -43
  131. package/src/prover/smt/solver/mpf.ts +2 -4
  132. package/src/prover/smt/solver/mus.ts +2 -3
  133. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  134. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  135. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  136. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  137. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  138. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  139. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  140. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  141. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  142. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  143. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  144. package/src/prover/smt/solver/nlqsat.ts +1 -1
  145. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  146. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  147. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  148. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  149. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  150. package/src/prover/smt/solver/nlsat/solver.ts +74 -71
  151. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  152. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  153. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  154. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  155. package/src/prover/smt/solver/nnf.ts +6 -2
  156. package/src/prover/smt/solver/opt-context.ts +21 -7
  157. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  158. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  159. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  160. package/src/prover/smt/solver/opt-solver.ts +10 -6
  161. package/src/prover/smt/solver/optsmt.ts +1 -1
  162. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  163. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  164. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  165. package/src/prover/smt/solver/probes.ts +88 -23
  166. package/src/prover/smt/solver/proto-model.ts +8 -8
  167. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  168. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  169. package/src/prover/smt/solver/qe-lite.ts +2 -2
  170. package/src/prover/smt/solver/qe.ts +3 -2
  171. package/src/prover/smt/solver/qsat.ts +23 -8
  172. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  173. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  174. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  175. package/src/prover/smt/solver/rewriter.ts +31 -25
  176. package/src/prover/smt/solver/rlimit.ts +20 -3
  177. package/src/prover/smt/solver/sat/config.ts +1 -1
  178. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  179. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  180. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  181. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  182. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  183. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  184. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  185. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  186. package/src/prover/smt/solver/sat/solver.ts +27 -47
  187. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  188. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  189. package/src/prover/smt/solver/seq-derive.ts +4 -7
  190. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  191. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  192. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  193. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  194. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  195. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  196. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  197. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  198. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  199. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  200. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  201. package/src/prover/smt/solver/smt-setup.ts +106 -13
  202. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  203. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  204. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  205. package/src/prover/smt/solver/solver.ts +18 -3
  206. package/src/prover/smt/solver/tactic.ts +350 -195
  207. package/src/prover/smt/solver/theory-bv.ts +13 -3
  208. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  209. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  210. package/src/prover/smt/solver/theory-lra-internalize.ts +10 -0
  211. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  212. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  213. package/src/prover/smt/solver/theory-lra.ts +1 -1
  214. package/src/prover/smt/solver/theory-pb.ts +24 -7
  215. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  216. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  217. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  218. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  219. package/src/prover/tlapm/cache.ts +8 -8
  220. package/src/prover/zenon/equality-rules.ts +24 -0
  221. package/src/prover/zenon/expr.ts +21 -0
  222. package/src/prover/zenon/index-table.ts +7 -2
  223. package/src/prover/zenon/isar-case.ts +1 -1
  224. package/src/prover/zenon/isar.ts +2 -2
  225. package/src/prover/zenon/phrase.ts +1 -1
  226. package/src/prover/zenon/rules.ts +2 -1
  227. package/src/resolve.ts +1274 -258
  228. package/src/runtime.ts +25 -2
  229. package/src/sany/builtins.ts +10 -10
  230. package/src/sany/generation.ts +5 -15
  231. package/src/sany/generator-def-entries.ts +123 -36
  232. package/src/sany/generator-definitions.ts +5 -3
  233. package/src/sany/generator-expressions.ts +60 -37
  234. package/src/sany/generator-proofs.ts +18 -12
  235. package/src/sany/generator.ts +12 -6
  236. package/src/sany/lexer.ts +15 -7
  237. package/src/sany/modules.ts +4 -2
  238. package/src/sany/nodes.ts +1 -1
  239. package/src/sany/selectors.ts +11 -6
  240. package/src/sany/xml.ts +2 -3
  241. package/src/search.ts +348 -153
  242. package/src/simulate.ts +250 -185
  243. package/src/spec-description.ts +15 -7
  244. package/src/standard-definitions.ts +5 -0
  245. package/src/standard-modules.ts +56 -22
  246. package/src/subexpressions.ts +564 -138
  247. package/src/successors.ts +50 -20
  248. package/src/symmetry.ts +2 -1
  249. package/src/tlc/jar-data.ts +10 -0
  250. package/src/tlc/messages.ts +3 -3
  251. package/src/tlc/order.ts +14 -3
  252. package/src/tlc/random.ts +2 -1
  253. package/src/tlc/replay.ts +147 -46
  254. package/src/tlc/tlc-operators.ts +10 -8
  255. package/src/tlc/tlcext-operators.ts +87 -26
  256. package/src/tlc/trace-spec.ts +11 -25
  257. package/src/trace-liveness.ts +529 -0
  258. package/src/typed-tier.ts +52 -31
  259. package/src/typescript/types.ts +2 -2
  260. package/src/values.ts +150 -79
package/src/simulate.ts CHANGED
@@ -1,4 +1,5 @@
1
1
  import type { CheckOptions, TraceStep, Violation } from "./check";
2
+ import type { CoverageOutput } from "./coverage";
2
3
  import {
3
4
  isStackOverflow,
4
5
  TlaEvaluationError,
@@ -10,11 +11,20 @@ import {
10
11
  UNEXPECTED_EVAL_EXCEPTION,
11
12
  UNEXPECTED_EXCEPTION,
12
13
  } from "./errors";
13
- import { EXIT_STATUS, getMessageExitStatus, withLivenessExitCode } from "./exit-codes";
14
- import { createLivenessChecker, type LivenessChecker } from "./liveness-checker";
15
- import { getIncompleteSuccessorMessage, prepareSearch, reportAssumptionViolation } from "./search";
14
+ import type { State } from "./evaluate";
15
+ import { EXIT_STATUS, getMessageExitStatus, withLivenessChecksExitCode } from "./exit-codes";
16
+ import { getHashMapOrder } from "./java-hash";
17
+ import { createLivenessChecks } from "./liveness-checker";
18
+ import {
19
+ addActionCoverage,
20
+ getIncompleteSuccessorMessage,
21
+ prepareSearch,
22
+ reportAssumptionViolation,
23
+ STOP_WALK,
24
+ walkCoveredSuccessors,
25
+ } from "./search";
16
26
  import { getActionLabel, toActionValue, type SpecAction } from "./spec-description";
17
- import { forEachInitialState, forEachSuccessor } from "./successors";
27
+ import { forEachInitialState, forEachSuccessor, type Successor } from "./successors";
18
28
  import {
19
29
  formatInnerMessage,
20
30
  formatNestedMessage,
@@ -25,15 +35,24 @@ import {
25
35
  isHeadedError,
26
36
  MESSAGE_CODE,
27
37
  withUnexpectedException,
38
+ type FailureMessage,
28
39
  } from "./tlc/messages";
29
40
  import { createJavaRandom, nextPrime, type JavaRandom } from "./tlc/random";
30
- import { createCounterExample } from "./tlc/tlcext-operators";
41
+ import { replayInitialStates } from "./tlc/replay";
42
+ import {
43
+ createActionRecord,
44
+ createCounterExample,
45
+ createTlcRecord,
46
+ type CounterExampleLoop,
47
+ } from "./tlc/tlcext-operators";
31
48
  import {
49
+ computeLikeTlcOnFailure,
32
50
  createModelValue,
33
51
  createRecord,
34
52
  formatState,
35
53
  getSetBound,
36
- isSameValue,
54
+ markNormalized,
55
+ valuesEqual,
37
56
  type Value,
38
57
  } from "./values";
39
58
 
@@ -58,6 +77,7 @@ export interface SimulationStatistics {
58
77
  export type SimulationOutput =
59
78
  | { kind: "message"; code: number; isError: boolean; message: string; toolMessage: string }
60
79
  | { kind: "behavior"; trace: TraceStep[]; isLastStateOnly: boolean }
80
+ | CoverageOutput
61
81
  | { kind: "progress"; statistics: SimulationStatistics }
62
82
  | { kind: "summary"; statistics: SimulationStatistics };
63
83
 
@@ -67,6 +87,7 @@ interface TraceNode {
67
87
  predecessor: TraceNode | undefined;
68
88
  level: number;
69
89
  deferred?: (next: Value[]) => void;
90
+ incomplete?: State;
70
91
  }
71
92
 
72
93
  interface WorkerError {
@@ -77,6 +98,8 @@ interface WorkerError {
77
98
  isException: boolean;
78
99
  isSummarized: boolean;
79
100
  violation?: Violation;
101
+ failures?: FailureMessage[];
102
+ counterExample?: Value;
80
103
  }
81
104
 
82
105
  const FATAL_CODES = new Set<number>([
@@ -91,14 +114,25 @@ const RL_ALPHA = 0.3;
91
114
  const RL_GAMMA = 0.7;
92
115
  const RL_REWARD = -10;
93
116
 
94
- const isSameState = (left: Value[], right: Value[]) =>
95
- left.every((value, index) => isSameValue(value, right[index]));
117
+ const isUnequal = () => false;
118
+
119
+ // TLC's SimulationWorker#getTrace drops a step its TLCState#equals finds stuttering, which sorts the records it compares.
120
+ const isRepeatedState = (state: Value[], predecessor: Value[], order: number[]) => {
121
+ for (let position = 0; position < order.length; position++) {
122
+ const index = order[position];
123
+ // Deviation from TLC: TLCState#equals fails on values it can't compare, which hangs TLC's simulation.
124
+ if (!computeLikeTlcOnFailure(valuesEqual, isUnequal, state[index], predecessor[index])) {
125
+ return false;
126
+ }
127
+ }
128
+ return true;
129
+ };
96
130
 
97
- const getTrace = (last: TraceNode) => {
131
+ const getTrace = (last: TraceNode, order: number[]) => {
98
132
  const trace: TraceNode[] = [];
99
133
  for (let node: TraceNode | undefined = last; node; node = node.predecessor) {
100
134
  const predecessor = node.predecessor;
101
- if (predecessor && isSameState(node.state, predecessor.state)) continue;
135
+ if (predecessor && isRepeatedState(node.state, predecessor.state, order)) continue;
102
136
  trace.unshift(node);
103
137
  }
104
138
  trace.forEach((node, index) => {
@@ -108,57 +142,6 @@ const getTrace = (last: TraceNode) => {
108
142
  return trace;
109
143
  };
110
144
 
111
- const findTemporalViolation = (
112
- trace: TraceNode[],
113
- getFingerprint: (state: Value[]) => bigint,
114
- createChecker: (successors: number[][], states: Value[][]) => LivenessChecker | undefined,
115
- ) => {
116
- const fingerprints = trace.map((node) => getFingerprint(node.state));
117
- const indices = new Map<bigint, number>();
118
- const states: Value[][] = [];
119
- const successors: number[][] = [];
120
- fingerprints.forEach((fingerprint, position) => {
121
- if (!indices.has(fingerprint)) {
122
- indices.set(fingerprint, states.length);
123
- states.push(trace[position].state);
124
- successors.push([]);
125
- }
126
- if (position === 0) return;
127
- const source = indices.get(fingerprints[position - 1]) ?? 0;
128
- const target = indices.get(fingerprint) ?? 0;
129
- if (source !== target && !successors[source].includes(target)) {
130
- successors[source].push(target);
131
- }
132
- });
133
- const checker = createChecker(successors, states);
134
- if (!checker) return undefined;
135
- checker.addInitialState(0, states[0]);
136
- states.forEach((state, index) =>
137
- checker.addState(
138
- index,
139
- state,
140
- successors[index].map((successor) => ({ index: successor, state: states[successor] })),
141
- ),
142
- );
143
- const lasso = checker.findViolation();
144
- if (!lasso) return undefined;
145
- const getLength = (path: number[]) =>
146
- path.filter((index, position) => position === 0 || index !== path[position - 1]).length;
147
- const path = [...lasso.prefix, ...lasso.cycle];
148
- const length = getLength(path);
149
- const cyclePosition = getLength(path.slice(0, lasso.prefix.length + 1));
150
- const isStuttering =
151
- fingerprints[length - 1] === getFingerprint(states[path[lasso.prefix.length]]);
152
- return {
153
- length,
154
- loopStart: isStuttering ? length - 1 : cyclePosition - 1,
155
- properties: checker.getViolatedProperties(
156
- trace.slice(0, length).map((node) => node.state),
157
- cyclePosition - 1,
158
- ),
159
- };
160
- };
161
-
162
145
  const createScheduler = (
163
146
  scheduler: SimulationOptions["scheduler"],
164
147
  nextActions: SpecAction[],
@@ -242,18 +225,25 @@ export const simulate = (options: SimulationOptions): number => {
242
225
  };
243
226
  const reportMessage = (code: number, text: string, toolText = text, isError = true) =>
244
227
  output({ kind: "message", code, isError, message: text, toolMessage: toolText });
245
- const printSummary = () => output({ kind: "summary", statistics: { ...statistics } });
228
+ const reportCoverage = () => {
229
+ const report = prepared.getCoverage();
230
+ if (report) output({ kind: "coverage", coverage: report });
231
+ };
232
+ const printSummary = () => {
233
+ reportCoverage();
234
+ output({ kind: "summary", statistics: { ...statistics } });
235
+ };
246
236
  const nodes = new WeakMap<(Value | undefined)[], TraceNode>();
247
237
  const description = prepared.getDescription();
248
238
  const initActions = description.inits;
249
239
  const nextActions = description.actions;
240
+ const coverage = prepared.coverage;
241
+ const covered = coverage && addActionCoverage(coverage, environment, description);
250
242
  let traceCount = 0;
251
243
  let currentTrace = 0;
244
+ let evaluatedAction: SpecAction | undefined;
245
+ runtime.getSuccessorAction = () => evaluatedAction;
252
246
  runtime.getLevel = (state) => nodes.get(state)?.level ?? 0;
253
- runtime.getBehavior = (state) => {
254
- const node = nodes.get(state);
255
- return node ? getTrace(node).map((step) => step.state) : [state];
256
- };
257
247
  runtime.getSimulationValue = (key, state) => {
258
248
  const node = state && nodes.get(state);
259
249
  switch (key) {
@@ -266,7 +256,7 @@ export const simulate = (options: SimulationOptions): number => {
266
256
  case "action":
267
257
  return node && toActionValue(node.action);
268
258
  case "config":
269
- return createRecord([
259
+ return createTlcRecord([
270
260
  ["mode", options.isGenerating ? "generate" : "simulate"],
271
261
  ["depth", traceDepth === INFINITE_DEPTH ? -1 : traceDepth],
272
262
  ["traces", Number(BigInt.asIntN(32, traceLimit))],
@@ -282,14 +272,19 @@ export const simulate = (options: SimulationOptions): number => {
282
272
  for (let step = node; step && step.level > 1; step = step.predecessor) {
283
273
  actions.set(step.action.name, (actions.get(step.action.name) ?? 0) + 1);
284
274
  }
285
- return createRecord([
275
+ // TLC's SimulationWorker counts the actions of a behavior in a HashMap.
276
+ const counts = getHashMapOrder([...actions.keys()]).map((name): [string, Value] => [
277
+ name,
278
+ actions.get(name) ?? 0,
279
+ ]);
280
+ return createTlcRecord([
286
281
  ["traces", statistics.traces],
287
282
  ["duration", Math.floor((Date.now() - runtime.startedAt) / 1000)],
288
283
  ["generated", statistics.generatedStates],
289
284
  [
290
285
  "behavior",
291
- createRecord([
292
- ["actions", createRecord([...actions])],
286
+ createTlcRecord([
287
+ ["actions", createTlcRecord(counts)],
293
288
  ["id", currentTrace],
294
289
  ]),
295
290
  ],
@@ -309,6 +304,10 @@ export const simulate = (options: SimulationOptions): number => {
309
304
  if (!search) {
310
305
  throw new TlaUnsupportedError("tla-ts can't simulate a specification without variables");
311
306
  }
307
+ runtime.getBehavior = (state) => {
308
+ const node = nodes.get(state);
309
+ return node ? getTrace(node, search.getTlcOrder()).map((step) => step.state) : [state];
310
+ };
312
311
  const reportPostcondition = (isAfterViolation: boolean) => {
313
312
  const postcondition = search.findPostconditionViolation(isAfterViolation);
314
313
  if (!postcondition) return undefined;
@@ -320,19 +319,12 @@ export const simulate = (options: SimulationOptions): number => {
320
319
  );
321
320
  return postcondition;
322
321
  };
323
- const temporalProperties = search.properties.liveness;
324
- const createTemporalChecker = (successors: number[][], states: Value[][]) =>
325
- withLivenessExitCode(() =>
326
- withUnexpectedException(() =>
327
- createLivenessChecker(temporalProperties, search.spec.temporals, environment, {
328
- getFingerprint: (successor) =>
329
- Number(BigInt.asIntN(32, runtime.getFingerprint(successor.state))),
330
- getSuccessors: (index) =>
331
- successors[index].map((successor) => ({ index: successor, state: states[successor] })),
332
- }),
333
- ),
334
- );
335
- const branches = createTemporalChecker([], [])?.branches;
322
+ const livenessChecks = withLivenessChecksExitCode(() =>
323
+ withUnexpectedException(() =>
324
+ createLivenessChecks(search.properties.liveness, search.spec.temporals, environment),
325
+ ),
326
+ );
327
+ const branches = livenessChecks?.solutions.length;
336
328
  if (branches) options.onProgress?.({ kind: "liveness-prepared", branches });
337
329
  const assumptionStatus = reportAssumptionViolation(
338
330
  specification.assumptions,
@@ -349,25 +341,35 @@ export const simulate = (options: SimulationOptions): number => {
349
341
  const toRecord = (state: (Value | undefined)[]) =>
350
342
  search.toRecord(state.map((value) => value ?? createModelValue("null")));
351
343
  const toTraceSteps = (trace: TraceNode[]): TraceStep[] =>
352
- trace.map((node, index) => ({
353
- action: node.action.name,
354
- label: getActionLabel(node.action, options.version, node.level === 1),
355
- state:
356
- config.alias === undefined || !node.state.every((value) => value !== undefined)
357
- ? toRecord(node.state)
358
- : search.evaluateAlias(
359
- config.alias,
360
- node.state,
361
- (trace[index + 1] ?? node).state,
362
- options.isTool ?? false,
363
- ),
364
- }));
365
- const getCounterExample = (trace: TraceNode[]) =>
344
+ trace.map((node, index) => {
345
+ const successor = trace[index + 1] ?? node;
346
+ return {
347
+ action: node.action.name,
348
+ label: getActionLabel(node.action, options.version, node.level === 1),
349
+ state:
350
+ config.alias === undefined
351
+ ? toRecord(node.state)
352
+ : search.evaluateAlias(
353
+ config.alias,
354
+ node.incomplete ?? node.state,
355
+ successor.incomplete ?? successor.state,
356
+ options.isTool ?? false,
357
+ ),
358
+ };
359
+ });
360
+ const getCounterExample = (
361
+ trace: TraceNode[],
362
+ steps = toTraceSteps(trace),
363
+ loop?: CounterExampleLoop,
364
+ ) =>
366
365
  createCounterExample(
367
- trace.map((node) => search.toRecord(node.state)),
366
+ steps.map((step) => step.state),
368
367
  trace.slice(1).map((node) => toActionValue(node.action)),
369
- undefined,
368
+ loop,
370
369
  );
370
+ // TLC's Simulator binds CounterExample to an initial state that violates an invariant, not to its alias.
371
+ const getInitialCounterExample = (node: TraceNode) =>
372
+ createCounterExample([toRecord(node.state)], [], undefined);
371
373
 
372
374
  const initialStates: TraceNode[] = [];
373
375
  const isComplete = (state: (Value | undefined)[]): state is Value[] =>
@@ -401,7 +403,13 @@ export const simulate = (options: SimulationOptions): number => {
401
403
  return false;
402
404
  };
403
405
  try {
404
- if (init) forEachInitialState(init, environment, addGenerated, search.spec.scope, addGenerated);
406
+ if (covered) {
407
+ replayInitialStates(covered.inits, environment, addGenerated, (partial) =>
408
+ addGenerated([...partial]),
409
+ );
410
+ } else if (init) {
411
+ forEachInitialState(init, environment, addGenerated, search.spec.scope, addGenerated);
412
+ }
405
413
  } catch (error) {
406
414
  return reportInitialException(error, undefined);
407
415
  }
@@ -412,6 +420,7 @@ export const simulate = (options: SimulationOptions): number => {
412
420
  undefined,
413
421
  false,
414
422
  );
423
+ const generatedNodes: TraceNode[] = [];
415
424
  for (const state of generated) {
416
425
  if (!isComplete(state)) {
417
426
  reportMessage(
@@ -429,22 +438,11 @@ export const simulate = (options: SimulationOptions): number => {
429
438
  MESSAGE_CODE.invariantViolatedInitial,
430
439
  `Invariant ${violated.name} is violated by the initial state:\n${formatState(alias)}`,
431
440
  );
432
- runtime.counterExample = getCounterExample([node]);
441
+ runtime.counterExample = getInitialCounterExample(node);
433
442
  reportPostcondition(true);
434
443
  return EXIT_STATUS.safetyViolation;
435
444
  }
436
- // Deviation from TLC: its simulator checks no implied init, tla-ts checks them after invariants.
437
- const predicate = search.findFailedInitialPredicate(state);
438
- if (predicate) {
439
- const alias = toTraceSteps([node])[0].state;
440
- reportMessage(
441
- MESSAGE_CODE.propertyViolatedInitial,
442
- `Property ${predicate.name} is violated by the initial state:\n${formatState(alias)}`,
443
- );
444
- runtime.counterExample = getCounterExample([node]);
445
- reportPostcondition(true);
446
- return EXIT_STATUS.livenessViolation;
447
- }
445
+ generatedNodes.push(node);
448
446
  if (search.satisfiesConstraints(state)) {
449
447
  search.trackStatePossible(state);
450
448
  initialStates.push(node);
@@ -467,12 +465,32 @@ export const simulate = (options: SimulationOptions): number => {
467
465
  );
468
466
  return EXIT_STATUS.error;
469
467
  }
468
+ // Deviation from TLC: its simulator checks no implied init, tla-ts checks them after TLC's own checks of the initial states.
469
+ for (const node of generatedNodes) {
470
+ try {
471
+ const predicate = search.findFailedInitialPredicate(node.state);
472
+ if (predicate) {
473
+ const alias = toTraceSteps([node])[0].state;
474
+ reportMessage(
475
+ MESSAGE_CODE.propertyViolatedInitial,
476
+ `Property ${predicate.name} is violated by the initial state:\n${formatState(alias)}`,
477
+ );
478
+ runtime.counterExample = getInitialCounterExample(node);
479
+ reportPostcondition(true);
480
+ return EXIT_STATUS.livenessViolation;
481
+ }
482
+ } catch (error) {
483
+ return reportInitialException(error, node.state);
484
+ }
485
+ }
470
486
  reportMessage(
471
487
  MESSAGE_CODE.initGenerated1,
472
488
  `Finished computing initial states: ${initialStates.length} distinct state generated at ${formatTlcDate(new Date())}.`,
473
489
  undefined,
474
490
  false,
475
491
  );
492
+ // TLC's Simulator deep-normalizes the initial states, which sorts their records.
493
+ initialStates.forEach((node) => node.state.forEach(markNormalized));
476
494
 
477
495
  const toWorkerError = (code: number, text: string, node: TraceNode): WorkerError => ({
478
496
  code,
@@ -482,75 +500,102 @@ export const simulate = (options: SimulationOptions): number => {
482
500
  isException: false,
483
501
  isSummarized: true,
484
502
  });
485
- const getSuccessors = (current: TraceNode, action: SpecAction) => {
486
- const successors: TraceNode[] = [];
503
+ const generator = options.isGenerating ? { random: workerRandom, kept: 0 } : undefined;
504
+ const getSuccessors = (current: TraceNode, index: number) => {
505
+ const action = nextActions[index];
506
+ const coveredAction = covered?.actions[index];
507
+ const keptSuccessors: TraceNode[] = [];
508
+ if (generator) generator.kept = 0;
487
509
  let failure: WorkerError | undefined;
488
510
  runtime.deferred = undefined;
511
+ evaluatedAction = action;
512
+ const visit = (successor: Successor) => {
513
+ const node = toNode(successor.state, action, current);
514
+ node.deferred = runtime.deferred;
515
+ runtime.deferred = undefined;
516
+ statistics.generatedStates++;
517
+ try {
518
+ const violated = search.findViolatedInvariant(node.state, current.state);
519
+ if (violated) {
520
+ failure = toWorkerError(
521
+ MESSAGE_CODE.invariantViolatedBehavior,
522
+ `Invariant ${violated.name} is violated.`,
523
+ node,
524
+ );
525
+ return true;
526
+ }
527
+ const property = search.findViolatedActionProperty(current.state, node.state);
528
+ if (property) {
529
+ failure = toWorkerError(
530
+ MESSAGE_CODE.actionPropertyViolatedBehavior,
531
+ `Action property ${property.name} is violated.`,
532
+ node,
533
+ );
534
+ return true;
535
+ }
536
+ } catch (error) {
537
+ if (!(error instanceof TlaEvaluationError) || !isHeadedError(error)) throw error;
538
+ const text = getFailureMessage(error, true);
539
+ failure = {
540
+ ...toWorkerError(text.code, text.message, node),
541
+ toolMessage: text.toolMessage,
542
+ };
543
+ return true;
544
+ }
545
+ if (!search.satisfiesConstraints(node.state, current.state)) return false;
546
+ search.trackStatePossible(node.state);
547
+ if (!search.satisfiesActionConstraints(current.state, node.state)) return false;
548
+ search.trackActionPossible(current.state, node.state);
549
+ if (keptSuccessors.length === getSetBound()) throw new TlaTooManyStatesError();
550
+ if (coverage && coveredAction) coverage.secondary[coveredAction.node]++;
551
+ keptSuccessors.push(node);
552
+ if (generator) generator.kept++;
553
+ return false;
554
+ };
489
555
  try {
490
- forEachSuccessor(
491
- action.expression,
492
- current.state,
493
- environment,
494
- (successor) => {
495
- const node = toNode(successor.state, action, current);
496
- node.deferred = runtime.deferred;
497
- runtime.deferred = undefined;
498
- statistics.generatedStates++;
499
- try {
500
- const violated = search.findViolatedInvariant(node.state, current.state);
501
- if (violated) {
502
- failure = toWorkerError(
503
- MESSAGE_CODE.invariantViolatedBehavior,
504
- `Invariant ${violated.name} is violated.`,
505
- node,
506
- );
507
- return true;
508
- }
509
- const property = search.findViolatedActionProperty(current.state, node.state);
510
- if (property) {
511
- failure = toWorkerError(
512
- MESSAGE_CODE.actionPropertyViolatedBehavior,
513
- `Action property ${property.name} is violated.`,
514
- node,
515
- );
516
- return true;
517
- }
518
- } catch (error) {
519
- if (!(error instanceof TlaEvaluationError) || !isHeadedError(error)) throw error;
520
- const text = getFailureMessage(error, true);
521
- failure = {
522
- ...toWorkerError(text.code, text.message, node),
523
- toolMessage: text.toolMessage,
524
- };
525
- return true;
526
- }
527
- if (!search.satisfiesConstraints(node.state, current.state)) return false;
528
- search.trackStatePossible(node.state);
529
- if (!search.satisfiesActionConstraints(current.state, node.state)) return false;
530
- search.trackActionPossible(current.state, node.state);
531
- if (successors.length === getSetBound()) throw new TlaTooManyStatesError();
532
- successors.push(node);
533
- return false;
534
- },
535
- action.scope,
536
- options.isGenerating ? workerRandom : undefined,
537
- );
556
+ if (coverage && coveredAction) {
557
+ walkCoveredSuccessors(
558
+ coverage,
559
+ coveredAction,
560
+ current.state,
561
+ environment,
562
+ (state) => {
563
+ if (visit({ state, action: action.name })) throw STOP_WALK;
564
+ },
565
+ undefined,
566
+ generator,
567
+ );
568
+ } else {
569
+ forEachSuccessor(
570
+ action.expression,
571
+ current.state,
572
+ environment,
573
+ visit,
574
+ action.scope,
575
+ generator,
576
+ );
577
+ }
538
578
  } catch (error) {
579
+ if (error === STOP_WALK) return { successors: keptSuccessors, error: failure };
539
580
  if (!(error instanceof TlaIncompleteSuccessorError)) throw error;
540
581
  const node = toNode(
541
582
  error.state.map((value) => value ?? createModelValue("null")),
542
583
  action,
543
584
  current,
544
585
  );
586
+ node.incomplete = error.state;
545
587
  const text = getIncompleteSuccessorMessage(
546
588
  error.variables,
547
589
  action.name,
548
590
  nextActions.length,
549
591
  options.version,
550
592
  );
551
- return { successors, error: toWorkerError(MESSAGE_CODE.incompleteSuccessor, text, node) };
593
+ return {
594
+ successors: keptSuccessors,
595
+ error: toWorkerError(MESSAGE_CODE.incompleteSuccessor, text, node),
596
+ };
552
597
  }
553
- return { successors, error: failure };
598
+ return { successors: keptSuccessors, error: failure };
554
599
  };
555
600
  let currentNode = initialStates[0];
556
601
  const scheduler = createScheduler(
@@ -560,18 +605,35 @@ export const simulate = (options: SimulationOptions): number => {
560
605
  runtime.getFingerprint,
561
606
  search.getReward,
562
607
  );
563
- const getTemporalViolation = (last: TraceNode): Violation | undefined => {
564
- if (temporalProperties.length === 0) return undefined;
565
- const trace = getTrace(last);
566
- const found = findTemporalViolation(trace, runtime.getFingerprint, createTemporalChecker);
608
+ const getTemporalViolation = (last: TraceNode): WorkerError | undefined => {
609
+ if (!livenessChecks) return undefined;
610
+ const trace = getTrace(last, search.getTlcOrder());
611
+ // TLC's LiveCheck#checkTrace fingerprints each state, which sorts its records.
612
+ for (let position = 0; position < trace.length; position++) {
613
+ trace[position].state.forEach(markNormalized);
614
+ }
615
+ const found = livenessChecks.findTraceViolation(
616
+ trace.map((node) => node.state),
617
+ trace.map((node) => runtime.getFingerprint(node.state)),
618
+ );
567
619
  if (!found) return undefined;
568
- const back = trace[found.length];
620
+ const back = found.backPosition === undefined ? undefined : trace[found.backPosition];
621
+ const lasso = found.positions.map((position) => trace[position]);
622
+ const loopStart = back ? found.cyclePosition - 1 : lasso.length - 1;
623
+ const steps = toTraceSteps(lasso);
624
+ const loopAction = back ? toActionValue(back.action) : createActionRecord(undefined);
569
625
  return {
570
- name: found.properties[0],
571
- properties: found.properties,
572
- trace: toTraceSteps(trace.slice(0, found.length)),
573
- loopStart: found.loopStart,
574
- loopLabel: back && getActionLabel(back.action, options.version, back.level === 1),
626
+ ...toWorkerError(MESSAGE_CODE.temporalPropertyViolated, "", last),
627
+ isException: true,
628
+ violation: {
629
+ name: found.properties[0],
630
+ properties: found.properties,
631
+ trace: steps,
632
+ loopStart,
633
+ loopLabel: back && getActionLabel(back.action, options.version, back.level === 1),
634
+ },
635
+ failures: found.failures.map((failure) => toException(failure, last)),
636
+ counterExample: getCounterExample(lasso, steps, { start: loopStart, action: loopAction }),
575
637
  };
576
638
  };
577
639
  const simulateTrace = (): WorkerError | "stopped" | undefined => {
@@ -582,7 +644,8 @@ export const simulate = (options: SimulationOptions): number => {
582
644
  const prime = nextPrime(workerRandom);
583
645
  let successors: TraceNode[] = [];
584
646
  for (let attempt = 0; attempt < nextActions.length; attempt++) {
585
- const result = getSuccessors(currentNode, nextActions[actionIndex]);
647
+ const result = getSuccessors(currentNode, actionIndex);
648
+ // Deviation from TLC: TLCSet("exit") interrupts TLC's SimulationWorker, whose BlockingQueue#put then drops a violation found in the same step.
586
649
  if (result.error) return result.error;
587
650
  successors = result.successors;
588
651
  if (successors.length > 0) break;
@@ -600,13 +663,7 @@ export const simulate = (options: SimulationOptions): number => {
600
663
  }
601
664
  if (runtime.isStopped) return "stopped";
602
665
  const violation = getTemporalViolation(currentNode);
603
- if (violation) {
604
- return {
605
- ...toWorkerError(MESSAGE_CODE.temporalPropertyViolated, "", currentNode),
606
- isException: true,
607
- violation,
608
- };
609
- }
666
+ if (violation) return violation;
610
667
  const length = Math.min(traceDepth, currentNode.level);
611
668
  const delta = length - statistics.levelMean;
612
669
  statistics.levelMean += Math.trunc(delta / Math.max(statistics.traces, 1));
@@ -670,6 +727,9 @@ export const simulate = (options: SimulationOptions): number => {
670
727
  const reported = printed === -1 ? errors : errors.slice(0, printed + 1);
671
728
  reported.forEach((error) => {
672
729
  if (error.violation) {
730
+ error.failures?.forEach((failure) =>
731
+ reportMessage(failure.code, failure.message, failure.toolMessage),
732
+ );
673
733
  options.onProgress?.({
674
734
  kind: "violation",
675
735
  status: "liveness-violation",
@@ -681,20 +741,25 @@ export const simulate = (options: SimulationOptions): number => {
681
741
  reportMessage(error.code, error.message, error.toolMessage);
682
742
  output({
683
743
  kind: "behavior",
684
- trace: toTraceSteps(getTrace(error.node)),
744
+ trace: toTraceSteps(getTrace(error.node, search.getTlcOrder())),
685
745
  isLastStateOnly: traceDepth === INFINITE_DEPTH,
686
746
  });
687
747
  if (error.isSummarized) printSummary();
688
748
  });
689
749
  const last = reported[reported.length - 1];
690
750
  const errorStatus = last ? getMessageExitStatus(last.code) : EXIT_STATUS.success;
691
- if (last) runtime.counterExample = getCounterExample(getTrace(last.node));
751
+ if (last) {
752
+ runtime.counterExample =
753
+ last.counterExample ?? getCounterExample(getTrace(last.node, search.getTlcOrder()));
754
+ }
692
755
  const postcondition = reportPostcondition(last !== undefined);
693
756
  const postconditionStatus = postcondition
694
757
  ? getMessageExitStatus(postcondition.code)
695
758
  : EXIT_STATUS.success;
696
759
  const status = Math.max(errorStatus, postconditionStatus);
697
760
  output({ kind: "progress", statistics: { ...statistics } });
761
+ // TLC's ProgressReport prints the coverage again with its last progress unless -coverage spans more progress reports.
762
+ if (options.coverage !== undefined && options.coverage <= 1) reportCoverage();
698
763
  if (status === EXIT_STATUS.success) printSummary();
699
764
  return status;
700
765
  };