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
@@ -14,12 +14,13 @@ import {
14
14
  } from "./ast";
15
15
  import { hasUninterpreted, isAppOf, pushNotOwned } from "./ast-util";
16
16
  import { MBQI_MAX_ITERATIONS } from "./context";
17
- import { extractVars } from "./qe";
17
+ import { extractVars, mkQuantifierOfConsts } from "./qe";
18
18
  import type { Goal } from "./goal";
19
19
  import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
20
20
  import type { ProtoModel } from "./proto-model";
21
21
  import { Mbproj } from "./qe-mbp";
22
22
  import { QuantifierHoister } from "./quant-hoist";
23
+ import { hasSubterm } from "./recfun-decl-plugin";
23
24
  import { RefVector } from "./ref-vector";
24
25
  import { SmtKernel } from "./smt-kernel";
25
26
 
@@ -61,18 +62,6 @@ const hasQuantifiedUninterpreted = (manager: AstManager, expr: number) => {
61
62
  return false;
62
63
  };
63
64
 
64
- const isGround = (manager: AstManager, expr: number) => {
65
- const visited = new Set<number>();
66
- const todo = [expr];
67
- for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
68
- if (visited.has(current)) continue;
69
- visited.add(current);
70
- if (manager.kinds[current] !== KIND_APP) return false;
71
- manager.pushArgs(current, todo);
72
- }
73
- return true;
74
- };
75
-
76
65
  // pred_abs::get_free_vars: the uninterpreted constants of a formula.
77
66
  export const getFreeVars = (manager: AstManager, formula: number, vars: RefVector) => {
78
67
  const marked = new Set<number>();
@@ -182,22 +171,27 @@ class PredAbs {
182
171
  return;
183
172
  }
184
173
  if (level === 0) return;
185
- const evaluate = (pred: number) => {
174
+ const isFalseIn = (pred: number) => {
186
175
  const value = model.eval(pred, true);
187
176
  const isFalse = manager.isFalse(value);
188
177
  manager.decRef(value);
189
- return isFalse ? this.pin(manager.mkNot(pred)) : pred;
178
+ return isFalse;
190
179
  };
191
180
  for (let index = 0; index <= level - 1; index++)
192
- for (const pred of this.preds[index]) this.asms.push(evaluate(pred));
181
+ for (const pred of this.preds[index]) {
182
+ const isFalse = isFalseIn(pred);
183
+ if (!manager.limit.inc()) return;
184
+ this.asms.push(isFalse ? this.pin(manager.mkNot(pred)) : pred);
185
+ }
193
186
  for (const asm of this.asms.items) asms.push(asm);
194
187
  for (let index = level + 1; index < this.preds.length; index += 2)
195
188
  for (const pred of this.preds[index]) {
189
+ if (!manager.limit.inc()) return;
196
190
  const predLevel = this.elevel.get(pred) as MaxLevel;
197
191
  const isUsed =
198
192
  (predLevel.fa === index && (predLevel.ex === NO_LEVEL || predLevel.ex < level)) ||
199
193
  (predLevel.ex === index && (predLevel.fa === NO_LEVEL || predLevel.fa < level));
200
- if (isUsed) asms.push(evaluate(pred));
194
+ if (isUsed) asms.push(isFalseIn(pred) ? this.pin(manager.mkNot(pred)) : pred);
201
195
  }
202
196
  }
203
197
 
@@ -430,22 +424,25 @@ class Qsat {
430
424
  for (;;) {
431
425
  manager.limit.checkpoint();
432
426
  const asms = new RefVector(manager);
433
- for (const asm of this.asms.items) asms.push(asm);
434
- this.predAbs.getAssumptions(this.model, asms);
435
- const kernel = this.getKernel(this.level).solver;
436
- const result = kernel.check(asms.items);
437
- if (result === L_TRUE) {
438
- this.setModel(kernel.context.getModel());
439
- if (this.level === 0) this.setModelSave(this.model);
440
- this.push();
441
- } else if (result === L_FALSE) {
442
- if (this.level === 0) return L_FALSE;
443
- if (this.level === 1 && this.mode === QSAT_SAT) return L_TRUE;
444
- if (this.model === undefined) this.pop(1);
445
- else if (this.level === 1) this.projectQe(asms);
446
- else if (!this.project(asms)) return L_UNDEF;
447
- } else return result;
448
- asms.reset();
427
+ try {
428
+ for (const asm of this.asms.items) asms.push(asm);
429
+ this.predAbs.getAssumptions(this.model, asms);
430
+ const kernel = this.getKernel(this.level).solver;
431
+ const result = kernel.check(asms.items);
432
+ if (result === L_TRUE) {
433
+ this.setModel(kernel.context.getModel());
434
+ if (this.level === 0) this.setModelSave(this.model);
435
+ this.push();
436
+ } else if (result === L_FALSE) {
437
+ if (this.level === 0) return L_FALSE;
438
+ if (this.level === 1 && this.mode === QSAT_SAT) return L_TRUE;
439
+ if (this.model === undefined) this.pop(1);
440
+ else if (this.level === 1) this.projectQe(asms);
441
+ else if (!this.project(asms)) return L_UNDEF;
442
+ } else return result;
443
+ } finally {
444
+ asms.reset();
445
+ }
449
446
  }
450
447
  }
451
448
 
@@ -506,28 +503,31 @@ class Qsat {
506
503
  const pullInto = (target: RefVector) => {
507
504
  result = this.pinOwned(hoister.pullQuantifier(isForall, result, target));
508
505
  };
509
- if (this.mode !== QSAT_SAT) {
510
- isForall = true;
511
- const vars = new RefVector(manager);
512
- pullInto(vars);
513
- this.vars.push(vars);
514
- this.filterVars(vars);
515
- } else {
516
- const vars = new RefVector(manager);
517
- pullInto(vars);
518
- for (const innerVar of vars.items) freeVars.push(innerVar);
519
- this.filterVars(vars);
520
- vars.reset();
521
- }
522
- for (;;) {
523
- isForall = !isForall;
524
- const vars = new RefVector(manager);
525
- pullInto(vars);
526
- this.vars.push(vars);
527
- this.filterVars(vars);
528
- if (vars.size === 0) break;
506
+ try {
507
+ if (this.mode !== QSAT_SAT) {
508
+ isForall = true;
509
+ const vars = new RefVector(manager);
510
+ pullInto(vars);
511
+ this.vars.push(vars);
512
+ this.filterVars(vars);
513
+ } else {
514
+ const vars = new RefVector(manager);
515
+ pullInto(vars);
516
+ for (const innerVar of vars.items) freeVars.push(innerVar);
517
+ this.filterVars(vars);
518
+ vars.reset();
519
+ }
520
+ for (;;) {
521
+ isForall = !isForall;
522
+ const vars = new RefVector(manager);
523
+ pullInto(vars);
524
+ this.vars.push(vars);
525
+ this.filterVars(vars);
526
+ if (vars.size === 0) break;
527
+ }
528
+ } finally {
529
+ hoister.release();
529
530
  }
530
- hoister.release();
531
531
  this.initializeLevels();
532
532
  return result;
533
533
  }
@@ -683,38 +683,32 @@ class Qsat {
683
683
  if (manager.hasQuantifierFlags[formula]) return -1;
684
684
  this.reset();
685
685
  const exists = this.pin(
686
- manager.mkQuantifier({
687
- kind: QUANTIFIER_EXISTS,
688
- sorts: vars.items.map((innerVar) => manager.sorts[innerVar]),
689
- names: vars.items.map((innerVar) => manager.getDeclName(innerVar)),
690
- body: this.abstractVars(vars, formula),
691
- patterns: [],
692
- noPatterns: [],
693
- weight: 0,
694
- qid: "",
695
- }),
686
+ mkQuantifierOfConsts(
687
+ manager,
688
+ QUANTIFIER_EXISTS,
689
+ vars.items,
690
+ this.abstractVars(vars, formula),
691
+ 0,
692
+ ),
696
693
  );
697
694
  const hoisted = this.hoist(this.pinOwned(pushNotOwned(manager, exists)));
698
695
  this.assertFormula(hoisted);
699
696
  if (this.checkSat() !== L_FALSE) return -1;
700
697
  let result = this.pin(manager.mkAnd(this.answer.items));
701
698
  const freeVars = this.freeVars.items.filter((innerVar) =>
702
- isOccurringIn(manager, innerVar, result),
699
+ hasSubterm(manager, [result], (expr) => expr === innerVar),
703
700
  );
704
701
  if (freeVars.length > 0) {
705
702
  const subVars = new RefVector(manager);
706
703
  for (const innerVar of freeVars) subVars.push(innerVar);
707
704
  result = this.pin(
708
- manager.mkQuantifier({
709
- kind: QUANTIFIER_EXISTS,
710
- sorts: freeVars.map((innerVar) => manager.sorts[innerVar]),
711
- names: freeVars.map((innerVar) => manager.getDeclName(innerVar)),
712
- body: this.abstractVars(subVars, result),
713
- patterns: [],
714
- noPatterns: [],
715
- weight: 0,
716
- qid: "",
717
- }),
705
+ mkQuantifierOfConsts(
706
+ manager,
707
+ QUANTIFIER_EXISTS,
708
+ freeVars,
709
+ this.abstractVars(subVars, result),
710
+ 0,
711
+ ),
718
712
  );
719
713
  subVars.reset();
720
714
  }
@@ -753,7 +747,7 @@ class Qsat {
753
747
 
754
748
  private assertFormula(formula: number) {
755
749
  const manager = this.manager;
756
- if (!isGround(manager, formula)) throw new SmtTacticError("formula is not hoistable");
750
+ if (!manager.isGroundApp(formula)) throw new SmtTacticError("formula is not hoistable");
757
751
  const defs = new RefVector(manager);
758
752
  this.predAbs.abstractAtoms(formula, mkLevel(), defs);
759
753
  const abstracted = this.predAbs.mkAbstract(formula);
@@ -811,20 +805,6 @@ class Qsat {
811
805
  }
812
806
  }
813
807
 
814
- const isOccurringIn = (manager: AstManager, variable: number, expr: number) => {
815
- const visited = new Set<number>();
816
- const todo = [expr];
817
- for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
818
- if (current === variable) return true;
819
- if (visited.has(current)) continue;
820
- visited.add(current);
821
- if (manager.kinds[current] === KIND_APP) manager.pushArgs(current, todo);
822
- else if (manager.kinds[current] === KIND_QUANTIFIER)
823
- todo.push(manager.getQuantifier(current).body);
824
- }
825
- return false;
826
- };
827
-
828
808
  export const runQsat = (manager: AstManager, mode: number) => (goal: Goal) => {
829
809
  const qsat = new Qsat(manager, mode);
830
810
  try {
@@ -232,7 +232,7 @@ export class QuantifierAnalyzer {
232
232
 
233
233
  private isVarPlusGround(expr: number) {
234
234
  const manager = this.manager;
235
- if (manager.getOp(expr) !== OP_ADD || manager.isGround(expr)) return undefined;
235
+ if (manager.getOp(expr) !== OP_ADD || manager.isGroundApp(expr)) return undefined;
236
236
  const args: number[] = [];
237
237
  let variable: number | undefined;
238
238
  let isInverted = false;
@@ -247,7 +247,7 @@ export class QuantifierAnalyzer {
247
247
  isStopped = true;
248
248
  }
249
249
  const negated = this.manager.getTimesMinusOneArg(arg);
250
- if (this.manager.isGround(arg)) args.push(arg);
250
+ if (this.manager.isGroundApp(arg)) args.push(arg);
251
251
  else if (this.isVar(arg)) {
252
252
  if (variable !== undefined) return undefined;
253
253
  variable = arg;
@@ -267,12 +267,12 @@ export class QuantifierAnalyzer {
267
267
  }
268
268
 
269
269
  private isVarAndGround(lhs: number, rhs: number) {
270
- if (this.isVar(lhs) && this.manager.isGround(rhs))
270
+ if (this.isVar(lhs) && this.manager.isGroundApp(rhs))
271
271
  return { variable: lhs, term: rhs, isInverted: false };
272
- if (this.isVar(rhs) && this.manager.isGround(lhs))
272
+ if (this.isVar(rhs) && this.manager.isGroundApp(lhs))
273
273
  return { variable: rhs, term: lhs, isInverted: false };
274
274
  const left = this.isVarPlusGround(lhs);
275
- if (left !== undefined && this.manager.isGround(rhs))
275
+ if (left !== undefined && this.manager.isGroundApp(rhs))
276
276
  return {
277
277
  variable: left.variable,
278
278
  term: left.isInverted
@@ -281,7 +281,7 @@ export class QuantifierAnalyzer {
281
281
  isInverted: left.isInverted,
282
282
  };
283
283
  const right = this.isVarPlusGround(rhs);
284
- if (right !== undefined && this.manager.isGround(lhs))
284
+ if (right !== undefined && this.manager.isGroundApp(lhs))
285
285
  return {
286
286
  variable: right.variable,
287
287
  term: right.isInverted
@@ -337,7 +337,7 @@ export class QuantifierAnalyzer {
337
337
  }
338
338
 
339
339
  private visitFormula(expr: number, polarity: Polarity) {
340
- if (this.manager.isGround(expr)) return;
340
+ if (this.manager.isGroundApp(expr)) return;
341
341
  const cache = polarity === "pos" ? this.posCache : this.negCache;
342
342
  if (cache.has(expr)) return;
343
343
  this.ftodo.push([expr, polarity]);
@@ -345,7 +345,7 @@ export class QuantifierAnalyzer {
345
345
  }
346
346
 
347
347
  private visitTerm(expr: number) {
348
- if (this.manager.isGround(expr) || this.posCache.has(expr)) return;
348
+ if (this.manager.isGroundApp(expr) || this.posCache.has(expr)) return;
349
349
  this.ttodo.push(expr);
350
350
  this.posCache.add(expr);
351
351
  }
@@ -531,7 +531,7 @@ export class QuantifierAnalyzer {
531
531
  for (const literal of literals) {
532
532
  const isNegated = manager.isNot(literal);
533
533
  const atom = isNegated ? manager.getArg(literal, 0) : literal;
534
- if (!this.manager.isGround(atom)) this.processLiteral(atom, isNegated);
534
+ if (!this.manager.isGroundApp(atom)) this.processLiteral(atom, isNegated);
535
535
  }
536
536
  } else this.visitFormula(body, "pos");
537
537
  while (this.ftodo.length > 0 || this.ttodo.length > 0) {
@@ -15,6 +15,7 @@ import {
15
15
  } from "./ast";
16
16
  import type { Goal } from "./goal";
17
17
  import { MacroManager } from "./macro-finder";
18
+ import { hasSubterm } from "./recfun-decl-plugin";
18
19
  import { RefVector } from "./ref-vector";
19
20
  import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
20
21
 
@@ -24,25 +25,10 @@ interface QuasiMacro {
24
25
  }
25
26
 
26
27
  const isNonGroundUninterp = (manager: AstManager, expr: number) =>
27
- !manager.isGround(expr) &&
28
+ !manager.isGroundApp(expr) &&
28
29
  manager.kinds[expr] === KIND_APP &&
29
30
  manager.funcDecls[manager.decls[expr]].family === FAMILY_USER;
30
31
 
31
- const isDependingOn = (manager: AstManager, expr: number, decl: number) => {
32
- const visited = new Set<number>();
33
- const todo = [expr];
34
- for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
35
- if (visited.has(current)) continue;
36
- if (manager.kinds[current] === KIND_APP) {
37
- if (manager.decls[current] === decl) return true;
38
- for (let index = manager.getNumArgs(current); index > 0; index--)
39
- todo.push(manager.getArg(current, index - 1));
40
- }
41
- visited.add(current);
42
- }
43
- return false;
44
- };
45
-
46
32
  const isFullyDependingOn = (manager: AstManager, app: number, numDecls: number) => {
47
33
  const isUsed = Array.from({ length: numDecls }, () => false);
48
34
  for (const arg of manager.getArgs(app))
@@ -96,7 +82,12 @@ class QuasiMacros {
96
82
  return (
97
83
  isNonGroundUninterp(manager, lhs) &&
98
84
  this.isUnique(manager.decls[lhs]) &&
99
- !isDependingOn(manager, rhs, manager.decls[lhs]) &&
85
+ !hasSubterm(
86
+ manager,
87
+ [rhs],
88
+ (expr) => manager.kinds[expr] === KIND_APP && manager.decls[expr] === manager.decls[lhs],
89
+ false,
90
+ ) &&
100
91
  isFullyDependingOn(manager, lhs, numDecls)
101
92
  );
102
93
  }
@@ -145,7 +136,7 @@ class QuasiMacros {
145
136
  let numSeen = 0;
146
137
  for (const [index, arg] of manager.getArgs(macro.head).entries()) {
147
138
  const isVar = manager.kinds[arg] === KIND_VAR;
148
- if (!isVar && !manager.isGround(arg)) return -1;
139
+ if (!isVar && !manager.isGroundApp(arg)) return -1;
149
140
  if (isVar && !isSeen[manager.values[arg]]) {
150
141
  this.newVars.push(arg);
151
142
  isSeen[manager.values[arg]] = true;
@@ -1,4 +1,5 @@
1
1
  // Ported from Z3 (src/util/rational.h), MIT license, see z3-license.txt.
2
+ import { SmtInvariantError } from "../../../errors";
2
3
 
3
4
  export const getGcd = (first: bigint, second: bigint) => {
4
5
  let left = first < 0n ? -first : first;
@@ -63,6 +64,21 @@ const getIntRoot = (value: bigint, degree: number): bigint | undefined => {
63
64
  return low ** exponent === value ? low : undefined;
64
65
  };
65
66
 
67
+ // rational::mult_inverse: the inverse of the value modulo 2^bits, which only an odd value has.
68
+ export const getMultInverse = (value: bigint, bits: number) => {
69
+ if (value === 1n) return 1n;
70
+ if (value % 2n === 0n) return undefined;
71
+ const modulus = 1n << BigInt(bits);
72
+ let [oldRemainder, remainder] = [((value % modulus) + modulus) % modulus, modulus];
73
+ let [oldCoefficient, coefficient] = [1n, 0n];
74
+ while (remainder !== 0n) {
75
+ const quotient = oldRemainder / remainder;
76
+ [oldRemainder, remainder] = [remainder, oldRemainder - quotient * remainder];
77
+ [oldCoefficient, coefficient] = [coefficient, oldCoefficient - quotient * coefficient];
78
+ }
79
+ return ((oldCoefficient % modulus) + modulus) % modulus;
80
+ };
81
+
66
82
  export class Rational {
67
83
  static readonly zero = new Rational(0n, 1n);
68
84
  static readonly one = new Rational(1n, 1n);
@@ -85,6 +101,7 @@ export class Rational {
85
101
  }
86
102
 
87
103
  static fromDouble(value: number) {
104
+ if (!Number.isFinite(value)) throw new SmtInvariantError(`${value} is not a rational number`);
88
105
  let den = 1n;
89
106
  let scaled = value;
90
107
  while (!Number.isInteger(scaled)) {
@@ -10,6 +10,7 @@ import {
10
10
  SORT_BOOL,
11
11
  } from "./ast";
12
12
  import { ExprSafeReplace } from "./expr-safe-replace";
13
+ import { ObjMap } from "./hashtable";
13
14
 
14
15
  const getChildren = (manager: AstManager, expr: number, isUnderQuantifiers: boolean) =>
15
16
  manager.kinds[expr] === KIND_QUANTIFIER
@@ -32,28 +33,43 @@ export const getSubterms = (manager: AstManager, expr: number, isUnderQuantifier
32
33
  return [...visited];
33
34
  };
34
35
 
35
- export const isDefinedApp = (manager: AstManager, expr: number) =>
36
- manager.getOp(expr) === OP_FUN_DEFINED;
37
-
38
- const hasPredicate = (
36
+ // Whether a subterm of the roots satisfies the predicate, which the walk calls in no particular
37
+ // order.
38
+ export const hasSubterm = (
39
39
  manager: AstManager,
40
- expr: number,
40
+ roots: readonly number[],
41
41
  predicate: (term: number) => boolean,
42
- isUnderQuantifiers = false,
43
- ) => getSubterms(manager, expr, isUnderQuantifiers).some(predicate);
42
+ isUnderQuantifiers = true,
43
+ ) => {
44
+ const visited = new Set<number>();
45
+ const todo = [...roots];
46
+ for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
47
+ if (visited.has(current)) continue;
48
+ visited.add(current);
49
+ if (predicate(current)) return true;
50
+ if (manager.kinds[current] === KIND_APP) manager.pushArgs(current, todo);
51
+ else if (isUnderQuantifiers && manager.kinds[current] === KIND_QUANTIFIER)
52
+ todo.push(manager.getQuantifier(current).body);
53
+ }
54
+ return false;
55
+ };
56
+
57
+ export const isDefinedApp = (manager: AstManager, expr: number) =>
58
+ manager.getOp(expr) === OP_FUN_DEFINED;
44
59
 
45
60
  export const containsDef = (manager: AstManager, expr: number) =>
46
- hasPredicate(manager, expr, (term) => isDefinedApp(manager, term));
61
+ hasSubterm(manager, [expr], (term) => isDefinedApp(manager, term), false);
47
62
 
48
63
  // An ite on a condition without a defined function, with one in a branch.
49
64
  const containsIte = (manager: AstManager, expr: number) =>
50
- hasPredicate(
65
+ hasSubterm(
51
66
  manager,
52
- expr,
67
+ [expr],
53
68
  (term) =>
54
69
  manager.getOp(term) === OP_ITE &&
55
70
  !containsDef(manager, manager.getArg(term, 0)) &&
56
71
  containsDef(manager, term),
72
+ false,
57
73
  );
58
74
 
59
75
  interface ChoiceList {
@@ -153,12 +169,7 @@ const computeCases = (manager: AstManager, def: RecFunDef, isMacro: boolean, rhs
153
169
  const caseRhs = subst.apply(rhs);
154
170
  const guards = conditions.map((condition) => subst.apply(condition));
155
171
  subst.release();
156
- const isImmediate = !hasPredicate(
157
- manager,
158
- caseRhs,
159
- (term) => isDefinedApp(manager, term),
160
- true,
161
- );
172
+ const isImmediate = !hasSubterm(manager, [caseRhs], (term) => isDefinedApp(manager, term));
162
173
  addCase(manager, def, guards, caseRhs, isImmediate);
163
174
  manager.decRef(caseRhs);
164
175
  for (const guard of guards) manager.decRef(guard);
@@ -168,7 +179,8 @@ const computeCases = (manager: AstManager, def: RecFunDef, isMacro: boolean, rhs
168
179
  }
169
180
  };
170
181
 
171
- // compute_scores: the number of ites on the paths from the root to each subterm.
182
+ // compute_scores: the number of ites on the paths from the root to each subterm. The scores are in
183
+ // an obj_map, whose order decides which of the ites with the highest score redirect_ite takes.
172
184
  const computeScores = (manager: AstManager, expr: number) => {
173
185
  const parents = new Map<number, number[]>([[expr, []]]);
174
186
  const byDepth = new Map<number, number[]>();
@@ -182,7 +194,8 @@ const computeScores = (manager: AstManager, expr: number) => {
182
194
  const depth = manager.depths[term];
183
195
  byDepth.set(depth, [...(byDepth.get(depth) ?? []), term]);
184
196
  }
185
- const scores = new Map<number, number>([[expr, 0]]);
197
+ const scores = new ObjMap<number>((term) => manager.hashes[term]);
198
+ scores.set(expr, 0);
186
199
  for (let depth = manager.depths[expr]; depth > 0; depth--)
187
200
  for (const term of byDepth.get(depth) ?? []) {
188
201
  const score = (parents.get(term) ?? []).reduce(
@@ -211,8 +224,9 @@ const redirectIte = (manager: AstManager, def: RecFunDef, rhs: number) => {
211
224
  maxScore = score;
212
225
  }
213
226
  if (maxScore <= 4) break;
227
+ // mk_fresh_id gives the id after the increment.
214
228
  const decl = manager.mkRecFuncDecl(
215
- `fold-rec-${manager.mkFreshId()}`,
229
+ `fold-rec-${manager.mkFreshId() + 1}`,
216
230
  domain,
217
231
  manager.sorts[maxExpr],
218
232
  );
@@ -97,7 +97,7 @@ export const mkRecFunApp = (
97
97
  args.some(
98
98
  (arg, position) =>
99
99
  manager.getOp(arg) === OP_DT_CONSTRUCTOR &&
100
- isDecreasingArg(manager, decl, position, manager.isGround(arg)),
100
+ isDecreasingArg(manager, decl, position, manager.isGroundApp(arg)),
101
101
  ));
102
102
  if (!isSafe) return undefined;
103
103
  const subst = new VarSubst(manager, true);
@@ -193,13 +193,15 @@ abstract class VarShifterCore extends RewriterCore {
193
193
  frame.childIndex++;
194
194
  if (!this.visit(child)) return;
195
195
  }
196
- // A rewritten no-pattern is not a pattern, so Z3 drops it.
197
196
  const result = frame.hasNewChild
198
197
  ? manager.mkQuantifier({
199
198
  ...data,
200
199
  body: this.resultStack[frame.spos],
201
200
  patterns: this.resultStack.slice(frame.spos + 1, frame.spos + 1 + data.patterns.length),
202
- noPatterns: [],
201
+ noPatterns: this.resultStack.slice(
202
+ frame.spos + 1 + data.patterns.length,
203
+ frame.spos + children.length,
204
+ ),
203
205
  })
204
206
  : expr;
205
207
  this.finish(expr, frame, result);
@@ -385,6 +387,7 @@ class RewriterEngine extends SubstCore {
385
387
  }
386
388
 
387
389
  release() {
390
+ this.setLastResult(-1);
388
391
  this.invShifter.release();
389
392
  this.shifter.release();
390
393
  this.releaseCaches();
@@ -855,6 +858,7 @@ export class BetaReducer extends SubstCore {
855
858
  }
856
859
 
857
860
  release() {
861
+ this.setLastResult(-1);
858
862
  this.shifter.release();
859
863
  this.releaseCaches();
860
864
  }
@@ -270,7 +270,7 @@ export class Rewriter extends RewriterTpl {
270
270
  !isLambda &&
271
271
  data.patterns.length + data.noPatterns.length === 0 &&
272
272
  nested.patterns.length + nested.noPatterns.length === 0;
273
- if (!isMerging && isLambda && manager.isGround(body))
273
+ if (!isMerging && isLambda && manager.isGroundApp(body))
274
274
  return mkArrayApp(manager, OP_CONST_ARRAY, [body], [manager.sorts[expr]]);
275
275
  if (!isMerging && isLambda) {
276
276
  const reduced = this.array.mkLambdaCore(expr, body);