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

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 (263) 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 +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 -93
  29. package/src/check.ts +518 -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 +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 +255 -18
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +155 -66
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +152 -25
  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 +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/ackermannize-bv-tactic.ts +3 -2
  67. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  68. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  69. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  70. package/src/prover/smt/solver/ast-lt.ts +1 -1
  71. package/src/prover/smt/solver/ast.ts +66 -14
  72. package/src/prover/smt/solver/auf-solver.ts +23 -12
  73. package/src/prover/smt/solver/bit-blast-tactic.ts +28 -2
  74. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  75. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  76. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  77. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  78. package/src/prover/smt/solver/bv1-blast.ts +1 -1
  79. package/src/prover/smt/solver/card2bv.ts +35 -18
  80. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  81. package/src/prover/smt/solver/context.ts +84 -15
  82. package/src/prover/smt/solver/ctx-simplify.ts +9 -4
  83. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  84. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  85. package/src/prover/smt/solver/diff-neq.ts +9 -8
  86. package/src/prover/smt/solver/dt2bv-tactic.ts +66 -28
  87. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  88. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  89. package/src/prover/smt/solver/elim-uncnstr.ts +31 -28
  90. package/src/prover/smt/solver/eq2bv-tactic.ts +15 -6
  91. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  92. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  93. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  94. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  95. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  96. package/src/prover/smt/solver/euf/mam.ts +1 -5
  97. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  98. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  99. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  100. package/src/prover/smt/solver/factor.ts +36 -14
  101. package/src/prover/smt/solver/fd-solver.ts +608 -139
  102. package/src/prover/smt/solver/fix-dl-var.ts +2 -3
  103. package/src/prover/smt/solver/fm-tactic.ts +9 -7
  104. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  105. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  106. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  107. package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -1
  108. package/src/prover/smt/solver/goal.ts +6 -3
  109. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  110. package/src/prover/smt/solver/hashtable.ts +4 -0
  111. package/src/prover/smt/solver/internalizer.ts +1 -1
  112. package/src/prover/smt/solver/lia2pb.ts +1 -1
  113. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  114. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  115. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  116. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  117. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  118. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  119. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  120. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  121. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  122. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  123. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  124. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  125. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  126. package/src/prover/smt/solver/maxcore.ts +2 -1
  127. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  128. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  129. package/src/prover/smt/solver/model-checker.ts +1 -1
  130. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  131. package/src/prover/smt/solver/model-generator.ts +85 -43
  132. package/src/prover/smt/solver/mpf.ts +2 -4
  133. package/src/prover/smt/solver/mus.ts +2 -3
  134. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  135. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  136. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  137. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  138. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  139. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  140. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  141. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  142. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  143. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  144. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  145. package/src/prover/smt/solver/nlqsat.ts +2 -1
  146. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  147. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  148. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  149. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  150. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  151. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  152. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  153. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  154. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  155. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  156. package/src/prover/smt/solver/nnf.ts +6 -2
  157. package/src/prover/smt/solver/normalize-bounds.ts +2 -2
  158. package/src/prover/smt/solver/occf.ts +1 -1
  159. package/src/prover/smt/solver/opt-context.ts +21 -7
  160. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  161. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  162. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  163. package/src/prover/smt/solver/opt-solver.ts +10 -6
  164. package/src/prover/smt/solver/optsmt.ts +1 -1
  165. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  166. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  167. package/src/prover/smt/solver/pb2bv-tactic.ts +9 -3
  168. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  169. package/src/prover/smt/solver/probes.ts +88 -23
  170. package/src/prover/smt/solver/proto-model.ts +8 -8
  171. package/src/prover/smt/solver/purify-arith.ts +51 -49
  172. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  173. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  174. package/src/prover/smt/solver/qe-lite.ts +2 -2
  175. package/src/prover/smt/solver/qe.ts +3 -2
  176. package/src/prover/smt/solver/qsat.ts +23 -8
  177. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  178. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  179. package/src/prover/smt/solver/reduce-args.ts +2 -2
  180. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  181. package/src/prover/smt/solver/rewriter.ts +31 -25
  182. package/src/prover/smt/solver/rlimit.ts +7 -3
  183. package/src/prover/smt/solver/sat/config.ts +1 -1
  184. package/src/prover/smt/solver/sat/goal2sat.ts +75 -12
  185. package/src/prover/smt/solver/sat/inc-sat-solver.ts +149 -47
  186. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  187. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  188. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  189. package/src/prover/smt/solver/sat/sat-tactic.ts +54 -25
  190. package/src/prover/smt/solver/sat/sat2goal.ts +75 -50
  191. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  192. package/src/prover/smt/solver/sat/solver.ts +27 -47
  193. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  194. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  195. package/src/prover/smt/solver/seq-derive.ts +2 -2
  196. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  197. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  198. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  199. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  200. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  201. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  202. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  203. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  204. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  205. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  206. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  207. package/src/prover/smt/solver/smt-setup.ts +106 -13
  208. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  209. package/src/prover/smt/solver/smtlib-script.ts +718 -213
  210. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  211. package/src/prover/smt/solver/solver.ts +18 -4
  212. package/src/prover/smt/solver/tactic.ts +389 -199
  213. package/src/prover/smt/solver/theory-bv.ts +13 -3
  214. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  215. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  216. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  217. package/src/prover/smt/solver/theory-lra-propagate.ts +12 -3
  218. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  219. package/src/prover/smt/solver/theory-lra.ts +1 -1
  220. package/src/prover/smt/solver/theory-pb.ts +24 -7
  221. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  222. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  223. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  224. package/src/prover/smt/solver/tseitin-cnf.ts +15 -5
  225. package/src/prover/tlapm/cache.ts +8 -8
  226. package/src/prover/zenon/index-table.ts +5 -2
  227. package/src/prover/zenon/isar-case.ts +1 -1
  228. package/src/prover/zenon/isar.ts +2 -2
  229. package/src/prover/zenon/phrase.ts +1 -1
  230. package/src/resolve.ts +1311 -268
  231. package/src/runtime.ts +21 -2
  232. package/src/sany/builtins.ts +10 -10
  233. package/src/sany/generation.ts +5 -15
  234. package/src/sany/generator-def-entries.ts +123 -36
  235. package/src/sany/generator-definitions.ts +5 -3
  236. package/src/sany/generator-expressions.ts +60 -37
  237. package/src/sany/generator-proofs.ts +19 -12
  238. package/src/sany/generator.ts +12 -6
  239. package/src/sany/lexer.ts +15 -7
  240. package/src/sany/modules.ts +4 -2
  241. package/src/sany/nodes.ts +1 -1
  242. package/src/sany/selectors.ts +12 -6
  243. package/src/sany/xml.ts +2 -3
  244. package/src/search.ts +321 -135
  245. package/src/simulate.ts +247 -185
  246. package/src/spec-description.ts +15 -7
  247. package/src/standard-definitions.ts +1 -0
  248. package/src/standard-modules.ts +56 -22
  249. package/src/subexpressions.ts +666 -147
  250. package/src/successors.ts +50 -20
  251. package/src/symmetry.ts +2 -1
  252. package/src/tlc/jar-data.ts +10 -0
  253. package/src/tlc/messages.ts +3 -3
  254. package/src/tlc/order.ts +14 -3
  255. package/src/tlc/random.ts +2 -1
  256. package/src/tlc/replay.ts +147 -46
  257. package/src/tlc/tlc-operators.ts +10 -8
  258. package/src/tlc/tlcext-operators.ts +44 -15
  259. package/src/tlc/trace-spec.ts +9 -22
  260. package/src/trace-liveness.ts +529 -0
  261. package/src/typed-tier.ts +52 -31
  262. package/src/typescript/types.ts +2 -2
  263. 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,20 +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;
252
244
  let evaluatedAction: SpecAction | undefined;
253
245
  runtime.getSuccessorAction = () => evaluatedAction;
254
246
  runtime.getLevel = (state) => nodes.get(state)?.level ?? 0;
255
- runtime.getBehavior = (state) => {
256
- const node = nodes.get(state);
257
- return node ? getTrace(node).map((step) => step.state) : [state];
258
- };
259
247
  runtime.getSimulationValue = (key, state) => {
260
248
  const node = state && nodes.get(state);
261
249
  switch (key) {
@@ -268,7 +256,7 @@ export const simulate = (options: SimulationOptions): number => {
268
256
  case "action":
269
257
  return node && toActionValue(node.action);
270
258
  case "config":
271
- return createRecord([
259
+ return createTlcRecord([
272
260
  ["mode", options.isGenerating ? "generate" : "simulate"],
273
261
  ["depth", traceDepth === INFINITE_DEPTH ? -1 : traceDepth],
274
262
  ["traces", Number(BigInt.asIntN(32, traceLimit))],
@@ -284,14 +272,19 @@ export const simulate = (options: SimulationOptions): number => {
284
272
  for (let step = node; step && step.level > 1; step = step.predecessor) {
285
273
  actions.set(step.action.name, (actions.get(step.action.name) ?? 0) + 1);
286
274
  }
287
- 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([
288
281
  ["traces", statistics.traces],
289
282
  ["duration", Math.floor((Date.now() - runtime.startedAt) / 1000)],
290
283
  ["generated", statistics.generatedStates],
291
284
  [
292
285
  "behavior",
293
- createRecord([
294
- ["actions", createRecord([...actions])],
286
+ createTlcRecord([
287
+ ["actions", createTlcRecord(counts)],
295
288
  ["id", currentTrace],
296
289
  ]),
297
290
  ],
@@ -311,6 +304,10 @@ export const simulate = (options: SimulationOptions): number => {
311
304
  if (!search) {
312
305
  throw new TlaUnsupportedError("tla-ts can't simulate a specification without variables");
313
306
  }
307
+ runtime.getBehavior = (state) => {
308
+ const node = nodes.get(state);
309
+ return node ? getTrace(node, search.getTlcOrder()).map((step) => step.state) : [state];
310
+ };
314
311
  const reportPostcondition = (isAfterViolation: boolean) => {
315
312
  const postcondition = search.findPostconditionViolation(isAfterViolation);
316
313
  if (!postcondition) return undefined;
@@ -322,19 +319,12 @@ export const simulate = (options: SimulationOptions): number => {
322
319
  );
323
320
  return postcondition;
324
321
  };
325
- const temporalProperties = search.properties.liveness;
326
- const createTemporalChecker = (successors: number[][], states: Value[][]) =>
327
- withLivenessExitCode(() =>
328
- withUnexpectedException(() =>
329
- createLivenessChecker(temporalProperties, search.spec.temporals, environment, {
330
- getFingerprint: (successor) =>
331
- Number(BigInt.asIntN(32, runtime.getFingerprint(successor.state))),
332
- getSuccessors: (index) =>
333
- successors[index].map((successor) => ({ index: successor, state: states[successor] })),
334
- }),
335
- ),
336
- );
337
- 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;
338
328
  if (branches) options.onProgress?.({ kind: "liveness-prepared", branches });
339
329
  const assumptionStatus = reportAssumptionViolation(
340
330
  specification.assumptions,
@@ -351,25 +341,35 @@ export const simulate = (options: SimulationOptions): number => {
351
341
  const toRecord = (state: (Value | undefined)[]) =>
352
342
  search.toRecord(state.map((value) => value ?? createModelValue("null")));
353
343
  const toTraceSteps = (trace: TraceNode[]): TraceStep[] =>
354
- trace.map((node, index) => ({
355
- action: node.action.name,
356
- label: getActionLabel(node.action, options.version, node.level === 1),
357
- state:
358
- config.alias === undefined || !node.state.every((value) => value !== undefined)
359
- ? toRecord(node.state)
360
- : search.evaluateAlias(
361
- config.alias,
362
- node.state,
363
- (trace[index + 1] ?? node).state,
364
- options.isTool ?? false,
365
- ),
366
- }));
367
- 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
+ ) =>
368
365
  createCounterExample(
369
- trace.map((node) => search.toRecord(node.state)),
366
+ steps.map((step) => step.state),
370
367
  trace.slice(1).map((node) => toActionValue(node.action)),
371
- undefined,
368
+ loop,
372
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);
373
373
 
374
374
  const initialStates: TraceNode[] = [];
375
375
  const isComplete = (state: (Value | undefined)[]): state is Value[] =>
@@ -403,7 +403,13 @@ export const simulate = (options: SimulationOptions): number => {
403
403
  return false;
404
404
  };
405
405
  try {
406
- 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
+ }
407
413
  } catch (error) {
408
414
  return reportInitialException(error, undefined);
409
415
  }
@@ -414,6 +420,7 @@ export const simulate = (options: SimulationOptions): number => {
414
420
  undefined,
415
421
  false,
416
422
  );
423
+ const generatedNodes: TraceNode[] = [];
417
424
  for (const state of generated) {
418
425
  if (!isComplete(state)) {
419
426
  reportMessage(
@@ -431,22 +438,11 @@ export const simulate = (options: SimulationOptions): number => {
431
438
  MESSAGE_CODE.invariantViolatedInitial,
432
439
  `Invariant ${violated.name} is violated by the initial state:\n${formatState(alias)}`,
433
440
  );
434
- runtime.counterExample = getCounterExample([node]);
441
+ runtime.counterExample = getInitialCounterExample(node);
435
442
  reportPostcondition(true);
436
443
  return EXIT_STATUS.safetyViolation;
437
444
  }
438
- // Deviation from TLC: its simulator checks no implied init, tla-ts checks them after invariants.
439
- const predicate = search.findFailedInitialPredicate(state);
440
- if (predicate) {
441
- const alias = toTraceSteps([node])[0].state;
442
- reportMessage(
443
- MESSAGE_CODE.propertyViolatedInitial,
444
- `Property ${predicate.name} is violated by the initial state:\n${formatState(alias)}`,
445
- );
446
- runtime.counterExample = getCounterExample([node]);
447
- reportPostcondition(true);
448
- return EXIT_STATUS.livenessViolation;
449
- }
445
+ generatedNodes.push(node);
450
446
  if (search.satisfiesConstraints(state)) {
451
447
  search.trackStatePossible(state);
452
448
  initialStates.push(node);
@@ -469,12 +465,32 @@ export const simulate = (options: SimulationOptions): number => {
469
465
  );
470
466
  return EXIT_STATUS.error;
471
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
+ }
472
486
  reportMessage(
473
487
  MESSAGE_CODE.initGenerated1,
474
488
  `Finished computing initial states: ${initialStates.length} distinct state generated at ${formatTlcDate(new Date())}.`,
475
489
  undefined,
476
490
  false,
477
491
  );
492
+ // TLC's Simulator deep-normalizes the initial states, which sorts their records.
493
+ initialStates.forEach((node) => node.state.forEach(markNormalized));
478
494
 
479
495
  const toWorkerError = (code: number, text: string, node: TraceNode): WorkerError => ({
480
496
  code,
@@ -484,76 +500,102 @@ export const simulate = (options: SimulationOptions): number => {
484
500
  isException: false,
485
501
  isSummarized: true,
486
502
  });
487
- const getSuccessors = (current: TraceNode, action: SpecAction) => {
488
- 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;
489
509
  let failure: WorkerError | undefined;
490
510
  runtime.deferred = undefined;
491
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
+ };
492
555
  try {
493
- forEachSuccessor(
494
- action.expression,
495
- current.state,
496
- environment,
497
- (successor) => {
498
- const node = toNode(successor.state, action, current);
499
- node.deferred = runtime.deferred;
500
- runtime.deferred = undefined;
501
- statistics.generatedStates++;
502
- try {
503
- const violated = search.findViolatedInvariant(node.state, current.state);
504
- if (violated) {
505
- failure = toWorkerError(
506
- MESSAGE_CODE.invariantViolatedBehavior,
507
- `Invariant ${violated.name} is violated.`,
508
- node,
509
- );
510
- return true;
511
- }
512
- const property = search.findViolatedActionProperty(current.state, node.state);
513
- if (property) {
514
- failure = toWorkerError(
515
- MESSAGE_CODE.actionPropertyViolatedBehavior,
516
- `Action property ${property.name} is violated.`,
517
- node,
518
- );
519
- return true;
520
- }
521
- } catch (error) {
522
- if (!(error instanceof TlaEvaluationError) || !isHeadedError(error)) throw error;
523
- const text = getFailureMessage(error, true);
524
- failure = {
525
- ...toWorkerError(text.code, text.message, node),
526
- toolMessage: text.toolMessage,
527
- };
528
- return true;
529
- }
530
- if (!search.satisfiesConstraints(node.state, current.state)) return false;
531
- search.trackStatePossible(node.state);
532
- if (!search.satisfiesActionConstraints(current.state, node.state)) return false;
533
- search.trackActionPossible(current.state, node.state);
534
- if (successors.length === getSetBound()) throw new TlaTooManyStatesError();
535
- successors.push(node);
536
- return false;
537
- },
538
- action.scope,
539
- options.isGenerating ? workerRandom : undefined,
540
- );
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
+ }
541
578
  } catch (error) {
579
+ if (error === STOP_WALK) return { successors: keptSuccessors, error: failure };
542
580
  if (!(error instanceof TlaIncompleteSuccessorError)) throw error;
543
581
  const node = toNode(
544
582
  error.state.map((value) => value ?? createModelValue("null")),
545
583
  action,
546
584
  current,
547
585
  );
586
+ node.incomplete = error.state;
548
587
  const text = getIncompleteSuccessorMessage(
549
588
  error.variables,
550
589
  action.name,
551
590
  nextActions.length,
552
591
  options.version,
553
592
  );
554
- return { successors, error: toWorkerError(MESSAGE_CODE.incompleteSuccessor, text, node) };
593
+ return {
594
+ successors: keptSuccessors,
595
+ error: toWorkerError(MESSAGE_CODE.incompleteSuccessor, text, node),
596
+ };
555
597
  }
556
- return { successors, error: failure };
598
+ return { successors: keptSuccessors, error: failure };
557
599
  };
558
600
  let currentNode = initialStates[0];
559
601
  const scheduler = createScheduler(
@@ -563,18 +605,35 @@ export const simulate = (options: SimulationOptions): number => {
563
605
  runtime.getFingerprint,
564
606
  search.getReward,
565
607
  );
566
- const getTemporalViolation = (last: TraceNode): Violation | undefined => {
567
- if (temporalProperties.length === 0) return undefined;
568
- const trace = getTrace(last);
569
- 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
+ );
570
619
  if (!found) return undefined;
571
- 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);
572
625
  return {
573
- name: found.properties[0],
574
- properties: found.properties,
575
- trace: toTraceSteps(trace.slice(0, found.length)),
576
- loopStart: found.loopStart,
577
- 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 }),
578
637
  };
579
638
  };
580
639
  const simulateTrace = (): WorkerError | "stopped" | undefined => {
@@ -585,7 +644,8 @@ export const simulate = (options: SimulationOptions): number => {
585
644
  const prime = nextPrime(workerRandom);
586
645
  let successors: TraceNode[] = [];
587
646
  for (let attempt = 0; attempt < nextActions.length; attempt++) {
588
- 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.
589
649
  if (result.error) return result.error;
590
650
  successors = result.successors;
591
651
  if (successors.length > 0) break;
@@ -603,13 +663,7 @@ export const simulate = (options: SimulationOptions): number => {
603
663
  }
604
664
  if (runtime.isStopped) return "stopped";
605
665
  const violation = getTemporalViolation(currentNode);
606
- if (violation) {
607
- return {
608
- ...toWorkerError(MESSAGE_CODE.temporalPropertyViolated, "", currentNode),
609
- isException: true,
610
- violation,
611
- };
612
- }
666
+ if (violation) return violation;
613
667
  const length = Math.min(traceDepth, currentNode.level);
614
668
  const delta = length - statistics.levelMean;
615
669
  statistics.levelMean += Math.trunc(delta / Math.max(statistics.traces, 1));
@@ -673,6 +727,9 @@ export const simulate = (options: SimulationOptions): number => {
673
727
  const reported = printed === -1 ? errors : errors.slice(0, printed + 1);
674
728
  reported.forEach((error) => {
675
729
  if (error.violation) {
730
+ error.failures?.forEach((failure) =>
731
+ reportMessage(failure.code, failure.message, failure.toolMessage),
732
+ );
676
733
  options.onProgress?.({
677
734
  kind: "violation",
678
735
  status: "liveness-violation",
@@ -684,20 +741,25 @@ export const simulate = (options: SimulationOptions): number => {
684
741
  reportMessage(error.code, error.message, error.toolMessage);
685
742
  output({
686
743
  kind: "behavior",
687
- trace: toTraceSteps(getTrace(error.node)),
744
+ trace: toTraceSteps(getTrace(error.node, search.getTlcOrder())),
688
745
  isLastStateOnly: traceDepth === INFINITE_DEPTH,
689
746
  });
690
747
  if (error.isSummarized) printSummary();
691
748
  });
692
749
  const last = reported[reported.length - 1];
693
750
  const errorStatus = last ? getMessageExitStatus(last.code) : EXIT_STATUS.success;
694
- if (last) runtime.counterExample = getCounterExample(getTrace(last.node));
751
+ if (last) {
752
+ runtime.counterExample =
753
+ last.counterExample ?? getCounterExample(getTrace(last.node, search.getTlcOrder()));
754
+ }
695
755
  const postcondition = reportPostcondition(last !== undefined);
696
756
  const postconditionStatus = postcondition
697
757
  ? getMessageExitStatus(postcondition.code)
698
758
  : EXIT_STATUS.success;
699
759
  const status = Math.max(errorStatus, postconditionStatus);
700
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();
701
763
  if (status === EXIT_STATUS.success) printSummary();
702
764
  return status;
703
765
  };