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
@@ -162,8 +162,10 @@ export class Optsmt {
162
162
  }
163
163
 
164
164
  add(term: number) {
165
- const rewritten = new Rewriter(this.manager, TACTIC_REWRITER_OPTIONS).rewrite(term);
165
+ const rewriter = new Rewriter(this.manager, TACTIC_REWRITER_OPTIONS);
166
+ const rewritten = rewriter.rewrite(term);
166
167
  this.objs.push(rewritten);
168
+ rewriter.release();
167
169
  this.manager.decRef(rewritten);
168
170
  this.lower.push(ObjectiveValue.minusInfinity);
169
171
  this.upper.push(ObjectiveValue.infinity);
@@ -438,8 +440,9 @@ export class Optsmt {
438
440
  this.params.supremumRlimit,
439
441
  );
440
442
  const result = optimized.result;
443
+ if (!result.hasModel) return NLSAT_NO_RESULT;
441
444
  const model = result.model;
442
- if (model === null) return NLSAT_NO_RESULT;
445
+ const certified = result.sup;
443
446
  this.nlsatModels.push(model);
444
447
  if (result.isUnbounded) {
445
448
  this.model = model;
@@ -447,20 +450,20 @@ export class Optsmt {
447
450
  this.upper[index] = this.lower[index];
448
451
  return NLSAT_CERTIFIED;
449
452
  }
450
- if (result.isOpen && result.sup !== null) {
453
+ if (certified?.isOpen === true) {
451
454
  // The model is a feasible witness below the limit.
452
455
  this.model = model;
453
- const lower = InfEps.of(result.supLower, Rational.minusOne);
456
+ const lower = InfEps.of(certified.lower, Rational.minusOne);
454
457
  this.setBest(index, lower);
455
- this.lower[index] = new ObjectiveValue(lower, result.sup);
458
+ this.lower[index] = new ObjectiveValue(lower, certified.value);
456
459
  this.upper[index] = new ObjectiveValue(
457
- InfEps.of(result.supUpper, Rational.minusOne),
458
- result.sup,
460
+ InfEps.of(certified.upper, Rational.minusOne),
461
+ certified.value,
459
462
  );
460
463
  return NLSAT_CERTIFIED;
461
464
  }
462
465
  const value = InfEps.of(result.lower);
463
- if (value.compare(this.getLower(index)) < 0 || result.value === null) return NLSAT_NO_RESULT;
466
+ if (value.compare(this.getLower(index)) < 0) return NLSAT_NO_RESULT;
464
467
  this.model = model;
465
468
  this.setBest(index, value);
466
469
  if (optimized.status === L_TRUE) {
@@ -468,7 +471,7 @@ export class Optsmt {
468
471
  this.upper[index] = new ObjectiveValue(InfEps.of(result.upper), result.value);
469
472
  return NLSAT_CERTIFIED;
470
473
  }
471
- const sup = result.hasSup ? minInfEps(InfEps.of(result.supUpper), upper) : upper;
474
+ const sup = certified === null ? upper : minInfEps(InfEps.of(certified.upper), upper);
472
475
  this.upper[index] = new ObjectiveValue(
473
476
  sup.compare(this.getLower(index)) < 0 ? this.getLower(index) : sup,
474
477
  );
@@ -53,7 +53,7 @@ export class PatternInference {
53
53
 
54
54
  private isForbidden(expr: number) {
55
55
  const manager = this.manager;
56
- if (manager.isGround(expr)) return false;
56
+ if (manager.isGroundApp(expr)) return false;
57
57
  const decl = manager.funcDecls[manager.decls[expr]];
58
58
  if (decl.isSkolem) return true;
59
59
  if (decl.family === FAMILY_BASIC) return decl.op !== OP_TRUE && decl.op !== OP_FALSE;
@@ -227,7 +227,7 @@ export class PatternInference {
227
227
  args[index] = args[args.length - 1];
228
228
  index--;
229
229
  args.pop();
230
- if (manager.isGround(arg)) continue;
230
+ if (manager.isGroundApp(arg)) continue;
231
231
  for (let argIndex = 0; argIndex < manager.getNumArgs(arg); argIndex++) {
232
232
  const innerArg = manager.getArg(arg, argIndex);
233
233
  if (manager.kinds[innerArg] !== KIND_APP) return manager.mkPattern([candidate]);
@@ -101,9 +101,15 @@ export const mkPbEq = (
101
101
  return mkPbApp(manager, OP_PB_EQ, [normalized.k, ...normalized.coeffs], args);
102
102
  };
103
103
 
104
- // ast_util's mk_not.
105
- const mkNot = (manager: AstManager, expr: number) =>
106
- manager.isNot(expr) ? manager.getArg(expr, 0) : manager.mkNot(expr);
104
+ // ast_util's mk_not and pb_util's negate.
105
+ const negate = (manager: AstManager, expr: number) =>
106
+ expr === manager.trueExpr
107
+ ? manager.falseExpr
108
+ : expr === manager.falseExpr
109
+ ? manager.trueExpr
110
+ : manager.isNot(expr)
111
+ ? manager.getArg(expr, 0)
112
+ : manager.mkNot(expr);
107
113
 
108
114
  const mkAnd = (manager: AstManager, args: number[]) =>
109
115
  args.length === 0 ? manager.trueExpr : manager.mkAnd(args);
@@ -111,7 +117,7 @@ const mkAnd = (manager: AstManager, args: number[]) =>
111
117
  const unique = (manager: AstManager, args: PbArg[], bound: { k: Rational }) => {
112
118
  for (const arg of args)
113
119
  if (manager.isNot(arg.expr)) {
114
- arg.expr = mkNot(manager, arg.expr);
120
+ arg.expr = negate(manager, arg.expr);
115
121
  bound.k = bound.k.sub(arg.coeff);
116
122
  arg.coeff = arg.coeff.neg();
117
123
  }
@@ -119,7 +125,8 @@ const unique = (manager: AstManager, args: PbArg[], bound: { k: Rational }) => {
119
125
  if (arg.expr === manager.trueExpr) bound.k = bound.k.sub(arg.coeff);
120
126
  return arg.expr !== manager.trueExpr && arg.expr !== manager.falseExpr;
121
127
  });
122
- kept.sort((first, second) => first.expr - second.expr);
128
+ const ids = manager.ids;
129
+ kept.sort((first, second) => ids[first.expr] - ids[second.expr]);
123
130
  const coalesced: PbArg[] = [];
124
131
  for (const arg of kept) {
125
132
  const last = coalesced[coalesced.length - 1];
@@ -204,13 +211,6 @@ const normalizePb = (manager: AstManager, args: PbArg[], bound: { k: Rational },
204
211
  return L_UNDEF;
205
212
  };
206
213
 
207
- const negate = (manager: AstManager, expr: number) =>
208
- expr === manager.trueExpr
209
- ? manager.falseExpr
210
- : expr === manager.falseExpr
211
- ? manager.trueExpr
212
- : mkNot(manager, expr);
213
-
214
214
  const prune = (manager: AstManager, args: PbArg[], bound: { k: Rational }, isEq: boolean) => {
215
215
  if (isEq) return;
216
216
  let nlt = Rational.zero;
@@ -258,7 +258,7 @@ export const mkPbAppCore = (
258
258
  const size = vec.length;
259
259
  if (isEq) {
260
260
  if (size === 0) return k.isZero() ? manager.trueExpr : manager.falseExpr;
261
- if (k.isZero()) return mkNot(manager, manager.mkOr(exprs));
261
+ if (k.isZero()) return negate(manager, manager.mkOr(exprs));
262
262
  if (k.equals(Rational.one) && isAllUnit && size === 1) return exprs[0];
263
263
  if (slack.equals(k)) return mkAnd(manager, exprs);
264
264
  return mkPbEq(manager, coeffs, exprs, k);
@@ -232,7 +232,7 @@ export class PolyRewriter {
232
232
  }
233
233
 
234
234
  mkAddCore(args: number[]): number | Rewrite | undefined {
235
- if (args.length < 2) return undefined;
235
+ if (args.length < 2) return args.length === 1 ? args[0] : undefined;
236
236
  const manager = this.manager;
237
237
  if (
238
238
  this.options.isHoistIte === true &&
@@ -387,7 +387,7 @@ export class PolyRewriter {
387
387
  }
388
388
 
389
389
  mkMul(args: number[]): number | Rewrite | undefined {
390
- if (args.length < 2) return undefined;
390
+ if (args.length < 2) return args.length === 1 ? args[0] : undefined;
391
391
  this.currSort = this.manager.sorts[args[0]];
392
392
  const isFlatMonomial =
393
393
  args.length === 2 &&
@@ -267,7 +267,7 @@ const mkNonNira =
267
267
  const divisor = manager.getArg(expr, 1);
268
268
  if (isLinear)
269
269
  return !manager.isNumeral(divisor) || manager.getRationalValue(divisor).isZero();
270
- return !manager.isGround(manager.getArg(expr, 0)) || !manager.isGround(divisor);
270
+ return !manager.isGroundApp(manager.getArg(expr, 0)) || !manager.isGroundApp(divisor);
271
271
  }
272
272
  if (op === OP_IS_INT) return isReal;
273
273
  if (op === OP_TO_INT || op === OP_TO_REAL) return false;
@@ -23,6 +23,10 @@ const getSharedOccs = (manager: AstManager, forms: number[]) => {
23
23
  export const propagateValues = (manager: AstManager, goal: Goal, maxRounds = 4) => {
24
24
  goal.depth++;
25
25
  if (goal.isInconsistent) return;
26
+ if (goal.isProofsEnabled) {
27
+ goal.elimRedundancies();
28
+ return;
29
+ }
26
30
  const rewriter = new Rewriter(manager, TACTIC_REWRITER_OPTIONS);
27
31
  const substitution = new Map<number, number>();
28
32
  const dependencies = new Map<number, Dependency | undefined>();
@@ -144,7 +144,7 @@ export class FuncInterp {
144
144
  const manager = this.manager;
145
145
  if (manager.getOp(expr) !== OP_ITE) return undefined;
146
146
  const condition = manager.getArg(expr, 0);
147
- if (!manager.isGround(manager.getArg(expr, 1)) || this.arity === 0) return undefined;
147
+ if (!manager.isGroundApp(manager.getArg(expr, 1)) || this.arity === 0) return undefined;
148
148
  if (this.arity === 1 && manager.getOp(condition) !== OP_EQ) return undefined;
149
149
  if (
150
150
  this.arity > 1 &&
@@ -189,7 +189,7 @@ export class FuncInterp {
189
189
 
190
190
  isConstant() {
191
191
  const elseExpr = this.elseExpr;
192
- if (elseExpr === null || !this.manager.isGround(elseExpr)) return false;
192
+ if (elseExpr === null || !this.manager.isGroundApp(elseExpr)) return false;
193
193
  return this.entries.every((entry) => entry.result === elseExpr);
194
194
  }
195
195
 
@@ -211,7 +211,7 @@ export class FuncInterp {
211
211
  compress() {
212
212
  const manager = this.manager;
213
213
  const elseExpr = this.elseExpr;
214
- if (elseExpr === null || this.entries.length === 0 || !manager.isGround(elseExpr)) return;
214
+ if (elseExpr === null || this.entries.length === 0 || !manager.isGroundApp(elseExpr)) return;
215
215
  const kept = this.entries.filter((entry) => {
216
216
  if (entry.result !== elseExpr) return true;
217
217
  this.releaseEntry(entry);
@@ -252,10 +252,10 @@ export class FuncInterp {
252
252
  if (elseExpr === null) return undefined;
253
253
  const domain = manager.funcDecls[decl].domain;
254
254
  const isGround =
255
- manager.isGround(elseExpr) &&
255
+ manager.isGroundApp(elseExpr) &&
256
256
  this.entries.every(
257
257
  (entry) =>
258
- manager.isGround(entry.result) && entry.args.every((arg) => manager.isGround(arg)),
258
+ manager.isGroundApp(entry.result) && entry.args.every((arg) => manager.isGroundApp(arg)),
259
259
  );
260
260
  if (!isGround) {
261
261
  const interp = this.getInterp();
@@ -110,7 +110,7 @@ class PurifyState {
110
110
  private initCannotPurify() {
111
111
  const manager = this.manager;
112
112
  this.forEachApp((expr) => {
113
- if (manager.getArgs(expr).some((arg) => !manager.isGround(arg)))
113
+ if (manager.getArgs(expr).some((arg) => !manager.isGroundApp(arg)))
114
114
  this.cannotPurify.add(manager.decls[expr]);
115
115
  });
116
116
  }
@@ -253,7 +253,7 @@ class PurifyRewriter extends RewriterTpl {
253
253
  const expr = this.mk(decl, args, SORT_INT);
254
254
  const processed = this.state.appToFresh.get(expr);
255
255
  if (processed !== undefined) return processed;
256
- this.processIdiv(OP_IDIV, args);
256
+ this.processIdiv(decl, args);
257
257
  return this.state.appToFresh.get(expr) as number;
258
258
  }
259
259
 
@@ -377,9 +377,9 @@ class PurifyRewriter extends RewriterTpl {
377
377
  return -1;
378
378
  }
379
379
 
380
- // Inside [-1, 1], k is asin or acos on its principal range. Outside it, k is asin-u or acos-u
381
- // when the purification is complete.
382
- private processInverse(decl: number, x: number) {
380
+ // Inside [-1, 1], k is asin on its principal range. Outside it, k is asin-u when the
381
+ // purification is complete.
382
+ private processAsin(decl: number, x: number) {
383
383
  const state = this.state;
384
384
  if (!state.options.isElimInverses) return -1;
385
385
  const expr = this.mk(decl, [x], SORT_REAL);
@@ -387,27 +387,61 @@ class PurifyRewriter extends RewriterTpl {
387
387
  if (processed !== undefined) return processed;
388
388
  const fresh = this.mkFreshVar(false);
389
389
  this.cacheResult(expr, fresh);
390
- const isAsin = decl === OP_ASIN;
391
390
  const one = this.mkNumeral(Rational.one, false);
392
391
  const minusOne = this.mkNumeral(Rational.minusOne, false);
393
- const upper = isAsin ? this.mkHalfPi(1n) : this.manager.piExpr;
394
- const lower = isAsin ? this.mkHalfPi(-1n) : this.mkNumeral(Rational.zero, false);
392
+ const halfPi = this.mkHalfPi(1n);
393
+ const minusHalfPi = this.mkHalfPi(-1n);
395
394
  const xGeMinusOne = this.mk(OP_GE, [x, minusOne]);
395
+ const xLtMinusOne = this.mk(OP_NOT, [xGeMinusOne]);
396
396
  const xLeOne = this.mk(OP_LE, [x, one]);
397
- const outside = this.mk(OP_OR, [this.mk(OP_NOT, [xGeMinusOne]), this.mk(OP_NOT, [xLeOne])]);
398
- const inverseEq = this.mk(OP_EQ, [x, this.mk(isAsin ? OP_SIN : OP_COS, [fresh], SORT_REAL)]);
399
- const freshGeLower = this.mk(OP_GE, [fresh, lower]);
397
+ const outside = this.mk(OP_OR, [xLtMinusOne, this.mk(OP_NOT, [xLeOne])]);
398
+ const sinEq = this.mk(OP_EQ, [x, this.mk(OP_SIN, [fresh], SORT_REAL)]);
399
+ const freshGeMinusHalfPi = this.mk(OP_GE, [fresh, minusHalfPi]);
400
400
  this.pushConstraint(
401
401
  this.mk(OP_OR, [
402
402
  outside,
403
403
  this.mk(OP_AND, [
404
- inverseEq,
405
- this.mk(OP_AND, [freshGeLower, this.mk(OP_LE, [fresh, upper])]),
404
+ sinEq,
405
+ this.mk(OP_AND, [freshGeMinusHalfPi, this.mk(OP_LE, [fresh, halfPi])]),
406
406
  ]),
407
407
  ]),
408
408
  );
409
409
  if (state.options.isComplete) {
410
- const unspecified = this.mk(isAsin ? OP_U_ASIN : OP_U_ACOS, [x], SORT_REAL);
410
+ const unspecified = this.mk(OP_U_ASIN, [x], SORT_REAL);
411
+ this.pushConstraint(this.mk(OP_OR, [xGeMinusOne, this.mk(OP_EQ, [fresh, unspecified])]));
412
+ this.pushConstraint(this.mk(OP_OR, [xLeOne, this.mk(OP_EQ, [fresh, unspecified])]));
413
+ }
414
+ return fresh;
415
+ }
416
+
417
+ // Inside [-1, 1], k is acos on its principal range. Outside it, k is acos-u when the
418
+ // purification is complete.
419
+ private processAcos(decl: number, x: number) {
420
+ const state = this.state;
421
+ if (!state.options.isElimInverses) return -1;
422
+ const expr = this.mk(decl, [x], SORT_REAL);
423
+ const processed = state.appToFresh.get(expr);
424
+ if (processed !== undefined) return processed;
425
+ const fresh = this.mkFreshVar(false);
426
+ this.cacheResult(expr, fresh);
427
+ const one = this.mkNumeral(Rational.one, false);
428
+ const minusOne = this.mkNumeral(Rational.minusOne, false);
429
+ const pi = this.manager.piExpr;
430
+ const zero = this.mkNumeral(Rational.zero, false);
431
+ const xGeMinusOne = this.mk(OP_GE, [x, minusOne]);
432
+ const xLtMinusOne = this.mk(OP_NOT, [xGeMinusOne]);
433
+ const xLeOne = this.mk(OP_LE, [x, one]);
434
+ const outside = this.mk(OP_OR, [xLtMinusOne, this.mk(OP_NOT, [xLeOne])]);
435
+ const cosEq = this.mk(OP_EQ, [x, this.mk(OP_COS, [fresh], SORT_REAL)]);
436
+ const freshGeZero = this.mk(OP_GE, [fresh, zero]);
437
+ this.pushConstraint(
438
+ this.mk(OP_OR, [
439
+ outside,
440
+ this.mk(OP_AND, [cosEq, this.mk(OP_AND, [freshGeZero, this.mk(OP_LE, [fresh, pi])])]),
441
+ ]),
442
+ );
443
+ if (state.options.isComplete) {
444
+ const unspecified = this.mk(OP_U_ACOS, [x], SORT_REAL);
411
445
  this.pushConstraint(this.mk(OP_OR, [xGeMinusOne, this.mk(OP_EQ, [fresh, unspecified])]));
412
446
  this.pushConstraint(this.mk(OP_OR, [xLeOne, this.mk(OP_EQ, [fresh, unspecified])]));
413
447
  }
@@ -459,8 +493,9 @@ class PurifyRewriter extends RewriterTpl {
459
493
  case OP_POWER:
460
494
  return this.processPower(decl, args);
461
495
  case OP_ASIN:
496
+ return this.processAsin(decl, args[0]);
462
497
  case OP_ACOS:
463
- return this.processInverse(decl, args[0]);
498
+ return this.processAcos(decl, args[0]);
464
499
  case OP_SIN:
465
500
  return this.processSinCos(true, decl, args[0]);
466
501
  case OP_COS:
@@ -364,8 +364,9 @@ class ArithQeUtil {
364
364
  ? manager.getArg(expr, 1)
365
365
  : expr;
366
366
  };
367
+ const ids = manager.ids;
367
368
  const args = [...manager.getArgs(simplified)].sort(
368
- (first, second) => strip(first) - strip(second),
369
+ (first, second) => ids[strip(first)] - ids[strip(second)],
369
370
  );
370
371
  return this.mkAddN(args);
371
372
  }
@@ -8,7 +8,6 @@ import {
8
8
  FAMILY_DATATYPE,
9
9
  FAMILY_SEQ,
10
10
  KIND_APP,
11
- KIND_QUANTIFIER,
12
11
  OP_EQ,
13
12
  SORT_BOOL,
14
13
  } from "./ast";
@@ -20,24 +19,10 @@ import { applyMbpQel } from "./mbp/mbp-qel";
20
19
  import { filterRefVector } from "./mbp/mbp-term-graph";
21
20
  import type { ProtoModel } from "./proto-model";
22
21
  import { applyQel } from "./qel";
22
+ import { hasSubterm } from "./recfun-decl-plugin";
23
23
  import { RefVector } from "./ref-vector";
24
24
  import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
25
25
 
26
- const getSubterms = (manager: AstManager, roots: readonly number[]) => {
27
- const visited = new Set<number>();
28
- const todo = [...roots];
29
- for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
30
- if (visited.has(expr)) continue;
31
- visited.add(expr);
32
- if (manager.kinds[expr] === KIND_APP) manager.pushArgs(expr, todo);
33
- else if (manager.kinds[expr] === KIND_QUANTIFIER) todo.push(manager.getQuantifier(expr).body);
34
- }
35
- return visited;
36
- };
37
-
38
- const isOccurring = (manager: AstManager, variable: number, expr: number) =>
39
- getSubterms(manager, [expr]).has(variable);
40
-
41
26
  const hasSortFamily = (manager: AstManager, expr: number, families: readonly number[]) =>
42
27
  families.includes(manager.getSortFamily(manager.sorts[expr])) ||
43
28
  (manager.kinds[expr] === KIND_APP && families.includes(manager.getFamily(expr)));
@@ -58,7 +43,7 @@ export class Mbproj {
58
43
  apply(isForceElim: boolean, vars: RefVector, model: ProtoModel, fmls: RefVector) {
59
44
  const manager = this.manager;
60
45
  const context = new MbpContext(manager, model);
61
- const isUnsupportedTh = [...getSubterms(manager, fmls.items)].some((expr) =>
46
+ const isUnsupportedTh = hasSubterm(manager, fmls.items, (expr) =>
62
47
  hasSortFamily(manager, expr, [FAMILY_SEQ, FAMILY_CHAR]),
63
48
  );
64
49
  if (isUnsupportedTh) this.mbp(context, isForceElim, vars, fmls);
@@ -96,7 +81,7 @@ export class Mbproj {
96
81
  const manager = this.manager;
97
82
  // The term graph's rules for arrays and datatypes, and spacer_qe_lite, are not ported.
98
83
  if (
99
- [...getSubterms(manager, [formula])].some((expr) =>
84
+ hasSubterm(manager, [formula], (expr) =>
100
85
  hasSortFamily(manager, expr, [FAMILY_ARRAY, FAMILY_DATATYPE]),
101
86
  )
102
87
  )
@@ -117,7 +102,7 @@ export class Mbproj {
117
102
  if (
118
103
  !vars.items.includes(innerVar) &&
119
104
  !otherVars.items.includes(innerVar) &&
120
- isOccurring(manager, innerVar, result)
105
+ hasSubterm(manager, [result], (expr) => expr === innerVar)
121
106
  )
122
107
  otherVars.push(innerVar);
123
108
  if (otherVars.size > 0) {
@@ -161,7 +146,8 @@ export class Mbproj {
161
146
  }
162
147
  const term = terms.find(
163
148
  (candidate) =>
164
- context.eval(candidate, false) === value && !isOccurring(manager, innerVar, candidate),
149
+ context.eval(candidate, false) === value &&
150
+ !hasSubterm(manager, [candidate], (expr) => expr === innerVar),
165
151
  );
166
152
  if (term === undefined) {
167
153
  vars.set(kept++, innerVar);
@@ -221,13 +207,13 @@ export class Mbproj {
221
207
  filterRefVector(vars, (innerVar) => visited.has(innerVar));
222
208
  this.projectBools(context, vars, fmls);
223
209
  let isProgress = true;
224
- while (isProgress && vars.size > 0 && fmls.size > 0) {
210
+ while (isProgress && vars.size > 0 && fmls.size > 0 && manager.limit.inc()) {
225
211
  const newVars = new RefVector(manager);
226
212
  isProgress = false;
227
213
  const remaining = [...vars.items];
228
214
  arith.project(remaining, fmls);
229
215
  filterRefVector(vars, (innerVar) => remaining.includes(innerVar));
230
- while (vars.size > 0 && fmls.size > 0) {
216
+ while (vars.size > 0 && fmls.size > 0 && manager.limit.inc()) {
231
217
  const innerVar = vars.items[vars.size - 1];
232
218
  manager.incRef(innerVar);
233
219
  vars.pop();
@@ -236,7 +222,7 @@ export class Mbproj {
236
222
  else newVars.push(innerVar);
237
223
  manager.decRef(innerVar);
238
224
  }
239
- if (!isProgress && newVars.size > 0 && fmls.size > 0 && isForceElim) {
225
+ if (!isProgress && newVars.size > 0 && fmls.size > 0 && isForceElim && manager.limit.inc()) {
240
226
  const innerVar = newVars.items[newVars.size - 1];
241
227
  const subst = new ExprSafeReplace(manager);
242
228
  subst.insert(innerVar, context.eval(innerVar));
@@ -252,6 +238,10 @@ export class Mbproj {
252
238
  subst.release();
253
239
  isProgress = true;
254
240
  }
241
+ if (!manager.limit.inc()) {
242
+ newVars.reset();
243
+ return;
244
+ }
255
245
  for (const innerVar of newVars.items) vars.push(innerVar);
256
246
  newVars.reset();
257
247
  if (isProgress) this.preprocessSolve(context, vars, fmls);
@@ -31,6 +31,7 @@ import { ObjHashtable } from "./hashtable";
31
31
  import { L_TRUE, L_UNDEF } from "./lbool";
32
32
  import type { ProtoModel } from "./proto-model";
33
33
  import { ArithPlugin } from "./qe-arith-plugin";
34
+ import { hasSubterm } from "./recfun-decl-plugin";
34
35
  import { RefVector } from "./ref-vector";
35
36
  import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
36
37
  import { InvVarShifter, RewriterTpl, VarShifter } from "./rewriter-tpl";
@@ -1206,33 +1207,49 @@ class QuantElim {
1206
1207
  const result = this.eliminateExists(vars, formula, freeVars, false);
1207
1208
  const bound = freeVars.filter((x) => new ContainsApp(manager, x).has(result));
1208
1209
  if (bound.length === 0) return result;
1209
- return this.pin(mkExistsOver(manager, bound, result, this));
1210
+ return this.pin(mkQuantifierOver(manager, QUANTIFIER_EXISTS, bound, result, this));
1210
1211
  }
1211
1212
  }
1212
1213
 
1213
- // expr_abstract and mk_exists: binds the constants, the last one to (:var 0).
1214
- const mkExistsOver = (
1214
+ // mk_exists and mk_forall over the constants an abstracted body had.
1215
+ export const mkQuantifierOfConsts = (
1215
1216
  manager: AstManager,
1217
+ kind: number,
1216
1218
  vars: readonly number[],
1217
- formula: number,
1218
- quantElim: QuantElim,
1219
- ) => {
1220
- const replace = new ExprSafeReplace(manager);
1221
- vars.forEach((x, index) =>
1222
- replace.insert(x, quantElim.pin(manager.mkVar(vars.length - 1 - index, manager.sorts[x]))),
1223
- );
1224
- const body = quantElim.pinOwned(replace.apply(formula));
1225
- replace.release();
1226
- return manager.mkQuantifier({
1227
- kind: QUANTIFIER_EXISTS,
1219
+ body: number,
1220
+ weight: number,
1221
+ ) =>
1222
+ manager.mkQuantifier({
1223
+ kind,
1228
1224
  sorts: vars.map((x) => manager.sorts[x]),
1229
1225
  names: vars.map((x) => manager.getDeclName(x)),
1230
1226
  body,
1231
1227
  patterns: [],
1232
1228
  noPatterns: [],
1233
- weight: 1,
1229
+ weight,
1234
1230
  qid: "",
1235
1231
  });
1232
+
1233
+ interface Pins {
1234
+ pin(expr: number): number;
1235
+ pinOwned(expr: number): number;
1236
+ }
1237
+
1238
+ // expr_abstract and mk_quantifier: binds the constants, the last one to (:var 0).
1239
+ const mkQuantifierOver = (
1240
+ manager: AstManager,
1241
+ kind: number,
1242
+ vars: readonly number[],
1243
+ formula: number,
1244
+ pins: Pins,
1245
+ ) => {
1246
+ const replace = new ExprSafeReplace(manager);
1247
+ vars.forEach((x, index) =>
1248
+ replace.insert(x, pins.pin(manager.mkVar(vars.length - 1 - index, manager.sorts[x]))),
1249
+ );
1250
+ const body = pins.pinOwned(replace.apply(formula));
1251
+ replace.release();
1252
+ return mkQuantifierOfConsts(manager, kind, vars, body, 1);
1236
1253
  };
1237
1254
 
1238
1255
  // The body of the quantifier over fresh constants for its variables, with a reference.
@@ -1430,22 +1447,7 @@ class SimplifyRewriter extends RewriterTpl {
1430
1447
  manager.incRef(result);
1431
1448
  return result;
1432
1449
  }
1433
- const replace = new ExprSafeReplace(manager);
1434
- vars.forEach((x, index) =>
1435
- replace.insert(x, context.pin(manager.mkVar(vars.length - 1 - index, manager.sorts[x]))),
1436
- );
1437
- const abstracted = context.pinOwned(replace.apply(result));
1438
- replace.release();
1439
- const quantifier = manager.mkQuantifier({
1440
- kind: data.kind,
1441
- sorts: vars.map((x) => manager.sorts[x]),
1442
- names: vars.map((x) => manager.getDeclName(x)),
1443
- body: abstracted,
1444
- patterns: [],
1445
- noPatterns: [],
1446
- weight: 1,
1447
- qid: "",
1448
- });
1450
+ const quantifier = mkQuantifierOver(manager, data.kind, vars, result, context);
1449
1451
  manager.incRef(quantifier);
1450
1452
  return quantifier;
1451
1453
  }
@@ -1484,25 +1486,15 @@ export const runQe = (manager: AstManager) => (goal: Goal) => {
1484
1486
  }
1485
1487
  };
1486
1488
 
1487
- const hasUnsupportedSort = (manager: AstManager, formula: number) => {
1488
- const visited = new Set<number>();
1489
- const todo = [formula];
1490
- for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
1491
- if (visited.has(expr)) continue;
1492
- visited.add(expr);
1493
- const family = manager.getSortFamily(manager.sorts[expr]);
1494
- if (family === FAMILY_ARRAY || family === FAMILY_DATATYPE) return true;
1495
- if (manager.kinds[expr] === KIND_APP) manager.pushArgs(expr, todo);
1496
- else if (manager.kinds[expr] === KIND_QUANTIFIER) {
1497
- const data = manager.getQuantifier(expr);
1498
- if (
1499
- data.sorts.some((sort) =>
1500
- [FAMILY_ARRAY, FAMILY_DATATYPE].includes(manager.getSortFamily(sort)),
1501
- )
1502
- )
1503
- return true;
1504
- todo.push(data.body);
1505
- }
1506
- }
1507
- return false;
1508
- };
1489
+ const isArrayOrDatatype = (manager: AstManager, sort: number) =>
1490
+ manager.getSortFamily(sort) === FAMILY_ARRAY || manager.getSortFamily(sort) === FAMILY_DATATYPE;
1491
+
1492
+ const hasUnsupportedSort = (manager: AstManager, formula: number) =>
1493
+ hasSubterm(
1494
+ manager,
1495
+ [formula],
1496
+ (expr) =>
1497
+ isArrayOrDatatype(manager, manager.sorts[expr]) ||
1498
+ (manager.kinds[expr] === KIND_QUANTIFIER &&
1499
+ manager.getQuantifier(expr).sorts.some((sort) => isArrayOrDatatype(manager, sort))),
1500
+ );