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
@@ -70,662 +70,693 @@ export interface Env {
70
70
  rest: Env | undefined;
71
71
  }
72
72
 
73
+ export interface Encoder {
74
+ session: EncodingSession;
75
+ flattener: ReturnType<typeof createFlattener>;
76
+ anonymous: Map<string, number>;
77
+ recordFields: Map<string, string[]>;
78
+ context: ReturnType<typeof createContext>;
79
+ declared: Map<string, Identifier>;
80
+ }
81
+
73
82
  interface NestedContext {
74
83
  env: Env | undefined;
75
84
  mode: Mode;
76
85
  wrappers: ((body: string) => string)[];
77
86
  }
78
87
 
79
- export const createEncoder = (session: EncodingSession) => {
80
- const flattener = createFlattener();
81
- const flatten = flattener.flatten;
82
- const anonymous = new Map<string, number>();
83
- const recordFields = new Map<string, string[]>();
84
- const context = createContext();
85
- const declared = new Map<string, Identifier>();
88
+ const toBool = (term: Term) =>
89
+ term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
86
90
 
87
- const toBool = (term: Term) =>
88
- term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
91
+ const toIdv = (term: Term) =>
92
+ term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
89
93
 
90
- const toIdv = (term: Term) =>
91
- term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
94
+ const wrapBool = (text: string): Term => ({ isBool: true, text });
92
95
 
93
- const wrapBool = (text: string): Term => ({ isBool: true, text });
96
+ const wrapIdv = (text: string): Term => ({ isBool: false, text });
94
97
 
95
- const wrapIdv = (text: string): Term => ({ isBool: false, text });
98
+ const getBinding = (env: Env | undefined, index: number): Binding => {
99
+ const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
100
+ (current) => current?.rest,
101
+ env,
102
+ );
103
+ if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
104
+ return found.binding;
105
+ };
96
106
 
97
- const getBinding = (env: Env | undefined, index: number): Binding => {
98
- const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
99
- (current) => current?.rest,
100
- env,
101
- );
102
- if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
103
- return found.binding;
104
- };
105
-
106
- const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
107
-
108
- const getFree = (text: string, depth: number) =>
109
- [...new Set(text.match(/[^\s()]+#\d+/g))]
110
- .filter((variable) => getDepth(variable) < depth)
111
- .toSorted((left, right) => getDepth(left) - getDepth(right));
112
-
113
- const getUniqueName = (name: string) => {
114
- const identifier = context.adjoin(name);
115
- context.enter(identifier);
116
- declared.set(identifier.name, identifier);
117
- return identifier.name;
118
- };
119
-
120
- const clearPolarity = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
121
-
122
- const invert = (mode: Mode): Mode => ({
123
- ...mode,
124
- polarity:
125
- mode.polarity === "Positive"
126
- ? "Negative"
127
- : mode.polarity === "Negative"
128
- ? "Positive"
129
- : "Neither",
107
+ export const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
108
+
109
+ const getFree = (text: string, depth: number) =>
110
+ [...new Set(text.match(/[^\s()]+#\d+/g))]
111
+ .filter((variable) => getDepth(variable) < depth)
112
+ .toSorted((left, right) => getDepth(left) - getDepth(right));
113
+
114
+ export const getUniqueName = (encoder: Encoder, name: string) => {
115
+ const identifier = encoder.context.adjoin(name);
116
+ encoder.context.enter(identifier);
117
+ encoder.declared.set(identifier.name, identifier);
118
+ return identifier.name;
119
+ };
120
+
121
+ const clearPolarity = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
122
+
123
+ const invert = (mode: Mode): Mode => ({
124
+ ...mode,
125
+ polarity:
126
+ mode.polarity === "Positive"
127
+ ? "Negative"
128
+ : mode.polarity === "Negative"
129
+ ? "Positive"
130
+ : "Neither",
131
+ });
132
+
133
+ export const encodeIdv = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
134
+ toIdv(encode(encoder, expression, env, clearPolarity(mode)));
135
+
136
+ export const encodeBool = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
137
+ toBool(encode(encoder, expression, env, mode));
138
+
139
+ // tlapm's Rewrite encodes each Ditto's copy of a domain, so each copy flattens again.
140
+ const encodeDomains = (encoder: Encoder, bounds: Bound[], env: Env | undefined, mode: Mode) =>
141
+ bounds
142
+ .reduce<(Expr | undefined)[]>((domains, bound) => {
143
+ if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
144
+ if (bound.domain.kind === "NoDomain") return [...domains, undefined];
145
+ return [...domains, bound.domain.expression];
146
+ }, [])
147
+ .map((domain) => (domain === undefined ? undefined : encodeIdv(encoder, domain, env, mode)));
148
+
149
+ const getDomains = (
150
+ encoder: Encoder,
151
+ bounds: Bound[],
152
+ env: Env | undefined,
153
+ mode: Mode,
154
+ construct: string,
155
+ ) =>
156
+ encodeDomains(encoder, bounds, env, mode).map((domain) => {
157
+ if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
158
+ return domain;
130
159
  });
131
160
 
132
- const encodeIdv = (expression: Expr, env: Env | undefined, mode: Mode) =>
133
- toIdv(encode(expression, env, clearPolarity(mode)));
134
-
135
- const encodeBool = (expression: Expr, env: Env | undefined, mode: Mode) =>
136
- toBool(encode(expression, env, mode));
137
-
138
- // tlapm's Rewrite encodes each Ditto's copy of a domain, so each copy flattens again.
139
- const encodeDomains = (bounds: Bound[], env: Env | undefined, mode: Mode) =>
140
- bounds
141
- .reduce<(Expr | undefined)[]>((domains, bound) => {
142
- if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
143
- if (bound.domain.kind === "NoDomain") return [...domains, undefined];
144
- return [...domains, bound.domain.expression];
145
- }, [])
146
- .map((domain) => (domain === undefined ? undefined : encodeIdv(domain, env, mode)));
147
-
148
- const getDomains = (bounds: Bound[], env: Env | undefined, mode: Mode, construct: string) =>
149
- encodeDomains(bounds, env, mode).map((domain) => {
150
- if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
151
- return domain;
152
- });
153
-
154
- const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
155
- const variables = names.map((name, index) => getVariable(name, mode.depth + index));
156
- const inner = variables.reduce<Env | undefined>(
157
- (current, symbol) => push(current, { kind: "constant", symbol }),
158
- env,
159
- );
160
- return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
161
- };
162
-
163
- const encodeQuantifier = (
164
- expression: Extract<Expr, { kind: "Quant" }>,
165
- env: Env | undefined,
166
- mode: Mode,
167
- ) => {
168
- const domains = encodeDomains(expression.bounds, env, mode);
169
- const bound = bindVariables(
170
- expression.bounds.map((innerBound) => innerBound.name),
171
- env,
172
- mode,
173
- );
174
- const body = encodeBool(expression.body, bound.env, bound.mode);
175
- const guards = bound.variables.flatMap((variable, index) =>
176
- domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
177
- );
178
- return expression.quantifier === "Forall"
179
- ? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
180
- : `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
181
- };
182
-
183
- const encodeSetSt = (
184
- expression: Extract<Expr, { kind: "SetSt" }>,
185
- env: Env | undefined,
186
- mode: Mode,
187
- ) => {
188
- const domain = encodeIdv(expression.domain, env, mode);
189
- const bound = bindVariables([expression.name], env, clearPolarity(mode));
190
- const body = encodeBool(expression.body, bound.env, bound.mode);
191
- const free = getFree(body, mode.depth);
192
- const symbol = flatten(
193
- "SetSt",
194
- body,
195
- mode,
196
- (name) => getSetStAxioms(name, free, body, bound.variables[0]),
197
- free.length + 1,
198
- );
199
- return wrapIdv(call(symbol, [domain, ...free]));
200
- };
201
-
202
- const encodeSetOf = (
203
- expression: Extract<Expr, { kind: "SetOf" }>,
204
- env: Env | undefined,
205
- mode: Mode,
206
- ) => {
207
- const domains = getDomains(expression.bounds, env, mode, "a set of values");
208
- const bound = bindVariables(
209
- expression.bounds.map((innerBound) => innerBound.name),
210
- env,
211
- clearPolarity(mode),
212
- );
213
- const element = encodeIdv(expression.element, bound.env, bound.mode);
214
- const free = getFree(element, mode.depth);
215
- const count = domains.length;
216
- const symbol = flatten(
217
- `SetOf_${count}`,
218
- element,
219
- mode,
220
- (name) => getSetOfAxioms(name, free, element, bound.variables),
221
- count + free.length,
222
- );
223
- return wrapIdv(call(symbol, [...domains, ...free]));
224
- };
225
-
226
- const encodeFunction = (
227
- expression: Extract<Expr, { kind: "Fcn" }>,
228
- env: Env | undefined,
229
- mode: Mode,
230
- ) => {
231
- const domains = getDomains(expression.bounds, env, mode, "a function");
232
- const domain =
233
- domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
234
- const variable = getVariable(
235
- domains.length === 1 ? expression.bounds[0].name : "x",
236
- mode.depth,
237
- );
238
- const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
239
- const bodyEnv =
240
- domains.length === 1
241
- ? push(env, { kind: "constant", symbol: variable })
242
- : getIntegers(domains.length).reduce<Env | undefined>(
243
- (current, key) =>
244
- push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
245
- env,
246
- );
247
- const body = encodeIdv(expression.body, bodyEnv, inner);
248
- const free = getFree(body, mode.depth);
249
- const symbol = flatten(
250
- "FunFcn",
251
- body,
252
- mode,
253
- (name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
254
- free.length + 1,
255
- );
256
- return wrapIdv(call(symbol, [domain, ...free]));
257
- };
258
-
259
- const encodeChoose = (
260
- expression: Extract<Expr, { kind: "Choose" }>,
261
- env: Env | undefined,
262
- mode: Mode,
263
- ) => {
264
- const bound = bindVariables([expression.name], env, clearPolarity(mode));
265
- const variable = bound.variables[0];
266
- const domain =
267
- expression.domain && `(${MEM} ${variable} ${encodeIdv(expression.domain, env, mode)})`;
268
- const predicate = encodeBool(expression.body, bound.env, bound.mode);
269
- const body = domain === undefined ? predicate : conjoin([domain, predicate]);
270
- const free = getFree(body, mode.depth);
271
- const symbol = flatten(
272
- "Choose",
273
- body,
274
- mode,
275
- (name) => getChooseAxioms(name, free, body, variable),
276
- free.length,
277
- );
278
- return wrapIdv(call(symbol, free));
279
- };
280
-
281
- const encodeEquality = (args: Expr[], env: Env | undefined, mode: Mode, isNegated: boolean) =>
282
- getEquality(
283
- encodeIdv(args[0], env, mode),
284
- encodeIdv(args[1], env, mode),
285
- mode.polarity,
286
- isNegated,
287
- );
161
+ const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
162
+ const variables = names.map((name, index) => getVariable(name, mode.depth + index));
163
+ const inner = variables.reduce<Env | undefined>(
164
+ (current, symbol) => push(current, { kind: "constant", symbol }),
165
+ env,
166
+ );
167
+ return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
168
+ };
288
169
 
289
- const getSelectionTest = (test: Expr, env: Env | undefined, mode: Mode) => {
290
- const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
291
- const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, clearPolarity(mode));
292
- const body = encodeBool(
293
- lambda?.body ?? {
294
- kind: "Apply",
295
- operator: shiftExpr(1, test),
296
- args: [{ kind: "Ix", index: 1 }],
297
- },
298
- bound.env,
299
- bound.mode,
300
- );
301
- return { body, variable: bound.variables[0] };
302
- };
303
-
304
- const encodeBuiltin = (
305
- builtin: Builtin,
306
- args: Expr[],
307
- env: Env | undefined,
308
- mode: Mode,
309
- ): Term => {
310
- const encodeArgs = () => args.map((arg) => encodeIdv(arg, env, mode));
311
- switch (builtin) {
312
- case "Conj":
313
- return wrapBool(conjoin(args.map((arg) => encodeBool(arg, env, mode))));
314
- case "Disj":
315
- return wrapBool(disjoin(args.map((arg) => encodeBool(arg, env, mode))));
316
- case "Implies":
317
- return wrapBool(
318
- `(=> ${encodeBool(args[0], env, invert(mode))} ${encodeBool(args[1], env, mode)})`,
319
- );
320
- case "Equiv":
321
- return wrapBool(
322
- `(= ${args.map((arg) => encodeBool(arg, env, clearPolarity(mode))).join(" ")})`,
323
- );
324
- case "Neg":
325
- return wrapBool(`(not ${encodeBool(args[0], env, invert(mode))})`);
326
- case "Eq":
327
- return wrapBool(encodeEquality(args, env, mode, false));
328
- case "Neq":
329
- return wrapBool(encodeEquality(args, env, mode, true));
330
- case "Mem":
331
- return wrapBool(call(MEM, encodeArgs()));
332
- case "Notmem":
333
- return wrapBool(`(not ${call(MEM, encodeArgs())})`);
334
- case "Subseteq":
335
- return wrapBool(call(SUBSET_EQ, encodeArgs()));
336
- case "Lteq":
337
- return wrapBool(call(INT_LTEQ, encodeArgs()));
338
- case "Gteq":
339
- return wrapBool(call(INT_LTEQ, encodeArgs().toReversed()));
340
- case "Lt":
341
- case "Gt": {
342
- // Rewrite copies the operands before Flatten, which flattens each copy again.
343
- const getOperands = () => (builtin === "Lt" ? encodeArgs() : encodeArgs().toReversed());
344
- return wrapBool(
345
- `(and ${call(INT_LTEQ, getOperands())} (distinct ${getOperands().join(" ")}))`,
346
- );
347
- }
348
- case "SelectSeq": {
349
- const test = getSelectionTest(args[1], env, mode);
350
- const free = getFree(test.body, mode.depth);
351
- const symbol = flatten(
352
- "SelectSeq",
353
- test.body,
354
- mode,
355
- (name) => getSelectSeqAxioms(name, free, test.body, test.variable),
356
- free.length + 1,
170
+ const encodeQuantifier = (
171
+ encoder: Encoder,
172
+ expression: Extract<Expr, { kind: "Quant" }>,
173
+ env: Env | undefined,
174
+ mode: Mode,
175
+ ) => {
176
+ const domains = encodeDomains(encoder, expression.bounds, env, mode);
177
+ const bound = bindVariables(
178
+ expression.bounds.map((innerBound) => innerBound.name),
179
+ env,
180
+ mode,
181
+ );
182
+ const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
183
+ const guards = bound.variables.flatMap((variable, index) =>
184
+ domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
185
+ );
186
+ return expression.quantifier === "Forall"
187
+ ? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
188
+ : `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
189
+ };
190
+
191
+ const encodeSetSt = (
192
+ encoder: Encoder,
193
+ expression: Extract<Expr, { kind: "SetSt" }>,
194
+ env: Env | undefined,
195
+ mode: Mode,
196
+ ) => {
197
+ const domain = encodeIdv(encoder, expression.domain, env, mode);
198
+ const bound = bindVariables([expression.name], env, clearPolarity(mode));
199
+ const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
200
+ const free = getFree(body, mode.depth);
201
+ const symbol = encoder.flattener.flatten(
202
+ "SetSt",
203
+ body,
204
+ mode,
205
+ (name) => getSetStAxioms(name, free, body, bound.variables[0]),
206
+ free.length + 1,
207
+ );
208
+ return wrapIdv(call(symbol, [domain, ...free]));
209
+ };
210
+
211
+ const encodeSetOf = (
212
+ encoder: Encoder,
213
+ expression: Extract<Expr, { kind: "SetOf" }>,
214
+ env: Env | undefined,
215
+ mode: Mode,
216
+ ) => {
217
+ const domains = getDomains(encoder, expression.bounds, env, mode, "a set of values");
218
+ const bound = bindVariables(
219
+ expression.bounds.map((innerBound) => innerBound.name),
220
+ env,
221
+ clearPolarity(mode),
222
+ );
223
+ const element = encodeIdv(encoder, expression.element, bound.env, bound.mode);
224
+ const free = getFree(element, mode.depth);
225
+ const count = domains.length;
226
+ const symbol = encoder.flattener.flatten(
227
+ `SetOf_${count}`,
228
+ element,
229
+ mode,
230
+ (name) => getSetOfAxioms(name, free, element, bound.variables),
231
+ count + free.length,
232
+ );
233
+ return wrapIdv(call(symbol, [...domains, ...free]));
234
+ };
235
+
236
+ const encodeFunction = (
237
+ encoder: Encoder,
238
+ expression: Extract<Expr, { kind: "Fcn" }>,
239
+ env: Env | undefined,
240
+ mode: Mode,
241
+ ) => {
242
+ const domains = getDomains(encoder, expression.bounds, env, mode, "a function");
243
+ const domain =
244
+ domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
245
+ const variable = getVariable(domains.length === 1 ? expression.bounds[0].name : "x", mode.depth);
246
+ const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
247
+ const bodyEnv =
248
+ domains.length === 1
249
+ ? push(env, { kind: "constant", symbol: variable })
250
+ : getIntegers(domains.length).reduce<Env | undefined>(
251
+ (current, key) =>
252
+ push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
253
+ env,
357
254
  );
358
- return wrapIdv(call(symbol, [encodeIdv(args[0], env, mode), ...free]));
359
- }
360
- case "Unprimable": {
361
- const term = encode(args[0], env, clearPolarity(mode));
362
- return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
363
- }
364
- default: {
365
- const symbol = BUILTIN_SYMBOLS[builtin];
366
- if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
367
- return wrapIdv(call(symbol, encodeArgs()));
368
- }
255
+ const body = encodeIdv(encoder, expression.body, bodyEnv, inner);
256
+ const free = getFree(body, mode.depth);
257
+ const symbol = encoder.flattener.flatten(
258
+ "FunFcn",
259
+ body,
260
+ mode,
261
+ (name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
262
+ free.length + 1,
263
+ );
264
+ return wrapIdv(call(symbol, [domain, ...free]));
265
+ };
266
+
267
+ const encodeChoose = (
268
+ encoder: Encoder,
269
+ expression: Extract<Expr, { kind: "Choose" }>,
270
+ env: Env | undefined,
271
+ mode: Mode,
272
+ ) => {
273
+ const bound = bindVariables([expression.name], env, clearPolarity(mode));
274
+ const variable = bound.variables[0];
275
+ const domain =
276
+ expression.domain && `(${MEM} ${variable} ${encodeIdv(encoder, expression.domain, env, mode)})`;
277
+ const predicate = encodeBool(encoder, expression.body, bound.env, bound.mode);
278
+ const body = domain === undefined ? predicate : conjoin([domain, predicate]);
279
+ const free = getFree(body, mode.depth);
280
+ const symbol = encoder.flattener.flatten(
281
+ "Choose",
282
+ body,
283
+ mode,
284
+ (name) => getChooseAxioms(name, free, body, variable),
285
+ free.length,
286
+ );
287
+ return wrapIdv(call(symbol, free));
288
+ };
289
+
290
+ const encodeEquality = (
291
+ encoder: Encoder,
292
+ args: Expr[],
293
+ env: Env | undefined,
294
+ mode: Mode,
295
+ isNegated: boolean,
296
+ ) =>
297
+ getEquality(
298
+ encodeIdv(encoder, args[0], env, mode),
299
+ encodeIdv(encoder, args[1], env, mode),
300
+ mode.polarity,
301
+ isNegated,
302
+ );
303
+
304
+ const getSelectionTest = (encoder: Encoder, test: Expr, env: Env | undefined, mode: Mode) => {
305
+ const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
306
+ const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, clearPolarity(mode));
307
+ const body = encodeBool(
308
+ encoder,
309
+ lambda?.body ?? {
310
+ kind: "Apply",
311
+ operator: shiftExpr(1, test),
312
+ args: [{ kind: "Ix", index: 1 }],
313
+ },
314
+ bound.env,
315
+ bound.mode,
316
+ );
317
+ return { body, variable: bound.variables[0] };
318
+ };
319
+
320
+ const encodeBuiltin = (
321
+ encoder: Encoder,
322
+ builtin: Builtin,
323
+ args: Expr[],
324
+ env: Env | undefined,
325
+ mode: Mode,
326
+ ): Term => {
327
+ const encodeArgs = () => args.map((arg) => encodeIdv(encoder, arg, env, mode));
328
+ switch (builtin) {
329
+ case "Conj":
330
+ return wrapBool(conjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
331
+ case "Disj":
332
+ return wrapBool(disjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
333
+ case "Implies":
334
+ return wrapBool(
335
+ `(=> ${encodeBool(encoder, args[0], env, invert(mode))} ${encodeBool(encoder, args[1], env, mode)})`,
336
+ );
337
+ case "Equiv":
338
+ return wrapBool(
339
+ `(= ${args.map((arg) => encodeBool(encoder, arg, env, clearPolarity(mode))).join(" ")})`,
340
+ );
341
+ case "Neg":
342
+ return wrapBool(`(not ${encodeBool(encoder, args[0], env, invert(mode))})`);
343
+ case "Eq":
344
+ return wrapBool(encodeEquality(encoder, args, env, mode, false));
345
+ case "Neq":
346
+ return wrapBool(encodeEquality(encoder, args, env, mode, true));
347
+ case "Mem":
348
+ return wrapBool(call(MEM, encodeArgs()));
349
+ case "Notmem":
350
+ return wrapBool(`(not ${call(MEM, encodeArgs())})`);
351
+ case "Subseteq":
352
+ return wrapBool(call(SUBSET_EQ, encodeArgs()));
353
+ case "Lteq":
354
+ return wrapBool(call(INT_LTEQ, encodeArgs()));
355
+ case "Gteq":
356
+ return wrapBool(call(INT_LTEQ, encodeArgs().toReversed()));
357
+ case "Lt":
358
+ case "Gt": {
359
+ // Rewrite copies the operands before Flatten, which flattens each copy again.
360
+ const getOperands = () => (builtin === "Lt" ? encodeArgs() : encodeArgs().toReversed());
361
+ return wrapBool(
362
+ `(and ${call(INT_LTEQ, getOperands())} (distinct ${getOperands().join(" ")}))`,
363
+ );
369
364
  }
370
- };
371
-
372
- const encodeReference = (
373
- binding: Binding,
374
- args: Expr[],
375
- env: Env | undefined,
376
- mode: Mode,
377
- ): Term => {
378
- switch (binding.kind) {
379
- case "constant":
380
- case "variable":
381
- if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
382
- return wrapIdv(binding.symbol);
383
- case "operator":
384
- if (args.length !== binding.arity)
385
- throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
386
- return wrapIdv(
387
- call(
388
- binding.symbol,
389
- args.map((arg) => encodeIdv(arg, env, mode)),
390
- ),
391
- );
392
- case "secondOrder": {
393
- if (args.length !== binding.shapes.length)
394
- throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
395
- const operands = args.map((arg, index) => {
396
- if (binding.shapes[index] === 0)
397
- return { isFirstOrder: true, text: encodeIdv(arg, env, mode) };
398
- if (arg.kind === "Ix") {
399
- const argument = getBinding(env, arg.index);
400
- if (argument.kind !== "operator")
401
- throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
402
- return { isFirstOrder: false, text: argument.symbol };
403
- }
404
- if (arg.kind !== "Lambda")
405
- throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
406
- const bound = bindVariables(
407
- arg.params.map((param) => param.name),
408
- env,
409
- clearPolarity(mode),
410
- );
411
- return { isFirstOrder: false, text: encodeIdv(arg.body, bound.env, bound.mode) };
412
- });
413
- const firstOrder = operands.flatMap((operand) =>
414
- operand.isFirstOrder ? [operand.text] : [],
415
- );
416
- const higherOrder = operands.flatMap((operand) =>
417
- operand.isFirstOrder ? [] : [operand.text],
418
- );
419
- const free = getFree(higherOrder.join(" "), mode.depth);
420
- const symbol = flatten(
421
- "",
422
- higherOrder.join(" "),
423
- mode,
424
- () => [],
425
- firstOrder.length + free.length,
426
- binding.name,
427
- );
428
- return wrapIdv(call(symbol, [...firstOrder, ...free]));
429
- }
430
- case "unsupported":
431
- throw new TlaUnsupportedError(binding.reason);
365
+ case "SelectSeq": {
366
+ const test = getSelectionTest(encoder, args[1], env, mode);
367
+ const free = getFree(test.body, mode.depth);
368
+ const symbol = encoder.flattener.flatten(
369
+ "SelectSeq",
370
+ test.body,
371
+ mode,
372
+ (name) => getSelectSeqAxioms(name, free, test.body, test.variable),
373
+ free.length + 1,
374
+ );
375
+ return wrapIdv(call(symbol, [encodeIdv(encoder, args[0], env, mode), ...free]));
432
376
  }
433
- };
434
-
435
- const getPrimed = (env: Env | undefined, name: string): string => {
436
- if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
437
- const binding = env.binding;
438
- return binding.kind === "variable" && binding.name === name
439
- ? binding.primed
440
- : getPrimed(env.rest, name);
441
- };
442
-
443
- const encodeOpaque = (name: string, args: Expr[], env: Env | undefined, mode: Mode) => {
444
- if (args.length === 0 && name.endsWith("#prime"))
445
- return wrapIdv(getPrimed(env, name.slice(0, -"#prime".length)));
446
- const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
447
- anonymous.set(anonymousName, args.length);
448
- return wrapIdv(
449
- call(
450
- tla(anonymousName),
451
- args.map((arg) => encodeIdv(arg, env, mode)),
452
- ),
453
- );
454
- };
455
-
456
- const encodeExcept = (
457
- expression: Extract<Expr, { kind: "Except" }>,
458
- env: Env | undefined,
459
- mode: Mode,
460
- ) =>
461
- expression.specs.reduce(
462
- (base, spec) => {
463
- const update = (value: string, trail: typeof spec.trail): string => {
464
- if (trail.length === 0) return encodeIdv(spec.value, env, { ...mode, at: value });
465
- const point = trail[0];
466
- const encodeKey = () =>
467
- point.kind === "Dot"
468
- ? tla(`StrLit_${point.field}`)
469
- : encodeIdv(point.expression, env, mode);
470
- const key = encodeKey();
471
- // Elab.desugar repeats the key in the value it updates, and Flatten counts both.
472
- const inner = update(
473
- `(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
474
- trail.slice(1),
475
- );
476
- return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
477
- };
478
- return update(base, spec.trail);
479
- },
480
- encodeIdv(expression.function, env, mode),
481
- );
377
+ case "Unprimable": {
378
+ const term = encode(encoder, args[0], env, clearPolarity(mode));
379
+ return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
380
+ }
381
+ default: {
382
+ const symbol = BUILTIN_SYMBOLS[builtin];
383
+ if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
384
+ return wrapIdv(call(symbol, encodeArgs()));
385
+ }
386
+ }
387
+ };
482
388
 
483
- const getCaseError = () => {
484
- session.caseErrors++;
485
- const name = `Anon_incomplete_case_error_${session.caseErrors}`;
486
- anonymous.set(name, 0);
487
- return tla(name);
488
- };
489
-
490
- const encodeCase = (
491
- expression: Extract<Expr, { kind: "Case" }>,
492
- env: Env | undefined,
493
- mode: Mode,
494
- ): Term => {
495
- const bodies = expression.arms.map((arm) => encode(arm.body, env, mode));
496
- const other: Term = expression.other
497
- ? encode(expression.other, env, mode)
498
- : wrapIdv(getCaseError());
499
- const isBool = other.isBool && bodies.every((body) => body.isBool);
500
- const isInteger =
501
- other.integer !== undefined && bodies.every((body) => body.integer !== undefined);
502
- if (isInteger) {
503
- const integer = expression.arms.reduceRight(
504
- (rest, arm, index) =>
505
- `(ite ${encodeBool(arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
506
- other.integer ?? "",
389
+ const encodeReference = (
390
+ encoder: Encoder,
391
+ binding: Binding,
392
+ args: Expr[],
393
+ env: Env | undefined,
394
+ mode: Mode,
395
+ ): Term => {
396
+ switch (binding.kind) {
397
+ case "constant":
398
+ case "variable":
399
+ if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
400
+ return wrapIdv(binding.symbol);
401
+ case "operator":
402
+ if (args.length !== binding.arity)
403
+ throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
404
+ return wrapIdv(
405
+ call(
406
+ binding.symbol,
407
+ args.map((arg) => encodeIdv(encoder, arg, env, mode)),
408
+ ),
507
409
  );
508
- return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
410
+ case "secondOrder": {
411
+ if (args.length !== binding.shapes.length)
412
+ throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
413
+ const operands = args.map((arg, index) => {
414
+ if (binding.shapes[index] === 0)
415
+ return { isFirstOrder: true, text: encodeIdv(encoder, arg, env, mode) };
416
+ if (arg.kind === "Ix") {
417
+ const argument = getBinding(env, arg.index);
418
+ if (argument.kind !== "operator")
419
+ throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
420
+ return { isFirstOrder: false, text: argument.symbol };
421
+ }
422
+ if (arg.kind !== "Lambda")
423
+ throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
424
+ const bound = bindVariables(
425
+ arg.params.map((param) => param.name),
426
+ env,
427
+ clearPolarity(mode),
428
+ );
429
+ return { isFirstOrder: false, text: encodeIdv(encoder, arg.body, bound.env, bound.mode) };
430
+ });
431
+ const firstOrder = operands.flatMap((operand) =>
432
+ operand.isFirstOrder ? [operand.text] : [],
433
+ );
434
+ const higherOrder = operands.flatMap((operand) =>
435
+ operand.isFirstOrder ? [] : [operand.text],
436
+ );
437
+ const free = getFree(higherOrder.join(" "), mode.depth);
438
+ const symbol = encoder.flattener.flatten(
439
+ "",
440
+ higherOrder.join(" "),
441
+ mode,
442
+ () => [],
443
+ firstOrder.length + free.length,
444
+ binding.name,
445
+ );
446
+ return wrapIdv(call(symbol, [...firstOrder, ...free]));
509
447
  }
510
- const convert = (term: Term) => (isBool ? term.text : toIdv(term));
511
- const text = expression.arms.reduceRight(
448
+ case "unsupported":
449
+ throw new TlaUnsupportedError(binding.reason);
450
+ }
451
+ };
452
+
453
+ const getPrimed = (env: Env | undefined, name: string): string => {
454
+ if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
455
+ const binding = env.binding;
456
+ return binding.kind === "variable" && binding.name === name
457
+ ? binding.primed
458
+ : getPrimed(env.rest, name);
459
+ };
460
+
461
+ const encodeOpaque = (
462
+ encoder: Encoder,
463
+ name: string,
464
+ args: Expr[],
465
+ env: Env | undefined,
466
+ mode: Mode,
467
+ ) => {
468
+ if (args.length === 0 && name.endsWith("#prime"))
469
+ return wrapIdv(getPrimed(env, name.slice(0, -"#prime".length)));
470
+ const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
471
+ encoder.anonymous.set(anonymousName, args.length);
472
+ return wrapIdv(
473
+ call(
474
+ tla(anonymousName),
475
+ args.map((arg) => encodeIdv(encoder, arg, env, mode)),
476
+ ),
477
+ );
478
+ };
479
+
480
+ const encodeExcept = (
481
+ encoder: Encoder,
482
+ expression: Extract<Expr, { kind: "Except" }>,
483
+ env: Env | undefined,
484
+ mode: Mode,
485
+ ) =>
486
+ expression.specs.reduce(
487
+ (base, spec) => {
488
+ const update = (value: string, trail: typeof spec.trail): string => {
489
+ if (trail.length === 0) return encodeIdv(encoder, spec.value, env, { ...mode, at: value });
490
+ const point = trail[0];
491
+ const encodeKey = () =>
492
+ point.kind === "Dot"
493
+ ? tla(`StrLit_${point.field}`)
494
+ : encodeIdv(encoder, point.expression, env, mode);
495
+ const key = encodeKey();
496
+ // Elab.desugar repeats the key in the value it updates, and Flatten counts both.
497
+ const inner = update(
498
+ `(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
499
+ trail.slice(1),
500
+ );
501
+ return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
502
+ };
503
+ return update(base, spec.trail);
504
+ },
505
+ encodeIdv(encoder, expression.function, env, mode),
506
+ );
507
+
508
+ const getCaseError = (encoder: Encoder) => {
509
+ encoder.session.caseErrors++;
510
+ const name = `Anon_incomplete_case_error_${encoder.session.caseErrors}`;
511
+ encoder.anonymous.set(name, 0);
512
+ return tla(name);
513
+ };
514
+
515
+ const encodeCase = (
516
+ encoder: Encoder,
517
+ expression: Extract<Expr, { kind: "Case" }>,
518
+ env: Env | undefined,
519
+ mode: Mode,
520
+ ): Term => {
521
+ const bodies = expression.arms.map((arm) => encode(encoder, arm.body, env, mode));
522
+ const other: Term = expression.other
523
+ ? encode(encoder, expression.other, env, mode)
524
+ : wrapIdv(getCaseError(encoder));
525
+ const isBool = other.isBool && bodies.every((body) => body.isBool);
526
+ const isInteger =
527
+ other.integer !== undefined && bodies.every((body) => body.integer !== undefined);
528
+ if (isInteger) {
529
+ const integer = expression.arms.reduceRight(
512
530
  (rest, arm, index) =>
513
- `(ite ${encodeBool(arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
514
- convert(other),
531
+ `(ite ${encodeBool(encoder, arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
532
+ other.integer ?? "",
515
533
  );
516
- return { isBool, text };
517
- };
518
-
519
- const encodeSequent = (sequent: Sequent, env: Env | undefined, mode: Mode): string => {
520
- const steps = sequent.context.reduce<NestedContext>(
521
- (state, hyp) => {
522
- switch (hyp.kind) {
523
- case "Fresh": {
524
- if (hyp.shape > 0) {
525
- if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
526
- const variable = getVariable(hyp.name, state.mode.depth);
527
- return {
528
- env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
529
- mode: { ...state.mode, depth: state.mode.depth + 1 },
530
- wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
531
- };
532
- }
533
- if (hyp.level !== "Constant")
534
- throw new TlaUnsupportedError("a NEW declaration that isn't constant");
535
- const domain = hyp.domain && encodeIdv(hyp.domain, state.env, state.mode);
536
- const bound = bindVariables([hyp.name], state.env, state.mode);
537
- const variable = bound.variables[0];
538
- const guard = domain && `(${MEM} ${variable} ${domain})`;
539
- return {
540
- env: bound.env,
541
- mode: bound.mode,
542
- wrappers: [
543
- ...state.wrappers,
544
- (body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
545
- ],
546
- };
547
- }
548
- case "Fact": {
549
- const fact =
550
- hyp.visibility === "Visible"
551
- ? encodeBool(hyp.expression, state.env, invert(state.mode))
552
- : undefined;
534
+ return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
535
+ }
536
+ const convert = (term: Term) => (isBool ? term.text : toIdv(term));
537
+ const text = expression.arms.reduceRight(
538
+ (rest, arm, index) =>
539
+ `(ite ${encodeBool(encoder, arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
540
+ convert(other),
541
+ );
542
+ return { isBool, text };
543
+ };
544
+
545
+ const encodeSequent = (
546
+ encoder: Encoder,
547
+ sequent: Sequent,
548
+ env: Env | undefined,
549
+ mode: Mode,
550
+ ): string => {
551
+ const steps = sequent.context.reduce<NestedContext>(
552
+ (state, hyp) => {
553
+ switch (hyp.kind) {
554
+ case "Fresh": {
555
+ if (hyp.shape > 0) {
556
+ if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
557
+ const variable = getVariable(hyp.name, state.mode.depth);
553
558
  return {
554
- env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
555
- mode: state.mode,
556
- wrappers: fact
557
- ? [...state.wrappers, (body) => `(=> ${fact} ${body})`]
558
- : state.wrappers,
559
+ env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
560
+ mode: { ...state.mode, depth: state.mode.depth + 1 },
561
+ wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
559
562
  };
560
563
  }
561
- default:
562
- throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
564
+ if (hyp.level !== "Constant")
565
+ throw new TlaUnsupportedError("a NEW declaration that isn't constant");
566
+ const domain = hyp.domain && encodeIdv(encoder, hyp.domain, state.env, state.mode);
567
+ const bound = bindVariables([hyp.name], state.env, state.mode);
568
+ const variable = bound.variables[0];
569
+ const guard = domain && `(${MEM} ${variable} ${domain})`;
570
+ return {
571
+ env: bound.env,
572
+ mode: bound.mode,
573
+ wrappers: [
574
+ ...state.wrappers,
575
+ (body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
576
+ ],
577
+ };
563
578
  }
564
- },
565
- { env, mode, wrappers: [] },
566
- );
567
- return steps.wrappers.reduceRight(
568
- (body, wrap) => wrap(body),
569
- encodeBool(sequent.active, steps.env, steps.mode),
570
- );
571
- };
572
-
573
- const encode = (expression: Expr, env: Env | undefined, mode: Mode): Term => {
574
- switch (expression.kind) {
575
- case "Ix":
576
- return encodeReference(getBinding(env, expression.index), [], env, mode);
577
- case "Internal":
578
- switch (expression.builtin) {
579
- case "TRUE":
580
- return wrapBool("true");
581
- case "FALSE":
582
- return wrapBool("false");
583
- case "BOOLEAN":
584
- return wrapIdv(BOOL_SET);
585
- case "STRING":
586
- return wrapIdv(STR_SET);
587
- case "Nat":
588
- return wrapIdv(NAT_SET);
589
- case "Int":
590
- return wrapIdv(INT_SET);
591
- default:
592
- throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
579
+ case "Fact": {
580
+ const fact =
581
+ hyp.visibility === "Visible"
582
+ ? encodeBool(encoder, hyp.expression, state.env, invert(state.mode))
583
+ : undefined;
584
+ return {
585
+ env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
586
+ mode: state.mode,
587
+ wrappers: fact ? [...state.wrappers, (body) => `(=> ${fact} ${body})`] : state.wrappers,
588
+ };
593
589
  }
594
- case "Apply": {
595
- const operator = expression.operator;
596
- if (operator.kind === "Internal")
597
- return encodeBuiltin(operator.builtin, expression.args, env, mode);
598
- if (operator.kind === "Ix")
599
- return encodeReference(getBinding(env, operator.index), expression.args, env, mode);
600
- if (operator.kind === "Opaque")
601
- return encodeOpaque(operator.name, expression.args, env, mode);
602
- if (operator.kind === "Lambda")
603
- return encode(normalizeApply(operator, expression.args), env, mode);
604
- throw new TlaUnsupportedError(`an application of ${operator.kind}`);
590
+ default:
591
+ throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
605
592
  }
606
- case "Sequent":
607
- return wrapBool(encodeSequent(expression.sequent, env, mode));
608
- case "With":
609
- case "Parens":
610
- return encode(expression.expression, env, mode);
611
- case "If": {
612
- const condition = encodeBool(expression.condition, env, mode);
613
- const consequent = encode(expression.consequent, env, mode);
614
- const alternative = encode(expression.alternative, env, mode);
615
- if (consequent.integer !== undefined && alternative.integer !== undefined) {
616
- const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
617
- return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
618
- }
619
- return consequent.isBool && alternative.isBool
620
- ? wrapBool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
621
- : wrapIdv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
622
- }
623
- case "List": {
624
- const items = expression.items.map((item) => encodeBool(item, env, mode));
625
- return wrapBool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
626
- }
627
- case "Opaque":
628
- return encodeOpaque(expression.name, [], env, mode);
629
- case "Quant":
630
- return wrapBool(encodeQuantifier(expression, env, mode));
631
- case "Choose":
632
- return encodeChoose(expression, env, mode);
633
- case "SetSt":
634
- return encodeSetSt(expression, env, mode);
635
- case "SetOf":
636
- return encodeSetOf(expression, env, mode);
637
- case "SetEnum":
638
- return wrapIdv(
639
- call(
640
- tla(`SetEnum_${expression.elements.length}`),
641
- expression.elements.map((element) => encodeIdv(element, env, mode)),
642
- ),
643
- );
644
- case "Product":
645
- return wrapIdv(
646
- call(
647
- tla(`Product_${expression.factors.length}`),
648
- expression.factors.map((factor) => encodeIdv(factor, env, mode)),
649
- ),
650
- );
651
- case "Tuple":
652
- return wrapIdv(
653
- call(
654
- tla(`Tuple_${expression.elements.length}`),
655
- expression.elements.map((element) => encodeIdv(element, env, mode)),
656
- ),
657
- );
658
- case "Fcn":
659
- return encodeFunction(expression, env, mode);
660
- case "FcnApp": {
661
- const encodedFunction = encodeIdv(expression.function, env, mode);
662
- const args = expression.args.map((arg) => encodeIdv(arg, env, mode));
663
- const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
664
- return wrapIdv(`(${FUN_APP} ${encodedFunction} ${argument})`);
593
+ },
594
+ { env, mode, wrappers: [] },
595
+ );
596
+ return steps.wrappers.reduceRight(
597
+ (body, wrap) => wrap(body),
598
+ encodeBool(encoder, sequent.active, steps.env, steps.mode),
599
+ );
600
+ };
601
+
602
+ const encode = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode): Term => {
603
+ switch (expression.kind) {
604
+ case "Ix":
605
+ return encodeReference(encoder, getBinding(env, expression.index), [], env, mode);
606
+ case "Internal":
607
+ switch (expression.builtin) {
608
+ case "TRUE":
609
+ return wrapBool("true");
610
+ case "FALSE":
611
+ return wrapBool("false");
612
+ case "BOOLEAN":
613
+ return wrapIdv(BOOL_SET);
614
+ case "STRING":
615
+ return wrapIdv(STR_SET);
616
+ case "Nat":
617
+ return wrapIdv(NAT_SET);
618
+ case "Int":
619
+ return wrapIdv(INT_SET);
620
+ default:
621
+ throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
665
622
  }
666
- case "Arrow":
667
- return wrapIdv(
668
- call(FUN_SET, [
669
- encodeIdv(expression.domain, env, mode),
670
- encodeIdv(expression.range, env, mode),
671
- ]),
672
- );
673
- case "Record":
674
- case "Rect": {
675
- const names = expression.fields.map((field) => field.name);
676
- const suffix = names.join("_");
677
- recordFields.set(`Record_${suffix}`, names);
678
- recordFields.set(`RecordSet_${suffix}`, names);
679
- return wrapIdv(
680
- call(
681
- tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
682
- expression.fields.map((field) => encodeIdv(field.value, env, mode)),
683
- ),
623
+ case "Apply": {
624
+ const operator = expression.operator;
625
+ if (operator.kind === "Internal")
626
+ return encodeBuiltin(encoder, operator.builtin, expression.args, env, mode);
627
+ if (operator.kind === "Ix")
628
+ return encodeReference(
629
+ encoder,
630
+ getBinding(env, operator.index),
631
+ expression.args,
632
+ env,
633
+ mode,
684
634
  );
635
+ if (operator.kind === "Opaque")
636
+ return encodeOpaque(encoder, operator.name, expression.args, env, mode);
637
+ if (operator.kind === "Lambda")
638
+ return encode(encoder, normalizeApply(operator, expression.args), env, mode);
639
+ throw new TlaUnsupportedError(`an application of ${operator.kind}`);
640
+ }
641
+ case "Sequent":
642
+ return wrapBool(encodeSequent(encoder, expression.sequent, env, mode));
643
+ case "With":
644
+ case "Parens":
645
+ return encode(encoder, expression.expression, env, mode);
646
+ case "If": {
647
+ const condition = encodeBool(encoder, expression.condition, env, mode);
648
+ const consequent = encode(encoder, expression.consequent, env, mode);
649
+ const alternative = encode(encoder, expression.alternative, env, mode);
650
+ if (consequent.integer !== undefined && alternative.integer !== undefined) {
651
+ const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
652
+ return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
685
653
  }
686
- case "Except":
687
- return wrapIdv(encodeExcept(expression, env, mode));
688
- case "Dot":
689
- return wrapIdv(
690
- `(${FUN_APP} ${encodeIdv(expression.expression, env, mode)} ${tla(`StrLit_${expression.field}`)})`,
691
- );
692
- case "Case":
693
- return encodeCase(expression, env, mode);
694
- case "String":
695
- return wrapIdv(tla(`StrLit_${expression.value}`));
696
- case "Num":
697
- if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
698
- return {
699
- isBool: false,
700
- text: `(${CAST_INT} ${BigInt(expression.integer)})`,
701
- integer: String(BigInt(expression.integer)),
702
- };
703
- case "At":
704
- if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
705
- return wrapIdv(mode.at);
706
- case "Tquant":
707
- case "Tsub":
708
- case "Fair":
709
- throw new TlaUnsupportedError("a temporal formula");
710
- default:
711
- throw new TlaUnsupportedError(`the expression ${expression.kind}`);
654
+ return consequent.isBool && alternative.isBool
655
+ ? wrapBool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
656
+ : wrapIdv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
657
+ }
658
+ case "List": {
659
+ const items = expression.items.map((item) => encodeBool(encoder, item, env, mode));
660
+ return wrapBool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
661
+ }
662
+ case "Opaque":
663
+ return encodeOpaque(encoder, expression.name, [], env, mode);
664
+ case "Quant":
665
+ return wrapBool(encodeQuantifier(encoder, expression, env, mode));
666
+ case "Choose":
667
+ return encodeChoose(encoder, expression, env, mode);
668
+ case "SetSt":
669
+ return encodeSetSt(encoder, expression, env, mode);
670
+ case "SetOf":
671
+ return encodeSetOf(encoder, expression, env, mode);
672
+ case "SetEnum":
673
+ return wrapIdv(
674
+ call(
675
+ tla(`SetEnum_${expression.elements.length}`),
676
+ expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
677
+ ),
678
+ );
679
+ case "Product":
680
+ return wrapIdv(
681
+ call(
682
+ tla(`Product_${expression.factors.length}`),
683
+ expression.factors.map((factor) => encodeIdv(encoder, factor, env, mode)),
684
+ ),
685
+ );
686
+ case "Tuple":
687
+ return wrapIdv(
688
+ call(
689
+ tla(`Tuple_${expression.elements.length}`),
690
+ expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
691
+ ),
692
+ );
693
+ case "Fcn":
694
+ return encodeFunction(encoder, expression, env, mode);
695
+ case "FcnApp": {
696
+ const encodedFunction = encodeIdv(encoder, expression.function, env, mode);
697
+ const args = expression.args.map((arg) => encodeIdv(encoder, arg, env, mode));
698
+ const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
699
+ return wrapIdv(`(${FUN_APP} ${encodedFunction} ${argument})`);
700
+ }
701
+ case "Arrow":
702
+ return wrapIdv(
703
+ call(FUN_SET, [
704
+ encodeIdv(encoder, expression.domain, env, mode),
705
+ encodeIdv(encoder, expression.range, env, mode),
706
+ ]),
707
+ );
708
+ case "Record":
709
+ case "Rect": {
710
+ const names = expression.fields.map((field) => field.name);
711
+ const suffix = names.join("_");
712
+ encoder.recordFields.set(`Record_${suffix}`, names);
713
+ encoder.recordFields.set(`RecordSet_${suffix}`, names);
714
+ return wrapIdv(
715
+ call(
716
+ tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
717
+ expression.fields.map((field) => encodeIdv(encoder, field.value, env, mode)),
718
+ ),
719
+ );
712
720
  }
713
- };
714
-
715
- const getEntries = (line: string): Entry[] => [
716
- ...flattener.takeIntroduced(),
717
- removeUnprimable(resolveTriggers(line, false)),
718
- ];
719
-
720
- return {
721
- encodeIdv,
722
- encodeBool,
723
- push,
724
- getEntries,
725
- getUniqueName,
726
- flattened: flattener.flattened,
727
- anonymous,
728
- recordFields,
729
- declared,
730
- };
721
+ case "Except":
722
+ return wrapIdv(encodeExcept(encoder, expression, env, mode));
723
+ case "Dot":
724
+ return wrapIdv(
725
+ `(${FUN_APP} ${encodeIdv(encoder, expression.expression, env, mode)} ${tla(`StrLit_${expression.field}`)})`,
726
+ );
727
+ case "Case":
728
+ return encodeCase(encoder, expression, env, mode);
729
+ case "String":
730
+ return wrapIdv(tla(`StrLit_${expression.value}`));
731
+ case "Num":
732
+ if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
733
+ return {
734
+ isBool: false,
735
+ text: `(${CAST_INT} ${BigInt(expression.integer)})`,
736
+ integer: String(BigInt(expression.integer)),
737
+ };
738
+ case "At":
739
+ if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
740
+ return wrapIdv(mode.at);
741
+ case "Tquant":
742
+ case "Tsub":
743
+ case "Fair":
744
+ throw new TlaUnsupportedError("a temporal formula");
745
+ default:
746
+ throw new TlaUnsupportedError(`the expression ${expression.kind}`);
747
+ }
731
748
  };
749
+
750
+ export const getEntries = (encoder: Encoder, line: string): Entry[] => [
751
+ ...encoder.flattener.takeIntroduced(),
752
+ removeUnprimable(resolveTriggers(line, false)),
753
+ ];
754
+
755
+ export const createEncoder = (session: EncodingSession): Encoder => ({
756
+ session,
757
+ flattener: createFlattener(),
758
+ anonymous: new Map(),
759
+ recordFields: new Map(),
760
+ context: createContext(),
761
+ declared: new Map(),
762
+ });