tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e5c8dc315

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 (263) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +56 -56
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +97 -92
  20. package/dist/transfer.js +97 -92
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +31 -3
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -93
  29. package/src/check.ts +518 -281
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +18 -4
  33. package/src/cli/tlc.ts +18 -12
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +255 -18
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +155 -66
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +152 -25
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +179 -60
  49. package/src/liveness.ts +55 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +3 -2
  67. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  68. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  69. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  70. package/src/prover/smt/solver/ast-lt.ts +1 -1
  71. package/src/prover/smt/solver/ast.ts +66 -14
  72. package/src/prover/smt/solver/auf-solver.ts +23 -12
  73. package/src/prover/smt/solver/bit-blast-tactic.ts +28 -2
  74. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  75. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  76. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  77. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  78. package/src/prover/smt/solver/bv1-blast.ts +1 -1
  79. package/src/prover/smt/solver/card2bv.ts +35 -18
  80. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  81. package/src/prover/smt/solver/context.ts +84 -15
  82. package/src/prover/smt/solver/ctx-simplify.ts +9 -4
  83. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  84. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  85. package/src/prover/smt/solver/diff-neq.ts +9 -8
  86. package/src/prover/smt/solver/dt2bv-tactic.ts +66 -28
  87. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  88. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  89. package/src/prover/smt/solver/elim-uncnstr.ts +31 -28
  90. package/src/prover/smt/solver/eq2bv-tactic.ts +15 -6
  91. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  92. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  93. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  94. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  95. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  96. package/src/prover/smt/solver/euf/mam.ts +1 -5
  97. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  98. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  99. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  100. package/src/prover/smt/solver/factor.ts +36 -14
  101. package/src/prover/smt/solver/fd-solver.ts +608 -139
  102. package/src/prover/smt/solver/fix-dl-var.ts +2 -3
  103. package/src/prover/smt/solver/fm-tactic.ts +9 -7
  104. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  105. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  106. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  107. package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -1
  108. package/src/prover/smt/solver/goal.ts +6 -3
  109. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  110. package/src/prover/smt/solver/hashtable.ts +4 -0
  111. package/src/prover/smt/solver/internalizer.ts +1 -1
  112. package/src/prover/smt/solver/lia2pb.ts +1 -1
  113. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  114. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  115. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  116. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  117. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  118. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  119. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  120. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  121. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  122. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  123. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  124. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  125. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  126. package/src/prover/smt/solver/maxcore.ts +2 -1
  127. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  128. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  129. package/src/prover/smt/solver/model-checker.ts +1 -1
  130. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  131. package/src/prover/smt/solver/model-generator.ts +85 -43
  132. package/src/prover/smt/solver/mpf.ts +2 -4
  133. package/src/prover/smt/solver/mus.ts +2 -3
  134. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  135. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  136. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  137. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  138. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  139. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  140. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  141. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  142. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  143. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  144. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  145. package/src/prover/smt/solver/nlqsat.ts +2 -1
  146. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  147. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  148. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  149. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  150. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  151. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  152. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  153. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  154. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  155. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  156. package/src/prover/smt/solver/nnf.ts +6 -2
  157. package/src/prover/smt/solver/normalize-bounds.ts +2 -2
  158. package/src/prover/smt/solver/occf.ts +1 -1
  159. package/src/prover/smt/solver/opt-context.ts +21 -7
  160. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  161. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  162. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  163. package/src/prover/smt/solver/opt-solver.ts +10 -6
  164. package/src/prover/smt/solver/optsmt.ts +1 -1
  165. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  166. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  167. package/src/prover/smt/solver/pb2bv-tactic.ts +9 -3
  168. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  169. package/src/prover/smt/solver/probes.ts +88 -23
  170. package/src/prover/smt/solver/proto-model.ts +8 -8
  171. package/src/prover/smt/solver/purify-arith.ts +51 -49
  172. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  173. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  174. package/src/prover/smt/solver/qe-lite.ts +2 -2
  175. package/src/prover/smt/solver/qe.ts +3 -2
  176. package/src/prover/smt/solver/qsat.ts +23 -8
  177. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  178. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  179. package/src/prover/smt/solver/reduce-args.ts +2 -2
  180. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  181. package/src/prover/smt/solver/rewriter.ts +31 -25
  182. package/src/prover/smt/solver/rlimit.ts +7 -3
  183. package/src/prover/smt/solver/sat/config.ts +1 -1
  184. package/src/prover/smt/solver/sat/goal2sat.ts +75 -12
  185. package/src/prover/smt/solver/sat/inc-sat-solver.ts +149 -47
  186. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  187. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  188. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  189. package/src/prover/smt/solver/sat/sat-tactic.ts +54 -25
  190. package/src/prover/smt/solver/sat/sat2goal.ts +75 -50
  191. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  192. package/src/prover/smt/solver/sat/solver.ts +27 -47
  193. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  194. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  195. package/src/prover/smt/solver/seq-derive.ts +2 -2
  196. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  197. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  198. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  199. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  200. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  201. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  202. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  203. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  204. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  205. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  206. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  207. package/src/prover/smt/solver/smt-setup.ts +106 -13
  208. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  209. package/src/prover/smt/solver/smtlib-script.ts +718 -213
  210. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  211. package/src/prover/smt/solver/solver.ts +18 -4
  212. package/src/prover/smt/solver/tactic.ts +389 -199
  213. package/src/prover/smt/solver/theory-bv.ts +13 -3
  214. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  215. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  216. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  217. package/src/prover/smt/solver/theory-lra-propagate.ts +12 -3
  218. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  219. package/src/prover/smt/solver/theory-lra.ts +1 -1
  220. package/src/prover/smt/solver/theory-pb.ts +24 -7
  221. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  222. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  223. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  224. package/src/prover/smt/solver/tseitin-cnf.ts +15 -5
  225. package/src/prover/tlapm/cache.ts +8 -8
  226. package/src/prover/zenon/index-table.ts +5 -2
  227. package/src/prover/zenon/isar-case.ts +1 -1
  228. package/src/prover/zenon/isar.ts +2 -2
  229. package/src/prover/zenon/phrase.ts +1 -1
  230. package/src/resolve.ts +1311 -268
  231. package/src/runtime.ts +21 -2
  232. package/src/sany/builtins.ts +10 -10
  233. package/src/sany/generation.ts +5 -15
  234. package/src/sany/generator-def-entries.ts +123 -36
  235. package/src/sany/generator-definitions.ts +5 -3
  236. package/src/sany/generator-expressions.ts +60 -37
  237. package/src/sany/generator-proofs.ts +19 -12
  238. package/src/sany/generator.ts +12 -6
  239. package/src/sany/lexer.ts +15 -7
  240. package/src/sany/modules.ts +4 -2
  241. package/src/sany/nodes.ts +1 -1
  242. package/src/sany/selectors.ts +12 -6
  243. package/src/sany/xml.ts +2 -3
  244. package/src/search.ts +321 -135
  245. package/src/simulate.ts +247 -185
  246. package/src/spec-description.ts +15 -7
  247. package/src/standard-definitions.ts +1 -0
  248. package/src/standard-modules.ts +56 -22
  249. package/src/subexpressions.ts +666 -147
  250. package/src/successors.ts +50 -20
  251. package/src/symmetry.ts +2 -1
  252. package/src/tlc/jar-data.ts +10 -0
  253. package/src/tlc/messages.ts +3 -3
  254. package/src/tlc/order.ts +14 -3
  255. package/src/tlc/random.ts +2 -1
  256. package/src/tlc/replay.ts +147 -46
  257. package/src/tlc/tlc-operators.ts +10 -8
  258. package/src/tlc/tlcext-operators.ts +44 -15
  259. package/src/tlc/trace-spec.ts +9 -22
  260. package/src/trace-liveness.ts +529 -0
  261. package/src/typed-tier.ts +52 -31
  262. package/src/typescript/types.ts +2 -2
  263. package/src/values.ts +150 -79
@@ -1,4 +1,4 @@
1
- import { SmtCanceledError } from "../../../errors";
1
+ import { SmtCanceledError, SmtTacticError } from "../../../errors";
2
2
  import {
3
3
  type AstManager,
4
4
  KIND_APP,
@@ -7,27 +7,38 @@ import {
7
7
  OP_AND,
8
8
  OP_EQ,
9
9
  OP_IMPLIES,
10
+ OP_OR,
10
11
  OP_UBV2INT,
11
12
  OP_ULEQ,
12
13
  SORT_BOOL,
13
14
  SORT_INT,
14
15
  } from "./ast";
16
+ import { mkNot } from "./ast-util";
15
17
  import { BoundManager } from "./bound-manager";
16
18
  import { mkBvApp } from "./bv-decl-plugin";
17
19
  import { Bv2IntContext, Bv2IntRewriter } from "./bv2int-rewriter";
18
- import { card2bv } from "./card2bv";
19
- import { runEnum2Bv } from "./dt2bv-tactic";
20
+ import { createCard2Bv } from "./card2bv";
21
+ import { DependentExprState } from "./dependent-expr-state";
22
+ import { Enum2BvRewriter } from "./dt2bv-tactic";
23
+ import { assignOwned, release } from "./expr-ref";
20
24
  import { ExprSafeReplace } from "./expr-safe-replace";
21
- import { type Definition, Goal } from "./goal";
22
- import { ObjMap } from "./hashtable";
23
- import { L_FALSE, L_TRUE } from "./lbool";
25
+ import {
26
+ type Definition,
27
+ type Dependency,
28
+ getDependencyValues,
29
+ Goal,
30
+ mkDependencyLeaf,
31
+ } from "./goal";
32
+ import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
33
+ import type { ProtoModel } from "./proto-model";
34
+ import type { Rational } from "./rational";
24
35
  import { RefVector } from "./ref-vector";
25
36
  import { Rewriter } from "./rewriter";
26
- import { convertModel, getRewriterOptions } from "./tactic";
37
+ import { RewriterTpl } from "./rewriter-tpl";
38
+ import { applyDefinitions, getRewriterOptions } from "./tactic";
27
39
  import { UINT_MAX } from "./sat/clause";
28
40
  import type { SatParams } from "./sat/config";
29
41
  import { IncSatSolver } from "./sat/inc-sat-solver";
30
- import { SubstReplacer } from "./solve-eqs";
31
42
 
32
43
  const getNumBits = (value: bigint) => {
33
44
  let bound = 1n;
@@ -47,77 +58,384 @@ const collectBounds = (manager: AstManager, bounds: BoundManager, form: number)
47
58
  for (const arg of manager.getArgs(form)) collectBounds(manager, bounds, arg);
48
59
  };
49
60
 
50
- // bounded_int2bv_simplifier: an integer constant between two bounds becomes an unsigned
51
- // bit-vector plus the lower bound.
52
- const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
53
- const bounds = new BoundManager(manager);
54
- for (const form of goal.forms.items) collectBounds(manager, bounds, form);
55
- const substitution = new ObjMap<number>((expr) => manager.hashes[expr]);
56
- const trail = new RefVector(manager);
57
- const sideConditions = new RefVector(manager);
58
- const definitions: Definition[] = [];
59
- for (const expr of bounds.boundedVars) {
60
- const lower = bounds.lowers.get(expr);
61
- const upper = bounds.uppers.get(expr);
62
- if (
63
- lower === undefined ||
64
- upper === undefined ||
65
- lower.value.compare(upper.value) > 0 ||
66
- lower.isStrict ||
67
- upper.isStrict ||
68
- manager.sorts[expr] !== SORT_INT
69
- )
70
- continue;
71
- const domainSize = upper.value.sub(lower.value).num + 1n;
72
- const numBits = getNumBits(domainSize);
73
- const bits = manager.mkFreshConst("b", manager.mkBvSort(numBits));
74
- trail.push(bits);
75
- const offset = lower.value;
76
- const unsigned = mkBvApp(manager, OP_UBV2INT, [bits]);
77
- const replacement = offset.isZero()
61
+ class SolverFormulas extends Goal {
62
+ override assert(form: number, dependency?: Dependency) {
63
+ if (this.manager.isFalse(form)) this.isInconsistent = true;
64
+ this.forms.push(form);
65
+ this.dependencies.push(dependency);
66
+ }
67
+
68
+ override update(index: number, form: number, dependency?: Dependency) {
69
+ if (this.manager.isFalse(form)) this.isInconsistent = true;
70
+ this.forms.set(index, form);
71
+ this.dependencies[index] = dependency;
72
+ }
73
+
74
+ flattenSuffix(qhead: number) {
75
+ const manager = this.manager;
76
+ const forms = this.forms;
77
+ const seen = new Set<number>();
78
+ const pinned = new RefVector(manager);
79
+ let kept = qhead;
80
+ for (let index = qhead; index < forms.size; index++) {
81
+ const form = forms.items[index];
82
+ const dependency = this.dependencies[index];
83
+ pinned.push(form);
84
+ if (seen.has(form)) continue;
85
+ seen.add(form);
86
+ if (manager.isTrue(form)) continue;
87
+ if (manager.getOp(form) === OP_AND) {
88
+ const numArgs = manager.getNumArgs(form);
89
+ for (let argIndex = 0; argIndex < numArgs; argIndex++)
90
+ this.assert(manager.getArg(form, argIndex), dependency);
91
+ continue;
92
+ }
93
+ if (manager.isNot(form) && manager.getOp(manager.getArg(form, 0)) === OP_OR) {
94
+ const disjunction = manager.getArg(form, 0);
95
+ const numArgs = manager.getNumArgs(disjunction);
96
+ for (let argIndex = 0; argIndex < numArgs; argIndex++)
97
+ this.assert(mkNot(manager, manager.getArg(disjunction, argIndex)), dependency);
98
+ continue;
99
+ }
100
+ if (index !== kept) {
101
+ forms.set(kept, form);
102
+ this.dependencies[kept] = dependency;
103
+ }
104
+ kept++;
105
+ }
106
+ this.shrinkTo(kept);
107
+ pinned.reset();
108
+ }
109
+
110
+ shrinkTo(size: number) {
111
+ this.forms.shrink(size);
112
+ this.dependencies.length = size;
113
+ }
114
+ }
115
+
116
+ // Z3's dep_expr_state reads the formulas in place, without holding one.
117
+ class FdState extends DependentExprState {
118
+ declare readonly goal: SolverFormulas;
119
+
120
+ override get(index: number) {
121
+ return this.goal.forms.items[index];
122
+ }
123
+ }
124
+
125
+ class MacroReplacer extends RewriterTpl {
126
+ constructor(
127
+ manager: AstManager,
128
+ private readonly decl: number,
129
+ private readonly def: number,
130
+ ) {
131
+ super(manager);
132
+ }
133
+
134
+ override isRewritingPatterns() {
135
+ return false;
136
+ }
137
+
138
+ override getSubst(expr: number) {
139
+ return this.manager.kinds[expr] === KIND_APP && this.manager.decls[expr] === this.decl
140
+ ? this.def
141
+ : undefined;
142
+ }
143
+ }
144
+
145
+ const addVars = (manager: AstManager, expr: number, freeVars: Set<number>) => {
146
+ const visited = new Set<number>();
147
+ const todo = [expr];
148
+ for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
149
+ if (visited.has(current)) continue;
150
+ visited.add(current);
151
+ if (manager.kinds[current] === KIND_QUANTIFIER) todo.push(manager.getQuantifier(current).body);
152
+ else if (manager.kinds[current] === KIND_APP) {
153
+ if (manager.isUninterpreted(current)) freeVars.add(manager.decls[current]);
154
+ manager.pushArgs(current, todo);
155
+ }
156
+ }
157
+ };
158
+
159
+ const retainDefinitions = (manager: AstManager, definitions: readonly Definition[]) => {
160
+ for (const definition of definitions) {
161
+ manager.incDeclRef(definition.decl);
162
+ if (definition.def !== -1) manager.incRef(definition.def);
163
+ }
164
+ return [...definitions];
165
+ };
166
+
167
+ const releaseDefinitions = (manager: AstManager, definitions: readonly Definition[]) => {
168
+ for (let index = definitions.length - 1; index >= 0; index--) {
169
+ const definition = definitions[index];
170
+ if (definition.def !== -1) manager.decRef(definition.def);
171
+ manager.decDeclRef(definition.decl);
172
+ }
173
+ };
174
+
175
+ class ModelTrail {
176
+ readonly entries: Definition[] = [];
177
+
178
+ constructor(private readonly manager: AstManager) {}
179
+
180
+ hide(decl: number) {
181
+ this.manager.incDeclRef(decl);
182
+ this.entries.push({ decl, def: -1 });
183
+ }
184
+
185
+ define(decl: number, def: number) {
186
+ this.manager.incDeclRef(decl);
187
+ this.manager.incRef(def);
188
+ this.entries.push({ decl, def });
189
+ }
190
+
191
+ shrink(size: number) {
192
+ releaseDefinitions(this.manager, this.entries.splice(size));
193
+ }
194
+
195
+ replay(qhead: number, assumptions: RefVector, fmls: SolverFormulas) {
196
+ const manager = this.manager;
197
+ if (this.entries.length === 0) return;
198
+ if (qhead === fmls.forms.size && assumptions.size === 0) return;
199
+ const freeVars = new Set<number>();
200
+ for (let index = qhead; index < fmls.forms.size; index++)
201
+ addVars(manager, fmls.forms.items[index], freeVars);
202
+ for (const assumption of assumptions.items) addVars(manager, assumption, freeVars);
203
+ if (!this.entries.some((entry) => entry.def !== -1 && freeVars.has(entry.decl))) return;
204
+ for (const entry of this.entries) {
205
+ if (entry.def === -1 || !freeVars.has(entry.decl)) continue;
206
+ addVars(manager, entry.def, freeVars);
207
+ const replacer = new MacroReplacer(manager, entry.decl, entry.def);
208
+ // Deviation from Z3: macro_replacer returns the rewrite of a named formula's last name, which drops the formula.
209
+ for (let index = qhead; index < fmls.forms.size; index++) {
210
+ const form = fmls.forms.items[index];
211
+ const replaced = replacer.rewrite(form);
212
+ replacer.reset();
213
+ if (replaced !== form) fmls.update(index, replaced, fmls.getDependency(index));
214
+ manager.decRef(replaced);
215
+ }
216
+ for (let index = 0; index < assumptions.size; index++) {
217
+ assumptions.setOwned(index, replacer.rewrite(assumptions.items[index]));
218
+ replacer.reset();
219
+ }
220
+ replacer.release();
221
+ }
222
+ }
223
+ }
224
+
225
+ class BoundedInt2BvSimplifier {
226
+ private readonly bounds: BoundManager[];
227
+ private readonly bvFns: number[] = [];
228
+ private readonly intFns: number[] = [];
229
+ private readonly fnLimits: number[] = [];
230
+ private readonly int2bv = new Map<number, number>();
231
+ private readonly bv2offset = new Map<number, Rational>();
232
+ private readonly context: Bv2IntContext;
233
+ private readonly rewriter: Bv2IntRewriter;
234
+ private readonly sideConditions: RefVector;
235
+
236
+ constructor(private readonly manager: AstManager) {
237
+ this.bounds = [new BoundManager(manager)];
238
+ this.context = new Bv2IntContext(manager, UINT_MAX);
239
+ this.rewriter = new Bv2IntRewriter(manager, this.context);
240
+ this.sideConditions = new RefVector(manager);
241
+ }
242
+
243
+ private accumulateSubstitution(
244
+ substitution: ExprSafeReplace,
245
+ bounds: BoundManager,
246
+ trail: ModelTrail,
247
+ ) {
248
+ const manager = this.manager;
249
+ for (const expr of bounds.boundedVars) {
250
+ const lower = bounds.lowers.get(expr);
251
+ const upper = bounds.uppers.get(expr);
252
+ if (
253
+ lower === undefined ||
254
+ upper === undefined ||
255
+ lower.value.compare(upper.value) > 0 ||
256
+ lower.isStrict ||
257
+ upper.isStrict ||
258
+ manager.sorts[expr] !== SORT_INT
259
+ )
260
+ continue;
261
+ const decl = manager.decls[expr];
262
+ const bvDecl =
263
+ this.int2bv.get(decl) ?? this.addBitVector(decl, lower.value, upper.value, trail);
264
+ const offset = this.bv2offset.get(bvDecl) ?? lower.value;
265
+ substitution.insert(expr, this.mkValue(bvDecl, offset));
266
+ }
267
+ }
268
+
269
+ private mkValue(bvDecl: number, offset: Rational) {
270
+ const manager = this.manager;
271
+ const unsigned = mkBvApp(manager, OP_UBV2INT, [
272
+ manager.mkApp(bvDecl, [], manager.funcDecls[bvDecl].range),
273
+ ]);
274
+ return offset.isZero()
78
275
  ? unsigned
79
276
  : manager.mkApp(OP_ADD, [unsigned, manager.mkNumeral(offset.num)], SORT_INT);
80
- trail.push(replacement);
81
- definitions.push(
82
- { decl: manager.decls[bits], def: -1 },
83
- { decl: manager.decls[expr], def: replacement },
84
- );
85
- if (!offset.isZero() && (domainSize & (domainSize - 1n)) !== 0n)
86
- sideConditions.push(
277
+ }
278
+
279
+ private addBitVector(decl: number, lower: Rational, upper: Rational, trail: ModelTrail) {
280
+ const manager = this.manager;
281
+ const domainSize = upper.sub(lower).num + 1n;
282
+ const numBits = getNumBits(domainSize);
283
+ const bits = manager.mkFreshConst("b", manager.mkBvSort(numBits));
284
+ manager.incRef(bits);
285
+ const bvDecl = manager.decls[bits];
286
+ this.int2bv.set(decl, bvDecl);
287
+ this.bv2offset.set(bvDecl, lower);
288
+ manager.incDeclRef(bvDecl);
289
+ this.bvFns.push(bvDecl);
290
+ manager.incDeclRef(decl);
291
+ this.intFns.push(decl);
292
+ trail.hide(bvDecl);
293
+ trail.define(decl, this.mkValue(bvDecl, lower));
294
+ if (!lower.isZero() && (domainSize & (domainSize - 1n)) !== 0n)
295
+ this.sideConditions.push(
87
296
  mkBvApp(manager, OP_ULEQ, [bits, manager.mkBvNumeral(domainSize - 1n, numBits)]),
88
297
  );
89
- substitution.set(expr, replacement);
90
- }
91
- if (substitution.size > 0) {
92
- const replacer = new SubstReplacer(manager, substitution);
93
- const context = new Bv2IntContext(manager, UINT_MAX);
94
- const rewriter = new Bv2IntRewriter(manager, context);
95
- for (let index = 0; index < goal.forms.size; index++) {
96
- const form = goal.forms.items[index];
97
- const replaced = replacer.rewrite(form);
98
- const result = rewriter.rewrite(replaced);
99
- manager.decRef(replaced);
100
- if (result !== form) goal.update(index, result);
101
- manager.decRef(result);
298
+ manager.decRef(bits);
299
+ return bvDecl;
300
+ }
301
+
302
+ reduce(state: FdState, trail: ModelTrail) {
303
+ const manager = this.manager;
304
+ const fmls = state.goal;
305
+ const bounds = this.bounds[this.bounds.length - 1];
306
+ state.forEachIndex((index) => collectBounds(manager, bounds, fmls.forms.items[index]));
307
+ const substitution = new ExprSafeReplace(manager);
308
+ try {
309
+ for (const scopeBounds of this.bounds)
310
+ this.accumulateSubstitution(substitution, scopeBounds, trail);
311
+ if (substitution.sources.size > 0) {
312
+ let replaced = -1;
313
+ let result = -1;
314
+ try {
315
+ state.forEachIndex((index) => {
316
+ const form = fmls.forms.items[index];
317
+ replaced = assignOwned(manager, replaced, substitution.apply(form));
318
+ result = assignOwned(manager, result, this.rewriter.rewrite(replaced));
319
+ if (result !== form) fmls.update(index, result, fmls.getDependency(index));
320
+ });
321
+ } finally {
322
+ release(manager, result);
323
+ release(manager, replaced);
324
+ }
325
+ }
326
+ for (const condition of this.sideConditions.items) fmls.assert(condition);
327
+ this.sideConditions.reset();
328
+ this.rewriter.reset();
329
+ } finally {
330
+ substitution.release();
102
331
  }
103
- rewriter.release();
104
- context.release();
105
- replacer.release();
106
332
  }
107
- for (const condition of sideConditions.items) goal.assert(condition);
108
- if (definitions.length > 0) goal.addDefinitions(definitions);
109
- sideConditions.reset();
110
- trail.reset();
111
- };
112
333
 
113
- const runFdSimplifier = (manager: AstManager, forms: readonly number[]) => {
114
- const fmls = new Goal(manager);
115
- for (const form of forms) fmls.assert(form);
116
- runBoundedInt2Bv(manager, fmls);
117
- card2bv(manager, fmls, getRewriterOptions(manager, new Map()));
118
- runEnum2Bv(manager, fmls);
119
- return fmls;
120
- };
334
+ push() {
335
+ this.fnLimits.push(this.bvFns.length);
336
+ this.bounds.push(new BoundManager(this.manager));
337
+ }
338
+
339
+ pop(numScopes: number) {
340
+ const manager = this.manager;
341
+ const limit = this.fnLimits[this.fnLimits.length - numScopes];
342
+ for (let index = this.intFns.length - 1; index >= limit; index--) {
343
+ this.int2bv.delete(this.intFns[index]);
344
+ this.bv2offset.delete(this.bvFns[index]);
345
+ }
346
+ for (const decl of this.bvFns.splice(limit)) manager.decDeclRef(decl);
347
+ for (const decl of this.intFns.splice(limit)) manager.decDeclRef(decl);
348
+ this.fnLimits.length -= numScopes;
349
+ this.bounds.length -= numScopes;
350
+ }
351
+
352
+ release() {
353
+ const manager = this.manager;
354
+ this.sideConditions.reset();
355
+ this.rewriter.release();
356
+ this.context.release();
357
+ for (const decl of this.intFns) manager.decDeclRef(decl);
358
+ for (const decl of this.bvFns) manager.decDeclRef(decl);
359
+ }
360
+ }
361
+
362
+ class Enum2BvSimplifier {
363
+ private readonly rewriter: Enum2BvRewriter;
364
+ private readonly hidden = new Set<number>();
365
+ private readonly defined = new Set<number>();
366
+ private readonly hiddenTrail: number[] = [];
367
+ private readonly definedTrail: number[] = [];
368
+ private readonly hiddenLimits: number[] = [];
369
+ private readonly definedLimits: number[] = [];
370
+
371
+ constructor(private readonly manager: AstManager) {
372
+ this.rewriter = new Enum2BvRewriter(manager, undefined);
373
+ }
374
+
375
+ reduce(state: FdState, trail: ModelTrail) {
376
+ const manager = this.manager;
377
+ const fmls = state.goal;
378
+ const rewriter = this.rewriter;
379
+ let result = -1;
380
+ try {
381
+ state.forEachIndex((index) => {
382
+ const form = fmls.forms.items[index];
383
+ result = assignOwned(manager, result, rewriter.rewrite(form));
384
+ if (result !== form) fmls.update(index, result, fmls.getDependency(index));
385
+ });
386
+ const bounds = new RefVector(manager);
387
+ for (const bound of rewriter.bounds.items) bounds.push(bound);
388
+ rewriter.bounds.reset();
389
+ for (const bound of bounds.items) fmls.assert(bound);
390
+ bounds.reset();
391
+ for (const [, index] of rewriter.enumIndexes) {
392
+ const bvDecl = rewriter.enumBvs[index];
393
+ if (this.hidden.has(bvDecl)) continue;
394
+ this.hidden.add(bvDecl);
395
+ manager.incDeclRef(bvDecl);
396
+ this.hiddenTrail.push(bvDecl);
397
+ trail.hide(bvDecl);
398
+ }
399
+ for (const [decl, index] of rewriter.enumIndexes) {
400
+ if (this.defined.has(decl)) continue;
401
+ this.defined.add(decl);
402
+ manager.incDeclRef(decl);
403
+ this.definedTrail.push(decl);
404
+ trail.define(decl, rewriter.enumDefs.items[index]);
405
+ }
406
+ } finally {
407
+ release(manager, result);
408
+ }
409
+ }
410
+
411
+ push() {
412
+ this.rewriter.push();
413
+ this.hiddenLimits.push(this.hiddenTrail.length);
414
+ this.definedLimits.push(this.definedTrail.length);
415
+ }
416
+
417
+ pop(numScopes: number) {
418
+ const manager = this.manager;
419
+ const hiddenLimit = this.hiddenLimits[this.hiddenLimits.length - numScopes];
420
+ const definedLimit = this.definedLimits[this.definedLimits.length - numScopes];
421
+ for (let index = this.hiddenTrail.length - 1; index >= hiddenLimit; index--)
422
+ this.hidden.delete(this.hiddenTrail[index]);
423
+ for (let index = this.definedTrail.length - 1; index >= definedLimit; index--)
424
+ this.defined.delete(this.definedTrail[index]);
425
+ for (const decl of this.hiddenTrail.splice(hiddenLimit)) manager.decDeclRef(decl);
426
+ for (const decl of this.definedTrail.splice(definedLimit)) manager.decDeclRef(decl);
427
+ this.hiddenLimits.length -= numScopes;
428
+ this.definedLimits.length -= numScopes;
429
+ this.rewriter.pop(numScopes);
430
+ }
431
+
432
+ release() {
433
+ const manager = this.manager;
434
+ for (const decl of this.definedTrail) manager.decDeclRef(decl);
435
+ for (const decl of this.hiddenTrail) manager.decDeclRef(decl);
436
+ this.rewriter.release();
437
+ }
438
+ }
121
439
 
122
440
  // The sole uninterpreted constant of a term, which stands for it in the SAT solver.
123
441
  const getRepresentative = (manager: AstManager, expr: number) => {
@@ -137,49 +455,115 @@ const getRepresentative = (manager: AstManager, expr: number) => {
137
455
  return result;
138
456
  };
139
457
 
140
- // simplifier_solver::get_consequences over the fd solver: a variable the simplifier defines is
141
- // queried through the constant of its definition, and its value is decoded from that constant's.
142
- export const getFdConsequences = (
143
- manager: AstManager,
144
- params: SatParams,
145
- forms: readonly number[],
146
- assumptions: readonly number[],
147
- vars: readonly number[],
148
- ) => {
149
- const fmls = runFdSimplifier(manager, forms);
150
- const trail = new RefVector(manager);
151
- const definitions = new ExprSafeReplace(manager);
152
- for (const converter of fmls.converters)
153
- if ("definitions" in converter)
154
- for (const definition of converter.definitions) {
155
- const decl = manager.funcDecls[definition.decl];
156
- if (definition.def !== -1 && decl.domain.length === 0)
157
- definitions.insert(manager.mkApp(definition.decl, [], decl.range), definition.def);
158
- }
159
- const rewriter = new Rewriter(manager, getRewriterOptions(manager, new Map()));
160
- const rewrite = (expr: number) => {
161
- const result = rewriter.rewrite(expr);
162
- trail.pushOwned(result);
458
+ interface FdScope {
459
+ qhead: number;
460
+ size: number;
461
+ trailSize: number;
462
+ isInconsistent: boolean;
463
+ }
464
+
465
+ export class FdSolver {
466
+ private readonly solver: IncSatSolver;
467
+ private readonly fmls: SolverFormulas;
468
+ private readonly state: FdState;
469
+ private readonly trail: ModelTrail;
470
+ private readonly int2bv: BoundedInt2BvSimplifier;
471
+ private readonly enum2bv: Enum2BvSimplifier;
472
+ private readonly coreReplace: ExprSafeReplace;
473
+ private readonly core: RefVector;
474
+ private readonly scopes: FdScope[] = [];
475
+ private converter: Definition[] = [];
476
+ private model: ProtoModel | undefined;
477
+
478
+ constructor(
479
+ private readonly manager: AstManager,
480
+ params: SatParams,
481
+ isIncremental = true,
482
+ ) {
483
+ this.solver = new IncSatSolver(manager, params, isIncremental);
484
+ this.fmls = new SolverFormulas(manager);
485
+ this.state = new FdState(manager, this.fmls);
486
+ this.trail = new ModelTrail(manager);
487
+ this.int2bv = new BoundedInt2BvSimplifier(manager);
488
+ this.enum2bv = new Enum2BvSimplifier(manager);
489
+ this.coreReplace = new ExprSafeReplace(manager);
490
+ this.core = new RefVector(manager);
491
+ }
492
+
493
+ get reasonUnknown() {
494
+ return this.solver.reasonUnknown;
495
+ }
496
+
497
+ assertExpr(form: number, name = -1) {
498
+ this.clearModel();
499
+ this.fmls.forms.push(form);
500
+ this.fmls.dependencies.push(name === -1 ? undefined : mkDependencyLeaf(name));
501
+ }
502
+
503
+ push() {
504
+ this.flush([]).reset();
505
+ this.scopes.push({
506
+ qhead: this.state.qhead,
507
+ size: this.fmls.forms.size,
508
+ trailSize: this.trail.entries.length,
509
+ isInconsistent: this.fmls.isInconsistent,
510
+ });
511
+ this.int2bv.push();
512
+ this.enum2bv.push();
513
+ this.solver.push();
514
+ }
515
+
516
+ pop(numScopes: number) {
517
+ this.solver.pop(numScopes);
518
+ this.clearModel();
519
+ this.int2bv.pop(numScopes);
520
+ this.enum2bv.pop(numScopes);
521
+ const scope = this.scopes[this.scopes.length - numScopes];
522
+ this.scopes.length -= numScopes;
523
+ this.trail.shrink(scope.trailSize);
524
+ this.fmls.isInconsistent = scope.isInconsistent;
525
+ this.fmls.shrinkTo(scope.size);
526
+ this.state.qhead = scope.qhead;
527
+ }
528
+
529
+ check(assumptions: readonly number[] = []) {
530
+ const flushed = this.flush(assumptions);
531
+ const result = this.solver.check(flushed.items);
532
+ flushed.reset();
533
+ // solver::check_sat counts a step to see whether the limit stopped a search that gave up.
534
+ if (result === L_UNDEF) this.manager.limit.inc();
163
535
  return result;
164
- };
165
- const flush = (expr: number) => {
166
- const replaced = definitions.apply(expr);
167
- trail.pushOwned(replaced);
168
- return rewrite(replaced);
169
- };
170
- const asms1 = assumptions.map(flush);
171
- const vars1 = vars.map(flush);
172
- const queryVars = vars1.map((expr) => {
173
- const representative = getRepresentative(manager, expr);
174
- return representative === -1 ? expr : representative;
175
- });
176
- const solver = new IncSatSolver(manager, params);
177
- try {
178
- for (const form of fmls.forms.items) solver.assertExpr(form);
179
- if (fmls.isInconsistent) solver.assertExpr(manager.falseExpr);
180
- const found = solver.getConsequences(asms1, queryVars);
181
- const coreReplace = new ExprSafeReplace(manager);
182
- asms1.forEach((assumption, index) => coreReplace.insert(assumption, assumptions[index]));
536
+ }
537
+
538
+ getModel() {
539
+ if (this.model !== undefined) return this.model;
540
+ const model = this.solver.mkModel();
541
+ if (model === null) return undefined;
542
+ const converted = this.converter.length > 0 ? applyDefinitions(this.converter, model) : model;
543
+ converted.incRef();
544
+ this.model = converted;
545
+ return converted;
546
+ }
547
+
548
+ getUnsatCore() {
549
+ this.core.reset();
550
+ for (const expr of this.solver.getUnsatCore())
551
+ this.core.pushOwned(this.coreReplace.apply(expr));
552
+ return this.core.items;
553
+ }
554
+
555
+ getConsequences(assumptions: readonly number[], vars: readonly number[]) {
556
+ const manager = this.manager;
557
+ const flushed = this.flush([...assumptions, ...vars]);
558
+ const asms1 = flushed.items.slice(0, assumptions.length);
559
+ const vars1 = flushed.items.slice(assumptions.length);
560
+ const queryVars = vars1.map((expr) => {
561
+ const representative = getRepresentative(manager, expr);
562
+ return representative === -1 ? expr : representative;
563
+ });
564
+ const found = this.solver.getConsequences(asms1, queryVars);
565
+ const trail = new RefVector(manager);
566
+ const rewriter = new Rewriter(manager, getRewriterOptions(manager, new Map()));
183
567
  const consequences = new RefVector(manager);
184
568
  for (const consequence of found.consequences) {
185
569
  const premise = manager.getArg(consequence, 0);
@@ -212,50 +596,135 @@ export const getFdConsequences = (
212
596
  const replaced = substitution.apply(vars1[index]);
213
597
  trail.pushOwned(replaced);
214
598
  substitution.release();
599
+ const rewritten = rewriter.rewrite(replaced);
600
+ trail.pushOwned(rewritten);
215
601
  return manager.mkApp(
216
602
  OP_IMPLIES,
217
- [premise, manager.mkEq(vars[index], rewrite(replaced))],
603
+ [premise, manager.mkEq(vars[index], rewritten)],
218
604
  SORT_BOOL,
219
605
  );
220
606
  })();
221
- consequences.pushOwned(coreReplace.apply(decoded));
607
+ consequences.pushOwned(this.coreReplace.apply(decoded));
222
608
  }
223
- coreReplace.release();
224
- const model = found.result === L_TRUE ? solver.getModel() : null;
225
- model?.incRef();
226
- return {
227
- result: found.result,
228
- consequences,
229
- model: model === null ? undefined : convertModel(fmls, model),
230
- };
231
- } finally {
232
- solver.release();
233
609
  rewriter.release();
234
- definitions.release();
235
610
  trail.reset();
611
+ flushed.reset();
612
+ return { result: found.result, consequences };
613
+ }
614
+
615
+ getAssertions() {
616
+ return this.solver.getAssertions();
236
617
  }
237
- };
238
618
 
239
- // qffd without parallel.enable: solver2tactic over simplifier_solver(inc_sat_solver, fd_simplifier).
619
+ getConverters(): Goal["converters"] {
620
+ const definitions = retainDefinitions(this.manager, this.converter);
621
+ return [...(definitions.length > 0 ? [{ definitions }] : []), ...this.solver.getConverters()];
622
+ }
623
+
624
+ private flush(assumptions: readonly number[]) {
625
+ const manager = this.manager;
626
+ const fmls = this.fmls;
627
+ this.clearModel();
628
+ const qhead = this.state.qhead;
629
+ const flushed = new RefVector(manager);
630
+ for (const assumption of assumptions) flushed.push(assumption);
631
+ this.coreReplace.reset();
632
+ this.replay(qhead, flushed);
633
+ if (qhead < fmls.forms.size) {
634
+ this.reduce();
635
+ if (!manager.limit.inc()) return flushed;
636
+ this.replay(qhead, flushed);
637
+ this.state.qhead = fmls.forms.size;
638
+ }
639
+ flushed.items.forEach((assumption, index) =>
640
+ this.coreReplace.insert(assumption, assumptions[index]),
641
+ );
642
+ const converter = retainDefinitions(manager, this.trail.entries);
643
+ releaseDefinitions(manager, this.converter);
644
+ this.converter = converter;
645
+ for (let index = qhead; index < fmls.forms.size; index++) {
646
+ const names = getDependencyValues(fmls.getDependency(index));
647
+ if (names.length === 0) this.solver.assertExpr(fmls.forms.items[index]);
648
+ else this.solver.assertNamed(fmls.forms.items[index], manager.mkAnd(names));
649
+ }
650
+ return flushed;
651
+ }
652
+
653
+ private replay(qhead: number, assumptions: RefVector) {
654
+ const manager = this.manager;
655
+ this.trail.replay(qhead, assumptions, this.fmls);
656
+ if (assumptions.size === 0) return;
657
+ const rewriter = new Rewriter(manager, getRewriterOptions(manager, new Map()));
658
+ for (let index = 0; index < assumptions.size; index++)
659
+ assumptions.setOwned(index, rewriter.rewrite(assumptions.items[index]));
660
+ rewriter.release();
661
+ }
662
+
663
+ private reduce() {
664
+ const manager = this.manager;
665
+ const fmls = this.fmls;
666
+ const state = this.state;
667
+ if (fmls.isInconsistent || !manager.limit.inc()) return;
668
+ const simplifiers = [
669
+ () => this.int2bv.reduce(state, this.trail),
670
+ () => {
671
+ const simplifier = createCard2Bv(manager, getRewriterOptions(manager, new Map()))(state);
672
+ try {
673
+ simplifier.reduce();
674
+ } finally {
675
+ simplifier.release();
676
+ }
677
+ },
678
+ () => this.enum2bv.reduce(state, this.trail),
679
+ ];
680
+ for (const simplify of simplifiers) {
681
+ if (fmls.isInconsistent || !manager.limit.inc()) break;
682
+ try {
683
+ simplify();
684
+ } catch (error) {
685
+ // The rewriter_exception of a canceled rewrite or of a nested datatype.
686
+ if (!(error instanceof SmtCanceledError || error instanceof SmtTacticError)) throw error;
687
+ break;
688
+ }
689
+ fmls.flattenSuffix(state.qhead);
690
+ }
691
+ fmls.flattenSuffix(state.qhead);
692
+ }
693
+
694
+ private clearModel() {
695
+ this.model?.decRef();
696
+ this.model = undefined;
697
+ }
698
+
699
+ release() {
700
+ this.clearModel();
701
+ this.core.reset();
702
+ this.coreReplace.release();
703
+ releaseDefinitions(this.manager, this.converter);
704
+ this.converter = [];
705
+ this.int2bv.release();
706
+ this.enum2bv.release();
707
+ this.trail.shrink(0);
708
+ this.fmls.reset();
709
+ this.solver.release();
710
+ }
711
+ }
712
+
240
713
  export const createFdTactic = (manager: AstManager, params: SatParams) => (goal: Goal) => {
241
- const fmls = runFdSimplifier(manager, goal.forms.items);
242
- const solver = new IncSatSolver(manager, params, false);
714
+ const solver = new FdSolver(manager, params, false);
243
715
  try {
244
- for (const form of fmls.forms.items) solver.assertExpr(form);
245
- const result = fmls.isInconsistent ? L_FALSE : solver.check();
716
+ for (const form of goal.forms.items) solver.assertExpr(form);
717
+ const result = solver.check();
246
718
  goal.reset();
247
719
  if (result === L_TRUE) {
248
720
  const model = solver.getModel();
249
721
  model?.incRef();
250
- if (model !== null) {
251
- goal.converters = [...goal.converters, ...fmls.converters];
252
- goal.model = model;
253
- }
722
+ if (model !== undefined) goal.model = model;
254
723
  } else if (result === L_FALSE) goal.assert(manager.falseExpr);
255
724
  else {
256
- if (!manager.limit.inc()) throw new SmtCanceledError();
725
+ if (!manager.limit.inc()) throw new SmtTacticError("canceled");
257
726
  for (const form of solver.getAssertions()) goal.assert(form);
258
- goal.converters = [...goal.converters, ...fmls.converters, ...solver.getConverters()];
727
+ goal.converters = [...goal.converters, ...solver.getConverters()];
259
728
  }
260
729
  goal.depth++;
261
730
  return [goal];