tla-ts 0.0.10-dev.99796fe03 → 0.0.10-dev.a17d6d9fa

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 (226) 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 +3 -2
  7. package/dist/index.d.ts +3 -2
  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 +60 -60
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -44
  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 +39 -39
  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 +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +1 -1
  28. package/src/check-trace.ts +90 -51
  29. package/src/check.ts +367 -178
  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 +1 -2
  33. package/src/cli/tlc.ts +16 -10
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +26 -9
  36. package/src/dependencies.ts +49 -9
  37. package/src/dfid.ts +22 -10
  38. package/src/environment.ts +58 -33
  39. package/src/errors.ts +7 -0
  40. package/src/evaluate.ts +117 -41
  41. package/src/exit-codes.ts +4 -2
  42. package/src/instances.ts +5 -5
  43. package/src/java-hash.ts +14 -0
  44. package/src/java-overrides.ts +2 -2
  45. package/src/levels.ts +138 -90
  46. package/src/liveness-checker.ts +81 -33
  47. package/src/liveness.ts +49 -11
  48. package/src/obligations/index.ts +1 -1
  49. package/src/obligations/normalize.ts +1 -4
  50. package/src/obligations/printer.ts +5 -5
  51. package/src/parallel-worker.ts +8 -2
  52. package/src/parallel.ts +5 -0
  53. package/src/parser.ts +112 -145
  54. package/src/prover/isabelle/isar/attrib.ts +4 -4
  55. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  56. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  57. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  58. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  59. package/src/prover/isabelle/pure/term.ts +3 -3
  60. package/src/prover/prep/md5.ts +26 -29
  61. package/src/prover/smt/rewrite.ts +2 -7
  62. package/src/prover/smt/simplify.ts +1 -1
  63. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  64. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  65. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  66. package/src/prover/smt/solver/ast-lt.ts +1 -1
  67. package/src/prover/smt/solver/ast.ts +63 -14
  68. package/src/prover/smt/solver/auf-solver.ts +23 -12
  69. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  70. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  71. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  72. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  73. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  74. package/src/prover/smt/solver/card2bv.ts +32 -18
  75. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  76. package/src/prover/smt/solver/context.ts +47 -9
  77. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  78. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  79. package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
  80. package/src/prover/smt/solver/diff-neq.ts +1 -2
  81. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  82. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  83. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  84. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  87. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  88. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  89. package/src/prover/smt/solver/euf/mam.ts +1 -5
  90. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  91. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  92. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  93. package/src/prover/smt/solver/factor.ts +36 -14
  94. package/src/prover/smt/solver/fd-solver.ts +2 -0
  95. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  96. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  97. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  98. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  99. package/src/prover/smt/solver/goal.ts +6 -3
  100. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  101. package/src/prover/smt/solver/hashtable.ts +4 -0
  102. package/src/prover/smt/solver/internalizer.ts +1 -1
  103. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  104. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  105. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  106. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  107. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  108. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  109. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  110. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  111. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  112. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  113. package/src/prover/smt/solver/model-generator.ts +85 -43
  114. package/src/prover/smt/solver/mpf.ts +2 -4
  115. package/src/prover/smt/solver/mus.ts +2 -3
  116. package/src/prover/smt/solver/muz/dl-context.ts +10 -4
  117. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  118. package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
  119. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  120. package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
  121. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  122. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  123. package/src/prover/smt/solver/nlqsat.ts +1 -1
  124. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  125. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  126. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  127. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  128. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  129. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  130. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  131. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  132. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  133. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  134. package/src/prover/smt/solver/nnf.ts +6 -2
  135. package/src/prover/smt/solver/opt-context.ts +20 -7
  136. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  137. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  138. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  139. package/src/prover/smt/solver/opt-solver.ts +9 -5
  140. package/src/prover/smt/solver/optsmt.ts +1 -1
  141. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  142. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  143. package/src/prover/smt/solver/probes.ts +88 -23
  144. package/src/prover/smt/solver/proto-model.ts +8 -8
  145. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  146. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  147. package/src/prover/smt/solver/qe-lite.ts +2 -2
  148. package/src/prover/smt/solver/qe.ts +3 -2
  149. package/src/prover/smt/solver/qsat.ts +16 -6
  150. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  151. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  152. package/src/prover/smt/solver/rewriter.ts +31 -25
  153. package/src/prover/smt/solver/rlimit.ts +4 -0
  154. package/src/prover/smt/solver/sat/config.ts +1 -1
  155. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  156. package/src/prover/smt/solver/sat/inc-sat-solver.ts +39 -5
  157. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  158. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  159. package/src/prover/smt/solver/sat/sat-tactic.ts +13 -5
  160. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  161. package/src/prover/smt/solver/sat/solver.ts +25 -47
  162. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  163. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  164. package/src/prover/smt/solver/seq-derive.ts +2 -2
  165. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  166. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  167. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  168. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  169. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  170. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  171. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  172. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  173. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  174. package/src/prover/smt/solver/smt-kernel.ts +39 -5
  175. package/src/prover/smt/solver/smt-setup.ts +96 -10
  176. package/src/prover/smt/solver/smtlib-parser.ts +584 -223
  177. package/src/prover/smt/solver/smtlib-script.ts +509 -154
  178. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  179. package/src/prover/smt/solver/solver.ts +18 -3
  180. package/src/prover/smt/solver/tactic.ts +284 -168
  181. package/src/prover/smt/solver/theory-bv.ts +13 -3
  182. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  183. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  184. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  185. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  186. package/src/prover/smt/solver/theory-lra.ts +1 -1
  187. package/src/prover/smt/solver/theory-pb.ts +24 -7
  188. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  189. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  190. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  191. package/src/prover/tlapm/cache.ts +8 -8
  192. package/src/prover/zenon/index-table.ts +5 -2
  193. package/src/prover/zenon/isar-case.ts +1 -1
  194. package/src/prover/zenon/isar.ts +2 -2
  195. package/src/prover/zenon/phrase.ts +1 -1
  196. package/src/resolve.ts +959 -243
  197. package/src/runtime.ts +7 -1
  198. package/src/sany/builtins.ts +10 -10
  199. package/src/sany/generation.ts +2 -13
  200. package/src/sany/generator-definitions.ts +3 -1
  201. package/src/sany/generator-expressions.ts +36 -30
  202. package/src/sany/generator-proofs.ts +5 -3
  203. package/src/sany/generator.ts +2 -1
  204. package/src/sany/lexer.ts +3 -3
  205. package/src/sany/modules.ts +4 -2
  206. package/src/sany/nodes.ts +1 -1
  207. package/src/sany/selectors.ts +11 -6
  208. package/src/sany/xml.ts +2 -3
  209. package/src/search.ts +166 -101
  210. package/src/simulate.ts +110 -50
  211. package/src/spec-description.ts +5 -6
  212. package/src/standard-modules.ts +15 -6
  213. package/src/subexpressions.ts +398 -108
  214. package/src/successors.ts +4 -2
  215. package/src/symmetry.ts +1 -1
  216. package/src/tlc/jar-data.ts +10 -0
  217. package/src/tlc/messages.ts +3 -3
  218. package/src/tlc/order.ts +14 -3
  219. package/src/tlc/random.ts +2 -1
  220. package/src/tlc/replay.ts +3 -2
  221. package/src/tlc/tlc-operators.ts +10 -8
  222. package/src/tlc/tlcext-operators.ts +44 -15
  223. package/src/tlc/trace-spec.ts +9 -22
  224. package/src/typed-tier.ts +32 -25
  225. package/src/typescript/types.ts +2 -2
  226. package/src/values.ts +135 -78
@@ -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,
@@ -1108,6 +1131,7 @@ export const createEnvironment = (
1108
1131
  variableIndex,
1109
1132
  facts,
1110
1133
  startupValues: Array.from({ length: facts.ids.size }, (): Value | undefined => undefined),
1134
+ tlcEvalValues: new WeakMap(),
1111
1135
  substitutedDefinitions,
1112
1136
  instanceParams,
1113
1137
  evaluators: new WeakMap(),
@@ -1171,6 +1195,7 @@ export const createEnvironment = (
1171
1195
  ),
1172
1196
  javaOverrides: linkOrder.flatMap((linked) => javaOverrides.get(linked.module.name) ?? []),
1173
1197
  moduleOperators,
1198
+ runtimeInvariants,
1174
1199
  rootName: root.name,
1175
1200
  };
1176
1201
  };
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,
@@ -152,6 +152,7 @@ export interface Environment {
152
152
  variableIndex: Map<string, number>;
153
153
  facts: DefinitionFacts;
154
154
  startupValues: (Value | undefined)[];
155
+ tlcEvalValues: WeakMap<Expression, Value>;
155
156
  substitutedDefinitions: Set<Definition>;
156
157
  instanceParams: Set<OperatorParam>;
157
158
  evaluators: WeakMap<Expression, Evaluator>;
@@ -523,10 +524,13 @@ const someElement = (
523
524
  return false;
524
525
  };
525
526
 
526
- export const mapBoundSets = <Result>(bounds: Bound[], map: (set: Expression) => Result) =>
527
+ export const mapBoundSets = <Result>(
528
+ bounds: Bound[],
529
+ map: (set: Expression, index: number) => Result,
530
+ ) =>
527
531
  bounds.reduce<Result[]>((results, bound, index) => {
528
532
  results.push(
529
- index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set),
533
+ index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
530
534
  );
531
535
  return results;
532
536
  }, []);
@@ -615,12 +619,16 @@ export const bindLazyArguments = (
615
619
  typeof value.domain === "object" && value.domain.kind === "ProductSet"
616
620
  ? value.domain.factors
617
621
  : [];
618
- // Deviation from TLC: FcnLambdaValue#apply indexes past an argument tuple shorter than the bounds and ignores a longer one.
622
+ if (elements === undefined) {
623
+ throw new TlaEvaluationError(
624
+ `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
625
+ );
626
+ }
627
+ // Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
619
628
  const createListError = () =>
620
629
  new TlaEvaluationError(
621
630
  `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
631
  );
623
- if (elements === undefined) throw createListError();
624
632
  bounds.forEach((bound, index) => {
625
633
  if (index >= elements.length) throw createListError();
626
634
  const element = elements[index];
@@ -669,7 +677,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
669
677
  },
670
678
  ],
671
679
  ),
672
- body: formatRange(range),
680
+ body: describeNode(body),
673
681
  };
674
682
  };
675
683
 
@@ -817,7 +825,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
817
825
  if (definition.kind === "Operator" && definition.params.length > 0) return;
818
826
  const name = definition.name;
819
827
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
820
- if (!isConstantLevel(definition, environment)) return;
828
+ if (!isEvaluatedAtStartup(definition, environment)) return;
821
829
  const definitionId = environment.facts.ids.get(definition);
822
830
  if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
823
831
  const context = { environment, scope: undefined, state: undefined, next: undefined };
@@ -969,6 +977,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
969
977
  return operator !== undefined && getArity(operator) > 0;
970
978
  };
971
979
 
980
+ // 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
981
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
973
982
  args.map((arg) =>
974
983
  isOperatorArgument(arg, context)
@@ -1177,7 +1186,9 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1177
1186
  }
1178
1187
  const builtin = context.environment.builtins.get(name);
1179
1188
  if (builtin?.arity === 0) return builtin.evaluate([], context);
1180
- throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
1189
+ throw new TlaEvaluationError(
1190
+ `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
1191
+ );
1181
1192
  };
1182
1193
 
1183
1194
  export const getReevaluatedDefinitions = (
@@ -1329,6 +1340,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
1329
1340
  },
1330
1341
  });
1331
1342
 
1343
+ // TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
1344
+ const compileTracedJunction = (
1345
+ expression: Expression & { kind: "And" | "Or" },
1346
+ operands: Evaluator[],
1347
+ callStack: CallStack | undefined,
1348
+ ): Evaluator | undefined => {
1349
+ const range = expression.location.range;
1350
+ const prefixEnds = expression.prefixEnds;
1351
+ if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
1352
+ return undefined;
1353
+ }
1354
+ const prefixes = prefixEnds
1355
+ .slice(0, operands.length - 2)
1356
+ .map((end) => ({
1357
+ ...expression,
1358
+ location: { ...expression.location, range: { ...range, end } },
1359
+ }))
1360
+ .reverse();
1361
+ const isAnd = expression.kind === "And";
1362
+ return (context) => {
1363
+ callStack.expressions.push(...prefixes);
1364
+ for (let index = 0; index < operands.length; index++) {
1365
+ if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
1366
+ const value = operands[index](context);
1367
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1368
+ if (value !== isAnd) {
1369
+ if (!callStack.isFrozen)
1370
+ callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
1371
+ return value;
1372
+ }
1373
+ }
1374
+ return isAnd;
1375
+ };
1376
+ };
1377
+
1332
1378
  const traceFrames =
1333
1379
  (
1334
1380
  expression: Expression,
@@ -1547,13 +1593,20 @@ const compileApply = (
1547
1593
  return (context) => domain(operand(context));
1548
1594
  }
1549
1595
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1596
+ // Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
1550
1597
  const isCached =
1551
1598
  !contextualApplications.has(expression) && !isNonconstant(args[0], environment);
1552
- return (context) =>
1553
- global.evaluate(
1554
- getLazyArguments(args, context),
1555
- isCached && context.scope === undefined ? undefined : context,
1556
- );
1599
+ const tlcEvalValues = environment.tlcEvalValues;
1600
+ return (context) => {
1601
+ if (!isCached || context.scope !== undefined) {
1602
+ return global.evaluate(getLazyArguments(args, context), context);
1603
+ }
1604
+ const cached = tlcEvalValues.get(expression);
1605
+ if (cached !== undefined) return cached;
1606
+ const value = global.evaluate(getLazyArguments(args, context), undefined);
1607
+ tlcEvalValues.set(expression, value);
1608
+ return value;
1609
+ };
1557
1610
  }
1558
1611
  if (global?.kind === "Builtin" && global.name === "\\subseteq" && args.length === 2) {
1559
1612
  const left = getEvaluator(args[0], environment);
@@ -1717,8 +1770,14 @@ export const getFunctionBuilder = (
1717
1770
  return markLambdaFunction(functionValue);
1718
1771
  }
1719
1772
  const pairs: [Value, Value][] = [];
1720
- const sets = mapBoundSets(bounds, (set) =>
1721
- getNormalizedElements(evaluate(set, context), set, context.environment.runtime.version),
1773
+ const sets = mapBoundSets(bounds, (set, index) =>
1774
+ getNormalizedElements(
1775
+ bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
1776
+ ? domain.factors[index]
1777
+ : domain,
1778
+ set,
1779
+ context.environment.runtime.version,
1780
+ ),
1722
1781
  );
1723
1782
  forEachBoundElement(bounds, sets, context.scope, (scope) => {
1724
1783
  const key =
@@ -1864,12 +1923,11 @@ export const getLazyFilter = (
1864
1923
  ) => {
1865
1924
  const predicate = getEvaluator(expression.predicate, environment);
1866
1925
  const pattern = expression.bound.pattern;
1867
- const range = expression.predicate.location.range;
1868
- const source = range && {
1926
+ const predicateNode = describeNode(expression.predicate);
1927
+ const source = expression.predicate.location.range && {
1869
1928
  names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1870
- predicate: formatRange(range),
1929
+ predicate: predicateNode,
1871
1930
  };
1872
- const predicateNode = describeNode(expression.predicate);
1873
1931
  const coverage = environment.coverage;
1874
1932
  const testCovered = (node: number, isMember: boolean, test: () => Value) => {
1875
1933
  if (!coverage || node === -1) return test();
@@ -2035,20 +2093,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
2035
2093
 
2036
2094
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
2037
2095
  const fields = getSortedFields(recordFields);
2038
- const hasDuplicates = hasDuplicateFields(fields);
2039
- const values = fields.map((field) => getEvaluator(field.value, environment));
2040
- if (hasDuplicates) {
2096
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2097
+ if (hasDuplicateFields(fields)) {
2041
2098
  return (context) =>
2042
2099
  createRecord(
2043
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2100
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2044
2101
  );
2045
2102
  }
2046
2103
  const names = fields.map((field) => field.name);
2047
2104
  const writtenNames = recordFields.map((field) => field.name);
2048
2105
  if (writtenNames.some((name, index) => name !== names[index])) {
2106
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
2049
2107
  return (context) =>
2050
2108
  createWrittenRecord(
2051
2109
  names,
2110
+ writtenIndexes,
2052
2111
  values.map((value) => value(context)),
2053
2112
  writtenNames,
2054
2113
  );
@@ -2098,25 +2157,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2098
2157
  };
2099
2158
  case "And": {
2100
2159
  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
- };
2160
+ return (
2161
+ compileTracedJunction(expression, operands, environment.callStack) ??
2162
+ ((context) => {
2163
+ for (let index = 0; index < operands.length; index++) {
2164
+ const value = operands[index](context);
2165
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2166
+ if (!value) return false;
2167
+ }
2168
+ return true;
2169
+ })
2170
+ );
2109
2171
  }
2110
2172
  case "Or": {
2111
2173
  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
- };
2174
+ return (
2175
+ compileTracedJunction(expression, operands, environment.callStack) ??
2176
+ ((context) => {
2177
+ for (let index = 0; index < operands.length; index++) {
2178
+ const value = operands[index](context);
2179
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2180
+ if (value) return true;
2181
+ }
2182
+ return false;
2183
+ })
2184
+ );
2120
2185
  }
2121
2186
  case "Prime": {
2122
2187
  const inner = getChildEvaluator(expression.expression);
@@ -2202,8 +2267,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2202
2267
  case "RecordSet": {
2203
2268
  const fields = getSortedFields(expression.fields);
2204
2269
  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)) });
2270
+ const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
2271
+ const sets = expression.fields.map((field) => getChildEvaluator(field.value));
2272
+ if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
2273
+ return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2274
+ }
2275
+ return (context) => {
2276
+ const writtenSets = sets.map((set) => set(context));
2277
+ return {
2278
+ kind: "RecordSet",
2279
+ names,
2280
+ sets: writtenIndexes.map((index) => writtenSets[index]),
2281
+ };
2282
+ };
2207
2283
  }
2208
2284
  case "Except":
2209
2285
  return compileExcept(expression, environment);
package/src/exit-codes.ts CHANGED
@@ -2,6 +2,7 @@ import type { LivenessChecker } from "./liveness-checker";
2
2
 
3
3
  export const EXIT_STATUS = {
4
4
  success: 0,
5
+ abort: 1,
5
6
  assumptionViolation: 10,
6
7
  deadlock: 11,
7
8
  safetyViolation: 12,
@@ -17,13 +18,13 @@ export const EXIT_STATUS = {
17
18
 
18
19
  const MESSAGE_EXIT_STATUSES = new Map<number, number>([
19
20
  ...[
20
- ...Array.from({ length: 24 }, (_, index) => 2222 + index),
21
+ ...Array.from({ length: 24 }, (_value, index) => 2222 + index),
21
22
  2272,
22
23
  2273,
23
24
  2274,
24
25
  2280,
25
26
  2281,
26
- ...Array.from({ length: 7 }, (_, index) => 5001 + index),
27
+ ...Array.from({ length: 7 }, (_value, index) => 5001 + index),
27
28
  ].map((code): [number, number] => [code, EXIT_STATUS.configParseError]),
28
29
  [2253, EXIT_STATUS.livenessEvaluationFailure],
29
30
  [2109, EXIT_STATUS.specEvaluationFailure],
@@ -82,6 +83,7 @@ export const withLivenessExitCode = (
82
83
  addState: (index, state, successors, tracing) =>
83
84
  withErrorExitCode(() => checker.addState(index, state, successors, tracing)),
84
85
  storeState: checker.storeState,
86
+ getStateCounts: checker.getStateCounts,
85
87
  findViolation: () => withErrorExitCode(() => checker.findViolation()),
86
88
  getViolatedProperties: (path, cycleStart) =>
87
89
  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.
package/src/java-hash.ts CHANGED
@@ -5,3 +5,17 @@ export const getJavaHashCode = (text: string): number => {
5
5
  }
6
6
  return hash;
7
7
  };
8
+
9
+ const getHashMapHash = (text: string) => {
10
+ const hash = getJavaHashCode(text);
11
+ return hash ^ (hash >>> 16);
12
+ };
13
+
14
+ export const getHashMapOrder = (names: string[]) => {
15
+ const unique = [...new Set(names)];
16
+ const capacity = 2 ** Math.max(4, Math.ceil(Math.log2(unique.length / 0.75)));
17
+ return unique
18
+ .map((name, index) => ({ name, index, bucket: getHashMapHash(name) & (capacity - 1) }))
19
+ .sort((left, right) => left.bucket - right.bucket || left.index - right.index)
20
+ .map((entry) => entry.name);
21
+ };
@@ -184,8 +184,8 @@ const readClassFile = (bytes: Uint8Array) => {
184
184
  getJavaClassName(pool, thrown.readUint16()),
185
185
  )
186
186
  : [];
187
- const modifiers = METHOD_MODIFIERS.filter(([flag]) => (access & flag) !== 0).map(
188
- ([, modifier]) => modifier,
187
+ const modifiers = METHOD_MODIFIERS.filter((entry) => (access & entry[0]) !== 0).map(
188
+ (entry) => entry[1],
189
189
  );
190
190
  const returnType = getTypeNames(descriptor.slice(parametersEnd + 1))[0];
191
191
  const throwsClause = exceptions.length === 0 ? "" : ` throws ${exceptions.join(",")}`;