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
@@ -23,8 +23,6 @@ import { Rational } from "./rational";
23
23
  import { Rewriter } from "./rewriter";
24
24
  import { AufSolver, type Evaluate, InstantiationSet, Node } from "./auf-solver";
25
25
 
26
- export const MBQI_FORCE_TEMPLATE = 10;
27
-
28
26
  type QInfo =
29
27
  | { kind: "f_var"; decl: number; argIndex: number; varIndex: number }
30
28
  | { kind: "f_var_plus_offset"; decl: number; argIndex: number; varIndex: number; offset: number }
@@ -38,6 +36,7 @@ const mkVarPair = (kind: "x_eq_y" | "x_neq_y" | "x_leq_y", first: number, second
38
36
  first > second ? { kind, first: second, second: first } : { kind, first, second };
39
37
 
40
38
  export class QuantifierInfo {
39
+ private manager: AstManager;
41
40
  readonly flatQ: number;
42
41
  qinfos: QInfo[] = [];
43
42
  isAuf = true;
@@ -47,11 +46,12 @@ export class QuantifierInfo {
47
46
  readonly condMacros;
48
47
 
49
48
  constructor(
50
- private manager: AstManager,
51
49
  private context: Context,
52
50
  readonly quantifier: number,
53
51
  macroRewriter: Rewriter,
54
52
  ) {
53
+ const manager = context.manager;
54
+ this.manager = manager;
55
55
  const isNested = manager.hasQuantifierFlags[manager.getQuantifier(quantifier).body];
56
56
  this.flatQ = isNested ? pullQuant(manager, quantifier) : quantifier;
57
57
  if (!isNested) manager.incRef(quantifier);
@@ -262,10 +262,6 @@ export class QuantifierAnalyzer {
262
262
  return { variable, term, isInverted };
263
263
  }
264
264
 
265
- private mkSub(first: number, second: number) {
266
- return this.rewriter.mkSub(first, second);
267
- }
268
-
269
265
  private mkAdd(first: number, second: number) {
270
266
  return this.rewriter.mkAdd([first, second]);
271
267
  }
@@ -279,14 +275,18 @@ export class QuantifierAnalyzer {
279
275
  if (left !== undefined && this.manager.isGround(rhs))
280
276
  return {
281
277
  variable: left.variable,
282
- term: left.isInverted ? this.mkSub(left.term, rhs) : this.mkSub(rhs, left.term),
278
+ term: left.isInverted
279
+ ? this.rewriter.mkSub(left.term, rhs)
280
+ : this.rewriter.mkSub(rhs, left.term),
283
281
  isInverted: left.isInverted,
284
282
  };
285
283
  const right = this.isVarPlusGround(rhs);
286
284
  if (right !== undefined && this.manager.isGround(lhs))
287
285
  return {
288
286
  variable: right.variable,
289
- term: right.isInverted ? this.mkSub(right.term, lhs) : this.mkSub(lhs, right.term),
287
+ term: right.isInverted
288
+ ? this.rewriter.mkSub(right.term, lhs)
289
+ : this.rewriter.mkSub(lhs, right.term),
290
290
  isInverted: right.isInverted,
291
291
  };
292
292
  return undefined;
@@ -332,7 +332,7 @@ export class QuantifierAnalyzer {
332
332
  const one = manager.mkNumeralOfSort(Rational.one, manager.sorts[found.term]);
333
333
  return {
334
334
  variable: found.variable,
335
- term: isLe ? this.mkAdd(found.term, one) : this.mkSub(found.term, one),
335
+ term: isLe ? this.mkAdd(found.term, one) : this.rewriter.mkSub(found.term, one),
336
336
  };
337
337
  }
338
338
 
@@ -45,7 +45,7 @@ export class DefaultQuantifierManager {
45
45
  this.mam = new Mam(context, onMatch);
46
46
  this.lazyMam = new Mam(context, onMatch);
47
47
  if (!isMbqi) return;
48
- const finder = new ModelFinder(context.manager, context);
48
+ const finder = new ModelFinder(context);
49
49
  this.mbqi = { finder, checker: new ModelChecker(context, finder, this) };
50
50
  }
51
51
 
@@ -64,10 +64,6 @@ export class DefaultQuantifierManager {
64
64
  this.generations.delete(quantifier);
65
65
  }
66
66
 
67
- hasQuantifiers() {
68
- return this.quantifiers.length > 0;
69
- }
70
-
71
67
  getGeneration(quantifier: number) {
72
68
  return this.generations.get(quantifier) ?? 0;
73
69
  }
@@ -30,7 +30,6 @@ import {
30
30
  OP_TRUE,
31
31
  OP_FALSE,
32
32
  OP_UMINUS,
33
- OP_UNINTERPRETED,
34
33
  OP_XOR,
35
34
  SORT_BOOL,
36
35
  SORT_INT,
@@ -58,36 +57,56 @@ interface ApplicationFrame {
58
57
  next: number;
59
58
  }
60
59
 
61
- const BUILTIN_OPS = new Map<string, number>([
62
- ["and", OP_AND],
63
- ["or", OP_OR],
64
- ["not", OP_NOT],
65
- ["=>", OP_IMPLIES],
66
- ["xor", OP_XOR],
67
- ["ite", OP_ITE],
68
- ["distinct", OP_DISTINCT],
69
- ["+", OP_ADD],
70
- ["*", OP_MUL],
71
- ["/", OP_DIV],
72
- ["div", OP_IDIV],
73
- ["mod", OP_MOD],
74
- ["abs", OP_ABS],
75
- ["to_real", OP_TO_REAL],
76
- ["to_int", OP_TO_INT],
77
- ["is_int", OP_IS_INT],
78
- ]);
60
+ interface Operator {
61
+ op: number;
62
+ symbol?: string;
63
+ isChainable?: boolean;
64
+ arity: [min: number, max: number];
65
+ domain: "join" | "branches" | "arith" | "first" | number;
66
+ range: "domain" | number;
67
+ }
79
68
 
80
- const COERCING_OPS = new Set([OP_ADD, OP_SUB, OP_UMINUS, OP_MUL, OP_LE, OP_GE, OP_LT, OP_GT]);
69
+ const OPERATORS: Operator[] = [
70
+ { op: OP_AND, symbol: "and", arity: [0, Infinity], domain: SORT_BOOL, range: SORT_BOOL },
71
+ { op: OP_OR, symbol: "or", arity: [0, Infinity], domain: SORT_BOOL, range: SORT_BOOL },
72
+ { op: OP_NOT, symbol: "not", arity: [1, 1], domain: SORT_BOOL, range: SORT_BOOL },
73
+ { op: OP_IMPLIES, symbol: "=>", arity: [2, 2], domain: SORT_BOOL, range: SORT_BOOL },
74
+ { op: OP_XOR, symbol: "xor", arity: [2, 2], domain: SORT_BOOL, range: SORT_BOOL },
75
+ { op: OP_ITE, symbol: "ite", arity: [3, 3], domain: "branches", range: "domain" },
76
+ { op: OP_DISTINCT, symbol: "distinct", arity: [2, Infinity], domain: "join", range: SORT_BOOL },
77
+ { op: OP_ADD, symbol: "+", arity: [1, Infinity], domain: "arith", range: "domain" },
78
+ { op: OP_MUL, symbol: "*", arity: [1, Infinity], domain: "arith", range: "domain" },
79
+ { op: OP_DIV, symbol: "/", arity: [2, 2], domain: SORT_REAL, range: SORT_REAL },
80
+ { op: OP_IDIV, symbol: "div", arity: [2, 2], domain: SORT_INT, range: SORT_INT },
81
+ { op: OP_MOD, symbol: "mod", arity: [2, 2], domain: SORT_INT, range: SORT_INT },
82
+ { op: OP_ABS, symbol: "abs", arity: [1, 1], domain: "first", range: "domain" },
83
+ { op: OP_TO_REAL, symbol: "to_real", arity: [1, 1], domain: "first", range: SORT_REAL },
84
+ { op: OP_TO_INT, symbol: "to_int", arity: [1, 1], domain: "first", range: SORT_INT },
85
+ { op: OP_IS_INT, symbol: "is_int", arity: [1, 1], domain: SORT_REAL, range: SORT_BOOL },
86
+ {
87
+ op: OP_EQ,
88
+ symbol: "=",
89
+ isChainable: true,
90
+ arity: [2, Infinity],
91
+ domain: "join",
92
+ range: SORT_BOOL,
93
+ },
94
+ { op: OP_LE, symbol: "<=", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
95
+ { op: OP_GE, symbol: ">=", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
96
+ { op: OP_LT, symbol: "<", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
97
+ { op: OP_GT, symbol: ">", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
98
+ { op: OP_SUB, arity: [1, Infinity], domain: "arith", range: "domain" },
99
+ { op: OP_UMINUS, arity: [1, 1], domain: "arith", range: "domain" },
100
+ ];
81
101
 
82
- const DECIMAL = /^([0-9]+)\.([0-9]+)$/;
102
+ const OPERATORS_BY_OP = new Map<number, Operator>();
103
+ const OPERATORS_BY_SYMBOL = new Map<string, Operator>();
104
+ for (const operator of OPERATORS) {
105
+ OPERATORS_BY_OP.set(operator.op, operator);
106
+ if (operator.symbol !== undefined) OPERATORS_BY_SYMBOL.set(operator.symbol, operator);
107
+ }
83
108
 
84
- const CHAINABLE_OPS = new Map<string, number>([
85
- ["=", OP_EQ],
86
- ["<=", OP_LE],
87
- [">=", OP_GE],
88
- ["<", OP_LT],
89
- [">", OP_GT],
90
- ]);
109
+ const DECIMAL = /^([0-9]+)\.([0-9]+)$/;
91
110
 
92
111
  const tokenize = (text: string) => {
93
112
  const tokens: string[] = [];
@@ -183,30 +202,13 @@ export const parseSmtlib = (
183
202
  return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
184
203
  };
185
204
 
186
- const getDomainSort = (op: number, args: number[]) => {
187
- if (op === OP_ITE) return getJoin(args.slice(1));
188
- if (op === OP_EQ || op === OP_DISTINCT) return getJoin(args);
189
- if (COERCING_OPS.has(op)) return getJoin(args) === SORT_REAL ? SORT_REAL : SORT_INT;
190
- if (op === OP_ABS || op === OP_TO_REAL || op === OP_TO_INT) return manager.sorts[args[0]];
191
- if (op === OP_IDIV || op === OP_MOD) return SORT_INT;
192
- if (op === OP_DIV || op === OP_IS_INT) return SORT_REAL;
193
- return SORT_BOOL;
205
+ const getDomainSort = (operator: Operator, args: number[]) => {
206
+ if (operator.domain === "branches") return getJoin(args.slice(1));
207
+ if (operator.domain === "join") return getJoin(args);
208
+ if (operator.domain === "arith") return getJoin(args) === SORT_REAL ? SORT_REAL : SORT_INT;
209
+ return operator.domain === "first" ? manager.sorts[args[0]] : operator.domain;
194
210
  };
195
211
 
196
- const getRange = (op: number, domainSort: number) =>
197
- op === OP_TO_REAL || op === OP_DIV
198
- ? SORT_REAL
199
- : op === OP_TO_INT || op === OP_IDIV || op === OP_MOD
200
- ? SORT_INT
201
- : op === OP_ITE ||
202
- op === OP_ABS ||
203
- op === OP_ADD ||
204
- op === OP_SUB ||
205
- op === OP_UMINUS ||
206
- op === OP_MUL
207
- ? domainSort
208
- : SORT_BOOL;
209
-
210
212
  const coerce = (arg: number, sort: number) => {
211
213
  const argSort = manager.sorts[arg];
212
214
  if (argSort === sort || !isArithSort(argSort) || !isArithSort(sort)) return arg;
@@ -216,61 +218,44 @@ export const parseSmtlib = (
216
218
  };
217
219
 
218
220
  const mkApp = (decl: number, inputArgs: number[], domainSort?: number) => {
219
- const op = manager.funcDecls[decl].op;
220
- const name = manager.funcDecls[decl].name;
221
- const isUninterpreted = op === OP_UNINTERPRETED;
222
- const domain = manager.funcDecls[decl].domain;
223
- const builtinSort = isUninterpreted ? -1 : (domainSort ?? getDomainSort(op, inputArgs));
221
+ const funcDecl = manager.funcDecls[decl];
222
+ const operator = OPERATORS_BY_OP.get(funcDecl.op);
223
+ const builtinSort =
224
+ operator === undefined ? -1 : (domainSort ?? getDomainSort(operator, inputArgs));
224
225
  const getExpected = (index: number) =>
225
- isUninterpreted ? domain[index] : op === OP_ITE && index === 0 ? SORT_BOOL : builtinSort;
226
+ operator === undefined
227
+ ? funcDecl.domain[index]
228
+ : operator.op === OP_ITE && index === 0
229
+ ? SORT_BOOL
230
+ : builtinSort;
226
231
  const args = inputArgs.map((arg, index) =>
227
232
  getExpected(index) === undefined ? arg : coerce(arg, getExpected(index)),
228
233
  );
229
- const isArity = (min: number, max: number) => args.length >= min && args.length <= max;
230
- const isArityOk = isUninterpreted
231
- ? args.length === domain.length
232
- : op === OP_AND || op === OP_OR
233
- ? true
234
- : op === OP_ITE
235
- ? isArity(3, 3)
236
- : op === OP_EQ || op === OP_DISTINCT
237
- ? isArity(2, Infinity)
238
- : op === OP_NOT ||
239
- op === OP_UMINUS ||
240
- op === OP_ABS ||
241
- op === OP_TO_REAL ||
242
- op === OP_TO_INT ||
243
- op === OP_IS_INT
244
- ? isArity(1, 1)
245
- : op === OP_IMPLIES ||
246
- op === OP_XOR ||
247
- op === OP_IDIV ||
248
- op === OP_MOD ||
249
- op === OP_DIV ||
250
- op === OP_LE ||
251
- op === OP_GE ||
252
- op === OP_LT ||
253
- op === OP_GT
254
- ? isArity(2, 2)
255
- : isArity(1, Infinity);
256
- const isBuiltinArith = manager.funcDecls[decl].family === FAMILY_ARITH;
234
+ const isArityOk =
235
+ operator === undefined
236
+ ? args.length === funcDecl.domain.length
237
+ : args.length >= operator.arity[0] && args.length <= operator.arity[1];
257
238
  const isWellSorted =
258
239
  isArityOk &&
259
- (!isBuiltinArith || isArithSort(builtinSort)) &&
240
+ (funcDecl.family !== FAMILY_ARITH || isArithSort(builtinSort)) &&
260
241
  args.every((arg, index) => manager.sorts[arg] === getExpected(index));
261
- if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}`);
242
+ if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${funcDecl.name}`);
262
243
  return manager.mkApp(
263
244
  decl,
264
245
  args,
265
- isUninterpreted ? manager.funcDecls[decl].range : getRange(op, builtinSort),
246
+ operator === undefined
247
+ ? funcDecl.range
248
+ : operator.range === "domain"
249
+ ? builtinSort
250
+ : operator.range,
266
251
  );
267
252
  };
268
253
 
269
- const mkChain = (op: number, args: number[]) => {
270
- const domainSort = getDomainSort(op, args);
254
+ const mkChain = (operator: Operator, args: number[]) => {
255
+ const domainSort = getDomainSort(operator, args);
271
256
  const pairs: number[] = [];
272
257
  for (let index = 0; index + 1 < args.length; index++)
273
- pairs.push(mkApp(op, [args[index], args[index + 1]], domainSort));
258
+ pairs.push(mkApp(operator.op, [args[index], args[index + 1]], domainSort));
274
259
  return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs);
275
260
  };
276
261
 
@@ -384,15 +369,14 @@ export const parseSmtlib = (
384
369
  };
385
370
 
386
371
  const parseApp = (name: string, args: number[]) => {
387
- const chainable = CHAINABLE_OPS.get(name);
388
- if (chainable !== undefined) return mkChain(chainable, args);
389
372
  if (name === "-") return mkApp(args.length === 1 ? OP_UMINUS : OP_SUB, args);
390
373
  if (name === "/" && args.length > 2)
391
374
  return args
392
375
  .slice(1)
393
376
  .reduce((dividend, divisor) => mkApp(OP_DIV, [dividend, divisor]), args[0]);
394
- const op = BUILTIN_OPS.get(name);
395
- if (op !== undefined) return mkApp(op, args);
377
+ const operator = OPERATORS_BY_SYMBOL.get(name);
378
+ if (operator?.isChainable) return mkChain(operator, args);
379
+ if (operator !== undefined) return mkApp(operator.op, args);
396
380
  const decl = funcs.get(name);
397
381
  if (decl === undefined) throw new SmtParseError(`unknown function ${name}`);
398
382
  return mkApp(decl, args);
@@ -76,7 +76,6 @@ export abstract class TheoryLraBounds extends TheoryLraInternalize {
76
76
  this.internalizeHead--;
77
77
  const column = this.registerVar(thVar);
78
78
  const isInt = this.isIntVar(thVar);
79
- const partial = { isLower, isInt };
80
79
  const kindTrue = isLower ? KIND_GE : KIND_LE;
81
80
  const kindFalse = isLower ? (isInt ? KIND_LE : KIND_LT) : isInt ? KIND_GE : KIND_GT;
82
81
  const constraintTrue = this.solver.mkVarBound(column, kindTrue, value);
@@ -88,7 +87,7 @@ export abstract class TheoryLraBounds extends TheoryLraInternalize {
88
87
  const constraintFalse = this.solver.mkVarBound(column, kindFalse, falseValue);
89
88
  this.constraintSources[constraintTrue] = mkLiteral(boolVar);
90
89
  this.constraintSources[constraintFalse] = mkLiteral(boolVar, true);
91
- return { boolVar, thVar, column, value, constraintTrue, constraintFalse, ...partial };
90
+ return { boolVar, thVar, column, value, constraintTrue, constraintFalse, isLower, isInt };
92
91
  }
93
92
 
94
93
  private mkBoundAxioms(bound: ApiBound) {
@@ -265,10 +265,8 @@ export abstract class TheoryLraInternalize extends TheoryLraAxioms {
265
265
  toEnsureEnode.push(term);
266
266
  const op = manager.getOp(term);
267
267
  if (op === OP_ADD) {
268
- for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
269
- const arg = manager.getArg(term, argIndex);
270
- push(arg, coeffs[index]);
271
- }
268
+ for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++)
269
+ push(manager.getArg(term, argIndex), coeffs[index]);
272
270
  if (terms.size !== index + 1) {
273
271
  terms.set(index, terms.items[terms.size - 1]);
274
272
  coeffs[index] = coeffs[coeffs.length - 1];
@@ -324,10 +322,7 @@ export abstract class TheoryLraInternalize extends TheoryLraAxioms {
324
322
  if (op === OP_DIV) {
325
323
  const divisor = context.rewriter.rewrite(manager.getArg(term, 1));
326
324
  if (!this.isNonzeroNumeral(divisor)) this.foundUnderspecified(term);
327
- for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
328
- const arg = manager.getArg(term, argIndex);
329
- toEnsureVar.push(arg);
330
- }
325
+ manager.pushArgs(term, toEnsureVar);
331
326
  } else if (op === OP_IDIV) {
332
327
  if (!this.isNonzeroNumeral(manager.getArg(term, 1))) this.foundUnderspecified(term);
333
328
  const remainder = manager.mkApp(OP_MOD, manager.getArgs(term), SORT_INT);
@@ -362,16 +357,10 @@ export abstract class TheoryLraInternalize extends TheoryLraAxioms {
362
357
  nla.divisions.addDivisibility(this.registerDivision(quotient, term));
363
358
  }
364
359
  } else if (op === OP_IDIV0 || op === OP_MOD0) {
365
- for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
366
- const arg = manager.getArg(term, argIndex);
367
- toEnsureVar.push(arg);
368
- }
360
+ manager.pushArgs(term, toEnsureVar);
369
361
  } else if (op !== OP_TO_INT && op !== OP_DIV0) {
370
362
  this.foundUnsupported(term);
371
- for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
372
- const arg = manager.getArg(term, argIndex);
373
- toEnsureVar.push(arg);
374
- }
363
+ manager.pushArgs(term, toEnsureVar);
375
364
  }
376
365
  if (!context.relevancy.isEnabled && op !== OP_MOD) this.relevantEh(term);
377
366
  }
@@ -19,7 +19,9 @@ import {
19
19
  writeMarshaled,
20
20
  type OcamlValue,
21
21
  } from "./ocaml-marshal";
22
- import type { ProofAttempt } from "../prove";
22
+ import { getBudget } from "../prep/methods";
23
+ import { getFailureReason, isProvedAttempt, type ProofAttempt } from "../prove";
24
+ import { BACKENDS, type Backend } from "../verdict";
23
25
 
24
26
  export type FingerprintTable = Map<string, OcamlValue[]>;
25
27
 
@@ -27,7 +29,7 @@ const MAGIC_NUMBER = 20210223;
27
29
 
28
30
  const RECORD_SIZE = 23;
29
31
 
30
- const PROVERS: Record<string, { field: number; tag: number }> = {
32
+ const PROVERS: Record<Backend, { field: number; tag: number }> = {
31
33
  zenon: { field: 1, tag: 1 },
32
34
  isabelle: { field: 2, tag: 0 },
33
35
  smt: { field: 10, tag: 8 },
@@ -102,7 +104,10 @@ export const loadFingerprints = (table: FingerprintTable, path: string, isSafe:
102
104
  });
103
105
  };
104
106
 
105
- const decodeResult = (prover: string, result: OcamlValue | undefined): ProofAttempt | undefined => {
107
+ const decodeResult = (
108
+ prover: Backend,
109
+ result: OcamlValue | undefined,
110
+ ): ProofAttempt | undefined => {
106
111
  const status = getField(result, 0);
107
112
  const outcome = getField(status, 0);
108
113
  const argument = getField(getField(status, 1), 0);
@@ -111,13 +116,13 @@ const decodeResult = (prover: string, result: OcamlValue | undefined): ProofAtte
111
116
  const tactic = prover === "isabelle" ? getField(argument, 1) : undefined;
112
117
  const reason = getField(getField(outcome, 0), 0);
113
118
  return {
119
+ kind: "stored",
114
120
  method: {
115
121
  prover,
116
122
  timeLimitMs: seconds * 1000,
117
123
  ...(typeof tactic === "string" && { tactic }),
118
124
  },
119
125
  isProved: outcome === 0,
120
- isReused: false,
121
126
  ...(reason !== undefined && {
122
127
  reason: typeof reason === "number" ? REASONS[reason] : String(getField(reason, 0)),
123
128
  }),
@@ -125,29 +130,30 @@ const decodeResult = (prover: string, result: OcamlValue | undefined): ProofAtte
125
130
  };
126
131
 
127
132
  // Fpfile.fp_writes, whose date counts months from 0.
128
- const encodeResult = (attempt: ProofAttempt) => {
133
+ const encodeResult = (prover: Backend, attempt: ProofAttempt) => {
129
134
  const now = new Date();
130
135
  const method = attempt.method;
131
- const timeout = { float: method.rlimit ?? method.timeLimitMs / 1000 };
136
+ const timeout = { float: getBudget(method) };
132
137
  const argument =
133
- method.prover === "zenon"
138
+ prover === "zenon"
134
139
  ? createBlock(0, timeout, FAIL_METHOD)
135
- : method.prover === "isabelle"
140
+ : prover === "isabelle"
136
141
  ? createBlock(0, createBlock(0, timeout), method.tactic ?? "auto")
137
142
  : createBlock(0, timeout);
138
- const reasonIndex = REASONS.indexOf(attempt.reason ?? "");
143
+ const failure = getFailureReason(attempt);
144
+ const reasonIndex = REASONS.indexOf(failure ?? "");
139
145
  const reason =
140
- attempt.reason === undefined
146
+ failure === undefined
141
147
  ? 0
142
- : createBlock(0, reasonIndex === -1 ? createBlock(0, attempt.reason) : reasonIndex);
148
+ : createBlock(0, reasonIndex === -1 ? createBlock(0, failure) : reasonIndex);
143
149
  return createBlock(
144
150
  0,
145
151
  createBlock(
146
152
  0,
147
153
  createBlock(
148
154
  0,
149
- attempt.isProved ? 0 : createBlock(0, reason),
150
- createBlock(PROVERS[method.prover].tag, argument),
155
+ isProvedAttempt(attempt) ? 0 : createBlock(0, reason),
156
+ createBlock(PROVERS[prover].tag, argument),
151
157
  ),
152
158
  createBlock(
153
159
  0,
@@ -201,10 +207,11 @@ export const getKnownResults = (table: FingerprintTable) => {
201
207
  const results = new Map(
202
208
  [...table].map(([fingerprint, record]) => {
203
209
  const attempts = new Map(
204
- Object.entries(PROVERS).flatMap(([prover, known]) => {
205
- const result = decodeResult(prover, getField(record[known.field], 0));
210
+ BACKENDS.flatMap((prover) => {
211
+ const stored = record[PROVERS[prover].field];
212
+ const result = decodeResult(prover, getField(stored, 0));
206
213
  if (!result) return [];
207
- storedResults.set(result, record[known.field]);
214
+ storedResults.set(result, stored);
208
215
  return [[prover, result]];
209
216
  }),
210
217
  );
@@ -216,8 +223,11 @@ export const getKnownResults = (table: FingerprintTable) => {
216
223
  table.clear();
217
224
  results.forEach((attempts, fingerprint) => {
218
225
  const record = [...(storedRecords.get(attempts) ?? Array<OcamlValue>(RECORD_SIZE).fill(0))];
219
- attempts.forEach((attempt, prover) => {
220
- record[PROVERS[prover].field] = storedResults.get(attempt) ?? encodeResult(attempt);
226
+ BACKENDS.forEach((prover) => {
227
+ const attempt = attempts.get(prover);
228
+ if (attempt)
229
+ record[PROVERS[prover].field] =
230
+ storedResults.get(attempt) ?? encodeResult(prover, attempt);
221
231
  });
222
232
  table.set(fingerprint, record);
223
233
  });
@@ -1,4 +1,4 @@
1
- import { TlaUnsupportedError } from "../../errors";
1
+ import { TlaProverError, TlaUnsupportedError } from "../../errors";
2
2
 
3
3
  // Loaded at runtime so browser bundles leave them out. prove loads this module only in Node and Bun.
4
4
  const childProcess = process.getBuiltinModule("node:child_process");
@@ -22,12 +22,14 @@ export const getTlapmPaths = () =>
22
22
  .map((directory) => path.join(directory, "tlapm"))
23
23
  .filter((tlapm) => fileSystem.existsSync(tlapm));
24
24
 
25
+ const MESSAGE_END = "@!!END";
26
+
25
27
  const parseToolboxMessages = (text: string) =>
26
28
  text
27
29
  .split("@!!BEGIN\n")
28
30
  .slice(1)
29
31
  .flatMap((block) => {
30
- const end = block.indexOf("@!!END");
32
+ const end = block.indexOf(MESSAGE_END);
31
33
  if (end === -1) return [];
32
34
  const fields = new Map<string, string>();
33
35
  block
@@ -69,23 +71,27 @@ export const proveWithTlapm = async (
69
71
  );
70
72
  const kill = () => child.kill();
71
73
  options.signal?.addEventListener("abort", kill);
72
- let text = "";
73
- let parsedCount = 0;
74
+ let unparsed = "";
74
75
  child.stderr.on("data", (chunk: Buffer) => {
75
- text += chunk.toString("utf8");
76
- const messages = parseToolboxMessages(text);
77
- messages.slice(parsedCount).forEach((fields) => {
76
+ const text = unparsed + chunk.toString("utf8");
77
+ const end = text.lastIndexOf(MESSAGE_END);
78
+ const parsedLength = end === -1 ? 0 : end + MESSAGE_END.length;
79
+ unparsed = text.slice(parsedLength);
80
+ parseToolboxMessages(text.slice(0, parsedLength)).forEach((fields) => {
78
81
  const result = getResult(fields);
79
82
  const id = Number(fields.get("id"));
80
83
  if (fields.get("type") !== "obligation" || !result) return;
81
84
  results.set(id, result);
82
85
  options.onResult?.(id, result);
83
86
  });
84
- parsedCount = messages.length;
85
87
  });
86
- await new Promise((resolve) => child.on("close", resolve));
88
+ const failure = await new Promise<Error | undefined>((resolve) => {
89
+ child.on("error", resolve);
90
+ child.on("close", () => resolve(undefined));
91
+ });
87
92
  options.signal?.removeEventListener("abort", kill);
88
93
  fileSystem.rmSync(directory, { recursive: true, force: true });
89
94
  options.signal?.throwIfAborted();
95
+ if (failure) throw new TlaProverError(failure.message, failure);
90
96
  return results;
91
97
  };
@@ -1,5 +1,12 @@
1
1
  export type Verdict = "unsat" | "sat" | "unknown";
2
2
 
3
+ export const BACKENDS = ["zenon", "isabelle", "smt", "z3", "ls4"] as const;
4
+
5
+ export type Backend = (typeof BACKENDS)[number];
6
+
7
+ export const isBackend = (prover: string): prover is Backend =>
8
+ BACKENDS.some((backend) => backend === prover);
9
+
3
10
  export interface Decision {
4
11
  verdict: Verdict;
5
12
  timeUsedMs: number;
@@ -87,8 +87,7 @@ export const checkProof = (root: Proof<Term>, context: CheckContext, limits: Lim
87
87
  if (!needed.has(subproof)) stack.push([subproof, false]);
88
88
  }
89
89
  const hypotheses = new Set(context.hypotheses.map(keys.getTopKey));
90
- const missing = [...(needed.get(root) ?? [])].filter((key) => !hypotheses.has(key));
91
- return missing.length === 0;
90
+ return [...(needed.get(root) ?? [])].every((key) => hypotheses.has(key));
92
91
  } catch (error) {
93
92
  if (error instanceof UncheckedError) return false;
94
93
  throw error;
@@ -25,7 +25,7 @@ export const getFields = (record: Term, constructor: "TLA.record" | "TLA.records
25
25
  return fields;
26
26
  };
27
27
 
28
- const getLabels = (fields: [Term, Term][]) =>
28
+ export const getLabels = (fields: [Term, Term][]) =>
29
29
  app(
30
30
  "TLA.set",
31
31
  fields.map((field) => field[0]),
@@ -1,4 +1,5 @@
1
- import type { CheckContext, RelationProperty, Term } from "./terms";
1
+ import type { RelationProperty } from "../eqrel";
2
+ import type { CheckContext, Term } from "./terms";
2
3
 
3
4
  type Polarity = "positive" | "negative" | "both";
4
5
 
@@ -1,15 +1,13 @@
1
1
  import type { PlainRuleName } from "../proof";
2
- import { getFields } from "./records";
2
+ import { getFields, getLabels } from "./records";
3
3
  import {
4
4
  and,
5
- app,
6
5
  domain,
7
6
  ensure,
8
7
  equal,
9
8
  expectApp,
10
9
  FALSE,
11
10
  fapply,
12
- getPairs,
13
11
  getStringText,
14
12
  instantiate,
15
13
  isApp,
@@ -157,18 +155,7 @@ export const REWRITE_RULES = {
157
155
  record_domain: (args, checker) =>
158
156
  getRewriteSpec(checker, args[0], args[2], (filled) => {
159
157
  const record = expectApp(filled, "TLA.DOMAIN", 1)[0];
160
- const fields = getPairs(expectApp(record, "TLA.record"));
161
- return [
162
- [
163
- instantiate(
164
- args[2],
165
- app(
166
- "TLA.set",
167
- fields.map((field) => field[0]),
168
- ),
169
- ),
170
- ],
171
- ];
158
+ return [[instantiate(args[2], getLabels(getFields(record, "TLA.record")))]];
172
159
  }),
173
160
  boolcase_not: (args, checker) =>
174
161
  getBoolCaseSpec(checker, args, (operand) => operand.kind === "not"),