tla-ts 0.0.10-dev.28c823e4b → 0.0.10-dev.63a6693bd

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 (172) hide show
  1. package/dist/compile.cjs +6 -6
  2. package/dist/compile.js +10 -10
  3. package/dist/deciders.cjs +29 -29
  4. package/dist/deciders.js +40 -40
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove-worker.cjs +1 -1
  10. package/dist/prove-worker.js +1 -1
  11. package/dist/prove.cjs +54 -54
  12. package/dist/prove.js +52 -52
  13. package/dist/run.cjs +42 -42
  14. package/dist/run.js +44 -44
  15. package/dist/tlapm.cjs +2 -2
  16. package/dist/tlapm.js +2 -2
  17. package/dist/transfer.cjs +39 -39
  18. package/dist/transfer.js +41 -41
  19. package/dist/worker.cjs +4 -4
  20. package/dist/worker.js +4 -4
  21. package/package.json +1 -1
  22. package/src/ast.ts +44 -39
  23. package/src/builtins.ts +4 -13
  24. package/src/check-failure.ts +116 -0
  25. package/src/check-trace.ts +282 -0
  26. package/src/check.ts +152 -518
  27. package/src/cli/options.ts +6 -31
  28. package/src/cli/shared.ts +1 -1
  29. package/src/cli/tlapm.ts +14 -13
  30. package/src/cli/tlc-arguments.ts +222 -210
  31. package/src/cli/tlc-output.ts +687 -0
  32. package/src/cli/tlc-usage.ts +1 -1
  33. package/src/cli/tlc.ts +34 -701
  34. package/src/cli/xml-exporter.ts +23 -33
  35. package/src/codegen.ts +5 -10
  36. package/src/coverage.ts +3 -10
  37. package/src/dependencies.ts +8 -13
  38. package/src/dfid.ts +16 -16
  39. package/src/environment-config.ts +315 -0
  40. package/src/environment.ts +45 -333
  41. package/src/errors.ts +3 -2
  42. package/src/evaluate.ts +5 -4
  43. package/src/fingerprints.ts +65 -1
  44. package/src/instances.ts +47 -10
  45. package/src/java-hash.ts +7 -0
  46. package/src/json.ts +4 -7
  47. package/src/levels.ts +39 -42
  48. package/src/liveness-checker.ts +24 -37
  49. package/src/liveness.ts +47 -54
  50. package/src/obligations/action.ts +4 -11
  51. package/src/obligations/anonymize.ts +4 -2
  52. package/src/obligations/expression.ts +18 -2
  53. package/src/obligations/generate.ts +45 -38
  54. package/src/obligations/index.ts +2 -2
  55. package/src/obligations/module.ts +27 -38
  56. package/src/obligations/normalize.ts +2 -1
  57. package/src/obligations/simplify.ts +39 -44
  58. package/src/obligations/source.ts +47 -57
  59. package/src/obligations/temporal.ts +5 -5
  60. package/src/parallel-worker.ts +10 -30
  61. package/src/parallel.ts +22 -45
  62. package/src/parser.ts +19 -34
  63. package/src/prover/decide-pool.ts +3 -3
  64. package/src/prover/deciders.ts +3 -3
  65. package/src/prover/isabelle/encode.ts +1 -1
  66. package/src/prover/isabelle/isar/inner-syntax.ts +9 -4
  67. package/src/prover/isabelle/isar/method.ts +14 -25
  68. package/src/prover/isabelle/isar/theory.ts +11 -10
  69. package/src/prover/isabelle/isar/type-check.ts +6 -6
  70. package/src/prover/isabelle/provers/blast/blast.ts +7 -63
  71. package/src/prover/isabelle/provers/hypsubst.ts +17 -26
  72. package/src/prover/isabelle/pure/bicompose.ts +9 -25
  73. package/src/prover/isabelle/pure/conv.ts +2 -8
  74. package/src/prover/isabelle/pure/drule.ts +9 -2
  75. package/src/prover/isabelle/pure/logic.ts +1 -1
  76. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -13
  77. package/src/prover/isabelle/pure/rewriter.ts +5 -9
  78. package/src/prover/isabelle/pure/table.ts +2 -1
  79. package/src/prover/isabelle/pure/tactical.ts +42 -35
  80. package/src/prover/isabelle/pure/thm.ts +14 -11
  81. package/src/prover/isabelle/tla/classical-setup.ts +17 -14
  82. package/src/prover/isabelle/tla/context.ts +7 -2
  83. package/src/prover/isabelle/tla/logic.ts +10 -21
  84. package/src/prover/isabelle/tla/simpdata.ts +1 -10
  85. package/src/prover/prep/action.ts +11 -19
  86. package/src/prover/prep/fingerprint.ts +2 -5
  87. package/src/prover/prep/methods.ts +24 -3
  88. package/src/prover/prove.ts +87 -64
  89. package/src/prover/smt/context.ts +1 -2
  90. package/src/prover/smt/data.ts +418 -406
  91. package/src/prover/smt/encode.ts +30 -18
  92. package/src/prover/smt/rewrite.ts +657 -626
  93. package/src/prover/smt/solver/ast.ts +0 -22
  94. package/src/prover/smt/solver/auf-solver.ts +2 -5
  95. package/src/prover/smt/solver/context.ts +3 -3
  96. package/src/prover/smt/solver/e-matching.ts +1 -1
  97. package/src/prover/smt/solver/expr-safe-replace.ts +1 -1
  98. package/src/prover/smt/solver/internalizer.ts +1 -2
  99. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -8
  100. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -1
  101. package/src/prover/smt/solver/lp/nla-core.ts +2 -6
  102. package/src/prover/smt/solver/mam-compiler.ts +4 -2
  103. package/src/prover/smt/solver/model-checker.ts +1 -1
  104. package/src/prover/smt/solver/model-finder.ts +12 -17
  105. package/src/prover/smt/solver/model-macro-solver.ts +11 -19
  106. package/src/prover/smt/solver/nlsat/algebraic.ts +9 -9
  107. package/src/prover/smt/solver/nlsat/atoms.ts +20 -4
  108. package/src/prover/smt/solver/nlsat/explain.ts +7 -22
  109. package/src/prover/smt/solver/nlsat/levelwise.ts +1 -6
  110. package/src/prover/smt/solver/nlsat/polynomial.ts +12 -3
  111. package/src/prover/smt/solver/nlsat/solver.ts +12 -24
  112. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -1
  113. package/src/prover/smt/solver/proto-model.ts +0 -4
  114. package/src/prover/smt/solver/quantifier-analyzer.ts +10 -10
  115. package/src/prover/smt/solver/quantifier-manager.ts +1 -5
  116. package/src/prover/smt/solver/smtlib-parser.ts +78 -94
  117. package/src/prover/smt/solver/theory-lra-bounds.ts +1 -2
  118. package/src/prover/smt/solver/theory-lra-internalize.ts +5 -16
  119. package/src/prover/tlapm/cache.ts +28 -18
  120. package/src/prover/tlapm/tlapm.ts +15 -9
  121. package/src/prover/verdict.ts +7 -0
  122. package/src/prover/zenon/check/check.ts +1 -2
  123. package/src/prover/zenon/check/records.ts +1 -1
  124. package/src/prover/zenon/check/relations.ts +2 -1
  125. package/src/prover/zenon/check/rewrites.ts +2 -15
  126. package/src/prover/zenon/check/sets.ts +40 -58
  127. package/src/prover/zenon/check/terms.ts +1 -2
  128. package/src/prover/zenon/eqrel.ts +2 -0
  129. package/src/prover/zenon/expr.ts +7 -0
  130. package/src/prover/zenon/index-table.ts +9 -19
  131. package/src/prover/zenon/isar.ts +35 -35
  132. package/src/prover/zenon/llproof.ts +2 -11
  133. package/src/prover/zenon/mltoll.ts +12 -28
  134. package/src/prover/zenon/parse.ts +3 -6
  135. package/src/prover/zenon/search.ts +4 -14
  136. package/src/prover/zenon/tla/functions.ts +2 -2
  137. package/src/prover/zenon/tla/llproof.ts +9 -11
  138. package/src/prover/zenon/tla/records.ts +1 -6
  139. package/src/prover/zenon/tla/sets.ts +15 -14
  140. package/src/prover/zenon/tla/tla.ts +7 -6
  141. package/src/resolve.ts +55 -72
  142. package/src/sany/generation.ts +394 -0
  143. package/src/sany/generator-def-entries.ts +210 -0
  144. package/src/sany/generator-definitions.ts +686 -0
  145. package/src/sany/generator-expressions.ts +1100 -0
  146. package/src/sany/generator-proofs.ts +662 -0
  147. package/src/sany/generator.ts +155 -2625
  148. package/src/sany/lexer.ts +17 -16
  149. package/src/sany/nodes.ts +6 -13
  150. package/src/sany/report.ts +3 -6
  151. package/src/sany/selectors.ts +35 -38
  152. package/src/sany/xml.ts +23 -55
  153. package/src/search.ts +65 -27
  154. package/src/simulate.ts +157 -133
  155. package/src/spec-description.ts +33 -48
  156. package/src/standard-modules.ts +16 -32
  157. package/src/state-graph.ts +2 -7
  158. package/src/substitution-levels.ts +5 -4
  159. package/src/successors.ts +5 -7
  160. package/src/tlc/messages.ts +20 -15
  161. package/src/tlc/order.ts +2 -9
  162. package/src/tlc/random.ts +4 -4
  163. package/src/tlc/replay.ts +8 -15
  164. package/src/tlc/tlc-operators.ts +2 -3
  165. package/src/tlc/trace-spec.ts +25 -45
  166. package/src/typescript/actions.ts +2 -4
  167. package/src/typescript/collections.ts +34 -20
  168. package/src/typescript/compile.ts +1 -3
  169. package/src/typescript/formula.ts +5 -3
  170. package/src/typescript/model.ts +4 -5
  171. package/src/typescript/steps.ts +20 -18
  172. package/src/values.ts +63 -158
@@ -0,0 +1,662 @@
1
+ import type {
2
+ AssumeProve,
3
+ Assumption,
4
+ Expression,
5
+ Fact,
6
+ NewSymbol,
7
+ Proof,
8
+ ProofStep,
9
+ Theorem,
10
+ UseOrHide,
11
+ } from "../ast";
12
+ import { TlaSyntaxError } from "../errors";
13
+ import { createLevelFields } from "./builtins";
14
+ import {
15
+ addToContext,
16
+ type AssumeNode,
17
+ type AssumeProveNode,
18
+ type Context,
19
+ createContext,
20
+ type DefStepNode,
21
+ type ExprOrOpArgNode,
22
+ type FactNode,
23
+ type FormalParamNode,
24
+ type InstanceNode,
25
+ type LabelNode,
26
+ type LeafProofNode,
27
+ type LevelNode,
28
+ NEW_CONSTANT_KIND,
29
+ type NewSymbNode,
30
+ type NonLeafProofNode,
31
+ type OpDeclNode,
32
+ type OpDefNode,
33
+ type ProofStepNode,
34
+ type SanyLocation,
35
+ type TheoremNode,
36
+ type ThmOrAssumpDefNode,
37
+ type UseOrHideNode,
38
+ } from "./nodes";
39
+ import { getSelectorItems, isGeneralId } from "./selectors";
40
+ import {
41
+ findNameTokens,
42
+ getExpressionSpan,
43
+ getRangeSpan,
44
+ getSpanLocation,
45
+ getTokenIndex,
46
+ getTokenLocation,
47
+ isBoxToken,
48
+ isToken,
49
+ type SourceFile,
50
+ type TokenSpan,
51
+ } from "./source";
52
+ import {
53
+ addSymbol,
54
+ applyBuiltin,
55
+ type AssumeProveScope,
56
+ createFormalParam,
57
+ createOpAppl,
58
+ createOpDef,
59
+ endProof,
60
+ getLocation,
61
+ getTopContext,
62
+ getUnitLocation,
63
+ getUnitSpan,
64
+ type ModuleGeneration,
65
+ popLabels,
66
+ pushLabelScope,
67
+ resolveModule,
68
+ resolveName,
69
+ resolveSynonym,
70
+ withContext,
71
+ } from "./generation";
72
+ import { getOperandSpan, reportDefEntry } from "./generator-def-entries";
73
+ import {
74
+ generateInstance,
75
+ getOperatorSpan,
76
+ processFunction,
77
+ processModuleDefinition,
78
+ processOperator,
79
+ } from "./generator-definitions";
80
+ import {
81
+ findNameOrKeyword,
82
+ generateBounds,
83
+ generateExpression,
84
+ generateSelector,
85
+ generateWithParams,
86
+ } from "./generator-expressions";
87
+
88
+ const NEW_SYMBOL_KINDS = {
89
+ Constant: { declKind: NEW_CONSTANT_KIND, level: 0 },
90
+ Variable: { declKind: 25, level: 1 },
91
+ State: { declKind: 26, level: 1 },
92
+ Action: { declKind: 27, level: 2 },
93
+ Temporal: { declKind: 28, level: 3 },
94
+ };
95
+
96
+ const getFactModules = (generation: ModuleGeneration, fact: Fact & { kind: "ModuleFact" }) => {
97
+ const module =
98
+ resolveModule(generation, fact.name) ??
99
+ (fact.name === generation.currentModule.name ? generation.currentModule : undefined);
100
+ if (module !== undefined) return [module];
101
+ generation.addError(
102
+ getTokenLocation(generation.file, getTokenIndex(generation.file, fact.location) + 1),
103
+ `Module \`${fact.name}' used without being extended or instantiated.`,
104
+ );
105
+ return [];
106
+ };
107
+
108
+ const generateFacts = (generation: ModuleGeneration, facts: Fact[]) =>
109
+ facts.flatMap((fact): FactNode[] => {
110
+ if (fact.kind === "ModuleFact") return getFactModules(generation, fact);
111
+ const items = getSelectorItems(fact);
112
+ if (items === undefined || !isGeneralId(items)) return [generateExpression(generation, fact)];
113
+ const node = generateSelector(generation, fact, 0, true, false);
114
+ if (node.kind === "ThmOrAssumpDef") throw new TlaSyntaxError("Expected a fact");
115
+ return [node];
116
+ });
117
+
118
+ const generateDefs = (generation: ModuleGeneration, defs: Fact[]) =>
119
+ defs.flatMap((fact): UseOrHideNode["defs"] => {
120
+ if (fact.kind === "ModuleFact") return getFactModules(generation, fact);
121
+ if (reportDefEntry(generation, fact)) return [];
122
+ const symbol = generateSelector(
123
+ generation,
124
+ fact.kind === "OperatorReference"
125
+ ? { kind: "Identifier", name: fact.operator, location: fact.location }
126
+ : fact,
127
+ -1,
128
+ false,
129
+ true,
130
+ );
131
+ const isDefinition =
132
+ symbol.kind === "OpDef" || (symbol.kind === "ThmOrAssumpDef" && !symbol.name.startsWith("<"));
133
+ if (!isDefinition) {
134
+ generation.addError(
135
+ getLocation(generation.file, fact),
136
+ "DEF clause entry should describe a defined operator.",
137
+ );
138
+ return [];
139
+ }
140
+ return [symbol];
141
+ });
142
+
143
+ const checkKeywordOnly = (
144
+ generation: ModuleGeneration,
145
+ statement: UseOrHide | Extract<Proof, { kind: "By" }>,
146
+ location: SanyLocation,
147
+ ) => {
148
+ if (statement.isOnly || statement.facts.length + statement.defs.length > 0) return;
149
+ generation.addError(location, "Empty BY, USE, or HIDE");
150
+ };
151
+
152
+ export const generateUseOrHide = (generation: ModuleGeneration, use: UseOrHide): UseOrHideNode => {
153
+ const location = getUnitLocation(generation.file, use.location);
154
+ checkKeywordOnly(generation, use, location);
155
+ const facts = generateFacts(generation, use.facts);
156
+ const defs = generateDefs(generation, use.defs);
157
+ if (facts.length + defs.length === 0)
158
+ generation.addError(location, "Empty USE or HIDE statement.");
159
+ if (use.kind === "Hide") {
160
+ facts
161
+ .filter((fact) => fact.kind === "OpAppl" && fact.operator.kind !== "ThmOrAssumpDef")
162
+ .forEach((fact) =>
163
+ generation.addError(
164
+ fact.location,
165
+ "The only expression allowed as a fact in a HIDE is \nthe name of a theorem, assumption, or step.",
166
+ ),
167
+ );
168
+ }
169
+ return {
170
+ ...createLevelFields(generation.getId()),
171
+ kind: "UseOrHide",
172
+ facts,
173
+ defs,
174
+ isOnly: use.isOnly,
175
+ isHide: use.kind === "Hide",
176
+ location,
177
+ };
178
+ };
179
+
180
+ const generateNewSymbol = (generation: ModuleGeneration, symbol: NewSymbol): NewSymbNode => {
181
+ const span = getUnitSpan(generation.file, symbol.location);
182
+ const set = symbol.set && generateExpression(generation, symbol.set);
183
+ const nameIndex = findNameOrKeyword(generation.file, span.start, symbol.name);
184
+ const kind = NEW_SYMBOL_KINDS[symbol.level];
185
+ const declaration: OpDeclNode = {
186
+ ...createLevelFields(generation.getId()),
187
+ levelChecked: 1,
188
+ level: kind.level,
189
+ kind: "OpDecl",
190
+ name: resolveSynonym(symbol.name),
191
+ arity: symbol.arity,
192
+ declKind: kind.declKind,
193
+ location: getSpanLocation(
194
+ generation.file,
195
+ getOperatorSpan(generation.file, nameIndex, symbol.arity),
196
+ ),
197
+ module: generation.currentModule,
198
+ };
199
+ addSymbol(generation, declaration);
200
+ return {
201
+ ...createLevelFields(generation.getId()),
202
+ kind: "NewSymb",
203
+ declaration,
204
+ set,
205
+ location: getSpanLocation(generation.file, span),
206
+ };
207
+ };
208
+
209
+ const generateAssumeProve = (
210
+ generation: ModuleGeneration,
211
+ assumeProve: AssumeProve,
212
+ depth: number,
213
+ goal?: { isSuffices: boolean },
214
+ ): AssumeProveNode => {
215
+ const span = getUnitSpan(generation.file, assumeProve.location);
216
+ const isBoxed = isBoxToken(generation.file, span.start - 1);
217
+ const conclusionStart = getExpressionSpan(generation.file, assumeProve.conclusion).start;
218
+ const proveIndex = generation.file.tokens.findLastIndex(
219
+ (token, index) => index < conclusionStart && token.kind === "Keyword" && token.text === "PROVE",
220
+ );
221
+ const assumeLocation = getSpanLocation(generation.file, {
222
+ start: isBoxed ? span.start - 1 : span.start,
223
+ end: span.start,
224
+ });
225
+ if (isBoxed !== isBoxToken(generation.file, proveIndex - 1)) {
226
+ generation.addError(
227
+ assumeLocation,
228
+ isBoxed
229
+ ? "[]ASSUME matched by PROVE instead of []PROVE"
230
+ : "ASSUME matched by []PROVE instead of PROVE",
231
+ );
232
+ }
233
+ // SANY numbers the AssumeProveNode before it generates its clauses.
234
+ const id = generation.getId();
235
+ if (depth > 1) generation.contexts.push(createContext());
236
+ if (isBoxed && generation.contexts.some((context) => generation.assumeContexts.has(context))) {
237
+ generation.addError(
238
+ assumeLocation,
239
+ "[]ASSUME used within the scope of an ordinary ASSUME's assumptions",
240
+ );
241
+ }
242
+ if (!isBoxed) generation.assumeContexts.add(getTopContext(generation.contexts));
243
+ const scope: AssumeProveScope = {
244
+ isDeclaredBefore: [false],
245
+ hasGoal: goal !== undefined,
246
+ isSuffices: goal?.isSuffices ?? false,
247
+ isInProof: true,
248
+ };
249
+ generation.assumeProveState.depth = depth;
250
+ generation.assumeProveState.isDeclared[depth] = false;
251
+ if (depth === 1) {
252
+ generation.assumeProveState.goal = goal && scope;
253
+ generation.assumeProveState.goalClause = 0;
254
+ }
255
+ const assumptions = assumeProve.assumptions.map((assumption, index): LevelNode => {
256
+ const isNew = assumption.kind === "NewSymbol";
257
+ const node =
258
+ assumption.kind === "AssumeProve"
259
+ ? generateAssumeProve(generation, assumption, depth + 1)
260
+ : isNew
261
+ ? generateNewSymbol(generation, assumption)
262
+ : generateExpression(generation, assumption);
263
+ generation.assumeProveState.depth = depth;
264
+ if (isNew) generation.assumeProveState.isDeclared[depth] = true;
265
+ scope.isDeclaredBefore.push(scope.isDeclaredBefore[index] || isNew);
266
+ if (depth === 1) generation.assumeProveState.goalClause++;
267
+ return node;
268
+ });
269
+ const conclusion = generateExpression(generation, assumeProve.conclusion);
270
+ if (depth > 1) generation.contexts.pop();
271
+ generation.assumeProveState.depth = depth - 1;
272
+ if (depth === 1) generation.assumeProveState.goal = undefined;
273
+ const node: AssumeProveNode = {
274
+ ...createLevelFields(id),
275
+ kind: "AssumeProve",
276
+ assumptions,
277
+ goal: conclusion,
278
+ isSuffices: scope.isSuffices,
279
+ isBoxed,
280
+ location: getSpanLocation(generation.file, {
281
+ start: isBoxed ? span.start - 1 : span.start,
282
+ end: span.end,
283
+ }),
284
+ };
285
+ generation.assumeProveScopes.set(node, scope);
286
+ return node;
287
+ };
288
+
289
+ const createTheoremDefinition = (
290
+ generation: ModuleGeneration,
291
+ id: number,
292
+ name: string,
293
+ body: LevelNode,
294
+ location: SanyLocation,
295
+ labels: Map<string, LabelNode>,
296
+ isTheorem = true,
297
+ ): ThmOrAssumpDefNode => ({
298
+ ...createLevelFields(id),
299
+ kind: "ThmOrAssumpDef",
300
+ name,
301
+ isTheorem,
302
+ body,
303
+ params: [],
304
+ isLocal: false,
305
+ location,
306
+ module: generation.currentModule,
307
+ source: undefined,
308
+ labels,
309
+ isLeibnizArg: [],
310
+ isLeibniz: false,
311
+ opLevelCond: [],
312
+ maxLevels: [],
313
+ minMaxLevel: [],
314
+ });
315
+
316
+ const generateLeafProof = (
317
+ generation: ModuleGeneration,
318
+ proof: Exclude<Proof, { kind: "Steps" }>,
319
+ ): LeafProofNode => {
320
+ const location = getUnitLocation(generation.file, proof.location);
321
+ if (proof.kind === "By") checkKeywordOnly(generation, proof, location);
322
+ const facts = proof.kind === "By" ? generateFacts(generation, proof.facts) : [];
323
+ const defs = proof.kind === "By" ? generateDefs(generation, proof.defs) : [];
324
+ // The UseOrHideNode SANY makes of a BY proof's facts and definitions.
325
+ if (proof.kind === "By") generation.getId();
326
+ if (proof.kind === "By" && facts.length + defs.length === 0)
327
+ generation.addError(location, "Empty BY");
328
+ return {
329
+ ...createLevelFields(generation.getId()),
330
+ kind: "LeafProof",
331
+ facts,
332
+ defs,
333
+ isOmitted: proof.kind === "Omitted",
334
+ isOnly: proof.kind === "By" && proof.isOnly,
335
+ location,
336
+ };
337
+ };
338
+
339
+ const generateStepBody = (
340
+ generation: ModuleGeneration,
341
+ body: ProofStep["body"],
342
+ bodySpan: TokenSpan,
343
+ ) => {
344
+ const bodyLocation = getSpanLocation(generation.file, bodySpan);
345
+ switch (body.kind) {
346
+ case "Have":
347
+ return applyBuiltin(
348
+ generation,
349
+ "$Have",
350
+ [generateExpression(generation, body.expression)],
351
+ bodyLocation,
352
+ );
353
+ case "Case":
354
+ return applyBuiltin(
355
+ generation,
356
+ "$Pfcase",
357
+ [generateExpression(generation, body.expression)],
358
+ bodyLocation,
359
+ );
360
+ case "Witness":
361
+ return applyBuiltin(
362
+ generation,
363
+ "$Witness",
364
+ body.expressions.map((witness) => generateExpression(generation, witness)),
365
+ bodyLocation,
366
+ );
367
+ case "Qed":
368
+ return applyBuiltin(generation, "$Qed", [], bodyLocation);
369
+ case "Take":
370
+ case "Pick": {
371
+ const isPick = body.kind === "Pick";
372
+ const name = isPick ? "$Pick" : "$Take";
373
+ if (isPick) generation.contexts.push(createContext());
374
+ const getOperands = (params: FormalParamNode[]) =>
375
+ body.kind === "Pick" ? [generateWithParams(generation, params, body.body)] : [];
376
+ if (body.bounds.length > 0) {
377
+ const bounds = generateBounds(generation, body.bounds, bodySpan.start);
378
+ const operands = getOperands(bounds.bounded.flat());
379
+ return applyBuiltin(generation, name, operands, bodyLocation, bounds);
380
+ }
381
+ const indexes = findNameTokens(generation.file, bodySpan.start, bodySpan.end + 1, body.names);
382
+ const unbounded = body.names.map((paramName, index) =>
383
+ createFormalParam(
384
+ generation,
385
+ paramName,
386
+ 0,
387
+ getTokenLocation(generation.file, indexes[index]),
388
+ true,
389
+ ),
390
+ );
391
+ const operands = getOperands(unbounded);
392
+ return applyBuiltin(generation, name, operands, bodyLocation, { unbounded });
393
+ }
394
+ }
395
+ return undefined;
396
+ };
397
+
398
+ const isInfixExpression = (file: SourceFile, expression: Expression) => {
399
+ if ((expression.kind === "And" || expression.kind === "Or") && !expression.isBulleted)
400
+ return true;
401
+ if (expression.kind !== "Apply" || expression.args.length !== 2) return false;
402
+ const left = getOperandSpan(file, expression.args[0]);
403
+ const start = getExpressionSpan(file, expression).start;
404
+ return left.start === start && !isToken(file, left.end + 1, "(");
405
+ };
406
+
407
+ const generateProof = (
408
+ generation: ModuleGeneration,
409
+ proof: Proof,
410
+ ): LeafProofNode | NonLeafProofNode => {
411
+ if (proof.kind !== "Steps") return generateLeafProof(generation, proof);
412
+ const proofContext = createContext();
413
+ generation.contexts.push(proofContext);
414
+ const instances: InstanceNode[] = [];
415
+ const sufficesContexts: Context[] = [];
416
+ let previousRight: ExprOrOpArgNode | undefined;
417
+ const generateOtherStep = (
418
+ body: ProofStep["body"],
419
+ stepSpan: TokenSpan,
420
+ bodySpan: TokenSpan,
421
+ ): DefStepNode | UseOrHideNode | InstanceNode | undefined => {
422
+ if (body.kind === "Define") {
423
+ const defs = body.definitions.map((definition) => {
424
+ const defined: (OpDefNode | ThmOrAssumpDefNode)[] = [];
425
+ if (definition.kind === "Instance")
426
+ processModuleDefinition(generation, definition, defined, instances);
427
+ else if (definition.kind === "Function") processFunction(generation, definition, defined);
428
+ else processOperator(generation, definition, defined);
429
+ const last = defined[definition.kind === "Instance" ? defined.length - 1 : 0];
430
+ if (last?.kind !== "OpDef") throw new TlaSyntaxError("A DEFINE step defines no operator");
431
+ return last;
432
+ });
433
+ return {
434
+ ...createLevelFields(generation.getId()),
435
+ kind: "DefStep",
436
+ defs,
437
+ location: getSpanLocation(generation.file, bodySpan),
438
+ };
439
+ }
440
+ if (body.kind === "Use" || body.kind === "Hide") {
441
+ return {
442
+ ...generateUseOrHide(generation, body),
443
+ location: getSpanLocation(generation.file, stepSpan),
444
+ };
445
+ }
446
+ if (body.kind === "Instance") {
447
+ return generateInstance(generation, body, false, getSpanLocation(generation.file, bodySpan));
448
+ }
449
+ return undefined;
450
+ };
451
+ const steps = proof.steps.map((step): ProofStepNode => {
452
+ const stepSpan = getUnitSpan(generation.file, step.location);
453
+ const headSpan = getRangeSpan(generation.file, step.head);
454
+ const bodySpan = { start: headSpan.start + 1, end: headSpan.end };
455
+ const body = step.body;
456
+ if (step.name !== undefined && /^<[*+]>/.test(step.token)) {
457
+ generation.addError(
458
+ getTokenLocation(generation.file, stepSpan.start),
459
+ "<*> and <+> cannot be used for a named step.",
460
+ );
461
+ }
462
+ if (step.name !== undefined) pushLabelScope(generation);
463
+ const definitionId = step.name === undefined ? undefined : generation.getId();
464
+ if (body.kind !== "Assert") previousRight = undefined;
465
+ const otherStep = generateOtherStep(body, stepSpan, bodySpan);
466
+ if (otherStep !== undefined) {
467
+ if (step.name !== undefined) {
468
+ addSymbol(
469
+ generation,
470
+ createOpDef(generation, {
471
+ defKind: "NumberedProofStep",
472
+ name: step.name,
473
+ location: getSpanLocation(generation.file, stepSpan),
474
+ labels: popLabels(generation),
475
+ step: otherStep,
476
+ }),
477
+ );
478
+ }
479
+ return otherStep;
480
+ }
481
+ const isAssumeProve = body.kind === "Assert" && body.statement.kind === "AssumeProve";
482
+ if (isAssumeProve) previousRight = undefined;
483
+ const isSuffices = body.kind === "Assert" && body.isSuffices;
484
+ const assumeContext = createContext();
485
+ const generateAssertion = (statement: Expression | AssumeProve): LevelNode => {
486
+ if (statement.kind === "AssumeProve") {
487
+ const node = withContext(generation, assumeContext, () =>
488
+ generateAssumeProve(
489
+ generation,
490
+ statement,
491
+ 1,
492
+ step.name === undefined ? undefined : { isSuffices },
493
+ ),
494
+ );
495
+ node.isSuffices = isSuffices;
496
+ return node;
497
+ }
498
+ if (isSuffices) {
499
+ const expression = generateExpression(generation, statement);
500
+ return applyBuiltin(
501
+ generation,
502
+ "$Suffices",
503
+ [expression],
504
+ getSpanLocation(generation.file, bodySpan),
505
+ );
506
+ }
507
+ const isAtStep =
508
+ previousRight !== undefined &&
509
+ statement.kind === "Apply" &&
510
+ isInfixExpression(generation.file, statement) &&
511
+ statement.args[0].kind === "ExceptAt";
512
+ // SANY generates an @ step's right side before the $Nop that stands for its @.
513
+ const atRight = isAtStep ? generateExpression(generation, statement.args[1]) : undefined;
514
+ const expression = isAtStep
515
+ ? createOpAppl(
516
+ generation,
517
+ resolveName(generation, statement.operator, getLocation(generation.file, statement)),
518
+ [
519
+ applyBuiltin(
520
+ generation,
521
+ "$Nop",
522
+ [previousRight],
523
+ getLocation(generation.file, statement.args[0]),
524
+ ),
525
+ atRight,
526
+ ],
527
+ getLocation(generation.file, statement),
528
+ )
529
+ : generateExpression(generation, statement);
530
+ const right = expression.kind === "OpAppl" ? expression.operands[1] : undefined;
531
+ previousRight = isInfixExpression(generation.file, statement) ? right : undefined;
532
+ return expression;
533
+ };
534
+ const stepBody =
535
+ body.kind === "Assert"
536
+ ? generateAssertion(body.statement)
537
+ : generateStepBody(generation, body, bodySpan);
538
+ if (stepBody === undefined) throw new TlaSyntaxError(`Unexpected proof step ${body.kind}`);
539
+ const pickContext = body.kind === "Pick" ? generation.contexts.pop() : undefined;
540
+ const definition =
541
+ step.name === undefined || definitionId === undefined
542
+ ? undefined
543
+ : createTheoremDefinition(
544
+ generation,
545
+ definitionId,
546
+ step.name,
547
+ stepBody,
548
+ getTokenLocation(generation.file, getTokenIndex(generation.file, step.location)),
549
+ popLabels(generation),
550
+ );
551
+ if (definition) addSymbol(generation, definition);
552
+ const isScoped = isAssumeProve && !isSuffices;
553
+ if (isScoped) generation.contexts.push(assumeContext);
554
+ const stepProof = step.proof && generateProof(generation, step.proof);
555
+ if (isScoped) generation.contexts.pop();
556
+ endProof(generation, stepBody);
557
+ if (isAssumeProve && isSuffices) {
558
+ sufficesContexts.push(assumeContext);
559
+ generation.contexts.push(assumeContext);
560
+ }
561
+ pickContext?.symbols.forEach((symbol) => addSymbol(generation, symbol));
562
+ return {
563
+ ...createLevelFields(generation.getId()),
564
+ kind: "Theorem",
565
+ definition,
566
+ body: stepBody,
567
+ proof: stepProof,
568
+ isSuffices,
569
+ location: getSpanLocation(generation.file, stepSpan),
570
+ };
571
+ });
572
+ sufficesContexts.forEach(() => {
573
+ generation.contexts.pop()?.symbols.forEach((symbol) => addToContext(proofContext, symbol));
574
+ });
575
+ generation.contexts.pop();
576
+ return {
577
+ ...createLevelFields(generation.getId()),
578
+ kind: "NonLeafProof",
579
+ steps,
580
+ instances,
581
+ proofLevel: proof.level,
582
+ location: getUnitLocation(generation.file, proof.location),
583
+ };
584
+ };
585
+
586
+ export const processTheorem = (generation: ModuleGeneration, theorem: Theorem) => {
587
+ const location = getUnitLocation(generation.file, theorem.location);
588
+ const statement = theorem.statement;
589
+ const assumeContext = createContext();
590
+ if (theorem.name !== undefined) pushLabelScope(generation);
591
+ const definitionId = theorem.name === undefined ? undefined : generation.getId();
592
+ if (statement.kind === "AssumeProve") generation.contexts.push(assumeContext);
593
+ const body =
594
+ statement.kind === "AssumeProve"
595
+ ? generateAssumeProve(
596
+ generation,
597
+ statement,
598
+ 1,
599
+ theorem.name === undefined ? undefined : { isSuffices: false },
600
+ )
601
+ : generateExpression(generation, statement);
602
+ const definition =
603
+ theorem.name === undefined || definitionId === undefined
604
+ ? undefined
605
+ : createTheoremDefinition(
606
+ generation,
607
+ definitionId,
608
+ theorem.name,
609
+ body,
610
+ location,
611
+ popLabels(generation),
612
+ );
613
+ if (definition) {
614
+ if (statement.kind === "AssumeProve") generation.contexts.pop();
615
+ addSymbol(generation, definition);
616
+ generation.currentModule.definitions.push(definition);
617
+ if (statement.kind === "AssumeProve") generation.contexts.push(assumeContext);
618
+ }
619
+ const proof = theorem.proof && generateProof(generation, theorem.proof);
620
+ if (statement.kind === "AssumeProve") generation.contexts.pop();
621
+ endProof(generation, body);
622
+ const node: TheoremNode = {
623
+ ...createLevelFields(generation.getId()),
624
+ kind: "Theorem",
625
+ definition,
626
+ body,
627
+ proof,
628
+ isSuffices: false,
629
+ location,
630
+ };
631
+ generation.currentModule.topLevel.push(node);
632
+ };
633
+
634
+ export const processAssumption = (generation: ModuleGeneration, assumption: Assumption) => {
635
+ const location = getUnitLocation(generation.file, assumption.location);
636
+ if (assumption.name !== undefined) pushLabelScope(generation);
637
+ const body = generateExpression(generation, assumption.expression);
638
+ const definition =
639
+ assumption.name === undefined
640
+ ? undefined
641
+ : createTheoremDefinition(
642
+ generation,
643
+ generation.getId(),
644
+ assumption.name,
645
+ body,
646
+ location,
647
+ popLabels(generation),
648
+ false,
649
+ );
650
+ if (definition) {
651
+ addSymbol(generation, definition);
652
+ generation.currentModule.definitions.push(definition);
653
+ }
654
+ const node: AssumeNode = {
655
+ ...createLevelFields(generation.getId()),
656
+ kind: "Assume",
657
+ definition,
658
+ body,
659
+ location,
660
+ };
661
+ generation.currentModule.topLevel.push(node);
662
+ };