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/successors.ts CHANGED
@@ -68,13 +68,18 @@ export interface Successor {
68
68
  action: string | undefined;
69
69
  }
70
70
 
71
+ export interface SuccessorGenerator {
72
+ random: JavaRandom;
73
+ kept: number;
74
+ }
75
+
71
76
  interface Run {
72
77
  environment: Environment;
73
78
  isInit: boolean;
74
79
  isEnabled: boolean;
75
80
  current: Value[] | undefined;
76
81
  isStopped: boolean;
77
- generator: JavaRandom | undefined;
82
+ generator: SuccessorGenerator | undefined;
78
83
  successors: number;
79
84
  onUnsatisfied?: (state: Value[], conjunct: Expression) => void;
80
85
  }
@@ -274,6 +279,7 @@ const getUnchangedVariables = (
274
279
 
275
280
  const ACTION_KINDS = new Set([
276
281
  "Label",
282
+ "Selection",
277
283
  "And",
278
284
  "Or",
279
285
  "Exists",
@@ -525,7 +531,7 @@ const compileMembership = (
525
531
  run.environment.runtime.version,
526
532
  )) {
527
533
  onComplete(assign(partial, index, element), action);
528
- if (run.successors > 0 || run.isStopped) return;
534
+ if (run.generator.kept > 0 || run.isStopped) return;
529
535
  }
530
536
  }
531
537
  for (let position = 0; position < elements.length && !run.isStopped; position++) {
@@ -723,6 +729,7 @@ const compileIdentifier = (
723
729
  !definition ||
724
730
  (expression.location.range && getStartupValue(definition, environment) !== undefined)
725
731
  ) {
732
+ // Deviation from TLC: Tool#getInitStates prints an unassigned variable's declaration as the non-boolean value it found.
726
733
  guard(run, scope, partial, action, isFixed, onComplete);
727
734
  return;
728
735
  }
@@ -880,8 +887,8 @@ const compileRandomChoice =
880
887
  (run, scope, partial, action, isFixed, onComplete) => {
881
888
  const generator = run.generator;
882
889
  if (!generator) throw new Error("A random choice needs the run's generator");
883
- const start = Math.floor(generator.nextDouble() * choices.length);
884
- const prime = nextPrime(generator);
890
+ const start = Math.floor(generator.random.nextDouble() * choices.length);
891
+ const prime = nextPrime(generator.random);
885
892
  for (let attempt = 0; attempt < choices.length; attempt++) {
886
893
  choices[(start + attempt * prime) % choices.length](
887
894
  run,
@@ -891,7 +898,7 @@ const compileRandomChoice =
891
898
  isFixed,
892
899
  onComplete,
893
900
  );
894
- if (run.successors > 0 || run.isStopped) return;
901
+ if (generator.kept > 0 || run.isStopped) return;
895
902
  }
896
903
  };
897
904
 
@@ -915,7 +922,7 @@ const compileRandomExists = (
915
922
  const visit = (position: number, boundScope: Scope | undefined): boolean => {
916
923
  if (position < 0) {
917
924
  body(run, boundScope, partial, action, isFixed, onComplete);
918
- return run.successors > 0 || run.isStopped;
925
+ return (run.generator?.kept ?? 0) > 0 || run.isStopped;
919
926
  }
920
927
  const pattern = expression.bounds[position].pattern;
921
928
  return orders[position].some((element) =>
@@ -926,6 +933,7 @@ const compileRandomExists = (
926
933
  };
927
934
  };
928
935
 
936
+ // Deviation from TLC: Tool#getNextStates in -generate throws an UnsupportedOperationException at a CASE, which tla-ts takes as the model checker does.
929
937
  const compileRandomAction = (expression: Expression, environment: Environment) => {
930
938
  if (expression.kind === "Exists") return compileRandomExists(expression, environment);
931
939
  if (expression.kind !== "Or") return undefined;
@@ -1091,10 +1099,16 @@ const compileAction = (
1091
1099
  case "Let": {
1092
1100
  const body = getChildRunner(expression.body);
1093
1101
  const reevaluated = getReevaluatedDefinitions(expression.definitions, environment);
1102
+ // TLC's Tool#enabled binds a LET's definitions to lazy values it caches, where Tool#getNextStates evaluates them at every use.
1103
+ const cached = { impure: new Set<Definition>(), streamed: reevaluated.streamed };
1094
1104
  return (run, scope, partial, action, isFixed, onComplete) =>
1095
1105
  body(
1096
1106
  run,
1097
- bindDefinitions(expression.definitions, getContext(run, scope, partial), reevaluated),
1107
+ bindDefinitions(
1108
+ expression.definitions,
1109
+ getContext(run, scope, partial),
1110
+ run.isEnabled ? cached : reevaluated,
1111
+ ),
1098
1112
  partial,
1099
1113
  action,
1100
1114
  isFixed,
@@ -1139,6 +1153,8 @@ const compileAction = (
1139
1153
  );
1140
1154
  case "Label":
1141
1155
  return getChildRunner(expression.body);
1156
+ case "Selection":
1157
+ return getChildRunner(expression.expression);
1142
1158
  case "Identifier":
1143
1159
  return compileIdentifier(expression, environment, isInit);
1144
1160
  case "FunctionApplication":
@@ -1203,7 +1219,9 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
1203
1219
  );
1204
1220
  }
1205
1221
  const environment = context.environment;
1206
- if (environment.callStack) return replayEnabled(expression, context.scope, state, environment);
1222
+ if (environment.callStack || (environment.coverage && environment.coverage.current !== -1)) {
1223
+ return replayEnabled(expression, context.scope, state, environment);
1224
+ }
1207
1225
  const run: Run = {
1208
1226
  environment,
1209
1227
  isInit: false,
@@ -1280,14 +1298,29 @@ export const getInitialStates = (
1280
1298
  return states;
1281
1299
  };
1282
1300
 
1301
+ export const createIncompleteSuccessorError = (
1302
+ partial: State,
1303
+ action: string | undefined,
1304
+ environment: Environment,
1305
+ ) => {
1306
+ const missing = environment.variables.filter((_name, index) => partial[index] === undefined);
1307
+ return new TlaIncompleteSuccessorError(
1308
+ `Successor state is not completely specified by action ${action ?? "Next"}. The following variables are not assigned: ${missing.join(", ")}`,
1309
+ partial,
1310
+ action,
1311
+ missing,
1312
+ );
1313
+ };
1314
+
1283
1315
  export const forEachSuccessor = (
1284
1316
  expression: Expression,
1285
1317
  state: Value[],
1286
1318
  environment: Environment,
1287
1319
  onSuccessor: (successor: Successor) => boolean,
1288
1320
  scope?: Scope,
1289
- generator?: JavaRandom,
1321
+ generator?: SuccessorGenerator,
1290
1322
  onUnsatisfied?: Run["onUnsatisfied"],
1323
+ onIncomplete?: (state: State, action: string | undefined) => void,
1291
1324
  ) => {
1292
1325
  const run: Run = {
1293
1326
  environment,
@@ -1308,15 +1341,11 @@ export const forEachSuccessor = (
1308
1341
  (partial, action) => {
1309
1342
  if (run.isStopped) return;
1310
1343
  if (!isComplete(partial)) {
1311
- const missing = environment.variables.filter(
1312
- (_name, index) => partial[index] === undefined,
1313
- );
1314
- throw new TlaIncompleteSuccessorError(
1315
- `Successor state is not completely specified by action ${action ?? "Next"}. The following variables are not assigned: ${missing.join(", ")}`,
1316
- partial,
1317
- action,
1318
- missing,
1319
- );
1344
+ if (onIncomplete) {
1345
+ onIncomplete(partial, action);
1346
+ return;
1347
+ }
1348
+ throw createIncompleteSuccessorError(partial, action, environment);
1320
1349
  }
1321
1350
  run.successors++;
1322
1351
  run.isStopped = onSuccessor({ state: partial, action });
@@ -1340,6 +1369,7 @@ export const hasIncompleteSuccessor = (
1340
1369
  generator: undefined,
1341
1370
  successors: 0,
1342
1371
  };
1372
+ // TLC's Tool#getState generates every successor of the action before it compares them.
1343
1373
  getRunner(expression, environment, false)(
1344
1374
  run,
1345
1375
  scope,
@@ -1347,10 +1377,10 @@ export const hasIncompleteSuccessor = (
1347
1377
  undefined,
1348
1378
  false,
1349
1379
  (partial) => {
1350
- if (!isComplete(partial)) run.isStopped = true;
1380
+ if (!isComplete(partial)) run.successors++;
1351
1381
  },
1352
1382
  );
1353
- return run.isStopped;
1383
+ return run.successors > 0;
1354
1384
  };
1355
1385
 
1356
1386
  export const getSuccessors = (
package/src/symmetry.ts CHANGED
@@ -24,7 +24,7 @@ export type Images = Map<string, ModelValue>;
24
24
 
25
25
  const getPermutationKey = (permutation: Images) =>
26
26
  [...permutation]
27
- .map(([name, image]) => `${name}>${image.name}`)
27
+ .map((entry) => `${entry[0]}>${entry[1].name}`)
28
28
  .sort()
29
29
  .join(",");
30
30
 
@@ -139,6 +139,7 @@ export const getSymmetryGroup = (
139
139
  `The set${isPlural ? "s" : ""} ${names.join(", and ")} ${isPlural ? "have" : "has"} been defined to be a symmetry set but contain${isPlural ? "" : "s"} less than two elements.`,
140
140
  );
141
141
  };
142
+ // Deviation from TLC: MVPerms#permutationSubgroup sizes a util.Set one below the number of permutations, which throws for fewer than two.
142
143
  if (permutedSets.length >= elements.length) {
143
144
  warnSmallSets(permutedSets);
144
145
  return undefined;
@@ -143,6 +143,16 @@ export const SANY_OPERATOR_SYNONYMS = [
143
143
  ["^+", "⁺"],
144
144
  ];
145
145
 
146
+ const SYNONYMS = new Map(
147
+ SANY_OPERATOR_SYNONYMS.flatMap((names) => names.slice(1).map((synonym) => [synonym, names[0]])),
148
+ );
149
+
150
+ export const resolveSynonym = (name: string) =>
151
+ name
152
+ .split("!")
153
+ .map((part) => SYNONYMS.get(part) ?? (part === "~" ? "\\lnot" : part))
154
+ .join("!");
155
+
146
156
  export const TLC_STARTUP_STRINGS = [
147
157
  "STRING",
148
158
  "FALSE",
@@ -345,14 +345,14 @@ interface CodedMessage {
345
345
  let codedMessagePatterns: { pattern: RegExp; message: CodedMessage }[] | undefined;
346
346
 
347
347
  const getCodedMessagePatterns = () =>
348
- (codedMessagePatterns ??= CODED_MESSAGES.map(([code, template, isEvalException]) => ({
348
+ (codedMessagePatterns ??= CODED_MESSAGES.map((codedMessage) => ({
349
349
  pattern: new RegExp(
350
- `^${template
350
+ `^${codedMessage[1]
351
351
  .split(/%\d+%/)
352
352
  .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
353
353
  .join("[\\s\\S]*")}$`,
354
354
  ),
355
- message: { code, isEvalException },
355
+ message: { code: codedMessage[0], isEvalException: codedMessage[2] },
356
356
  })));
357
357
 
358
358
  const UNCODED_MESSAGE_PATTERN =
package/src/tlc/order.ts CHANGED
@@ -444,7 +444,11 @@ const createContexts = (getParsed: ModuleSet) => {
444
444
  };
445
445
  };
446
446
 
447
- const getStringOrder = (getParsed: ModuleSet, config: ModelConfig): string[] => {
447
+ const getStringOrder = (
448
+ getParsed: ModuleSet,
449
+ config: ModelConfig,
450
+ runtimeModules: string[],
451
+ ): string[] => {
448
452
  const order = new Set<string>();
449
453
  const intern = (text: string) => {
450
454
  order.add(text);
@@ -541,12 +545,19 @@ const getStringOrder = (getParsed: ModuleSet, config: ModelConfig): string[] =>
541
545
  });
542
546
  };
543
547
  analyze(undefined);
548
+ runtimeModules.forEach((name) => {
549
+ const tokens = getUnitTokens(name);
550
+ getParsedTexts(tokens).forEach(intern);
551
+ tokens.forEach((token) => {
552
+ if (token.kind === "String") intern(token.text);
553
+ });
554
+ });
544
555
  TLC_RUNTIME_STRINGS.forEach(intern);
545
556
  return [...order];
546
557
  };
547
558
 
548
559
  export interface TlcOrder {
549
- getStringOrder: (config: ModelConfig) => string[];
560
+ getStringOrder: (config: ModelConfig, runtimeModules: string[]) => string[];
550
561
  getDeclarationOrder: (kind: "variable" | "constant") => string[];
551
562
  createDefinitionOrder: () => (name: string | undefined) => string[];
552
563
  parseModule: (source: string) => Module;
@@ -558,7 +569,7 @@ export const createTlcOrder = (source: string, loadModule: ModuleLoader): TlcOrd
558
569
  let contexts: ReturnType<typeof createContexts> | undefined;
559
570
  const getContexts = () => (contexts ??= createContexts(getParsed));
560
571
  return {
561
- getStringOrder: (config) => getStringOrder(getParsed, config),
572
+ getStringOrder: (config, runtimeModules) => getStringOrder(getParsed, config, runtimeModules),
562
573
  getDeclarationOrder: (kind) =>
563
574
  getContexts()
564
575
  .getContext(undefined)
package/src/tlc/random.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import { toEnumeratedSet } from "../builtins";
2
2
  import { TlaEvaluationError } from "../errors";
3
+ import { prettyPrint } from "../pretty-print";
3
4
  import type { TlcVersion } from "./version";
4
5
  import {
5
6
  createRecord,
@@ -226,7 +227,7 @@ export const getRandomElement = (set: Value, random: JavaRandom): Value => {
226
227
  const offset = Math.floor(random.nextDouble() * size);
227
228
  if (offset >= size) {
228
229
  throw new TlaEvaluationError(
229
- `Attempted to retrieve out-of-bounds element from the interval value ${formatValue(set)}.`,
230
+ `Attempted to retrieve out-of-bounds element from the interval value ${prettyPrint(formatValue(set))}.`,
230
231
  );
231
232
  }
232
233
  return set.low + offset;
package/src/tlc/replay.ts CHANGED
@@ -2,8 +2,10 @@ import type { Expression, SourceLocation } from "../ast";
2
2
  import { TlaEvaluationError } from "../errors";
3
3
  import { isConstantLevel } from "../dependencies";
4
4
  import {
5
+ chargeContexts,
6
+ chargeRandomOrder,
5
7
  countCoverage,
6
- costCoverage,
8
+ createChargedEnumerator,
7
9
  getCoverageNode,
8
10
  runAtCoverageNode,
9
11
  type Coverage,
@@ -16,6 +18,7 @@ import {
16
18
  evaluate,
17
19
  forEachBoundElement,
18
20
  freezeCallStack,
21
+ getContextElements,
19
22
  getLazyFunction,
20
23
  getQuantifierElements,
21
24
  mapBoundSets,
@@ -38,7 +41,9 @@ import {
38
41
  type Value,
39
42
  } from "../values";
40
43
  import { substitutionFrames } from "../instances";
44
+ import type { SuccessorGenerator } from "../successors";
41
45
  import { MESSAGE_CODE } from "./messages";
46
+ import { getRandomSubset, nextPrime } from "./random";
42
47
 
43
48
  interface ReplayAction {
44
49
  expression: Expression;
@@ -61,7 +66,8 @@ interface Replay {
61
66
  isEnabled: boolean;
62
67
  current: Value[] | undefined;
63
68
  onState: (state: Value[]) => void;
64
- onIncomplete: ((state: State) => void) | undefined;
69
+ onIncomplete: ((state: State) => boolean) | undefined;
70
+ generator: SuccessorGenerator | undefined;
65
71
  }
66
72
 
67
73
  const withFrame = <Result>(replay: Replay, expression: Expression, run: () => Result): Result => {
@@ -216,8 +222,7 @@ const proceedItems = (
216
222
  ): boolean => {
217
223
  if (items === undefined) {
218
224
  if (isComplete(partial)) return addState(replay, partial, node);
219
- replay.onIncomplete?.(partial);
220
- return false;
225
+ return replay.onIncomplete?.(partial) ?? false;
221
226
  }
222
227
  if (isComplete(partial) && isAssignedShortcut(replay)) {
223
228
  return proceedAssigned(replay, items, partial, node);
@@ -309,16 +314,19 @@ const visitAt = (
309
314
  case "Let": {
310
315
  const context = getContext(replay, scope, partial);
311
316
  const definitions = expression.definitions;
312
- const bound = replay.coverage
313
- ? bindDefinitions(definitions, context, {
314
- impure: new Set(definitions),
315
- streamed: new Set(),
316
- })
317
- : bindDefinitions(definitions, context);
317
+ const bound =
318
+ replay.coverage && !replay.isEnabled
319
+ ? bindDefinitions(definitions, context, {
320
+ impure: new Set(definitions),
321
+ streamed: new Set(),
322
+ })
323
+ : bindDefinitions(definitions, context);
318
324
  return visit(replay, expression.body, items, bound, partial, node);
319
325
  }
320
326
  case "Label":
321
327
  return visit(replay, expression.body, items, scope, partial, node);
328
+ case "Selection":
329
+ return visit(replay, expression.expression, items, scope, partial, node);
322
330
  default:
323
331
  if (LITERAL_KINDS.has(expression.kind))
324
332
  throw new TlaEvaluationError("The state relation is not a boolean expression.");
@@ -434,11 +442,6 @@ const createItem = (
434
442
  rest: ActionItem | undefined,
435
443
  ): ActionItem => ({ kind, expression, scope, node, rest });
436
444
 
437
- const getEnumerated = (replay: Replay, set: Value, elements: Value[]) => {
438
- if (replay.coverage) costCoverage(replay.coverage, set, elements.length + 1);
439
- return elements;
440
- };
441
-
442
445
  const visitAssignment = (
443
446
  replay: Replay,
444
447
  expression: Expression & { kind: "Apply" },
@@ -464,7 +467,10 @@ const visitAssignment = (
464
467
  return proceedWithValue(replay, items, partial, index, value, node);
465
468
  }
466
469
  const set: Value = expression.operator === "\\subseteq" ? { kind: "Subset", base: value } : value;
467
- if (typeof set === "object" && set !== value) replay.callStack?.sources.set(set, source);
470
+ if (typeof set === "object" && set !== value) {
471
+ replay.callStack?.sources.set(set, source);
472
+ replay.coverage?.values.set(set, node);
473
+ }
468
474
  if (assigned !== undefined) {
469
475
  return (
470
476
  evaluateAt(replay, node, expression, context) === true &&
@@ -473,11 +479,23 @@ const visitAssignment = (
473
479
  }
474
480
  if (!isTlcEnumerable(set))
475
481
  throw new TlaEvaluationError("The right side of \\IN is not enumerable.");
476
- return getEnumerated(replay, set, getStreamedElements(set)).reduce<boolean>(
477
- (isProduced, element) =>
478
- proceed(replay, items, assign(partial, index, element), node) || isProduced,
479
- false,
480
- );
482
+ const elements = getStreamedElements(set);
483
+ const generator = replay.generator;
484
+ if (generator) {
485
+ const order = getRandomOrder(replay, set, elements);
486
+ for (let position = 0; position < order.length; position++) {
487
+ const isProduced = proceed(replay, items, assign(partial, index, order[position]), node);
488
+ if (generator.kept > 0) return isProduced;
489
+ }
490
+ }
491
+ const enumerator =
492
+ replay.coverage && createChargedEnumerator(replay.coverage, set, elements, false);
493
+ const isProduced = elements.reduce<boolean>((isProduced, element) => {
494
+ enumerator?.next();
495
+ return proceed(replay, items, assign(partial, index, element), node) || isProduced;
496
+ }, false);
497
+ enumerator?.next();
498
+ return isProduced;
481
499
  };
482
500
 
483
501
  const ASSIGNMENT_OPERATORS = new Set(["=", "\\in", "\\subseteq"]);
@@ -512,6 +530,13 @@ export const getEnabledFailure = (expression: Expression) => {
512
530
  return undefined;
513
531
  };
514
532
 
533
+ const getRandomOrder = (replay: Replay, set: Value, elements: Value[]) => {
534
+ const runtime = replay.environment.runtime;
535
+ const order = getRandomSubset(elements.length, set, runtime.getRandom(), runtime.version);
536
+ if (replay.coverage) chargeRandomOrder(replay.coverage, set, elements.length, order);
537
+ return order;
538
+ };
539
+
515
540
  const getBindings = (
516
541
  replay: Replay,
517
542
  expression: Expression & { kind: "Exists" | "Forall" },
@@ -520,19 +545,26 @@ const getBindings = (
520
545
  ) => {
521
546
  const bindings: (Scope | undefined)[] = [];
522
547
  const version = replay.environment.runtime.version;
523
- const sets = runAt(replay, node, () =>
548
+ const bounded = runAt(replay, node, () =>
524
549
  mapBoundSets(expression.bounds, (set) => {
525
550
  const value = evaluate(set, context);
526
- const elements = getQuantifierElements(value, set, version);
527
- if (Array.isArray(elements)) getEnumerated(replay, value, elements);
528
- return elements;
551
+ return { value, elements: getQuantifierElements(value, set, version) };
529
552
  }),
530
553
  );
554
+ const sets = bounded.map((item) => item.elements);
531
555
  forEachBoundElement(expression.bounds, sets, context.scope, (bound) => {
532
556
  bindings.push(bound);
533
557
  return false;
534
558
  });
535
- return bindings;
559
+ const coverage = replay.coverage;
560
+ const charge =
561
+ coverage &&
562
+ chargeContexts(
563
+ coverage,
564
+ bounded.map((item) => item.value),
565
+ sets,
566
+ );
567
+ return { bindings, charge };
536
568
  };
537
569
 
538
570
  const visitApplication = (
@@ -582,7 +614,39 @@ const visitApplication = (
582
614
  }
583
615
  case "Or": {
584
616
  const operands = expression.operands;
585
- if (expression.isBulleted || operands.length === 2) {
617
+ const isWhole = expression.isBulleted || operands.length === 2;
618
+ const generator = replay.generator;
619
+ if (generator) {
620
+ const count = isWhole ? operands.length : 2;
621
+ const start = Math.floor(generator.random.nextDouble() * count);
622
+ const prime = nextPrime(generator.random);
623
+ let isProduced = false;
624
+ for (let attempt = 0; attempt < count; attempt++) {
625
+ const choice = (start + attempt * prime) % count;
626
+ const isChoiceProduced =
627
+ isWhole || choice === 1
628
+ ? visit(
629
+ replay,
630
+ operands[isWhole ? choice : operands.length - 1],
631
+ items,
632
+ scope,
633
+ partial,
634
+ node,
635
+ )
636
+ : visitAt(
637
+ replay,
638
+ getPrefix(expression, operands.length - 1),
639
+ items,
640
+ scope,
641
+ partial,
642
+ getPrefixNode(replay, node),
643
+ );
644
+ isProduced = isChoiceProduced || isProduced;
645
+ if (generator.kept > 0) return isProduced;
646
+ }
647
+ return isProduced;
648
+ }
649
+ if (isWhole) {
586
650
  return operands.reduce(
587
651
  (isProduced, operand) =>
588
652
  visit(replay, operand, items, scope, partial, node) || isProduced,
@@ -607,14 +671,36 @@ const visitApplication = (
607
671
  );
608
672
  return isPrefixProduced || isLastProduced;
609
673
  }
610
- case "Exists":
611
- return getBindings(replay, expression, context, node).reduce(
612
- (isProduced, bound) =>
613
- visit(replay, expression.body, items, bound, partial, node) || isProduced,
614
- false,
615
- );
674
+ case "Exists": {
675
+ const generator = replay.generator;
676
+ if (generator) {
677
+ const version = replay.environment.runtime.version;
678
+ const orders = runAt(replay, node, () =>
679
+ mapBoundSets(expression.bounds, (set) => evaluate(set, context)),
680
+ ).map((set, position) =>
681
+ getRandomOrder(
682
+ replay,
683
+ set,
684
+ getContextElements(set, expression.bounds[position].set, version),
685
+ ),
686
+ );
687
+ let isProduced = false;
688
+ forEachBoundElement(expression.bounds, orders, context.scope, (bound) => {
689
+ isProduced = visit(replay, expression.body, items, bound, partial, node) || isProduced;
690
+ return generator.kept > 0;
691
+ });
692
+ return isProduced;
693
+ }
694
+ const bound = getBindings(replay, expression, context, node);
695
+ return bound.bindings.reduce((isProduced, scope) => {
696
+ bound.charge?.();
697
+ return visit(replay, expression.body, items, scope, partial, node) || isProduced;
698
+ }, false);
699
+ }
616
700
  case "Forall": {
617
- const bounds = getBindings(replay, expression, context, node);
701
+ const bound = getBindings(replay, expression, context, node);
702
+ const bounds = bound.bindings;
703
+ bounds.forEach(() => bound.charge?.());
618
704
  if (bounds.length === 0) return proceed(replay, items, partial, node);
619
705
  const rest = bounds
620
706
  .slice(1)
@@ -715,6 +801,7 @@ const visitUnchanged = (
715
801
  if (index !== undefined) {
716
802
  const value = replay.current?.[index];
717
803
  if (value === undefined) return false;
804
+ if (replay.isEnabled && replay.coverage) countCoverage(replay.coverage, node);
718
805
  const assigned = partial[index];
719
806
  if (assigned !== undefined && !isEqualLikeTlc(assigned, value)) {
720
807
  warnChangedUnchanged(replay.environment, index, expression);
@@ -779,16 +866,19 @@ const createReplay = (
779
866
  kind: "init" | "next" | "enabled",
780
867
  current: Value[] | undefined,
781
868
  onState: (state: Value[]) => void,
782
- onIncomplete?: (state: State) => void,
869
+ onIncomplete?: (state: State) => boolean,
870
+ generator?: SuccessorGenerator,
783
871
  ): Replay => ({
784
872
  environment,
785
873
  callStack: environment.callStack,
786
- coverage: environment.coverage,
874
+ coverage:
875
+ kind === "enabled" && environment.coverage?.current === -1 ? undefined : environment.coverage,
787
876
  isInit: kind === "init",
788
877
  isEnabled: kind === "enabled",
789
878
  current,
790
879
  onState,
791
880
  onIncomplete,
881
+ generator,
792
882
  });
793
883
 
794
884
  const ENABLED_FOUND = new Error("The replay found a successor");
@@ -799,17 +889,19 @@ export const replayEnabled = (
799
889
  state: Value[],
800
890
  environment: Environment,
801
891
  ) => {
802
- const replay = createReplay(environment, "enabled", state, () => {
892
+ const found = () => {
803
893
  throw ENABLED_FOUND;
804
- });
894
+ };
895
+ const node = environment.coverage?.current ?? -1;
896
+ const replay = createReplay(environment, "enabled", state, found, found);
805
897
  const callStack = replay.callStack;
806
898
  const depth = callStack?.expressions.length ?? 0;
807
899
  try {
808
900
  if (expression.kind === "AngleAction" && expression.location === expression.action.location) {
809
- const changed = createItem("Changed", expression.subscript, scope, -1, undefined);
810
- visit(replay, expression.action, changed, scope, getEmptyState(environment), -1);
901
+ const changed = createItem("Changed", expression.subscript, scope, node, undefined);
902
+ visit(replay, expression.action, changed, scope, getEmptyState(environment), node);
811
903
  } else {
812
- visit(replay, expression, undefined, scope, getEmptyState(environment), -1);
904
+ visit(replay, expression, undefined, scope, getEmptyState(environment), node);
813
905
  }
814
906
  return false;
815
907
  } catch (error) {
@@ -826,7 +918,7 @@ export const replayInitialStates = (
826
918
  inits: (ReplayAction & { node?: number })[],
827
919
  environment: Environment,
828
920
  onState: (state: Value[]) => void,
829
- onIncomplete?: (state: State) => void,
921
+ onIncomplete?: (state: State) => boolean,
830
922
  ) => {
831
923
  const [first, ...others] = inits;
832
924
  if (first === undefined) return;
@@ -838,16 +930,21 @@ export const replayInitialStates = (
838
930
  visit(replay, first.expression, rest, first.scope, getEmptyState(environment), first.node ?? -1);
839
931
  };
840
932
 
841
- export const replaySuccessors = <Action extends ReplayAction>(
933
+ export const replaySuccessors = <Action extends ReplayAction & { node?: number }>(
842
934
  actions: Action[],
843
935
  state: Value[],
844
936
  environment: Environment,
845
937
  onState: (state: Value[], action: Action) => void,
846
938
  ) => {
847
939
  if (actions.some((action) => LITERAL_KINDS.has(action.expression.kind))) return;
940
+ const coverage = environment.coverage;
848
941
  actions.forEach((action) => {
849
942
  const successors: Value[][] = [];
850
- walkSuccessors(action, -1, state, environment, (next) => successors.push(next));
943
+ const node = action.node ?? -1;
944
+ walkSuccessors(action, node, state, environment, (next) => {
945
+ if (coverage && node !== -1) coverage.primary[node]++;
946
+ successors.push(next);
947
+ });
851
948
  successors.forEach((successor) => onState(successor, action));
852
949
  });
853
950
  };
@@ -858,9 +955,10 @@ export const walkSuccessors = (
858
955
  state: Value[],
859
956
  environment: Environment,
860
957
  onState: (state: Value[]) => void,
861
- onIncomplete?: (state: State) => void,
958
+ onIncomplete?: (state: State) => boolean,
959
+ generator?: SuccessorGenerator,
862
960
  ) => {
863
- const replay = createReplay(environment, "next", state, onState, onIncomplete);
961
+ const replay = createReplay(environment, "next", state, onState, onIncomplete, generator);
864
962
  visit(replay, action.expression, undefined, action.scope, getEmptyState(environment), node);
865
963
  };
866
964
 
@@ -907,6 +1005,9 @@ export const getPrimedRanges = (actions: ReplayAction[], environment: Environmen
907
1005
  case "Label":
908
1006
  collect(expression.body, scope, visited);
909
1007
  return;
1008
+ case "Selection":
1009
+ collect(expression.expression, scope, visited);
1010
+ return;
910
1011
  case "FunctionApplication":
911
1012
  collect(expression.function, scope, visited);
912
1013
  return;