tla-ts 0.0.10-dev.09e53c2a6 → 0.0.10-dev.11307be75

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 +779 -225
  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 +337 -102
  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
@@ -2,6 +2,7 @@ import {
2
2
  getChildren,
3
3
  type AssumeProve,
4
4
  type Bound,
5
+ type Declaration,
5
6
  type Definition,
6
7
  type Expression,
7
8
  type Fact,
@@ -14,17 +15,25 @@ import {
14
15
  type SourceRange,
15
16
  type StepBody,
16
17
  } from "./ast";
17
- import { formatRange, TlaSyntaxError } from "./errors";
18
+ import { formatRange, TlaSyntaxError, type SanyError } from "./errors";
18
19
  import { getSourceName, mapChildren, mapDefinition } from "./instances";
20
+ import { resolveSynonym } from "./tlc/jar-data";
19
21
  import {
20
22
  getArity,
21
23
  getBinder,
22
24
  getNameSelectors,
23
25
  getOperandIndex,
24
26
  getOperands,
27
+ getParamArities,
28
+ isBefore,
25
29
  LOCAL_RESOLUTION,
30
+ nullSelections,
31
+ operatorSelectionErrors,
26
32
  selectionErrors,
27
33
  selections,
34
+ factReferences,
35
+ type NullSelection,
36
+ type SelectionArguments,
28
37
  } from "./resolve";
29
38
 
30
39
  type Lookup = (name: string) => Definition | undefined;
@@ -49,6 +58,39 @@ interface SelectingName {
49
58
 
50
59
  const SELECTION_NAME = "$subexpression";
51
60
 
61
+ const declaredArities = new WeakMap<Definition, number>();
62
+
63
+ const setDeclaredArities = (declarations: Declaration[], definitions: Definition[]) =>
64
+ declarations.forEach((declaration) => {
65
+ const definition = definitions.find(
66
+ (candidate) => candidate.isRecursive && candidate.name === declaration.name,
67
+ );
68
+ if (definition) declaredArities.set(definition, declaration.arity);
69
+ });
70
+
71
+ const getSelectorName = (selector: Selector) => {
72
+ switch (selector.kind) {
73
+ case "Name":
74
+ return selector.name;
75
+ case "Operand":
76
+ return typeof selector.operand === "number"
77
+ ? `argument selector ${selector.operand}`
78
+ : selector.operand;
79
+ case "Bound":
80
+ return "!(...)";
81
+ case "At":
82
+ return "@";
83
+ case "Colon":
84
+ return ":";
85
+ }
86
+ };
87
+
88
+ const getExpressionArguments = (
89
+ operator: string,
90
+ range: SourceRange | undefined,
91
+ args: Expression[],
92
+ ): SelectionArguments => ({ operator, range, args, params: args.map(() => 0) });
93
+
52
94
  const createError = (message: string, location: SourceLocation) =>
53
95
  new TlaSyntaxError(`${message} at line ${location.line}, column ${location.column}`);
54
96
 
@@ -152,21 +194,30 @@ const applyDefinition = (definition: Definition, selection: Selection) => {
152
194
  const selectSubexpression = (
153
195
  selectors: Selector[],
154
196
  lookup: Lookup,
197
+ isGoal: (name: string) => boolean,
155
198
  reference: Expression & SelectingName,
156
199
  isOperator: boolean,
157
200
  ): Expression => {
158
201
  const location = reference.location;
159
202
  const selection: Selection = { params: [], args: [], lets: [], location };
160
203
  let selectorIndex = 0;
161
- let current = undefined as Expression | undefined;
204
+ let current: Expression | undefined;
162
205
  let isFailed = false;
206
+ const nulls: NullSelection[] = [];
207
+ const applications: SelectionArguments[] = [];
208
+ let expressionError: SanyError | undefined;
209
+ const deferToExpression = (range: SourceRange | undefined, message: string) => {
210
+ if (!expressionError && range) expressionError = { location: formatRange(range), message };
211
+ };
212
+ const checkNull = (node: Expression | undefined, message: string) => {
213
+ const range = reference.selectorRanges?.[selectorIndex];
214
+ if (node && range) nulls.push({ node, error: { location: formatRange(range), message } });
215
+ };
163
216
 
164
217
  const report = (range: SourceRange | undefined, message: string) => {
165
218
  if (!range) throw createError(message, location);
166
219
  selectionErrors.set(reference, {
167
- args: selectors
168
- .slice(0, selectorIndex)
169
- .flatMap((selector) => ("args" in selector ? selector.args : [])),
220
+ applications,
170
221
  error: { location: formatRange(range), message },
171
222
  });
172
223
  isFailed = true;
@@ -178,6 +229,7 @@ const selectSubexpression = (
178
229
  const args: Expression[] = [];
179
230
  while (selectorIndex < selectors.length) {
180
231
  const selector = selectors[selectorIndex];
232
+ if (selector.kind !== "Name" && !local) return undefined;
181
233
  if (selector.kind !== "Name") throw createError("Expected an operator name", location);
182
234
  names.push(selector.name);
183
235
  args.push(...selector.args);
@@ -194,16 +246,38 @@ const selectSubexpression = (
194
246
 
195
247
  const enterDefinition = (local: Definition[] | undefined) => {
196
248
  const found = findDefinition(local);
249
+ if (!found) {
250
+ isFailed = true;
251
+ return undefined;
252
+ }
197
253
  const definition = found.definition;
198
- const arity = getArity(definition);
254
+ const arity = declaredArities.get(definition) ?? getArity(definition);
199
255
  const isLast = selectorIndex === selectors.length - 1;
200
- if (found.args.length !== arity && (!isOperator || found.args.length !== 0)) {
256
+ if (found.args.length !== arity) {
257
+ const range = reference.argumentRanges?.[selectorIndex] ?? location.range;
258
+ const message = `The operator ${resolveSynonym(found.name)} requires ${arity - found.earlier} arguments.`;
259
+ if (!isOperator || found.args.length !== 0) return report(range, message);
260
+ deferToExpression(range, message);
261
+ }
262
+ if (isLast) return { definition, args: found.args };
263
+ applications.push({
264
+ operator: found.name,
265
+ range: reference.selectorRanges?.[selectorIndex],
266
+ args: found.args,
267
+ params: getParamArities(definition),
268
+ });
269
+ const range = definition.location.range;
270
+ if (
271
+ definition.isRecursive &&
272
+ range &&
273
+ range.module === location.range?.module &&
274
+ isBefore(location, range.end)
275
+ ) {
201
276
  return report(
202
- reference.argumentRanges?.[selectorIndex] ?? location.range,
203
- `The operator ${found.name} requires ${arity - found.earlier} arguments.`,
277
+ reference.selectorRanges?.[selectorIndex],
278
+ `Subexpression of \`${found.name}' used inside the operator's definition.`,
204
279
  );
205
280
  }
206
- if (isLast) return { definition, args: found.args };
207
281
  if (definition.kind !== "Operator") {
208
282
  throw createError(`Cannot select a subexpression of ${definition.name}`, location);
209
283
  }
@@ -222,12 +296,15 @@ const selectSubexpression = (
222
296
  const found = current && findLabel(current, selector.name, []);
223
297
  if (!found) return report(range, `Cannot find label \`${selector.name}'.`);
224
298
  const params = found.label.params;
225
- if (!isOperator && selector.args.length !== params.length) {
226
- return report(range, `Label \`${selector.name}' used with wrong number of arguments.`);
299
+ if (selector.args.length !== params.length) {
300
+ const message = `Label \`${selector.name}' used with wrong number of arguments.`;
301
+ if (!isOperator) return report(range, message);
302
+ deferToExpression(range, message);
227
303
  }
228
304
  selection.lets.push(...found.lets);
229
305
  selection.params.push(...params.map((name) => ({ name, arity: 0 })));
230
306
  selection.args.push(...selector.args);
307
+ applications.push(getExpressionArguments(selector.name, range, selector.args));
231
308
  current = found.label.body;
232
309
  selectorIndex++;
233
310
  }
@@ -236,14 +313,42 @@ const selectSubexpression = (
236
313
  const selectOperand = (selector: Selector) => {
237
314
  if (!current) throw createError("Subexpression selection failed", location);
238
315
  if (selector.kind === "Colon") return;
316
+ const range = reference.selectorRanges?.[selectorIndex];
317
+ const currentRange = current.location.range;
318
+ if (
319
+ (current.kind === "Subexpression" ||
320
+ (current.kind === "Identifier" && current.name.includes("!")) ||
321
+ (current.kind === "Apply" && current.operator.includes("!"))) &&
322
+ (currentRange?.module !== location.range?.module || isBefore(current.location, location))
323
+ ) {
324
+ const selected = resolveSubexpressions(current, lookup, isGoal);
325
+ if (selectionErrors.has(selected)) {
326
+ report(
327
+ range,
328
+ `Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`,
329
+ );
330
+ return;
331
+ }
332
+ if (selections.has(selected) && selected.kind !== "Lambda") {
333
+ current =
334
+ selected.kind === "Let" &&
335
+ selected.body.kind === "Apply" &&
336
+ selected.body.operator === SELECTION_NAME
337
+ ? selected.body
338
+ : // SANY wraps a selection without parameters in $Nop, whose only operand is the selection.
339
+ { kind: "Tuple", elements: [selected], location: selected.location };
340
+ }
341
+ }
239
342
  if (current.kind === "Label") {
240
343
  current = current.body;
241
344
  selectOperand(selector);
242
345
  return;
243
346
  }
347
+ const nonexistent = `Nonexistent operand specified by \`${getSelectorName(selector)}'.`;
244
348
  if (current.kind === "Let") {
245
349
  if (selector.kind !== "Operand" || getOperandIndex(selector.operand, 1) !== 0) {
246
- throw createError("A LET/IN expression has only one operand", location);
350
+ report(range, "A LET/IN expression has only one operand.");
351
+ return;
247
352
  }
248
353
  selection.lets.push(current.definitions);
249
354
  current = current.body;
@@ -252,32 +357,63 @@ const selectSubexpression = (
252
357
  const binder = getBinder(current);
253
358
  if (binder && (selector.kind === "Bound" || selector.kind === "At")) {
254
359
  selection.params.push(...binder.names.map((name) => ({ name, arity: 0 })));
255
- if (selector.kind === "Bound") selection.args.push(...selector.args);
360
+ if (selector.kind === "Bound") {
361
+ selection.args.push(...selector.args);
362
+ applications.push(getExpressionArguments("", range, selector.args));
363
+ }
256
364
  current = binder.body;
257
365
  return;
258
366
  }
259
- if (current.kind === "Case" && selector.kind === "Operand") {
367
+ if (current.kind === "Case") {
260
368
  const arms = [
261
369
  ...current.arms,
262
370
  ...(current.other ? [{ condition: undefined, body: current.other }] : []),
263
371
  ];
264
- const arm = arms[getOperandIndex(selector.operand, arms.length)];
265
- const next = selectors[selectorIndex + 1];
266
- if (!arm || next?.kind !== "Operand") {
267
- throw createError("A subexpression of CASE must have the form !i!j", location);
372
+ if (selectorIndex === selectors.length - 1) {
373
+ report(range, "Subexpression of CASE must have form !i!j.");
374
+ return;
375
+ }
376
+ const arm =
377
+ selector.kind === "Operand"
378
+ ? arms[getOperandIndex(selector.operand, arms.length)]
379
+ : undefined;
380
+ if (!arm) {
381
+ report(range, nonexistent);
382
+ return;
268
383
  }
269
384
  selectorIndex++;
270
- const part = getOperandIndex(next.operand, 2);
271
- const chosen = part === 0 ? arm.condition : part === 1 ? arm.body : undefined;
272
- if (!chosen) throw createError("Nonexistent CASE operand", location);
385
+ const next = selectors[selectorIndex];
386
+ const part = next.kind === "Operand" ? getOperandIndex(next.operand, 2) : -1;
387
+ const nextRange = reference.selectorRanges?.[selectorIndex];
388
+ if (part === -1) {
389
+ report(
390
+ nextRange,
391
+ "Second selector for CASE subexpression must specify one of two operands.",
392
+ );
393
+ return;
394
+ }
395
+ const chosen = part === 0 ? arm.condition : arm.body;
396
+ if (!chosen) {
397
+ report(nextRange, "Selecting OTHER in a CASE statement.");
398
+ return;
399
+ }
273
400
  current = chosen;
274
401
  return;
275
402
  }
276
- if (selector.kind !== "Operand")
277
- throw createError("Unexpected subexpression selector", location);
278
403
  const operands = binder ? binder.sets : getOperands(current);
404
+ if (!operands && current.kind !== "Identifier") {
405
+ report(range, "Selecting subexpression of expression that has none.");
406
+ return;
407
+ }
408
+ if (selector.kind !== "Operand") {
409
+ report(range, nonexistent);
410
+ return;
411
+ }
279
412
  const operand = operands?.[getOperandIndex(selector.operand, operands.length)];
280
- if (!operand) throw createError("Nonexistent operand specified by the selector", location);
413
+ if (!operand) {
414
+ report(range, nonexistent);
415
+ return;
416
+ }
281
417
  current = operand;
282
418
  };
283
419
 
@@ -304,12 +440,35 @@ const selectSubexpression = (
304
440
  followLabels();
305
441
  continue;
306
442
  }
443
+ if (selector.kind !== "Colon") {
444
+ checkNull(
445
+ current,
446
+ "Subexpression selection failed, probably due to an error in the selected expression.",
447
+ );
448
+ }
307
449
  selectOperand(selector);
450
+ checkNull(
451
+ current,
452
+ `An unexpected null node specified by '${getSelectorName(selectors[selectorIndex])}'.\nThis is probably due to a previous error.`,
453
+ );
308
454
  selectorIndex++;
309
455
  }
310
456
  if (isFailed) return reference;
311
457
  if (!current) throw createError("Subexpression selection failed", location);
312
- return createApplication(selection, current);
458
+ const params = selection.params.length;
459
+ const args = selection.args.length;
460
+ if (params !== args) {
461
+ const message = `Expected ${params} arguments but found ${args}.`;
462
+ if (!isOperator || args > 0) {
463
+ report(location.range, message);
464
+ return reference;
465
+ }
466
+ deferToExpression(location.range, message);
467
+ }
468
+ const selected = createApplication(selection, current);
469
+ nullSelections.set(selected, nulls);
470
+ if (expressionError) operatorSelectionErrors.set(selected, expressionError);
471
+ return selected;
313
472
  };
314
473
 
315
474
  const getQualifiedSelectors = (
@@ -338,6 +497,7 @@ const resolveSubexpressions = (
338
497
  ): Expression => {
339
498
  if (!containsReference(expression)) return expression;
340
499
  if (expression.kind === "Let") {
500
+ if (expression.recursive) setDeclaredArities(expression.recursive, expression.definitions);
341
501
  const local: Lookup = (name) =>
342
502
  expression.definitions.find((definition) => definition.name === name) ?? lookup(name);
343
503
  const mapped = mapChildren(expression, (child) => resolveSubexpressions(child, local, isGoal));
@@ -372,8 +532,22 @@ const resolveSubexpressions = (
372
532
  ? getQualifiedSelectors(mapped.operator, mapped.args, mapped.argumentCounts, lookup)
373
533
  : undefined;
374
534
  const first = selectors?.[0];
375
- if (!selectors || (first?.kind === "Name" && isGoal(first.name))) return mapped;
376
- const selected = selectSubexpression(selectors, lookup, mapped, isOperator);
535
+ if (!selectors) return mapped;
536
+ const nameCount = selectors.findIndex((selector) => selector.kind !== "Name");
537
+ const names = selectors.slice(0, nameCount === -1 ? selectors.length : nameCount);
538
+ const isQualified = names.some(
539
+ (_name, index) =>
540
+ index > 0 &&
541
+ lookup(
542
+ names
543
+ .slice(0, index + 1)
544
+ .map(getSelectorName)
545
+ .join("!"),
546
+ ),
547
+ );
548
+ if (first?.kind === "Name" && isGoal(first.name) && !isQualified) return mapped;
549
+ if (first?.kind === "Name" && selectors[1].kind !== "Name" && !lookup(first.name)) return mapped;
550
+ const selected = selectSubexpression(selectors, lookup, isGoal, mapped, isOperator);
377
551
  if (selected !== mapped) selections.add(selected);
378
552
  return selected;
379
553
  };
@@ -427,89 +601,148 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
427
601
  },
428
602
  ];
429
603
  });
430
- const lookup = createLookup([...available, ...module.definitions]);
604
+ const own = new Set([...module.definitions, ...clauses]);
605
+ setDeclaredArities(
606
+ module.units.flatMap((unit) => (unit.kind === "Recursive" ? unit.declarations : [])),
607
+ module.definitions,
608
+ );
609
+ const recursive = new Map(
610
+ module.units.flatMap((unit): [string, SourceLocation][] =>
611
+ unit.kind === "Recursive"
612
+ ? unit.declarations.map((declaration) => [declaration.name, declaration.location])
613
+ : [],
614
+ ),
615
+ );
616
+ const isDeclaredBefore = (definition: Definition, location: SourceLocation) => {
617
+ const declared = recursive.get(definition.name);
618
+ return (
619
+ isBefore(definition.location, location) ||
620
+ (definition.isRecursive && declared !== undefined && isBefore(declared, location))
621
+ );
622
+ };
623
+ const getVisibleLookup =
624
+ (lookup: Lookup, location: SourceLocation): Lookup =>
625
+ (name) => {
626
+ const definition = lookup(name);
627
+ return definition && (!own.has(definition) || isDeclaredBefore(definition, location))
628
+ ? definition
629
+ : undefined;
630
+ };
631
+ const proofLookup = createLookup([...available, ...module.definitions]);
431
632
  const isGoal = (name: string) => goals.has(name);
432
633
  const definitionLookup = createLookup([...available, ...module.definitions, ...clauses]);
433
- const resolve = (expression: Expression) =>
634
+ const resolve = (expression: Expression, location: SourceLocation) =>
434
635
  resolveSubexpressions(
435
636
  expression,
436
- definitionLookup,
637
+ getVisibleLookup(definitionLookup, location),
437
638
  (name) => isGoal(name) && clauses.every((clause) => clause.name !== name),
438
639
  );
439
- const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
440
- const resolveInProof = (expression: Expression) =>
441
- resolveSubexpressions(expression, lookup, isProofGoal);
442
- const resolveFacts = (facts: Fact[]) =>
443
- facts.map((fact) => (fact.kind === "ModuleFact" ? fact : resolveInProof(fact)));
444
- const resolveBounds = (bounds: Bound[]) =>
445
- bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
446
- const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
447
- statement.kind === "AssumeProve"
448
- ? {
449
- ...statement,
450
- assumptions: statement.assumptions.map((assumption) =>
451
- assumption.kind === "NewSymbol"
452
- ? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
453
- : resolveStatement(assumption),
454
- ),
455
- conclusion: resolveInProof(statement.conclusion),
456
- }
457
- : resolveInProof(statement);
458
- const resolveStep = (body: StepBody): StepBody => {
459
- switch (body.kind) {
460
- case "Use":
461
- case "Hide":
462
- return { ...body, facts: resolveFacts(body.facts) };
463
- case "Instance":
464
- return resolveInstance(body, lookup, isProofGoal);
465
- case "Define":
466
- return {
467
- ...body,
468
- definitions: body.definitions.map((definition) =>
469
- definition.kind === "Instance"
470
- ? resolveInstance(definition, lookup, isProofGoal)
471
- : mapDefinition(definition, resolveInProof),
472
- ),
473
- };
474
- case "Have":
475
- case "Case":
476
- return { ...body, expression: resolveInProof(body.expression) };
477
- case "Witness":
478
- return { ...body, expressions: body.expressions.map(resolveInProof) };
479
- case "Take":
480
- return { ...body, bounds: resolveBounds(body.bounds) };
481
- case "Pick":
482
- return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
483
- case "Assert":
484
- return { ...body, statement: resolveStatement(body.statement) };
485
- default:
486
- return body;
487
- }
488
- };
489
- const resolveProof = (proof: Proof | undefined): Proof | undefined =>
490
- proof?.kind === "By"
491
- ? { ...proof, facts: resolveFacts(proof.facts) }
492
- : proof?.kind === "Steps"
640
+ const createProofResolver = (lookup: Lookup) => {
641
+ const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
642
+ const resolveInProof = (expression: Expression) =>
643
+ resolveSubexpressions(expression, lookup, isProofGoal);
644
+ const resolveFacts = (facts: Fact[]) => {
645
+ const resolved = facts.map((fact) =>
646
+ fact.kind === "ModuleFact" ? fact : resolveInProof(fact),
647
+ );
648
+ factReferences.set(resolved, facts);
649
+ return resolved;
650
+ };
651
+ const resolveBounds = (bounds: Bound[]) =>
652
+ bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
653
+ const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
654
+ statement.kind === "AssumeProve"
493
655
  ? {
494
- ...proof,
495
- steps: proof.steps.map((step) => ({
496
- ...step,
497
- body: resolveStep(step.body),
498
- proof: resolveProof(step.proof),
499
- })),
656
+ ...statement,
657
+ assumptions: statement.assumptions.map((assumption) =>
658
+ assumption.kind === "NewSymbol"
659
+ ? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
660
+ : resolveStatement(assumption),
661
+ ),
662
+ conclusion: resolveInProof(statement.conclusion),
500
663
  }
501
- : proof;
664
+ : resolveInProof(statement);
665
+ const resolveStep = (body: StepBody): StepBody => {
666
+ switch (body.kind) {
667
+ case "Use":
668
+ case "Hide":
669
+ return { ...body, facts: resolveFacts(body.facts) };
670
+ case "Instance":
671
+ return resolveInstance(body, lookup, isProofGoal);
672
+ case "Define":
673
+ return {
674
+ ...body,
675
+ definitions: body.definitions.map((definition) =>
676
+ definition.kind === "Instance"
677
+ ? resolveInstance(definition, lookup, isProofGoal)
678
+ : mapDefinition(definition, resolveInProof),
679
+ ),
680
+ };
681
+ case "Have":
682
+ case "Case":
683
+ return { ...body, expression: resolveInProof(body.expression) };
684
+ case "Witness":
685
+ return { ...body, expressions: body.expressions.map(resolveInProof) };
686
+ case "Take":
687
+ return { ...body, bounds: resolveBounds(body.bounds) };
688
+ case "Pick":
689
+ return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
690
+ case "Assert":
691
+ return { ...body, statement: resolveStatement(body.statement) };
692
+ default:
693
+ return body;
694
+ }
695
+ };
696
+ const resolveProof = (proof: Proof | undefined): Proof | undefined => {
697
+ if (proof?.kind === "By") return { ...proof, facts: resolveFacts(proof.facts) };
698
+ if (proof?.kind !== "Steps") return proof;
699
+ let resolver = { lookup, resolveStep, resolveProof };
700
+ return {
701
+ ...proof,
702
+ steps: proof.steps.map((step) => {
703
+ const resolved = {
704
+ ...step,
705
+ body: resolver.resolveStep(step.body),
706
+ proof: resolver.resolveProof(step.proof),
707
+ };
708
+ if (step.body.kind === "Define") {
709
+ const definitions = step.body.definitions.flatMap((definition) =>
710
+ definition.kind === "Instance" ? [] : [definition],
711
+ );
712
+ const outer = resolver.lookup;
713
+ resolver = createProofResolver(
714
+ (name) => definitions.find((definition) => definition.name === name) ?? outer(name),
715
+ );
716
+ }
717
+ return resolved;
718
+ }),
719
+ };
720
+ };
721
+ return { lookup, resolveFacts, resolveStatement, resolveStep, resolveProof };
722
+ };
502
723
  const resolved = {
503
724
  ...module,
504
- theorems: module.theorems.map((theorem) => ({
505
- ...theorem,
506
- statement:
507
- theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
508
- ? theorem.statement
509
- : resolveStatement(theorem.statement),
510
- proof: resolveProof(theorem.proof),
725
+ theorems: module.theorems.map((theorem) => {
726
+ const resolver = createProofResolver(getVisibleLookup(proofLookup, theorem.location));
727
+ return {
728
+ ...theorem,
729
+ statement:
730
+ theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
731
+ ? theorem.statement
732
+ : resolver.resolveStatement(theorem.statement),
733
+ proof:
734
+ theorem.proof &&
735
+ createProofResolver(getVisibleLookup(proofLookup, theorem.proof.location)).resolveProof(
736
+ theorem.proof,
737
+ ),
738
+ };
739
+ }),
740
+ uses: module.uses.map((use) => ({
741
+ ...use,
742
+ facts: createProofResolver(getVisibleLookup(proofLookup, use.location)).resolveFacts(
743
+ use.facts,
744
+ ),
511
745
  })),
512
- uses: module.uses.map((use) => ({ ...use, facts: resolveFacts(use.facts) })),
513
746
  };
514
747
  const hasReferences =
515
748
  module.definitions.some((definition) => containsReference(definition.body)) ||
@@ -517,10 +750,12 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
517
750
  if (!hasReferences) return resolved;
518
751
  return {
519
752
  ...resolved,
520
- definitions: module.definitions.map((definition) => mapDefinition(definition, resolve)),
753
+ definitions: module.definitions.map((definition) =>
754
+ mapDefinition(definition, (expression) => resolve(expression, definition.location)),
755
+ ),
521
756
  assumptions: module.assumptions.map((assumption) => ({
522
757
  ...assumption,
523
- expression: resolve(assumption.expression),
758
+ expression: resolve(assumption.expression, assumption.location),
524
759
  })),
525
760
  };
526
761
  };
package/src/successors.ts CHANGED
@@ -723,6 +723,7 @@ const compileIdentifier = (
723
723
  !definition ||
724
724
  (expression.location.range && getStartupValue(definition, environment) !== undefined)
725
725
  ) {
726
+ // Deviation from TLC: Tool#getInitStates prints an unassigned variable's declaration as the non-boolean value it found.
726
727
  guard(run, scope, partial, action, isFixed, onComplete);
727
728
  return;
728
729
  }
package/src/symmetry.ts CHANGED
@@ -24,7 +24,7 @@ export type Images = Map<string, ModelValue>;
24
24
 
25
25
  const getPermutationKey = (permutation: Images) =>
26
26
  [...permutation]
27
- .map(([name, image]) => `${name}>${image.name}`)
27
+ .map((entry) => `${entry[0]}>${entry[1].name}`)
28
28
  .sort()
29
29
  .join(",");
30
30
 
@@ -143,6 +143,16 @@ export const SANY_OPERATOR_SYNONYMS = [
143
143
  ["^+", "⁺"],
144
144
  ];
145
145
 
146
+ const SYNONYMS = new Map(
147
+ SANY_OPERATOR_SYNONYMS.flatMap((names) => names.slice(1).map((synonym) => [synonym, names[0]])),
148
+ );
149
+
150
+ export const resolveSynonym = (name: string) =>
151
+ name
152
+ .split("!")
153
+ .map((part) => SYNONYMS.get(part) ?? (part === "~" ? "\\lnot" : part))
154
+ .join("!");
155
+
146
156
  export const TLC_STARTUP_STRINGS = [
147
157
  "STRING",
148
158
  "FALSE",
@@ -345,14 +345,14 @@ interface CodedMessage {
345
345
  let codedMessagePatterns: { pattern: RegExp; message: CodedMessage }[] | undefined;
346
346
 
347
347
  const getCodedMessagePatterns = () =>
348
- (codedMessagePatterns ??= CODED_MESSAGES.map(([code, template, isEvalException]) => ({
348
+ (codedMessagePatterns ??= CODED_MESSAGES.map((codedMessage) => ({
349
349
  pattern: new RegExp(
350
- `^${template
350
+ `^${codedMessage[1]
351
351
  .split(/%\d+%/)
352
352
  .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
353
353
  .join("[\\s\\S]*")}$`,
354
354
  ),
355
- message: { code, isEvalException },
355
+ message: { code: codedMessage[0], isEvalException: codedMessage[2] },
356
356
  })));
357
357
 
358
358
  const UNCODED_MESSAGE_PATTERN =