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
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,67 +500,84 @@ export const simulate = (options: SimulationOptions): number => {
484
500
  isException: false,
485
501
  isSummarized: true,
486
502
  });
487
- const getSuccessors = (current: TraceNode, action: SpecAction) => {
503
+ const getSuccessors = (current: TraceNode, index: number) => {
504
+ const action = nextActions[index];
505
+ const coveredAction = covered?.actions[index];
488
506
  const successors: TraceNode[] = [];
489
507
  let failure: WorkerError | undefined;
490
508
  runtime.deferred = undefined;
491
509
  evaluatedAction = action;
510
+ const visit = (successor: Successor) => {
511
+ const node = toNode(successor.state, action, current);
512
+ node.deferred = runtime.deferred;
513
+ runtime.deferred = undefined;
514
+ statistics.generatedStates++;
515
+ try {
516
+ const violated = search.findViolatedInvariant(node.state, current.state);
517
+ if (violated) {
518
+ failure = toWorkerError(
519
+ MESSAGE_CODE.invariantViolatedBehavior,
520
+ `Invariant ${violated.name} is violated.`,
521
+ node,
522
+ );
523
+ return true;
524
+ }
525
+ const property = search.findViolatedActionProperty(current.state, node.state);
526
+ if (property) {
527
+ failure = toWorkerError(
528
+ MESSAGE_CODE.actionPropertyViolatedBehavior,
529
+ `Action property ${property.name} is violated.`,
530
+ node,
531
+ );
532
+ return true;
533
+ }
534
+ } catch (error) {
535
+ if (!(error instanceof TlaEvaluationError) || !isHeadedError(error)) throw error;
536
+ const text = getFailureMessage(error, true);
537
+ failure = {
538
+ ...toWorkerError(text.code, text.message, node),
539
+ toolMessage: text.toolMessage,
540
+ };
541
+ return true;
542
+ }
543
+ if (!search.satisfiesConstraints(node.state, current.state)) return false;
544
+ search.trackStatePossible(node.state);
545
+ if (!search.satisfiesActionConstraints(current.state, node.state)) return false;
546
+ search.trackActionPossible(current.state, node.state);
547
+ if (successors.length === getSetBound()) throw new TlaTooManyStatesError();
548
+ if (coverage && coveredAction) coverage.secondary[coveredAction.node]++;
549
+ successors.push(node);
550
+ return false;
551
+ };
492
552
  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
- );
553
+ if (coverage && coveredAction && !options.isGenerating) {
554
+ walkCoveredSuccessors(coverage, coveredAction, current.state, environment, (state) => {
555
+ if (visit({ state, action: action.name })) throw STOP_WALK;
556
+ });
557
+ } else {
558
+ forEachSuccessor(
559
+ action.expression,
560
+ current.state,
561
+ environment,
562
+ coverage && coveredAction
563
+ ? (successor) => {
564
+ coverage.primary[coveredAction.node]++;
565
+ return visit(successor);
566
+ }
567
+ : visit,
568
+ action.scope,
569
+ options.isGenerating ? workerRandom : undefined,
570
+ );
571
+ }
541
572
  } catch (error) {
573
+ if (error === STOP_WALK) return { successors, error: failure };
542
574
  if (!(error instanceof TlaIncompleteSuccessorError)) throw error;
543
575
  const node = toNode(
544
576
  error.state.map((value) => value ?? createModelValue("null")),
545
577
  action,
546
578
  current,
547
579
  );
580
+ node.incomplete = error.state;
548
581
  const text = getIncompleteSuccessorMessage(
549
582
  error.variables,
550
583
  action.name,
@@ -563,18 +596,35 @@ export const simulate = (options: SimulationOptions): number => {
563
596
  runtime.getFingerprint,
564
597
  search.getReward,
565
598
  );
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);
599
+ const getTemporalViolation = (last: TraceNode): WorkerError | undefined => {
600
+ if (!livenessChecks) return undefined;
601
+ const trace = getTrace(last, search.getTlcOrder());
602
+ // TLC's LiveCheck#checkTrace fingerprints each state, which sorts its records.
603
+ for (let position = 0; position < trace.length; position++) {
604
+ trace[position].state.forEach(markNormalized);
605
+ }
606
+ const found = livenessChecks.findTraceViolation(
607
+ trace.map((node) => node.state),
608
+ trace.map((node) => runtime.getFingerprint(node.state)),
609
+ );
570
610
  if (!found) return undefined;
571
- const back = trace[found.length];
611
+ const back = found.backPosition === undefined ? undefined : trace[found.backPosition];
612
+ const lasso = found.positions.map((position) => trace[position]);
613
+ const loopStart = back ? found.cyclePosition - 1 : lasso.length - 1;
614
+ const steps = toTraceSteps(lasso);
615
+ const loopAction = back ? toActionValue(back.action) : createActionRecord(undefined);
572
616
  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),
617
+ ...toWorkerError(MESSAGE_CODE.temporalPropertyViolated, "", last),
618
+ isException: true,
619
+ violation: {
620
+ name: found.properties[0],
621
+ properties: found.properties,
622
+ trace: steps,
623
+ loopStart,
624
+ loopLabel: back && getActionLabel(back.action, options.version, back.level === 1),
625
+ },
626
+ failures: found.failures.map((failure) => toException(failure, last)),
627
+ counterExample: getCounterExample(lasso, steps, { start: loopStart, action: loopAction }),
578
628
  };
579
629
  };
580
630
  const simulateTrace = (): WorkerError | "stopped" | undefined => {
@@ -585,7 +635,8 @@ export const simulate = (options: SimulationOptions): number => {
585
635
  const prime = nextPrime(workerRandom);
586
636
  let successors: TraceNode[] = [];
587
637
  for (let attempt = 0; attempt < nextActions.length; attempt++) {
588
- const result = getSuccessors(currentNode, nextActions[actionIndex]);
638
+ const result = getSuccessors(currentNode, actionIndex);
639
+ // Deviation from TLC: TLCSet("exit") interrupts TLC's SimulationWorker, whose BlockingQueue#put then drops a violation found in the same step.
589
640
  if (result.error) return result.error;
590
641
  successors = result.successors;
591
642
  if (successors.length > 0) break;
@@ -603,13 +654,7 @@ export const simulate = (options: SimulationOptions): number => {
603
654
  }
604
655
  if (runtime.isStopped) return "stopped";
605
656
  const violation = getTemporalViolation(currentNode);
606
- if (violation) {
607
- return {
608
- ...toWorkerError(MESSAGE_CODE.temporalPropertyViolated, "", currentNode),
609
- isException: true,
610
- violation,
611
- };
612
- }
657
+ if (violation) return violation;
613
658
  const length = Math.min(traceDepth, currentNode.level);
614
659
  const delta = length - statistics.levelMean;
615
660
  statistics.levelMean += Math.trunc(delta / Math.max(statistics.traces, 1));
@@ -673,6 +718,9 @@ export const simulate = (options: SimulationOptions): number => {
673
718
  const reported = printed === -1 ? errors : errors.slice(0, printed + 1);
674
719
  reported.forEach((error) => {
675
720
  if (error.violation) {
721
+ error.failures?.forEach((failure) =>
722
+ reportMessage(failure.code, failure.message, failure.toolMessage),
723
+ );
676
724
  options.onProgress?.({
677
725
  kind: "violation",
678
726
  status: "liveness-violation",
@@ -684,20 +732,25 @@ export const simulate = (options: SimulationOptions): number => {
684
732
  reportMessage(error.code, error.message, error.toolMessage);
685
733
  output({
686
734
  kind: "behavior",
687
- trace: toTraceSteps(getTrace(error.node)),
735
+ trace: toTraceSteps(getTrace(error.node, search.getTlcOrder())),
688
736
  isLastStateOnly: traceDepth === INFINITE_DEPTH,
689
737
  });
690
738
  if (error.isSummarized) printSummary();
691
739
  });
692
740
  const last = reported[reported.length - 1];
693
741
  const errorStatus = last ? getMessageExitStatus(last.code) : EXIT_STATUS.success;
694
- if (last) runtime.counterExample = getCounterExample(getTrace(last.node));
742
+ if (last) {
743
+ runtime.counterExample =
744
+ last.counterExample ?? getCounterExample(getTrace(last.node, search.getTlcOrder()));
745
+ }
695
746
  const postcondition = reportPostcondition(last !== undefined);
696
747
  const postconditionStatus = postcondition
697
748
  ? getMessageExitStatus(postcondition.code)
698
749
  : EXIT_STATUS.success;
699
750
  const status = Math.max(errorStatus, postconditionStatus);
700
751
  output({ kind: "progress", statistics: { ...statistics } });
752
+ // TLC's ProgressReport prints the coverage again with its last progress unless -coverage spans more progress reports.
753
+ if (options.coverage !== undefined && options.coverage <= 1) reportCoverage();
701
754
  if (status === EXIT_STATUS.success) printSummary();
702
755
  return status;
703
756
  };