tla-ts 0.0.10-dev.09e53c2a6 → 0.0.10-dev.1ebc153bd

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 (214) 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 +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +2 -1
  7. package/dist/index.d.ts +2 -1
  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 +43 -43
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +33 -35
  16. package/dist/run.js +44 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +43 -43
  20. package/dist/transfer.js +38 -38
  21. package/dist/worker.cjs +6 -6
  22. package/dist/worker.js +6 -6
  23. package/package.json +1 -1
  24. package/src/ast.ts +1 -0
  25. package/src/bags.ts +46 -28
  26. package/src/check-trace.ts +2 -16
  27. package/src/check.ts +152 -64
  28. package/src/cli/runtime-invariants.ts +20 -56
  29. package/src/cli/tlc-arguments.ts +2 -2
  30. package/src/cli/tlc-output.ts +1 -2
  31. package/src/cli/tlc.ts +13 -8
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +9 -5
  34. package/src/dependencies.ts +49 -9
  35. package/src/dfid.ts +9 -2
  36. package/src/environment.ts +57 -33
  37. package/src/errors.ts +7 -0
  38. package/src/evaluate.ts +92 -32
  39. package/src/exit-codes.ts +4 -2
  40. package/src/instances.ts +5 -5
  41. package/src/java-overrides.ts +2 -2
  42. package/src/levels.ts +138 -90
  43. package/src/liveness-checker.ts +43 -4
  44. package/src/liveness.ts +1 -1
  45. package/src/obligations/index.ts +1 -1
  46. package/src/obligations/normalize.ts +1 -4
  47. package/src/obligations/printer.ts +5 -5
  48. package/src/parallel-worker.ts +8 -2
  49. package/src/parallel.ts +5 -0
  50. package/src/parser.ts +106 -144
  51. package/src/prover/isabelle/isar/attrib.ts +4 -4
  52. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  53. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  54. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  55. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  56. package/src/prover/isabelle/pure/term.ts +3 -3
  57. package/src/prover/prep/md5.ts +26 -29
  58. package/src/prover/smt/rewrite.ts +2 -7
  59. package/src/prover/smt/simplify.ts +1 -1
  60. package/src/prover/smt/solver/asserted-formulas.ts +66 -1
  61. package/src/prover/smt/solver/ast-lt.ts +1 -1
  62. package/src/prover/smt/solver/ast.ts +58 -11
  63. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  64. package/src/prover/smt/solver/bound-simplifier.ts +2 -3
  65. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  66. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  67. package/src/prover/smt/solver/card2bv.ts +3 -5
  68. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +2 -3
  69. package/src/prover/smt/solver/context.ts +24 -3
  70. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  71. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  72. package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
  73. package/src/prover/smt/solver/diff-neq.ts +1 -2
  74. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  75. package/src/prover/smt/solver/elim-uncnstr.ts +4 -7
  76. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  77. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  78. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  79. package/src/prover/smt/solver/euf/egraph.ts +4 -10
  80. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  81. package/src/prover/smt/solver/euf/mam.ts +1 -5
  82. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  83. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  84. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  85. package/src/prover/smt/solver/factor.ts +36 -14
  86. package/src/prover/smt/solver/fd-solver.ts +2 -0
  87. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  88. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  89. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  90. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  91. package/src/prover/smt/solver/goal.ts +6 -3
  92. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  93. package/src/prover/smt/solver/hashtable.ts +4 -0
  94. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  95. package/src/prover/smt/solver/lp/containers.ts +7 -1
  96. package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
  97. package/src/prover/smt/solver/lp/lp-settings.ts +1 -1
  98. package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
  99. package/src/prover/smt/solver/lp/nex.ts +2 -1
  100. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  101. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  102. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  103. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  104. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  105. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  106. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  107. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  108. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  109. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  110. package/src/prover/smt/solver/model-generator.ts +3 -1
  111. package/src/prover/smt/solver/mpf.ts +2 -4
  112. package/src/prover/smt/solver/mus.ts +2 -3
  113. package/src/prover/smt/solver/muz/dl-context.ts +10 -4
  114. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  115. package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
  116. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  117. package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
  118. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  119. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  120. package/src/prover/smt/solver/nlqsat.ts +1 -1
  121. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  122. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  123. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  124. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  125. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  126. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  127. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  128. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  129. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  130. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  131. package/src/prover/smt/solver/nnf.ts +6 -2
  132. package/src/prover/smt/solver/opt-context.ts +9 -3
  133. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  134. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  135. package/src/prover/smt/solver/opt-solver.ts +6 -3
  136. package/src/prover/smt/solver/optsmt.ts +1 -1
  137. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  138. package/src/prover/smt/solver/poly-rewriter.ts +74 -18
  139. package/src/prover/smt/solver/probes.ts +88 -23
  140. package/src/prover/smt/solver/proto-model.ts +4 -6
  141. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  142. package/src/prover/smt/solver/qe-lite.ts +2 -2
  143. package/src/prover/smt/solver/qe.ts +3 -2
  144. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  145. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  146. package/src/prover/smt/solver/rlimit.ts +4 -0
  147. package/src/prover/smt/solver/sat/config.ts +1 -1
  148. package/src/prover/smt/solver/sat/inc-sat-solver.ts +26 -1
  149. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  150. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  151. package/src/prover/smt/solver/sat/sat-tactic.ts +4 -3
  152. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  153. package/src/prover/smt/solver/sat/solver.ts +25 -47
  154. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  155. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  156. package/src/prover/smt/solver/seq-derive.ts +4 -7
  157. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  158. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  159. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  160. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  161. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  162. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  163. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  164. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  165. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  166. package/src/prover/smt/solver/smt-kernel.ts +9 -3
  167. package/src/prover/smt/solver/smt-setup.ts +68 -6
  168. package/src/prover/smt/solver/smtlib-parser.ts +558 -220
  169. package/src/prover/smt/solver/smtlib-script.ts +495 -153
  170. package/src/prover/smt/solver/solve-eqs.ts +13 -21
  171. package/src/prover/smt/solver/tactic.ts +219 -130
  172. package/src/prover/smt/solver/theory-bv.ts +2 -2
  173. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -1
  174. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
  175. package/src/prover/smt/solver/theory-lra-propagate.ts +6 -4
  176. package/src/prover/smt/solver/theory-lra.ts +0 -1
  177. package/src/prover/smt/solver/theory-pb.ts +24 -7
  178. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  179. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  180. package/src/prover/tlapm/cache.ts +8 -8
  181. package/src/prover/zenon/equality-rules.ts +24 -0
  182. package/src/prover/zenon/expr.ts +21 -0
  183. package/src/prover/zenon/index-table.ts +7 -2
  184. package/src/prover/zenon/isar-case.ts +1 -1
  185. package/src/prover/zenon/isar.ts +2 -2
  186. package/src/prover/zenon/phrase.ts +1 -1
  187. package/src/prover/zenon/rules.ts +2 -1
  188. package/src/resolve.ts +624 -187
  189. package/src/runtime.ts +3 -1
  190. package/src/sany/builtins.ts +10 -10
  191. package/src/sany/generation.ts +2 -13
  192. package/src/sany/generator-definitions.ts +3 -1
  193. package/src/sany/generator-expressions.ts +36 -30
  194. package/src/sany/generator-proofs.ts +5 -3
  195. package/src/sany/generator.ts +2 -1
  196. package/src/sany/lexer.ts +3 -3
  197. package/src/sany/modules.ts +4 -2
  198. package/src/sany/nodes.ts +1 -1
  199. package/src/sany/selectors.ts +11 -6
  200. package/src/sany/xml.ts +2 -3
  201. package/src/search.ts +51 -22
  202. package/src/spec-description.ts +2 -2
  203. package/src/subexpressions.ts +265 -94
  204. package/src/successors.ts +1 -0
  205. package/src/symmetry.ts +1 -1
  206. package/src/tlc/jar-data.ts +10 -0
  207. package/src/tlc/messages.ts +3 -3
  208. package/src/tlc/order.ts +14 -3
  209. package/src/tlc/tlc-operators.ts +3 -1
  210. package/src/tlc/tlcext-operators.ts +18 -5
  211. package/src/tlc/trace-spec.ts +5 -5
  212. package/src/typed-tier.ts +29 -23
  213. package/src/typescript/types.ts +2 -2
  214. package/src/values.ts +46 -27
@@ -29,6 +29,7 @@ const VARIABLE_LEVEL_FLAGS = 32;
29
29
  const ACTION_LEVEL_FLAGS = VARIABLE_LEVEL_FLAGS | 64;
30
30
  const TEMPORAL_LEVEL_FLAGS = ACTION_LEVEL_FLAGS | 128;
31
31
  const RANDOM = 256;
32
+ const ABOVE_CONSTANT_BOUND = 512;
32
33
 
33
34
  const ACTION_KINDS = new Set<Expression["kind"]>([
34
35
  "Prime",
@@ -80,6 +81,7 @@ interface Edge {
80
81
  callee: Definition;
81
82
  isOverridden: boolean;
82
83
  isLevelCounted: boolean;
84
+ isOperatorArgument: boolean;
83
85
  }
84
86
 
85
87
  const collectLocalFacts = (
@@ -104,20 +106,27 @@ const collectLocalFacts = (
104
106
  }
105
107
  return undefined;
106
108
  };
107
- const visit = (node: Expression, isLevelCounted: boolean) => {
109
+ const visit = (node: Expression, isLevelCounted: boolean, isOperatorArgument: boolean) => {
108
110
  const kind = node.kind;
111
+ // TLC's getLevelBound takes an operator argument for a constant.
112
+ const nonconstantFlags = isOperatorArgument ? NONCONSTANT : NONCONSTANT | ABOVE_CONSTANT_BOUND;
109
113
  if (
110
114
  NONCONSTANT_KINDS.has(kind) ||
111
115
  (kind === "UnboundedQuantifier" && node.isTemporal === true) ||
112
116
  (kind === "Apply" && NONCONSTANT_OPERATORS.has(node.operator))
113
117
  ) {
114
- row[0] |= NONCONSTANT;
118
+ row[0] |= nonconstantFlags;
115
119
  }
116
120
  if (NONCONSTANT_KINDS.has(kind)) row[0] |= READS_IMPURE;
117
121
  const ownLevelFlags = getOwnLevelFlags(node);
118
122
  if (isLevelCounted && ownLevelFlags !== undefined) row[0] |= ownLevelFlags;
119
123
  const isInnerLevelCounted = isLevelCounted && ownLevelFlags === undefined;
120
124
  const name = getReferencedName(node);
125
+ // TLC's getLevelBound takes a parameter named like a variable for that variable.
126
+ if (name !== undefined && isLocallyResolved(node) && environment.variableIndex.has(name)) {
127
+ if (!isOperatorArgument) row[0] |= ABOVE_CONSTANT_BOUND;
128
+ if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
129
+ }
121
130
  if (name !== undefined && !isLocallyResolved(node)) {
122
131
  const target = environment.substitutions.get(name) ?? name;
123
132
  const definition = environment.definitions.get(target);
@@ -128,14 +137,24 @@ const collectLocalFacts = (
128
137
  environment.builtins.get(name)?.isStateLevel ||
129
138
  (definition && environment.variableIndex.has(definition.name))
130
139
  ) {
131
- row[0] |= NONCONSTANT;
140
+ row[0] |= nonconstantFlags;
132
141
  }
133
142
  if (variableIndex !== undefined) {
134
143
  if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
135
144
  if (!isOverridden) row[1 + (variableIndex >>> 5)] |= 1 << (variableIndex & 31);
136
145
  }
137
146
  if (definition) {
138
- edges.push({ callee: definition, isOverridden, isLevelCounted: isInnerLevelCounted });
147
+ edges.push({
148
+ callee: definition,
149
+ isOverridden,
150
+ isLevelCounted: isInnerLevelCounted,
151
+ isOperatorArgument:
152
+ isOperatorArgument ||
153
+ kind === "OperatorReference" ||
154
+ (kind === "Identifier" &&
155
+ definition.kind === "Operator" &&
156
+ definition.params.length > 0),
157
+ });
139
158
  } else {
140
159
  if (isImpureBuiltin(name, environment)) {
141
160
  row[0] |= IMPURE | (name === "Assert" ? 0 : REPEATED_EFFECT);
@@ -155,9 +174,11 @@ const collectLocalFacts = (
155
174
  }
156
175
  }
157
176
  }
158
- getChildren(node).forEach((child) => visit(child, isInnerLevelCounted));
177
+ getChildren(node).forEach((child) =>
178
+ visit(child, isInnerLevelCounted, isOperatorArgument || kind === "Lambda"),
179
+ );
159
180
  };
160
- expressions.forEach((expression) => visit(expression, true));
181
+ expressions.forEach((expression) => visit(expression, true, false));
161
182
  return { row, edges };
162
183
  };
163
184
 
@@ -230,9 +251,10 @@ const closeRows = (local: Uint32Array, words: number, edges: Int32Array[], mask:
230
251
 
231
252
  const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM;
232
253
  const READ_MASK = NONCONSTANT | READS_IMPURE;
254
+ const STARTUP_MASK = NONCONSTANT | ABOVE_CONSTANT_BOUND;
233
255
 
234
256
  const isEvaluatedOnce = (definition: Definition, flags: number) =>
235
- definition.kind === "Operator" && definition.params.length === 0 && (flags & NONCONSTANT) === 0;
257
+ definition.kind === "Operator" && definition.params.length === 0 && (flags & STARTUP_MASK) === 0;
236
258
 
237
259
  export const createDefinitionFacts = (environment: DefinitionNames): DefinitionFacts => {
238
260
  const definitions = [...new Set(environment.definitions.values())];
@@ -256,18 +278,32 @@ export const createDefinitionFacts = (environment: DefinitionNames): DefinitionF
256
278
  new Int32Array(own.filter((edge) => !edge.isOverridden && edge.isLevelCounted).map(getId)),
257
279
  );
258
280
  const levels = closeRows(local, words, levelEdges, TEMPORAL_LEVEL_FLAGS);
281
+ const startupEdges = edges.map(
282
+ (own) =>
283
+ new Int32Array(
284
+ own.filter((edge) => !edge.isOverridden && !edge.isOperatorArgument).map(getId),
285
+ ),
286
+ );
287
+ const startup = closeRows(local, words, startupEdges, ABOVE_CONSTANT_BOUND);
259
288
  const purityEdges = edges.map(
260
289
  (own) =>
261
290
  new Int32Array(
262
291
  own
263
292
  .map(getId)
264
- .filter((callee) => !isEvaluatedOnce(definitions[callee], reads[callee * words])),
293
+ .filter(
294
+ (callee) =>
295
+ !isEvaluatedOnce(
296
+ definitions[callee],
297
+ reads[callee * words] | startup[callee * words],
298
+ ),
299
+ ),
265
300
  ),
266
301
  );
267
302
  const purity = closeRows(localImpurity, words, purityEdges, PURITY_MASK);
268
303
  const rows = reads.map((word, position) =>
269
304
  position % words === 0
270
305
  ? (word & READ_MASK) |
306
+ (startup[position] & ABOVE_CONSTANT_BOUND) |
271
307
  (levels[position] & TEMPORAL_LEVEL_FLAGS) |
272
308
  (purity[position] & PURITY_MASK)
273
309
  : word,
@@ -291,6 +327,7 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
291
327
  const callee = getRow(edge.callee, environment);
292
328
  if (!edge.isOverridden) {
293
329
  row[0] |= callee[0] & READ_MASK;
330
+ if (!edge.isOperatorArgument) row[0] |= callee[0] & ABOVE_CONSTANT_BOUND;
294
331
  if (edge.isLevelCounted) row[0] |= callee[0] & TEMPORAL_LEVEL_FLAGS;
295
332
  for (let word = 1; word < words; word++) row[word] |= callee[word];
296
333
  }
@@ -300,7 +337,10 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
300
337
  };
301
338
 
302
339
  export const isConstantLevel = (definition: Definition, environment: Environment) =>
303
- (getRow(definition, environment)[0] & NONCONSTANT) === 0;
340
+ (getRow(definition, environment)[0] & STARTUP_MASK) === 0;
341
+
342
+ export const isEvaluatedAtStartup = (definition: Definition, environment: Environment) =>
343
+ (getRow(definition, environment)[0] & ABOVE_CONSTANT_BOUND) === 0;
304
344
 
305
345
  const EFFECT_FLAGS = {
306
346
  any: IMPURE,
package/src/dfid.ts CHANGED
@@ -15,7 +15,7 @@ import { EXIT_STATUS, getMessageExitStatus, withLivenessExitCode } from "./exit-
15
15
  import { createLivenessChecker } from "./liveness-checker";
16
16
  import { getIncompleteSuccessorMessage, prepareSearch, reportAssumptionViolation } from "./search";
17
17
  import type { SpecAction } from "./spec-description";
18
- import { forEachInitialState, forEachSuccessor } from "./successors";
18
+ import { forEachInitialState, forEachSuccessor, getSuccessors } from "./successors";
19
19
  import {
20
20
  formatNestedMessage,
21
21
  formatTlcDate,
@@ -28,7 +28,7 @@ import {
28
28
  import { getTlcFingerprint } from "./tlc/fingerprint";
29
29
  import { replaySuccessors } from "./tlc/replay";
30
30
  import { getOptimisticProbability, getActualProbability } from "./tlc/summary";
31
- import { createModelValue, formatState, getSetBound, type Value } from "./values";
31
+ import { createModelValue, formatState, getSetBound, isSameValue, type Value } from "./values";
32
32
 
33
33
  export interface DepthFirstOptions extends CheckOptions {
34
34
  maxDepth: number;
@@ -165,6 +165,13 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
165
165
  if (assumptionStatus !== undefined) return assumptionStatus;
166
166
 
167
167
  const nextActions = prepared.getDescription().actions;
168
+ // Deviation from TLC: TLCExt#pickSuccessor casts the DFID checker to ModelChecker and fails, so tla-ts asks as model checking does.
169
+ runtime.getSuccessorAction = (state, next) =>
170
+ nextActions.find((action) =>
171
+ getSuccessors(action.expression, state, environment, action.scope).some((successor) =>
172
+ successor.state.every((value, index) => isSameValue(value, next[index])),
173
+ ),
174
+ );
168
175
  const statuses = new Map<bigint, number>();
169
176
  const fingerprintSet = { level: 1, leveled: 0, buckets: INITIAL_BUCKETS };
170
177
  const setStatus = (fingerprint: bigint, status: number) => {
@@ -100,6 +100,12 @@ interface EnvironmentOptions {
100
100
  version?: TlcVersion;
101
101
  moduleOperators?: ModuleOperator[];
102
102
  readLine?: () => string | undefined;
103
+ runtimeInvariants?: RuntimeInvariant[];
104
+ }
105
+
106
+ export interface RuntimeInvariant {
107
+ name: string;
108
+ module: string | undefined;
103
109
  }
104
110
 
105
111
  export interface ResolvedModuleOperator extends ModuleOperator {
@@ -114,6 +120,7 @@ export interface Specification {
114
120
  startupDefinitions: Definition[];
115
121
  javaOverrides: JavaOverride[];
116
122
  moduleOperators: ResolvedModuleOperator[];
123
+ runtimeInvariants: RuntimeInvariant[];
117
124
  rootName: string;
118
125
  }
119
126
 
@@ -498,7 +505,7 @@ export const createEnvironment = (
498
505
  const instantiation = createInstantiation({
499
506
  params,
500
507
  substitutions: new Map(
501
- [...substitutions].map(([name, expression]) => [name, renameLocals(expression, renamed)]),
508
+ [...substitutions].map((entry) => [entry[0], renameLocals(entry[1], renamed)]),
502
509
  ),
503
510
  variables: new Set(linked.variables),
504
511
  getDefinition: (key) => definitions.get(key),
@@ -541,9 +548,14 @@ export const createEnvironment = (
541
548
  instance.name === undefined
542
549
  ? standardSymbols
543
550
  : new Map(
544
- [...standardSymbols].map(([name, symbol]) => [
545
- `${instance.name}!${name}`,
546
- { key: symbol.key, arity: symbol.arity, params: symbol.params, kind: symbol.kind },
551
+ [...standardSymbols].map((entry) => [
552
+ `${instance.name}!${entry[0]}`,
553
+ {
554
+ key: entry[1].key,
555
+ arity: entry[1].arity,
556
+ params: entry[1].params,
557
+ kind: entry[1].kind,
558
+ },
547
559
  ]),
548
560
  );
549
561
 
@@ -556,32 +568,34 @@ export const createEnvironment = (
556
568
  const declared = new Set(declarations.map((declaration) => declaration.name));
557
569
  return new Map(
558
570
  [...exported]
559
- .filter(([name]) => !declared.has(name))
560
- .map(([name, symbol]): [string, ModuleSymbol] => {
571
+ .filter((entry) => !declared.has(entry[0]))
572
+ .map((entry): [string, ModuleSymbol] => {
561
573
  if (instance.name === undefined) {
562
574
  return [
563
- name,
575
+ entry[0],
564
576
  {
565
- key: getKey(symbol.key, name),
566
- arity: symbol.arity,
567
- params: symbol.params,
568
- kind: symbol.kind,
577
+ key: getKey(entry[1].key, entry[0]),
578
+ arity: entry[1].arity,
579
+ params: entry[1].params,
580
+ kind: entry[1].kind,
569
581
  range:
570
- parameterized.get(symbol.key) === true ? instance.location.range : symbol.range,
582
+ parameterized.get(entry[1].key) === true
583
+ ? instance.location.range
584
+ : entry[1].range,
571
585
  },
572
586
  ];
573
587
  }
574
- const qualified = `${instance.name}!${name}`;
588
+ const qualified = `${instance.name}!${entry[0]}`;
575
589
  return [
576
590
  qualified,
577
591
  {
578
- key: getKey(symbol.key, qualified),
579
- arity: symbol.arity + instance.params.length,
580
- params: symbol.params && [
592
+ key: getKey(entry[1].key, qualified),
593
+ arity: entry[1].arity + instance.params.length,
594
+ params: entry[1].params && [
581
595
  ...instance.params.map((param) => param.arity),
582
- ...symbol.params,
596
+ ...entry[1].params,
583
597
  ],
584
- kind: symbol.kind,
598
+ kind: entry[1].kind,
585
599
  },
586
600
  ];
587
601
  }),
@@ -629,11 +643,11 @@ export const createEnvironment = (
629
643
  const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
630
644
  if (standardSymbols) {
631
645
  if (instance.name === undefined) return [];
632
- return [...standardSymbols].map(([name, symbol]) => {
633
- const forwarded = createArgumentParams(symbol.arity, symbol.params);
646
+ return [...standardSymbols].map((entry) => {
647
+ const forwarded = createArgumentParams(entry[1].arity, entry[1].params);
634
648
  return createLocalAlias(
635
- `${instance.name}!${name}`,
636
- symbol.key,
649
+ `${instance.name}!${entry[0]}`,
650
+ entry[1].key,
637
651
  [...instance.params, ...forwarded],
638
652
  forwarded,
639
653
  location,
@@ -714,16 +728,16 @@ export const createEnvironment = (
714
728
  });
715
729
  const declared = new Set(declarations.map((declaration) => declaration.name));
716
730
  const aliases = [...linked.exported]
717
- .filter(([name]) => !declared.has(name))
718
- .map(([name, symbol]) => {
719
- const key = instantiation.getKey(symbol.key);
720
- const ownParams = createArgumentParams(symbol.arity, symbol.params);
731
+ .filter((entry) => !declared.has(entry[0]))
732
+ .map((entry) => {
733
+ const key = instantiation.getKey(entry[1].key);
734
+ const ownParams = createArgumentParams(entry[1].arity, entry[1].params);
721
735
  const params = [...instance.params, ...ownParams];
722
736
  return createLocalAlias(
723
- instance.name === undefined ? name : `${instance.name}!${name}`,
737
+ instance.name === undefined ? entry[0] : `${instance.name}!${entry[0]}`,
724
738
  key,
725
739
  params,
726
- key === symbol.key ? ownParams : params,
740
+ key === entry[1].key ? ownParams : params,
727
741
  location,
728
742
  );
729
743
  });
@@ -731,9 +745,9 @@ export const createEnvironment = (
731
745
  };
732
746
 
733
747
  const getAvailableDefinitions = (visible: Symbols) =>
734
- [...visible].flatMap(([name, symbol]) => {
735
- const definition = definitions.get(symbol.key);
736
- return definition ? [{ ...definition, name }] : [];
748
+ [...visible].flatMap((entry) => {
749
+ const definition = definitions.get(entry[1].key);
750
+ return definition ? [{ ...definition, name: entry[0] }] : [];
737
751
  });
738
752
 
739
753
  const javaOverrides = new Map<string, JavaOverride[]>();
@@ -902,7 +916,7 @@ export const createEnvironment = (
902
916
  getDefinitionSymbol(definition),
903
917
  ]),
904
918
  ].reduce(
905
- (symbols, [name, symbol]) => (symbols.has(name) ? symbols : symbols.set(name, symbol)),
919
+ (symbols, entry) => (symbols.has(entry[0]) ? symbols : symbols.set(entry[0], entry[1])),
906
920
  new Map(visible),
907
921
  );
908
922
  const linkNested = (nested: Module) => {
@@ -1031,6 +1045,15 @@ export const createEnvironment = (
1031
1045
  );
1032
1046
  linkOrder.push(...linkOrder.splice(linkOrder.indexOf(linkedRoot), 1));
1033
1047
  if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
1048
+ const runtimeInvariants = options.runtimeInvariants ?? [];
1049
+ runtimeInvariants.forEach((invariant) => {
1050
+ if (invariant.module === undefined) return;
1051
+ linkedModules.set(root.name, linkedRoot);
1052
+ const linked = getLinkedModule(invariant.module, root.name);
1053
+ linkOrder.splice(linkOrder.indexOf(linked), 1);
1054
+ const definition = definitions.get(linked.visible.get(invariant.name)?.key ?? invariant.name);
1055
+ if (definition) definitions.set(invariant.name, definition);
1056
+ });
1034
1057
  linkedRoot.visible.forEach((symbol, name) => {
1035
1058
  const definition = definitions.get(symbol.key);
1036
1059
  if (definition && symbol.key !== name) definitions.set(name, definition);
@@ -1057,7 +1080,7 @@ export const createEnvironment = (
1057
1080
  root: linkedRoot,
1058
1081
  moduleSymbols: new Map([
1059
1082
  ...standardExports,
1060
- ...[...linkedModules].map(([name, linked]): [string, Symbols] => [name, linked.visible]),
1083
+ ...[...linkedModules].map((entry): [string, Symbols] => [entry[0], entry[1].visible]),
1061
1084
  [root.name, linkedRoot.visible],
1062
1085
  ]),
1063
1086
  definitions,
@@ -1171,6 +1194,7 @@ export const createEnvironment = (
1171
1194
  ),
1172
1195
  javaOverrides: linkOrder.flatMap((linked) => javaOverrides.get(linked.module.name) ?? []),
1173
1196
  moduleOperators,
1197
+ runtimeInvariants,
1174
1198
  rootName: root.name,
1175
1199
  };
1176
1200
  };
package/src/errors.ts CHANGED
@@ -320,6 +320,13 @@ export class SmtTacticError extends TlaError {
320
320
  }
321
321
  }
322
322
 
323
+ export class SmtDefaultError extends TlaError {
324
+ constructor(message: string) {
325
+ super(message);
326
+ this.name = "SmtDefaultError";
327
+ }
328
+ }
329
+
323
330
  export class SmtInvariantError extends TlaError {
324
331
  constructor(message: string) {
325
332
  super(message);
package/src/evaluate.ts CHANGED
@@ -26,7 +26,7 @@ import { countCoverage, getCoverageNode, runAtCoverageNode, type Coverage } from
26
26
  import { MESSAGE_CODE } from "./tlc/messages";
27
27
  import type { CheckerRuntime } from "./runtime";
28
28
  import {
29
- isConstantLevel,
29
+ isEvaluatedAtStartup,
30
30
  isImpureDefinition,
31
31
  isNonconstant,
32
32
  type DefinitionFacts,
@@ -615,12 +615,16 @@ export const bindLazyArguments = (
615
615
  typeof value.domain === "object" && value.domain.kind === "ProductSet"
616
616
  ? value.domain.factors
617
617
  : [];
618
- // Deviation from TLC: FcnLambdaValue#apply indexes past an argument tuple shorter than the bounds and ignores a longer one.
618
+ if (elements === undefined) {
619
+ throw new TlaEvaluationError(
620
+ `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
621
+ );
622
+ }
623
+ // Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
619
624
  const createListError = () =>
620
625
  new TlaEvaluationError(
621
626
  `In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
622
627
  );
623
- if (elements === undefined) throw createListError();
624
628
  bounds.forEach((bound, index) => {
625
629
  if (index >= elements.length) throw createListError();
626
630
  const element = elements[index];
@@ -669,7 +673,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
669
673
  },
670
674
  ],
671
675
  ),
672
- body: formatRange(range),
676
+ body: describeNode(body),
673
677
  };
674
678
  };
675
679
 
@@ -817,7 +821,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
817
821
  if (definition.kind === "Operator" && definition.params.length > 0) return;
818
822
  const name = definition.name;
819
823
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
820
- if (!isConstantLevel(definition, environment)) return;
824
+ if (!isEvaluatedAtStartup(definition, environment)) return;
821
825
  const definitionId = environment.facts.ids.get(definition);
822
826
  if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
823
827
  const context = { environment, scope: undefined, state: undefined, next: undefined };
@@ -969,6 +973,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
969
973
  return operator !== undefined && getArity(operator) > 0;
970
974
  };
971
975
 
976
+ // Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
972
977
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
973
978
  args.map((arg) =>
974
979
  isOperatorArgument(arg, context)
@@ -1177,7 +1182,9 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1177
1182
  }
1178
1183
  const builtin = context.environment.builtins.get(name);
1179
1184
  if (builtin?.arity === 0) return builtin.evaluate([], context);
1180
- throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
1185
+ throw new TlaEvaluationError(
1186
+ `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
1187
+ );
1181
1188
  };
1182
1189
 
1183
1190
  export const getReevaluatedDefinitions = (
@@ -1329,6 +1336,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
1329
1336
  },
1330
1337
  });
1331
1338
 
1339
+ // TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
1340
+ const compileTracedJunction = (
1341
+ expression: Expression & { kind: "And" | "Or" },
1342
+ operands: Evaluator[],
1343
+ callStack: CallStack | undefined,
1344
+ ): Evaluator | undefined => {
1345
+ const range = expression.location.range;
1346
+ const prefixEnds = expression.prefixEnds;
1347
+ if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
1348
+ return undefined;
1349
+ }
1350
+ const prefixes = prefixEnds
1351
+ .slice(0, operands.length - 2)
1352
+ .map((end) => ({
1353
+ ...expression,
1354
+ location: { ...expression.location, range: { ...range, end } },
1355
+ }))
1356
+ .reverse();
1357
+ const isAnd = expression.kind === "And";
1358
+ return (context) => {
1359
+ callStack.expressions.push(...prefixes);
1360
+ for (let index = 0; index < operands.length; index++) {
1361
+ if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
1362
+ const value = operands[index](context);
1363
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1364
+ if (value !== isAnd) {
1365
+ if (!callStack.isFrozen)
1366
+ callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
1367
+ return value;
1368
+ }
1369
+ }
1370
+ return isAnd;
1371
+ };
1372
+ };
1373
+
1332
1374
  const traceFrames =
1333
1375
  (
1334
1376
  expression: Expression,
@@ -1547,6 +1589,7 @@ const compileApply = (
1547
1589
  return (context) => domain(operand(context));
1548
1590
  }
1549
1591
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1592
+ // Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
1550
1593
  const isCached =
1551
1594
  !contextualApplications.has(expression) && !isNonconstant(args[0], environment);
1552
1595
  return (context) =>
@@ -1864,12 +1907,11 @@ export const getLazyFilter = (
1864
1907
  ) => {
1865
1908
  const predicate = getEvaluator(expression.predicate, environment);
1866
1909
  const pattern = expression.bound.pattern;
1867
- const range = expression.predicate.location.range;
1868
- const source = range && {
1910
+ const predicateNode = describeNode(expression.predicate);
1911
+ const source = expression.predicate.location.range && {
1869
1912
  names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1870
- predicate: formatRange(range),
1913
+ predicate: predicateNode,
1871
1914
  };
1872
- const predicateNode = describeNode(expression.predicate);
1873
1915
  const coverage = environment.coverage;
1874
1916
  const testCovered = (node: number, isMember: boolean, test: () => Value) => {
1875
1917
  if (!coverage || node === -1) return test();
@@ -2035,20 +2077,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
2035
2077
 
2036
2078
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
2037
2079
  const fields = getSortedFields(recordFields);
2038
- const hasDuplicates = hasDuplicateFields(fields);
2039
- const values = fields.map((field) => getEvaluator(field.value, environment));
2040
- if (hasDuplicates) {
2080
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2081
+ if (hasDuplicateFields(fields)) {
2041
2082
  return (context) =>
2042
2083
  createRecord(
2043
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2084
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2044
2085
  );
2045
2086
  }
2046
2087
  const names = fields.map((field) => field.name);
2047
2088
  const writtenNames = recordFields.map((field) => field.name);
2048
2089
  if (writtenNames.some((name, index) => name !== names[index])) {
2090
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
2049
2091
  return (context) =>
2050
2092
  createWrittenRecord(
2051
2093
  names,
2094
+ writtenIndexes,
2052
2095
  values.map((value) => value(context)),
2053
2096
  writtenNames,
2054
2097
  );
@@ -2098,25 +2141,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2098
2141
  };
2099
2142
  case "And": {
2100
2143
  const operands = expression.operands.map(getChildEvaluator);
2101
- return (context) => {
2102
- for (let index = 0; index < operands.length; index++) {
2103
- const value = operands[index](context);
2104
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2105
- if (!value) return false;
2106
- }
2107
- return true;
2108
- };
2144
+ return (
2145
+ compileTracedJunction(expression, operands, environment.callStack) ??
2146
+ ((context) => {
2147
+ for (let index = 0; index < operands.length; index++) {
2148
+ const value = operands[index](context);
2149
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2150
+ if (!value) return false;
2151
+ }
2152
+ return true;
2153
+ })
2154
+ );
2109
2155
  }
2110
2156
  case "Or": {
2111
2157
  const operands = expression.operands.map(getChildEvaluator);
2112
- return (context) => {
2113
- for (let index = 0; index < operands.length; index++) {
2114
- const value = operands[index](context);
2115
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2116
- if (value) return true;
2117
- }
2118
- return false;
2119
- };
2158
+ return (
2159
+ compileTracedJunction(expression, operands, environment.callStack) ??
2160
+ ((context) => {
2161
+ for (let index = 0; index < operands.length; index++) {
2162
+ const value = operands[index](context);
2163
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2164
+ if (value) return true;
2165
+ }
2166
+ return false;
2167
+ })
2168
+ );
2120
2169
  }
2121
2170
  case "Prime": {
2122
2171
  const inner = getChildEvaluator(expression.expression);
@@ -2202,8 +2251,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2202
2251
  case "RecordSet": {
2203
2252
  const fields = getSortedFields(expression.fields);
2204
2253
  const names = fields.map((field) => field.name);
2205
- const sets = fields.map((field) => getChildEvaluator(field.value));
2206
- return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2254
+ const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
2255
+ const sets = expression.fields.map((field) => getChildEvaluator(field.value));
2256
+ if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
2257
+ return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2258
+ }
2259
+ return (context) => {
2260
+ const writtenSets = sets.map((set) => set(context));
2261
+ return {
2262
+ kind: "RecordSet",
2263
+ names,
2264
+ sets: writtenIndexes.map((index) => writtenSets[index]),
2265
+ };
2266
+ };
2207
2267
  }
2208
2268
  case "Except":
2209
2269
  return compileExcept(expression, environment);
package/src/exit-codes.ts CHANGED
@@ -17,13 +17,13 @@ export const EXIT_STATUS = {
17
17
 
18
18
  const MESSAGE_EXIT_STATUSES = new Map<number, number>([
19
19
  ...[
20
- ...Array.from({ length: 24 }, (_, index) => 2222 + index),
20
+ ...Array.from({ length: 24 }, (_value, index) => 2222 + index),
21
21
  2272,
22
22
  2273,
23
23
  2274,
24
24
  2280,
25
25
  2281,
26
- ...Array.from({ length: 7 }, (_, index) => 5001 + index),
26
+ ...Array.from({ length: 7 }, (_value, index) => 5001 + index),
27
27
  ].map((code): [number, number] => [code, EXIT_STATUS.configParseError]),
28
28
  [2253, EXIT_STATUS.livenessEvaluationFailure],
29
29
  [2109, EXIT_STATUS.specEvaluationFailure],
@@ -81,6 +81,8 @@ export const withLivenessExitCode = (
81
81
  withErrorExitCode(() => checker.addInitialState(index, state, tracing)),
82
82
  addState: (index, state, successors, tracing) =>
83
83
  withErrorExitCode(() => checker.addState(index, state, successors, tracing)),
84
+ storeState: checker.storeState,
85
+ getStateCounts: checker.getStateCounts,
84
86
  findViolation: () => withErrorExitCode(() => checker.findViolation()),
85
87
  getViolatedProperties: (path, cycleStart) =>
86
88
  withErrorExitCode(() => checker.getViolatedProperties(path, cycleStart)),
package/src/instances.ts CHANGED
@@ -522,7 +522,7 @@ const getInstanceOperator = (
522
522
  arity: number,
523
523
  location: SourceLocation,
524
524
  ): Expression => {
525
- const names = Array.from({ length: arity }, (_, index) => `argument${index}`);
525
+ const names = Array.from({ length: arity }, (_value, index) => `argument${index}`);
526
526
  return {
527
527
  kind: "Lambda",
528
528
  params: names,
@@ -744,14 +744,14 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
744
744
  ? mapped.body
745
745
  : {
746
746
  kind: "Let",
747
- definitions: [...bindings].map(([name, replacement]): Definition => ({
747
+ definitions: [...bindings].map((entry): Definition => ({
748
748
  kind: "Operator",
749
- name,
749
+ name: entry[0],
750
750
  params: [],
751
- body: replacement,
751
+ body: entry[1],
752
752
  isLocal: true,
753
753
  isRecursive: false,
754
- location: replacement.location,
754
+ location: entry[1].location,
755
755
  })),
756
756
  body: mapped.body,
757
757
  // TLC has no such LET, so the call stack it prints has no position for it.