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/coverage.ts CHANGED
@@ -1,4 +1,5 @@
1
1
  import {
2
+ getFunctionConstruction,
2
3
  isLocallyResolved,
3
4
  type Bound,
4
5
  type Definition,
@@ -7,10 +8,17 @@ import {
7
8
  type SourceRange,
8
9
  } from "./ast";
9
10
  import { formatRange } from "./errors";
11
+ import { SELECTION_NAME } from "./resolve";
10
12
  import type { Environment, Scope } from "./evaluate";
11
13
  import { getJavaHashCode } from "./java-hash";
12
14
  import { getTlcFingerprint } from "./tlc/fingerprint";
13
- import type { Value } from "./values";
15
+ import {
16
+ getCardinality,
17
+ isEmptySet,
18
+ isReducibleSet,
19
+ type IntervalValue,
20
+ type Value,
21
+ } from "./values";
14
22
 
15
23
  export type CoverageKind = "init" | "next" | "invariant" | "constraint" | "implied";
16
24
 
@@ -49,6 +57,11 @@ export interface CoverageReport {
49
57
  relations: CoverageRelationReport[];
50
58
  }
51
59
 
60
+ export interface CoverageOutput {
61
+ kind: "coverage";
62
+ coverage: CoverageReport;
63
+ }
64
+
52
65
  interface CoverageVariable {
53
66
  label: string;
54
67
  distinct: number;
@@ -81,6 +94,8 @@ interface Resolved {
81
94
  scope: Local | undefined;
82
95
  }
83
96
 
97
+ export const letDefinitions = new WeakMap<Scope, Definition>();
98
+
84
99
  const STANDARD_MODULES = new Set([
85
100
  "FiniteSets",
86
101
  "Sequences",
@@ -118,6 +133,17 @@ export const createCoverage = (variableCount: number): Coverage => ({
118
133
  relations: [],
119
134
  });
120
135
 
136
+ export const createCoverageEnvironment = (
137
+ environment: Environment,
138
+ coverage: Coverage,
139
+ ): Environment => ({
140
+ ...environment,
141
+ evaluators: new WeakMap(),
142
+ entryEvaluators: new WeakMap(),
143
+ definitionEvaluators: new WeakMap(),
144
+ coverage,
145
+ });
146
+
121
147
  const addNode = (
122
148
  coverage: Coverage,
123
149
  expression: Expression | undefined,
@@ -154,6 +180,10 @@ const findCoverageRelation = (coverage: Coverage, kind: CoverageKind, expression
154
180
  (relation) => relation.kind === kind && relation.expression === expression,
155
181
  )?.node;
156
182
 
183
+ const getRelationRange = (expression: Expression) =>
184
+ expression.location.range ??
185
+ (expression.kind === "Let" ? expression.body.location.range : undefined);
186
+
157
187
  export const addCoverageRelation = (
158
188
  coverage: Coverage,
159
189
  kind: CoverageKind,
@@ -163,7 +193,7 @@ export const addCoverageRelation = (
163
193
  ) => {
164
194
  const shared = kind === "next" ? findCoverageRelation(coverage, kind, expression) : undefined;
165
195
  if (shared !== undefined) return shared;
166
- const node = addNode(coverage, undefined, expression.location.range, -1, false);
196
+ const node = addNode(coverage, undefined, getRelationRange(expression), -1, false);
167
197
  coverage.relations.push({ kind, label, expression, scope, node });
168
198
  return node;
169
199
  };
@@ -184,9 +214,9 @@ export const getCoverageLabel = (
184
214
  ) => {
185
215
  const definition = name === undefined ? undefined : environment.definitions.get(name);
186
216
  const head = definition?.kind === "Operator" ? definition.head : undefined;
187
- const range = expression.location.range;
217
+ const range = getRelationRange(expression);
188
218
  if (!definition || !head) return `Action ${range ? formatRange(range) : "Unknown location"}`;
189
- if (isSameRange(definition.body.location.range, range) || !range) {
219
+ if (isSameRange(getRelationRange(definition.body), range) || !range) {
190
220
  return `${definition.name} ${formatRange(head)}`;
191
221
  }
192
222
  return `${definition.name} ${formatRange(head)} (${range.start.line} ${range.start.column} ${range.end.line} ${range.end.column})`;
@@ -233,6 +263,15 @@ const bindNames = (names: string[], locals: Local | undefined) =>
233
263
  locals,
234
264
  );
235
265
 
266
+ const bindLocalDefinitions = (definitions: Definition[], locals: Local | undefined) => {
267
+ const inner = definitions.reduce<Local | undefined>(
268
+ (parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
269
+ locals,
270
+ );
271
+ for (let local = inner; local !== locals && local; local = local.parent) local.scope = inner;
272
+ return inner;
273
+ };
274
+
236
275
  const getBoundNames = (bounds: Bound[]) =>
237
276
  bounds.flatMap((bound) =>
238
277
  bound.pattern.kind === "Name" ? [bound.pattern.name] : bound.pattern.names,
@@ -302,10 +341,13 @@ export const buildCoverage = (
302
341
  definition.kind === "Function"
303
342
  ? getBoundNames(definition.bounds)
304
343
  : definition.params.map((param) => param.name);
305
- walk(definition.body, bindNames(names, resolved.scope));
306
344
  if (definition.kind === "Function") {
307
- getBoundSets(definition.bounds).forEach((set) => walk(set, resolved.scope));
308
- }
345
+ const isLet = resolved.scope !== undefined;
346
+ enter(getFunctionConstruction(definition, isLet), definition.location.range, () => {
347
+ walk(definition.body, bindNames(names, resolved.scope));
348
+ getBoundSets(definition.bounds).forEach((set) => walk(set, resolved.scope));
349
+ });
350
+ } else walk(definition.body, bindNames(names, resolved.scope));
309
351
  walking.pop();
310
352
  };
311
353
 
@@ -380,20 +422,18 @@ export const buildCoverage = (
380
422
  case "Lambda":
381
423
  walk(expression.body, bindNames(expression.params, locals));
382
424
  return;
425
+ case "Selection":
426
+ if (range === undefined) walk(expression.expression, locals);
427
+ else enter(expression, range, () => walk(expression.expression, locals));
428
+ return;
383
429
  case "Let": {
384
- const inner = expression.definitions.reduce<Local | undefined>(
385
- (parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
386
- locals,
387
- );
388
- for (let local = inner; local !== locals && local; local = local.parent) {
389
- local.scope = inner;
390
- }
430
+ const inner = bindLocalDefinitions(expression.definitions, locals);
391
431
  expression.definitions.forEach((definition) => {
392
432
  if (definition.kind === "Operator") letBodies.set(definition.body, expression.body);
393
433
  });
394
- getHashtableOrder(expression.definitions).forEach((definition) =>
395
- walkDefinition({ definition, scope: inner }),
396
- );
434
+ getHashtableOrder(expression.definitions).forEach((definition) => {
435
+ if (definition.name !== SELECTION_NAME) walkDefinition({ definition, scope: inner });
436
+ });
397
437
  walk(expression.body, inner);
398
438
  return;
399
439
  }
@@ -551,9 +591,18 @@ export const buildCoverage = (
551
591
  }
552
592
  };
553
593
 
594
+ const getScopeLocals = (scope: Scope | undefined) => {
595
+ const scoped: Definition[] = [];
596
+ for (let node = scope; node; node = node.parent) {
597
+ const definition = letDefinitions.get(node);
598
+ if (definition) scoped.unshift(definition);
599
+ }
600
+ return bindLocalDefinitions(scoped, undefined);
601
+ };
602
+
554
603
  coverage.relations.forEach((relation) => {
555
604
  stack.push(relation.node);
556
- walk(relation.expression, undefined);
605
+ walk(relation.expression, getScopeLocals(relation.scope));
557
606
  stack.pop();
558
607
  });
559
608
  };
@@ -602,6 +651,194 @@ export const costCoverage = (coverage: Coverage, value: Value, cost: number) =>
602
651
  if (node !== undefined) coverage.secondary[node] += cost;
603
652
  };
604
653
 
654
+ export const chargeSetOperation = (
655
+ coverage: Coverage,
656
+ operator: string,
657
+ left: Value,
658
+ right: Value,
659
+ result: Value,
660
+ ): Value => {
661
+ const receiver = isReducibleSet(left)
662
+ ? left
663
+ : operator !== "\\" && isReducibleSet(right)
664
+ ? right
665
+ : undefined;
666
+ if (receiver === undefined || typeof result !== "object") return result;
667
+ const other = receiver === left ? right : left;
668
+ if (operator === "\\cup") {
669
+ if (isEmptySet(receiver) || !isReducibleSet(other)) return result;
670
+ const otherNode = coverage.values.get(other);
671
+ if (otherNode !== undefined) coverage.secondary[otherNode] += getCardinality(other) + 1;
672
+ }
673
+ const node = operator === "\\cup" ? undefined : coverage.values.get(receiver);
674
+ if (coverage.values.get(result) === node) return result;
675
+ const isShared = result === left || result === right || coverage.values.has(result);
676
+ const charged = isShared ? { ...result } : result;
677
+ if (node !== undefined) coverage.values.set(charged, node);
678
+ return charged;
679
+ };
680
+
681
+ interface ChargedEnumerator {
682
+ next: () => boolean;
683
+ reset: () => void;
684
+ }
685
+
686
+ const createListEnumerator = (coverage: Coverage, node: number | undefined, size: number) => {
687
+ let position = 0;
688
+ return {
689
+ next: () => {
690
+ if (node !== undefined) coverage.secondary[node]++;
691
+ return position++ < size;
692
+ },
693
+ reset: () => {
694
+ position = 0;
695
+ },
696
+ };
697
+ };
698
+
699
+ const createProductEnumerator = (
700
+ coverage: Coverage,
701
+ node: number,
702
+ sets: Value[],
703
+ ): ChargedEnumerator => {
704
+ if (sets.some((set) => isEmptySet(set))) return { next: () => false, reset: () => undefined };
705
+ const enumerators = sets.map((set) =>
706
+ createEnumerator(coverage, set, getCardinality(set), false),
707
+ );
708
+ const advance = () => {
709
+ for (let index = enumerators.length - 1; index > 0; index--) {
710
+ if (enumerators[index].next()) return true;
711
+ enumerators[index].reset();
712
+ enumerators[index].next();
713
+ }
714
+ return enumerators.length > 0 && enumerators[0].next();
715
+ };
716
+ let isDone = !enumerators.every((enumerator) => enumerator.next());
717
+ return {
718
+ next: () => {
719
+ if (isDone) return false;
720
+ coverage.secondary[node] += Math.max(enumerators.length, 1);
721
+ isDone = !advance();
722
+ return true;
723
+ },
724
+ reset: () => {
725
+ enumerators.forEach((enumerator) => {
726
+ enumerator.reset();
727
+ enumerator.next();
728
+ });
729
+ isDone = false;
730
+ },
731
+ };
732
+ };
733
+
734
+ export const createProductSetEnumerator = (coverage: Coverage, set: Value) => {
735
+ const node = typeof set === "object" ? coverage.values.get(set) : undefined;
736
+ if (node === undefined || typeof set !== "object") return undefined;
737
+ if (set.kind === "RecordSet") return createProductEnumerator(coverage, node, set.sets);
738
+ if (set.kind !== "FunctionSet") return undefined;
739
+ return createProductEnumerator(
740
+ coverage,
741
+ node,
742
+ Array.from({ length: getCardinality(set.domain) }, () => set.range),
743
+ );
744
+ };
745
+
746
+ const createEnumerator = (
747
+ coverage: Coverage,
748
+ set: Value,
749
+ size: number,
750
+ isNormalized: boolean,
751
+ ): ChargedEnumerator => {
752
+ const node = typeof set === "object" ? coverage.values.get(set) : undefined;
753
+ if (
754
+ typeof set === "object" &&
755
+ (set.kind === "Subset" || (!isNormalized && set.kind === "FilteredSet"))
756
+ ) {
757
+ return createListEnumerator(coverage, undefined, size);
758
+ }
759
+ const elements = createProductSetEnumerator(coverage, set);
760
+ if (!elements || node === undefined) return createListEnumerator(coverage, node, size);
761
+ if (!isNormalized) return elements;
762
+ let count = 0;
763
+ while (elements.next()) count++;
764
+ coverage.secondary[node] += count;
765
+ return createListEnumerator(coverage, node, count);
766
+ };
767
+
768
+ export const tagSubset = (coverage: Coverage, set: Value, subset: Value) => {
769
+ const node =
770
+ typeof set === "object" && set.kind === "Subset" ? coverage.values.get(set) : undefined;
771
+ if (node !== undefined && typeof subset === "object") coverage.values.set(subset, node);
772
+ };
773
+
774
+ const RANDOMLY_INDEXED_KINDS = new Set<string>([
775
+ "Set",
776
+ "MixedSet",
777
+ "Interval",
778
+ "FunctionSet",
779
+ "RecordSet",
780
+ "ProductSet",
781
+ ]);
782
+
783
+ // TLC's EnumerableValue#elements(Ordering.RANDOMIZED) draws indices, but a value class without its own k-out-of-n enumerator draws the whole set first, and SubsetValue converts itself to a SetEnumValue.
784
+ export const chargeRandomOrder = (coverage: Coverage, set: Value, size: number, order: Value[]) => {
785
+ if (typeof set !== "object" || RANDOMLY_INDEXED_KINDS.has(set.kind)) return;
786
+ if (set.kind !== "Subset") {
787
+ const enumerator = createEnumerator(coverage, set, size, false);
788
+ for (let position = 0; position <= size; position++) enumerator.next();
789
+ return;
790
+ }
791
+ const node = coverage.values.get(set);
792
+ if (node !== undefined) coverage.secondary[node] += size;
793
+ for (let position = 0; position < order.length; position++) {
794
+ tagSubset(coverage, set, order[position]);
795
+ }
796
+ };
797
+
798
+ export const createChargedEnumerator = (
799
+ coverage: Coverage,
800
+ set: Value,
801
+ list: Value[] | IntervalValue,
802
+ isNormalized: boolean,
803
+ ) => {
804
+ const size = Array.isArray(list) ? list.length : list.high - list.low + 1;
805
+ if (typeof set !== "object" || set.kind !== "Subset" || !Array.isArray(list)) {
806
+ return createEnumerator(coverage, set, size, isNormalized);
807
+ }
808
+ list.forEach((subset) => tagSubset(coverage, set, subset));
809
+ return createListEnumerator(coverage, undefined, size);
810
+ };
811
+
812
+ const chargeBindings = (enumerators: ChargedEnumerator[]) => {
813
+ enumerators.every((enumerator) => enumerator.next());
814
+ return () => {
815
+ for (let index = 0; index < enumerators.length; index++) {
816
+ if (enumerators[index].next() || index === enumerators.length - 1) return;
817
+ enumerators[index].reset();
818
+ enumerators[index].next();
819
+ }
820
+ };
821
+ };
822
+
823
+ export const chargeContexts = (
824
+ coverage: Coverage,
825
+ sets: Value[],
826
+ lists: (Value[] | IntervalValue)[],
827
+ ) =>
828
+ chargeBindings(
829
+ sets.map((set, index) => createChargedEnumerator(coverage, set, lists[index], true)),
830
+ );
831
+
832
+ export const chargeFunctionConstruction = (coverage: Coverage, node: number, sets: Value[]) => {
833
+ const sizes = sets.map((set) => getCardinality(set));
834
+ const advance = chargeBindings(
835
+ sets.map((set, index) => createEnumerator(coverage, set, sizes[index], false)),
836
+ );
837
+ const size = sizes.reduce((product, setSize) => product * setSize, 1);
838
+ for (let index = 0; index < size; index++) advance();
839
+ coverage.secondary[node] += size;
840
+ };
841
+
605
842
  const getLeadingZeros = (value: bigint) => {
606
843
  const high = Number(value >> 32n);
607
844
  return high === 0 ? 32 + Math.clz32(Number(value & 0xffffffffn)) : Math.clz32(high);
@@ -29,6 +29,8 @@ 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;
33
+ const TLC_EVAL = 1024;
32
34
 
33
35
  const ACTION_KINDS = new Set<Expression["kind"]>([
34
36
  "Prime",
@@ -80,6 +82,7 @@ interface Edge {
80
82
  callee: Definition;
81
83
  isOverridden: boolean;
82
84
  isLevelCounted: boolean;
85
+ isOperatorArgument: boolean;
83
86
  }
84
87
 
85
88
  const collectLocalFacts = (
@@ -104,20 +107,34 @@ const collectLocalFacts = (
104
107
  }
105
108
  return undefined;
106
109
  };
107
- const visit = (node: Expression, isLevelCounted: boolean) => {
110
+ const contexts = new Map<Expression, number>();
111
+ const visit = (node: Expression, isLevelCounted: boolean, isOperatorArgument: boolean) => {
108
112
  const kind = node.kind;
113
+ if (kind === "Selection") {
114
+ const seen = contexts.get(node.expression) ?? 0;
115
+ const context = isLevelCounted ? (isOperatorArgument ? 1 : 2) : isOperatorArgument ? 4 : 8;
116
+ if ((seen & context) !== 0) return;
117
+ contexts.set(node.expression, seen | context);
118
+ }
119
+ // TLC's getLevelBound takes an operator argument for a constant.
120
+ const nonconstantFlags = isOperatorArgument ? NONCONSTANT : NONCONSTANT | ABOVE_CONSTANT_BOUND;
109
121
  if (
110
122
  NONCONSTANT_KINDS.has(kind) ||
111
123
  (kind === "UnboundedQuantifier" && node.isTemporal === true) ||
112
124
  (kind === "Apply" && NONCONSTANT_OPERATORS.has(node.operator))
113
125
  ) {
114
- row[0] |= NONCONSTANT;
126
+ row[0] |= nonconstantFlags;
115
127
  }
116
128
  if (NONCONSTANT_KINDS.has(kind)) row[0] |= READS_IMPURE;
117
129
  const ownLevelFlags = getOwnLevelFlags(node);
118
130
  if (isLevelCounted && ownLevelFlags !== undefined) row[0] |= ownLevelFlags;
119
131
  const isInnerLevelCounted = isLevelCounted && ownLevelFlags === undefined;
120
132
  const name = getReferencedName(node);
133
+ // TLC's getLevelBound takes a parameter named like a variable for that variable.
134
+ if (name !== undefined && isLocallyResolved(node) && environment.variableIndex.has(name)) {
135
+ if (!isOperatorArgument) row[0] |= ABOVE_CONSTANT_BOUND;
136
+ if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
137
+ }
121
138
  if (name !== undefined && !isLocallyResolved(node)) {
122
139
  const target = environment.substitutions.get(name) ?? name;
123
140
  const definition = environment.definitions.get(target);
@@ -125,23 +142,34 @@ const collectLocalFacts = (
125
142
  const variableIndex = environment.variableIndex.get(name);
126
143
  if (
127
144
  variableIndex !== undefined ||
128
- environment.builtins.get(name)?.isStateLevel ||
145
+ environment.builtins.get(target)?.isStateLevel ||
129
146
  (definition && environment.variableIndex.has(definition.name))
130
147
  ) {
131
- row[0] |= NONCONSTANT;
148
+ row[0] |= nonconstantFlags;
132
149
  }
133
150
  if (variableIndex !== undefined) {
134
151
  if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
135
152
  if (!isOverridden) row[1 + (variableIndex >>> 5)] |= 1 << (variableIndex & 31);
136
153
  }
137
154
  if (definition) {
138
- edges.push({ callee: definition, isOverridden, isLevelCounted: isInnerLevelCounted });
155
+ edges.push({
156
+ callee: definition,
157
+ isOverridden,
158
+ isLevelCounted: isInnerLevelCounted,
159
+ isOperatorArgument:
160
+ isOperatorArgument ||
161
+ kind === "OperatorReference" ||
162
+ (kind === "Identifier" &&
163
+ definition.kind === "Operator" &&
164
+ definition.params.length > 0),
165
+ });
139
166
  } else {
140
- if (isImpureBuiltin(name, environment)) {
141
- row[0] |= IMPURE | (name === "Assert" ? 0 : REPEATED_EFFECT);
167
+ if (isImpureBuiltin(target, environment)) {
168
+ row[0] |= IMPURE | (target === "Assert" ? 0 : REPEATED_EFFECT);
142
169
  }
143
- if (STREAMED_BUILTINS.has(name)) row[0] |= STREAMED;
144
- if (RANDOM_BUILTINS.has(name)) row[0] |= RANDOM;
170
+ if (STREAMED_BUILTINS.has(target)) row[0] |= STREAMED;
171
+ if (RANDOM_BUILTINS.has(target)) row[0] |= RANDOM;
172
+ if (target === "TLCEval") row[0] |= TLC_EVAL;
145
173
  if (!isOverridden && isImpureBuiltin(target, environment)) row[0] |= READS_IMPURE;
146
174
  const builtin = environment.builtins.get(target);
147
175
  if (
@@ -155,9 +183,11 @@ const collectLocalFacts = (
155
183
  }
156
184
  }
157
185
  }
158
- getChildren(node).forEach((child) => visit(child, isInnerLevelCounted));
186
+ getChildren(node).forEach((child) =>
187
+ visit(child, isInnerLevelCounted, isOperatorArgument || kind === "Lambda"),
188
+ );
159
189
  };
160
- expressions.forEach((expression) => visit(expression, true));
190
+ expressions.forEach((expression) => visit(expression, true, false));
161
191
  return { row, edges };
162
192
  };
163
193
 
@@ -228,11 +258,12 @@ const closeRows = (local: Uint32Array, words: number, edges: Int32Array[], mask:
228
258
  return closed;
229
259
  };
230
260
 
231
- const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM;
261
+ const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM | TLC_EVAL;
232
262
  const READ_MASK = NONCONSTANT | READS_IMPURE;
263
+ const STARTUP_MASK = NONCONSTANT | ABOVE_CONSTANT_BOUND;
233
264
 
234
265
  const isEvaluatedOnce = (definition: Definition, flags: number) =>
235
- definition.kind === "Operator" && definition.params.length === 0 && (flags & NONCONSTANT) === 0;
266
+ definition.kind === "Operator" && definition.params.length === 0 && (flags & STARTUP_MASK) === 0;
236
267
 
237
268
  export const createDefinitionFacts = (environment: DefinitionNames): DefinitionFacts => {
238
269
  const definitions = [...new Set(environment.definitions.values())];
@@ -256,18 +287,32 @@ export const createDefinitionFacts = (environment: DefinitionNames): DefinitionF
256
287
  new Int32Array(own.filter((edge) => !edge.isOverridden && edge.isLevelCounted).map(getId)),
257
288
  );
258
289
  const levels = closeRows(local, words, levelEdges, TEMPORAL_LEVEL_FLAGS);
290
+ const startupEdges = edges.map(
291
+ (own) =>
292
+ new Int32Array(
293
+ own.filter((edge) => !edge.isOverridden && !edge.isOperatorArgument).map(getId),
294
+ ),
295
+ );
296
+ const startup = closeRows(local, words, startupEdges, ABOVE_CONSTANT_BOUND);
259
297
  const purityEdges = edges.map(
260
298
  (own) =>
261
299
  new Int32Array(
262
300
  own
263
301
  .map(getId)
264
- .filter((callee) => !isEvaluatedOnce(definitions[callee], reads[callee * words])),
302
+ .filter(
303
+ (callee) =>
304
+ !isEvaluatedOnce(
305
+ definitions[callee],
306
+ reads[callee * words] | startup[callee * words],
307
+ ),
308
+ ),
265
309
  ),
266
310
  );
267
311
  const purity = closeRows(localImpurity, words, purityEdges, PURITY_MASK);
268
312
  const rows = reads.map((word, position) =>
269
313
  position % words === 0
270
314
  ? (word & READ_MASK) |
315
+ (startup[position] & ABOVE_CONSTANT_BOUND) |
271
316
  (levels[position] & TEMPORAL_LEVEL_FLAGS) |
272
317
  (purity[position] & PURITY_MASK)
273
318
  : word,
@@ -291,6 +336,7 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
291
336
  const callee = getRow(edge.callee, environment);
292
337
  if (!edge.isOverridden) {
293
338
  row[0] |= callee[0] & READ_MASK;
339
+ if (!edge.isOperatorArgument) row[0] |= callee[0] & ABOVE_CONSTANT_BOUND;
294
340
  if (edge.isLevelCounted) row[0] |= callee[0] & TEMPORAL_LEVEL_FLAGS;
295
341
  for (let word = 1; word < words; word++) row[word] |= callee[word];
296
342
  }
@@ -300,7 +346,10 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
300
346
  };
301
347
 
302
348
  export const isConstantLevel = (definition: Definition, environment: Environment) =>
303
- (getRow(definition, environment)[0] & NONCONSTANT) === 0;
349
+ (getRow(definition, environment)[0] & STARTUP_MASK) === 0;
350
+
351
+ export const isEvaluatedAtStartup = (definition: Definition, environment: Environment) =>
352
+ (getRow(definition, environment)[0] & ABOVE_CONSTANT_BOUND) === 0;
304
353
 
305
354
  const EFFECT_FLAGS = {
306
355
  any: IMPURE,
@@ -308,6 +357,7 @@ const EFFECT_FLAGS = {
308
357
  streamed: STREAMED,
309
358
  // What a second evaluation shows: output again, or other random draws.
310
359
  replayed: REPEATED_EFFECT | RANDOM,
360
+ varying: IMPURE | RANDOM,
311
361
  };
312
362
 
313
363
  export const isExpressionImpure = (
@@ -322,6 +372,9 @@ export const isImpureDefinition = (
322
372
  effect: keyof typeof EFFECT_FLAGS = "any",
323
373
  ) => (getRow(definition, environment)[0] & EFFECT_FLAGS[effect]) !== 0;
324
374
 
375
+ export const isTlcEvalReached = (expression: Expression, environment: Environment) =>
376
+ (getExpressionsRow([expression], environment)[0] & TLC_EVAL) !== 0;
377
+
325
378
  export const getDefinitionLevel = (definition: Definition, environment: Environment) => {
326
379
  const flags = getRow(definition, environment)[0] & TEMPORAL_LEVEL_FLAGS;
327
380
  return flags === TEMPORAL_LEVEL_FLAGS