tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.94c3dd828

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 (196) hide show
  1. package/dist/deciders.cjs +37 -36
  2. package/dist/deciders.js +55 -54
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +3 -0
  5. package/dist/index.d.ts +3 -0
  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.cjs +146 -58
  10. package/dist/prove.js +142 -54
  11. package/dist/run.cjs +45 -43
  12. package/dist/run.js +47 -45
  13. package/dist/transfer.cjs +39 -36
  14. package/dist/transfer.js +23 -20
  15. package/dist/worker.cjs +1 -1
  16. package/dist/worker.js +1 -1
  17. package/package.json +1 -1
  18. package/src/ast.ts +3 -3
  19. package/src/check.ts +203 -33
  20. package/src/cli/tlapm.ts +261 -68
  21. package/src/dependencies.ts +23 -2
  22. package/src/errors.ts +1 -1
  23. package/src/exit-codes.ts +1 -0
  24. package/src/liveness-checker.ts +530 -201
  25. package/src/liveness.ts +47 -32
  26. package/src/obligations/anonymize.ts +2 -4
  27. package/src/obligations/index.ts +5 -3
  28. package/src/obligations/pragma.ts +2 -2
  29. package/src/parallel.ts +2 -2
  30. package/src/parser.ts +151 -42
  31. package/src/prover/deciders.ts +1 -8
  32. package/src/prover/isabelle/isar/attrib.ts +86 -45
  33. package/src/prover/isabelle/isar/context.ts +25 -22
  34. package/src/prover/isabelle/isar/induct.ts +2 -5
  35. package/src/prover/isabelle/isar/method.ts +5 -7
  36. package/src/prover/isabelle/isar/proof.ts +33 -16
  37. package/src/prover/isabelle/isar/rule-cases.ts +6 -14
  38. package/src/prover/isabelle/isar/theory.ts +16 -17
  39. package/src/prover/isabelle/isar/toplevel.ts +46 -52
  40. package/src/prover/isabelle/provers/classical.ts +1 -1
  41. package/src/prover/ocaml.ts +4 -1
  42. package/src/prover/prep/action.ts +1 -0
  43. package/src/prover/prep/methods.ts +50 -3
  44. package/src/prover/prep/normalize.ts +4 -1
  45. package/src/prover/prove.ts +58 -32
  46. package/src/prover/ptl/decide.ts +43 -63
  47. package/src/prover/smt/data.ts +51 -45
  48. package/src/prover/smt/encode.ts +1 -2
  49. package/src/prover/smt/rewrite.ts +1 -0
  50. package/src/prover/smt/solver/aig-tactic.ts +25 -15
  51. package/src/prover/smt/solver/arith-rewriter.ts +3 -5
  52. package/src/prover/smt/solver/asserted-formulas.ts +1 -1
  53. package/src/prover/smt/solver/ast-util.ts +3 -1
  54. package/src/prover/smt/solver/ast.ts +110 -152
  55. package/src/prover/smt/solver/bound-manager.ts +39 -28
  56. package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
  57. package/src/prover/smt/solver/bv-rewriter.ts +14 -16
  58. package/src/prover/smt/solver/bv1-blast.ts +1 -9
  59. package/src/prover/smt/solver/cg-table.ts +19 -14
  60. package/src/prover/smt/solver/check-logic.ts +6 -1
  61. package/src/prover/smt/solver/context.ts +20 -10
  62. package/src/prover/smt/solver/demodulator.ts +2 -2
  63. package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
  64. package/src/prover/smt/solver/distribute-forall.ts +1 -10
  65. package/src/prover/smt/solver/dom-simplify.ts +1 -1
  66. package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
  67. package/src/prover/smt/solver/e-matching.ts +6 -6
  68. package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
  69. package/src/prover/smt/solver/enode.ts +15 -1
  70. package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
  71. package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
  72. package/src/prover/smt/solver/euf/egraph.ts +65 -32
  73. package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
  74. package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
  75. package/src/prover/smt/solver/euf/mam.ts +6 -48
  76. package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
  77. package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
  78. package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
  79. package/src/prover/smt/solver/euf/q-solver.ts +2 -0
  80. package/src/prover/smt/solver/euf/th-solver.ts +1 -1
  81. package/src/prover/smt/solver/factor.ts +1 -11
  82. package/src/prover/smt/solver/fd-solver.ts +1 -2
  83. package/src/prover/smt/solver/fm-tactic.ts +19 -13
  84. package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
  85. package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
  86. package/src/prover/smt/solver/internalizer.ts +41 -2
  87. package/src/prover/smt/solver/lia2pb.ts +18 -4
  88. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  89. package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
  90. package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
  91. package/src/prover/smt/solver/macro-finder.ts +1 -1
  92. package/src/prover/smt/solver/mam-compiler.ts +13 -13
  93. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
  94. package/src/prover/smt/solver/maxcore.ts +4 -12
  95. package/src/prover/smt/solver/maxlex.ts +0 -7
  96. package/src/prover/smt/solver/maxsmt-base.ts +7 -0
  97. package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
  98. package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
  99. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
  100. package/src/prover/smt/solver/model-evaluator.ts +9 -5
  101. package/src/prover/smt/solver/model-macro-solver.ts +3 -3
  102. package/src/prover/smt/solver/muz/dl-context.ts +57 -3
  103. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
  104. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
  105. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
  106. package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
  107. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
  108. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
  109. package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
  110. package/src/prover/smt/solver/muz/hnf.ts +6 -5
  111. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
  112. package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
  113. package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
  114. package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
  115. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
  116. package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
  117. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
  118. package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
  119. package/src/prover/smt/solver/muz/substitution.ts +88 -37
  120. package/src/prover/smt/solver/nlqsat.ts +2 -2
  121. package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
  122. package/src/prover/smt/solver/nlsat/explain.ts +5 -0
  123. package/src/prover/smt/solver/nlsat/solver.ts +36 -25
  124. package/src/prover/smt/solver/opt-context.ts +9 -8
  125. package/src/prover/smt/solver/opt-nlsat.ts +68 -58
  126. package/src/prover/smt/solver/opt-solver.ts +16 -7
  127. package/src/prover/smt/solver/optsmt.ts +12 -9
  128. package/src/prover/smt/solver/pattern-inference.ts +2 -2
  129. package/src/prover/smt/solver/pb-rewriter.ts +13 -13
  130. package/src/prover/smt/solver/poly-rewriter.ts +2 -2
  131. package/src/prover/smt/solver/probes.ts +1 -1
  132. package/src/prover/smt/solver/propagate-values.ts +4 -0
  133. package/src/prover/smt/solver/proto-model.ts +5 -5
  134. package/src/prover/smt/solver/purify-arith.ts +50 -15
  135. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
  136. package/src/prover/smt/solver/qe-mbp.ts +13 -23
  137. package/src/prover/smt/solver/qe.ts +45 -53
  138. package/src/prover/smt/solver/qsat.ts +70 -90
  139. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
  140. package/src/prover/smt/solver/quasi-macros.ts +9 -18
  141. package/src/prover/smt/solver/rational.ts +17 -0
  142. package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
  143. package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
  144. package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
  145. package/src/prover/smt/solver/rewriter.ts +1 -1
  146. package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
  147. package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
  148. package/src/prover/smt/solver/sat/clause.ts +1 -3
  149. package/src/prover/smt/solver/sat/config.ts +3 -3
  150. package/src/prover/smt/solver/sat/consequences.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -15
  154. package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
  155. package/src/prover/smt/solver/sat/probing.ts +22 -19
  156. package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
  157. package/src/prover/smt/solver/sat/simplifier.ts +15 -56
  158. package/src/prover/smt/solver/sat/solver.ts +20 -19
  159. package/src/prover/smt/solver/sat/watch-list.ts +7 -0
  160. package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
  161. package/src/prover/smt/solver/seq-derive.ts +6 -7
  162. package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
  163. package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
  164. package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
  165. package/src/prover/smt/solver/seq-re-util.ts +1 -2
  166. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-live.ts +4 -4
  168. package/src/prover/smt/solver/seq-rewriter.ts +1 -4
  169. package/src/prover/smt/solver/smt-setup.ts +15 -9
  170. package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
  171. package/src/prover/smt/solver/smtlib-script.ts +866 -728
  172. package/src/prover/smt/solver/tactic.ts +66 -14
  173. package/src/prover/smt/solver/theory-array.ts +25 -58
  174. package/src/prover/smt/solver/theory-bv.ts +13 -50
  175. package/src/prover/smt/solver/theory-fpa.ts +46 -78
  176. package/src/prover/smt/solver/theory-pb.ts +10 -6
  177. package/src/prover/smt/solver/theory-recfun.ts +2 -2
  178. package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
  179. package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
  180. package/src/prover/smt/solver/theory-seq-state.ts +6 -3
  181. package/src/prover/smt/solver/theory-seq.ts +32 -54
  182. package/src/prover/smt/solver/theory.ts +16 -1
  183. package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
  184. package/src/prover/smt/solver/var-subst.ts +2 -2
  185. package/src/prover/smt/table.ts +3 -2
  186. package/src/prover/zenon/decide.ts +9 -11
  187. package/src/prover/zenon/node.ts +12 -11
  188. package/src/prover/zenon/tla/sets.ts +1 -1
  189. package/src/search.ts +131 -16
  190. package/src/successors.ts +1 -1
  191. package/src/symmetry.ts +2 -2
  192. package/src/tableau.ts +2 -2
  193. package/src/tlc/fingerprint.ts +81 -9
  194. package/src/tlc/summary.ts +29 -14
  195. package/src/typed-tier.ts +6535 -0
  196. package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
@@ -13,7 +13,6 @@ import {
13
13
  OP_FPA_TO_SBV,
14
14
  OP_FPA_TO_UBV,
15
15
  OP_IMPLIES,
16
- OP_ITE,
17
16
  OP_ULEQ,
18
17
  SORT_BOOL,
19
18
  } from "./ast";
@@ -182,15 +181,12 @@ export class TheoryFpa extends Theory {
182
181
  context.setVarTheory(boolVar, this.id);
183
182
  for (let index = 0; index < manager.getNumArgs(atom); index++)
184
183
  context.internalize(manager.getArg(atom, index), false);
185
- manager.withTemporaries(
186
- () => {
187
- const bvAtom = this.rewriter.convert(this.theoryRewriter, atom);
188
- manager.releaseLater(bvAtom);
189
- const withSideConditions = this.rewrite(manager.mkAnd([bvAtom, this.mkSideConditions()]));
190
- this.assertCnstr(manager.mkEq(atom, withSideConditions));
191
- },
192
- () => [],
193
- );
184
+ const outer = manager.beginTemporaries();
185
+ const bvAtom = this.rewriter.convert(this.theoryRewriter, atom);
186
+ manager.releaseLater(bvAtom);
187
+ const withSideConditions = this.rewrite(manager.mkAnd([bvAtom, this.mkSideConditions()]));
188
+ this.assertCnstr(manager.mkEq(atom, withSideConditions));
189
+ manager.endTemporaries(outer);
194
190
  return true;
195
191
  }
196
192
 
@@ -202,14 +198,12 @@ export class TheoryFpa extends Theory {
202
198
  const node = context.getEnode(term) ?? context.mkEnode(term, false, false, true);
203
199
  if (this.isAttachedToVar(node)) return true;
204
200
  this.attachNewThVar(node);
205
- if (CONVERTED_OPS.has(manager.getOp(term)))
206
- manager.withTemporaries(
207
- () => {
208
- this.assertCnstr(manager.mkEq(term, this.convert(term)));
209
- this.assertCnstr(this.mkSideConditions());
210
- },
211
- () => [],
212
- );
201
+ if (CONVERTED_OPS.has(manager.getOp(term))) {
202
+ const outer = manager.beginTemporaries();
203
+ this.assertCnstr(manager.mkEq(term, this.convert(term)));
204
+ this.assertCnstr(this.mkSideConditions());
205
+ manager.endTemporaries(outer);
206
+ }
213
207
  if (!context.relevancy.isEnabled) this.relevantEh(term);
214
208
  return true;
215
209
  }
@@ -219,14 +213,12 @@ export class TheoryFpa extends Theory {
219
213
  if (this.isAttachedToVar(node)) return;
220
214
  this.attachNewThVar(node);
221
215
  const owner = node.owner;
222
- if (manager.isRmSort(manager.sorts[owner]) && manager.getOp(owner) !== OP_FPA_BV2RM)
223
- manager.withTemporaries(
224
- () => {
225
- const limit = manager.mkBvNumeral(4n, 3);
226
- this.assertCnstr(mkBvApp(manager, OP_ULEQ, [this.converter.wrap(owner), limit]));
227
- },
228
- () => [],
229
- );
216
+ if (manager.isRmSort(manager.sorts[owner]) && manager.getOp(owner) !== OP_FPA_BV2RM) {
217
+ const outer = manager.beginTemporaries();
218
+ const limit = manager.mkBvNumeral(4n, 3);
219
+ this.assertCnstr(mkBvApp(manager, OP_ULEQ, [this.converter.wrap(owner), limit]));
220
+ manager.endTemporaries(outer);
221
+ }
230
222
  if (!this.context.relevancy.isEnabled) this.relevantEh(owner);
231
223
  }
232
224
 
@@ -244,57 +236,48 @@ export class TheoryFpa extends Theory {
244
236
  const secondExpr = this.getExpr(second);
245
237
  if (manager.getOp(firstExpr) === OP_FPA_BVWRAP || manager.getOp(secondExpr) === OP_FPA_BVWRAP)
246
238
  return;
247
- manager.withTemporaries(
248
- () => {
249
- const firstConverted = this.convert(firstExpr);
250
- const secondConverted = this.convert(secondExpr);
251
- const isFloatPair = this.isFloat(firstExpr) && this.isFloat(secondExpr);
252
- const eq = isFloatPair
253
- ? this.converter.mkEq(firstConverted, secondConverted)
254
- : manager.mkEq(firstConverted, secondConverted);
255
- const condition = this.rewrite(isNegated ? manager.mkNot(eq) : eq);
256
- const exprEq = manager.mkEq(firstExpr, secondExpr);
257
- this.assertCnstr(manager.mkEq(isNegated ? manager.mkNot(exprEq) : exprEq, condition));
258
- this.assertCnstr(this.mkSideConditions());
259
- },
260
- () => [],
261
- );
239
+ const outer = manager.beginTemporaries();
240
+ const firstConverted = this.convert(firstExpr);
241
+ const secondConverted = this.convert(secondExpr);
242
+ const isFloatPair = this.isFloat(firstExpr) && this.isFloat(secondExpr);
243
+ const eq = isFloatPair
244
+ ? this.converter.mkEq(firstConverted, secondConverted)
245
+ : manager.mkEq(firstConverted, secondConverted);
246
+ const condition = this.rewrite(isNegated ? manager.mkNot(eq) : eq);
247
+ const exprEq = manager.mkEq(firstExpr, secondExpr);
248
+ this.assertCnstr(manager.mkEq(isNegated ? manager.mkNot(exprEq) : exprEq, condition));
249
+ this.assertCnstr(this.mkSideConditions());
250
+ manager.endTemporaries(outer);
262
251
  }
263
252
 
264
253
  override assignEh(boolVar: BoolVar, isTrue: boolean) {
265
254
  const manager = this.manager;
266
255
  const expr = this.context.boolVar2Expr[boolVar];
267
- manager.withTemporaries(
268
- () => {
269
- const converted = manager.mkAnd([this.convert(expr), this.mkSideConditions()]);
270
- const constraint = isTrue
271
- ? manager.mkApp(OP_IMPLIES, [expr, converted], SORT_BOOL)
272
- : manager.mkApp(OP_IMPLIES, [converted, expr], SORT_BOOL);
273
- this.assertCnstr(this.rewrite(constraint));
274
- },
275
- () => [],
276
- );
256
+ const outer = manager.beginTemporaries();
257
+ const converted = manager.mkAnd([this.convert(expr), this.mkSideConditions()]);
258
+ const constraint = isTrue
259
+ ? manager.mkApp(OP_IMPLIES, [expr, converted], SORT_BOOL)
260
+ : manager.mkApp(OP_IMPLIES, [converted, expr], SORT_BOOL);
261
+ this.assertCnstr(this.rewrite(constraint));
262
+ manager.endTemporaries(outer);
277
263
  }
278
264
 
279
265
  override relevantEh(expr: number) {
280
266
  const manager = this.manager;
281
267
  const op = manager.getOp(expr);
282
268
  if (!this.isFloat(expr)) {
283
- if (manager.getFamily(expr) === FAMILY_FPA && CONVERTED_OPS.has(op))
284
- manager.withTemporaries(
285
- () => {
286
- this.assertCnstr(manager.mkEq(expr, this.convert(expr)));
287
- this.assertCnstr(this.mkSideConditions());
288
- },
289
- () => [],
290
- );
269
+ if (manager.getFamily(expr) === FAMILY_FPA && CONVERTED_OPS.has(op)) {
270
+ const outer = manager.beginTemporaries();
271
+ this.assertCnstr(manager.mkEq(expr, this.convert(expr)));
272
+ this.assertCnstr(this.mkSideConditions());
273
+ manager.endTemporaries(outer);
274
+ }
291
275
  return;
292
276
  }
293
277
  if (op === OP_FPA_FP) return;
294
- manager.withTemporaries(
295
- () => this.assertValueConstraints(expr),
296
- () => [],
297
- );
278
+ const outer = manager.beginTemporaries();
279
+ this.assertValueConstraints(expr);
280
+ manager.endTemporaries(outer);
298
281
  }
299
282
 
300
283
  private assertValueConstraints(expr: number) {
@@ -361,21 +344,6 @@ export class TheoryFpa extends Theory {
361
344
  super.popScopeEh(numScopes);
362
345
  }
363
346
 
364
- private getIteValue(expr: number) {
365
- const context = this.context;
366
- const manager = this.manager;
367
- let current = expr;
368
- while (manager.getOp(current) === OP_ITE && context.isEInternalized(current)) {
369
- const root = context.getEnode(current)?.root;
370
- const thenExpr = manager.getArg(current, 1);
371
- const elseExpr = manager.getArg(current, 2);
372
- if (context.getEnode(thenExpr)?.root === root) current = thenExpr;
373
- else if (context.getEnode(elseExpr)?.root === root) current = elseExpr;
374
- else break;
375
- }
376
- return current;
377
- }
378
-
379
347
  override mkValue(node: Enode): number | DependentValue | undefined {
380
348
  const context = this.context;
381
349
  const manager = this.manager;
@@ -694,19 +694,23 @@ export class TheoryPb extends Theory {
694
694
  override popScopeEh(numScopes: number) {
695
695
  let newLim = this.ineqsLim.length - numScopes;
696
696
  let size = this.ineqsLim[newLim];
697
- while (this.ineqsTrail.length > size) {
698
- const boolVar = this.ineqsTrail.pop() as BoolVar;
699
- this.clearIneqWatch(this.ineqs[boolVar] as Ineq);
697
+ for (let index = this.ineqsTrail.length - 1; index >= size; index--) {
698
+ const boolVar = this.ineqsTrail[index];
699
+ const ineq = this.ineqs[boolVar];
700
+ if (ineq !== undefined) this.clearIneqWatch(ineq);
700
701
  this.ineqs[boolVar] = undefined;
701
702
  }
703
+ this.ineqsTrail.length = size;
702
704
  this.ineqsLim.length = newLim;
703
705
  newLim = this.cardLim.length - numScopes;
704
706
  size = this.cardLim[newLim];
705
- while (this.cardTrail.length > size) {
706
- const boolVar = this.cardTrail.pop() as BoolVar;
707
- this.clearCardWatch(this.cards[boolVar] as Card);
707
+ for (let index = this.cardTrail.length - 1; index >= size; index--) {
708
+ const boolVar = this.cardTrail[index];
709
+ const card = this.cards[boolVar];
710
+ if (card !== undefined) this.clearCardWatch(card);
708
711
  this.cards[boolVar] = undefined;
709
712
  }
713
+ this.cardTrail.length = size;
710
714
  this.cardLim.length = newLim;
711
715
  super.popScopeEh(numScopes);
712
716
  }
@@ -112,8 +112,8 @@ export class TheoryRecfun extends Theory {
112
112
  for (const expr of exprs) this.keep(expr);
113
113
  this.propagationQueue.push({ kind, exprs });
114
114
  this.context.pushTrail(() => {
115
- for (const expr of (this.propagationQueue.pop() as PropagationItem).exprs)
116
- this.manager.decRef(expr);
115
+ this.propagationQueue.pop();
116
+ for (const expr of exprs) this.manager.decRef(expr);
117
117
  });
118
118
  }
119
119
 
@@ -218,8 +218,7 @@ export abstract class TheorySeqRegex extends TheorySeqSolve {
218
218
  private collectVars(seq: number, vars: number[]) {
219
219
  const manager = this.manager;
220
220
  const todo = [seq];
221
- while (todo.length > 0) {
222
- const expr = todo.pop()!;
221
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
223
222
  if (manager.getOp(expr) === OP_SEQ_CONCAT) {
224
223
  todo.push(...manager.getArgs(expr));
225
224
  continue;
@@ -257,8 +256,7 @@ export abstract class TheorySeqRegex extends TheorySeqSolve {
257
256
  const manager = this.manager;
258
257
  const todo = [term];
259
258
  let length = 0;
260
- while (todo.length > 0) {
261
- const expr = todo.pop()!;
259
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
262
260
  if (this.isConcat(expr)) {
263
261
  todo.push(manager.getArg(expr, 0), manager.getArg(expr, 1));
264
262
  continue;
@@ -508,8 +506,7 @@ export abstract class TheorySeqRegex extends TheorySeqSolve {
508
506
  if (this.hasLength(seq)) return true;
509
507
  const todo = [seq];
510
508
  let hasVar = false;
511
- while (todo.length > 0) {
512
- const expr = todo.pop()!;
509
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
513
510
  if (this.isConcat(expr)) {
514
511
  todo.push(manager.getArg(expr, 0), manager.getArg(expr, 1));
515
512
  continue;
@@ -360,11 +360,11 @@ export abstract class TheorySeqSolve extends TheorySeqState {
360
360
  this.propagateEq(deps, front, ls[0], rs[0], true);
361
361
  return true;
362
362
  }
363
- const back = this.reduceLength(ls.at(-1)!, rs.at(-1)!);
363
+ const back = this.reduceLength(ls[ls.length - 1], rs[rs.length - 1]);
364
364
  if (back !== undefined) {
365
365
  const deps = this.mkJoinLiterals(inputDeps, back);
366
366
  this.eqs.push(this.mkDepEq(this.eqId++, ls.slice(0, -1), rs.slice(0, -1), deps));
367
- this.propagateEq(deps, back, ls.at(-1)!, rs.at(-1)!, true);
367
+ this.propagateEq(deps, back, ls[ls.length - 1], rs[rs.length - 1], true);
368
368
  return true;
369
369
  }
370
370
  const getLength = (expr: number) => this.getLengthValue(expr);
@@ -404,7 +404,7 @@ export abstract class TheorySeqSolve extends TheorySeqState {
404
404
  const sumBack = (first: number, others: readonly number[], isStrict: boolean) => {
405
405
  const firstLength = getLength(first);
406
406
  if (firstLength === undefined) return undefined;
407
- let total = getLength(others.at(-1)!);
407
+ let total = getLength(others[others.length - 1]);
408
408
  if (total === undefined) return undefined;
409
409
  if (isStrict ? firstLength.compare(total) <= 0 : firstLength.compare(total) < 0)
410
410
  return undefined;
@@ -417,7 +417,7 @@ export abstract class TheorySeqSolve extends TheorySeqState {
417
417
  return firstLength.equals(total) && index > 0 ? index : undefined;
418
418
  };
419
419
  if (ls.length > 1) {
420
- const index = sumBack(ls.at(-1)!, rs, false);
420
+ const index = sumBack(ls[ls.length - 1], rs, false);
421
421
  if (
422
422
  index !== undefined &&
423
423
  index < rs.length &&
@@ -426,7 +426,7 @@ export abstract class TheorySeqSolve extends TheorySeqState {
426
426
  return true;
427
427
  }
428
428
  if (rs.length > 1) {
429
- const index = sumBack(rs.at(-1)!, ls, true);
429
+ const index = sumBack(rs[rs.length - 1], ls, true);
430
430
  if (
431
431
  index !== undefined &&
432
432
  index < ls.length &&
@@ -348,7 +348,6 @@ export abstract class TheorySeqState extends Theory {
348
348
  protected intStrings: number[] = [];
349
349
  protected hasLengthSet = new Set<number>();
350
350
  protected lengths: number[] = [];
351
- protected lengthLimitMap = new Map<number, number>();
352
351
  protected lengthLimits: number[] = [];
353
352
  protected replay: (() => void)[] = [];
354
353
  protected strRewriter: Rewriter;
@@ -600,8 +599,7 @@ export abstract class TheorySeqState extends Theory {
600
599
  const manager = this.manager;
601
600
  let value = Rational.zero;
602
601
  const todo = [input];
603
- while (todo.length > 0) {
604
- const expr = todo.pop()!;
602
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
605
603
  const op = manager.getOp(expr);
606
604
  const chars = manager.getString(expr);
607
605
  if (this.isConcat(expr)) todo.push(manager.getArg(expr, 0), manager.getArg(expr, 1));
@@ -748,8 +746,13 @@ export abstract class TheorySeqState extends Theory {
748
746
  isAddingToEqs = true,
749
747
  ) {
750
748
  const context = this.context;
749
+ const manager = this.manager;
750
+ manager.incRef(firstExpr);
751
+ manager.incRef(secondExpr);
751
752
  const first = this.ensureEnodeOf(firstExpr);
752
753
  const second = this.ensureEnodeOf(secondExpr);
754
+ manager.decRef(secondExpr);
755
+ manager.decRef(firstExpr);
753
756
  if (first.root === second.root) return false;
754
757
  context.markAsRelevant(first.owner);
755
758
  context.markAsRelevant(second.owner);
@@ -3,7 +3,6 @@ import { SmtUnsupportedError } from "../../../errors";
3
3
  import {
4
4
  FAMILY_SEQ,
5
5
  OP_EQ,
6
- OP_ITE,
7
6
  OP_SEQ_AT,
8
7
  OP_SEQ_CONTAINS,
9
8
  OP_SEQ_EXTRACT,
@@ -79,29 +78,26 @@ export class TheorySeq extends TheorySeqRegex {
79
78
  finalCheckEh() {
80
79
  if (!this.hasSeq) return FC_DONE;
81
80
  this.isNewPropagation = false;
82
- const checks = [
83
- () => this.simplifyAndSolveEqs(),
84
- () => this.checkEquationConflict(),
85
- () => this.checkLts(),
86
- () => this.solveNqs(0),
87
- () => this.checkFixedLength(true, false),
88
- () => this.checkFixedLength(false, false),
89
- () => this.checkFixedLength(false, true),
90
- () => this.checkContains(),
91
- () => this.checkIntString(),
92
- () => this.reduceLengthEq(),
93
- () => this.branchUnitVariable(),
94
- () => this.branchBinaryVariable(),
95
- () => this.branchVariable(),
96
- () => this.checkLengthCoherence(),
97
- () => !this.checkExtensionality(),
98
- () => this.branchNqs(),
99
- () => this.branchItos(),
100
- () => this.checkFixedLength(false, true),
101
- () => this.solveRecfuns(),
102
- () => this.finalCheckRegex(),
103
- ];
104
- if (checks.some((check) => check())) return FC_CONTINUE;
81
+ if (this.simplifyAndSolveEqs()) return FC_CONTINUE;
82
+ if (this.checkEquationConflict()) return FC_CONTINUE;
83
+ if (this.checkLts()) return FC_CONTINUE;
84
+ if (this.solveNqs(0)) return FC_CONTINUE;
85
+ if (this.checkFixedLength(true, false)) return FC_CONTINUE;
86
+ if (this.checkFixedLength(false, false)) return FC_CONTINUE;
87
+ if (this.checkFixedLength(false, true)) return FC_CONTINUE;
88
+ if (this.checkContains()) return FC_CONTINUE;
89
+ if (this.checkIntString()) return FC_CONTINUE;
90
+ if (this.reduceLengthEq()) return FC_CONTINUE;
91
+ if (this.branchUnitVariable()) return FC_CONTINUE;
92
+ if (this.branchBinaryVariable()) return FC_CONTINUE;
93
+ if (this.branchVariable()) return FC_CONTINUE;
94
+ if (this.checkLengthCoherence()) return FC_CONTINUE;
95
+ if (!this.checkExtensionality()) return FC_CONTINUE;
96
+ if (this.branchNqs()) return FC_CONTINUE;
97
+ if (this.branchItos()) return FC_CONTINUE;
98
+ if (this.checkFixedLength(false, true)) return FC_CONTINUE;
99
+ if (this.solveRecfuns()) return FC_CONTINUE;
100
+ if (this.finalCheckRegex()) return FC_CONTINUE;
105
101
  if (this.unhandledExpr !== undefined) return FC_GIVEUP;
106
102
  return this.eqs.size === 0 && this.ncs.size === 0 ? FC_DONE : FC_GIVEUP;
107
103
  }
@@ -140,8 +136,9 @@ export class TheorySeq extends TheorySeqRegex {
140
136
  if (op === OP_STRING_UBVTOS || op === OP_STRING_SBVTOS)
141
137
  throw new SmtUnsupportedError("str.from_ubv in the theory of sequences");
142
138
  if (op === OP_SEQ_LENGTH) this.mkVar(this.ensureEnodeOf(manager.getArg(term, 0)));
143
- if (context.isEInternalized(term)) {
144
- this.mkVar(context.getEnode(term)!);
139
+ const existing = context.getEnode(term);
140
+ if (existing !== undefined) {
141
+ this.mkVar(existing);
145
142
  return true;
146
143
  }
147
144
  const isBool = manager.isBool(term);
@@ -155,10 +152,7 @@ export class TheorySeq extends TheorySeqRegex {
155
152
  context.setVarTheory(context.mkBoolVar(term), this.id);
156
153
  context.markAsRelevant(term);
157
154
  }
158
- const node = context.isEInternalized(term)
159
- ? context.getEnode(term)!
160
- : context.mkEnode(term, false, isBool, true);
161
- this.mkVar(node);
155
+ this.mkVar(context.getEnode(term) ?? context.mkEnode(term, false, isBool, true));
162
156
  if (!context.relevancy.isEnabled) this.relevantEh(term);
163
157
  return true;
164
158
  }
@@ -389,8 +383,7 @@ export class TheorySeq extends TheorySeqRegex {
389
383
  private addLengthLimit(input: number, limit: number, isSearching: boolean) {
390
384
  const manager = this.manager;
391
385
  const todo = [input];
392
- while (todo.length > 0) {
393
- const expr = todo.pop()!;
386
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
394
387
  if (this.isConcat(expr)) {
395
388
  todo.push(...manager.getArgs(expr));
396
389
  continue;
@@ -810,16 +803,16 @@ export class TheorySeq extends TheorySeqRegex {
810
803
  minSeq = limit.seq;
811
804
  }
812
805
  }
813
- if (minLimit < MAX_UNFOLDING) {
806
+ if (minSeq !== undefined && minLimit < MAX_UNFOLDING) {
814
807
  this.maxUnfoldingDepth++;
815
808
  let limit = minLimit * 2;
816
- if (this.isSeq(minSeq!)) {
817
- limit = Math.max(this.getMinLength(minSeq!), limit);
818
- const lower = this.lowerBound2(minSeq!);
809
+ if (this.isSeq(minSeq)) {
810
+ limit = Math.max(this.getMinLength(minSeq), limit);
811
+ const lower = this.lowerBound2(minSeq);
819
812
  if (lower !== undefined && !lower.isNegative() && lower.num <= 0xffffffffn)
820
813
  limit = Math.max(Number(lower.num), limit);
821
814
  }
822
- this.addLengthLimit(minSeq!, limit, false);
815
+ this.addLengthLimit(minSeq, limit, false);
823
816
  return true;
824
817
  }
825
818
  if (hasMaxUnfolding) {
@@ -860,21 +853,6 @@ export class TheorySeq extends TheorySeqRegex {
860
853
  this.rep.popScope(1);
861
854
  }
862
855
 
863
- private getIteValue(input: number) {
864
- const context = this.context;
865
- const manager = this.manager;
866
- let expr = input;
867
- while (this.isOp(expr, OP_ITE) && context.isEInternalized(expr)) {
868
- const root = context.getEnode(expr)!.root;
869
- const thenExpr = manager.getArg(expr, 1);
870
- const elseExpr = manager.getArg(expr, 2);
871
- if (context.getEnode(thenExpr)!.root === root) expr = thenExpr;
872
- else if (context.getEnode(elseExpr)!.root === root) expr = elseExpr;
873
- else break;
874
- }
875
- return expr;
876
- }
877
-
878
856
  mkValue(node: Enode): number | DependentValue {
879
857
  const manager = this.manager;
880
858
  const context = this.context;
@@ -882,8 +860,8 @@ export class TheorySeq extends TheorySeqRegex {
882
860
  if (!this.isSeq(expr)) return this.mkValueOf(expr);
883
861
  const concats: number[] = [];
884
862
  const todo = [expr];
885
- while (todo.length > 0) {
886
- const current = this.rep.find(this.getIteValue(this.rep.find(todo.pop()!)));
863
+ for (let next = todo.pop(); next !== undefined; next = todo.pop()) {
864
+ const current = this.rep.find(this.getIteValue(this.rep.find(next)));
887
865
  if (this.isConcat(current)) todo.push(manager.getArg(current, 1), manager.getArg(current, 0));
888
866
  else concats.push(current);
889
867
  }
@@ -1,6 +1,6 @@
1
1
  // Ported from Z3 (src/smt/smt_theory.h, src/smt/smt_theory.cpp), MIT license, see z3-license.txt.
2
2
  import { shrink } from "./array";
3
- import type { AstManager } from "./ast";
3
+ import { type AstManager, OP_ITE } from "./ast";
4
4
  import type { Context } from "./context";
5
5
  import type { Enode } from "./enode";
6
6
  import { type BoolVar, FALSE_LITERAL, type Literal, negate, TRUE_LITERAL } from "./literal";
@@ -86,6 +86,21 @@ export abstract class Theory {
86
86
  return node;
87
87
  }
88
88
 
89
+ protected getIteValue(expr: number) {
90
+ const context = this.context;
91
+ const manager = this.manager;
92
+ let current = expr;
93
+ while (manager.getOp(current) === OP_ITE && context.isEInternalized(current)) {
94
+ const root = context.getEnode(current)?.root;
95
+ const thenExpr = manager.getArg(current, 1);
96
+ const elseExpr = manager.getArg(current, 2);
97
+ if (context.getEnode(thenExpr)?.root === root) current = thenExpr;
98
+ else if (context.getEnode(elseExpr)?.root === root) current = elseExpr;
99
+ else break;
100
+ }
101
+ return current;
102
+ }
103
+
89
104
  abstract internalizeAtom(atom: number, isGateContext: boolean): boolean;
90
105
 
91
106
  abstract internalizeTerm(term: number): boolean;
@@ -47,8 +47,8 @@ const getSharedApps = (manager: AstManager, forms: readonly number[]) => {
47
47
  return shared;
48
48
  };
49
49
 
50
- const getOrderedById = (first: number, second: number) =>
51
- first > second ? [second, first] : [first, second];
50
+ const getOrderedById = (manager: AstManager, first: number, second: number) =>
51
+ manager.ids[first] > manager.ids[second] ? [second, first] : [first, second];
52
52
 
53
53
  const getProductNext = (sizes: readonly number[], iterator: number[]) => {
54
54
  for (let index = 0; index < sizes.length; index++) {
@@ -168,7 +168,7 @@ export const tseitinCnf = (manager: AstManager, goal: Goal) => {
168
168
  if (!manager.isNot(arg)) return null;
169
169
  const inner = manager.getArg(arg, 0);
170
170
  if (isShared(inner) || !isOrOf(inner, 2)) return null;
171
- ors.push(getOrderedById(manager.getArg(inner, 0), manager.getArg(inner, 1)));
171
+ ors.push(getOrderedById(manager, manager.getArg(inner, 0), manager.getArg(inner, 1)));
172
172
  }
173
173
  const [[a1, a2], [b1, b2], [c1, c2]] = ors;
174
174
  if (
@@ -118,7 +118,7 @@ export const replaceFreeVars = (
118
118
  ...data,
119
119
  body: children[0],
120
120
  patterns: children.slice(1, 1 + data.patterns.length),
121
- noPatterns: [],
121
+ noPatterns: children.slice(1 + data.patterns.length),
122
122
  });
123
123
  frames.pop();
124
124
  cache.set(frame.shift * numNodes + current, result);
@@ -177,7 +177,7 @@ export class UnusedVarsEliminator {
177
177
  manager.kinds[expr] === KIND_QUANTIFIER && !manager.isLambda(expr)
178
178
  ? manager.getQuantifier(expr)
179
179
  : null;
180
- const kept = data === null ? expr : manager.isGround(data.body) ? data.body : -1;
180
+ const kept = data === null ? expr : manager.isGroundApp(data.body) ? data.body : -1;
181
181
  if (kept !== -1 || data === null) {
182
182
  manager.incRef(kept);
183
183
  return kept;
@@ -130,7 +130,7 @@ export const TYPED_SYMBOLS = [
130
130
  "TIntLteq",
131
131
  ];
132
132
 
133
- export type AxiomArgument = number | string | AxiomArgument[];
133
+ export type AxiomArgument = number | bigint | string | AxiomArgument[];
134
134
 
135
135
  export interface Axiom {
136
136
  name: string;
@@ -151,7 +151,8 @@ export const axiom = (
151
151
  formula,
152
152
  });
153
153
 
154
- export const getAxiomKey = (entry: Axiom) => `${entry.name} ${JSON.stringify(entry.args)}`;
154
+ export const getAxiomKey = (entry: Axiom) =>
155
+ `${entry.name} ${JSON.stringify(entry.args, (_key, value: unknown) => (typeof value === "bigint" ? `${value}n` : value))}`;
155
156
 
156
157
  const getAxiomRank = (entry: Axiom) => {
157
158
  const constant = CONSTANT_AXIOMS.indexOf(entry.name);
@@ -1,7 +1,7 @@
1
1
  // Ported from Zenon's main.ml, as shipped in tlapm. Copyright 1997 INRIA, see LICENSE.
2
2
 
3
3
  import { TlaZenonError } from "../../errors";
4
- import type { DecideOptions } from "../verdict";
4
+ import type { DecideOptions, Decision } from "../verdict";
5
5
  import { checkProof } from "./check/check";
6
6
  import { createRelations } from "./eqrel";
7
7
  import { createExpressions } from "./expr";
@@ -87,16 +87,14 @@ export const runZenon = (text: string, options: DecideOptions): ZenonRun => {
87
87
  };
88
88
  };
89
89
 
90
- type ZenonDecision = { verdict: "unsat"; proof: string } | { verdict: "unknown"; error?: string };
90
+ const FAILURE_ERRORS = new Map<ZenonRun["failure"], string>([
91
+ ["exhausted", "Zenon error: exhausted search space without finding a proof\n"],
92
+ ["memory limit", "Zenon error: could not find a proof within the memory size limit\n"],
93
+ ]);
91
94
 
92
- const FAILURE_ERRORS: Partial<Record<SearchFailure | "zenon error", string>> = {
93
- exhausted: "Zenon error: exhausted search space without finding a proof\n",
94
- "memory limit": "Zenon error: could not find a proof within the memory size limit\n",
95
- };
96
-
97
- export const decideZenon = (text: string, options: DecideOptions): ZenonDecision => {
95
+ export const decideZenon = (text: string, options: DecideOptions): Omit<Decision, "timeUsedMs"> => {
98
96
  const run = runZenon(text, options);
99
- if (run.isar !== undefined) return { verdict: "unsat", proof: run.isar };
100
- const error = run.failure && FAILURE_ERRORS[run.failure];
101
- return { verdict: "unknown", ...(error !== undefined && { error }) };
97
+ return run.isar === undefined
98
+ ? { verdict: "unknown", errorOutput: FAILURE_ERRORS.get(run.failure) }
99
+ : { verdict: "unsat", output: run.isar };
102
100
  };
@@ -158,18 +158,19 @@ const canInstantiate = (meta: Expr, expression: Expr): boolean => {
158
158
  };
159
159
 
160
160
  // A list cell and a node record take 3 and 6 words, and each block has a header word.
161
- const getNodeWords = (node: Node) =>
162
- node.branches.reduce(
163
- (words, branch) => words + 3 * branch.length,
161
+ const getNodeWords = (node: Node) => {
162
+ let words =
164
163
  3 +
165
- 6 +
166
- 3 * node.conclusions.length +
167
- 1 +
168
- node.rule.args.length +
169
- (typeof node.priority === "object" ? 2 : 0) +
170
- 1 +
171
- node.branches.length,
172
- );
164
+ 6 +
165
+ 3 * node.conclusions.length +
166
+ 1 +
167
+ node.rule.args.length +
168
+ (typeof node.priority === "object" ? 2 : 0) +
169
+ 1 +
170
+ node.branches.length;
171
+ for (const branch of node.branches) words += 3 * branch.length;
172
+ return words;
173
+ };
173
174
 
174
175
  export const insertNode = (previous: Queue, node: Node): Queue => {
175
176
  const queue = { ...previous, nodeWords: previous.nodeWords + getNodeWords(node) };
@@ -316,7 +316,7 @@ export const getSubsetNodes = (literal: Literal): Item[] | undefined => {
316
316
  ]);
317
317
  }
318
318
  if (isApp(right, "TLA.cap", 2)) {
319
- // tlapm's Zenon builds both subsets from the second set, and Isabelle rejects its proofs.
319
+ // Deviation from Zenon: ext_tla.ml builds both subsets from the second set, which is unsound.
320
320
  const first = exprs.eapp("TLA.subseteq", [left, right.args[0]]);
321
321
  const second = exprs.eapp("TLA.subseteq", [left, right.args[1]]);
322
322
  return isNegated