tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.7a3bb1545

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 (538) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +3 -3
  3. package/dist/compile.js +1 -1
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +58 -54
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +4 -1
  8. package/dist/index.d.ts +4 -1
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +2682 -426
  15. package/dist/prove.js +2679 -423
  16. package/dist/run.cjs +43 -42
  17. package/dist/run.js +45 -44
  18. package/dist/tlapm.cjs +1 -1
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +43 -40
  21. package/dist/transfer.js +43 -40
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +1 -1
  25. package/src/ast.ts +3 -3
  26. package/src/bags.ts +46 -28
  27. package/src/check-trace.ts +2 -16
  28. package/src/check.ts +336 -88
  29. package/src/cli/runtime-invariants.ts +20 -56
  30. package/src/cli/tlapm.ts +424 -62
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +4 -5
  33. package/src/cli/tlc-usage.ts +0 -1
  34. package/src/cli/tlc.ts +26 -7
  35. package/src/dependencies.ts +23 -2
  36. package/src/dfid.ts +9 -2
  37. package/src/environment.ts +27 -5
  38. package/src/errors.ts +30 -3
  39. package/src/evaluate.ts +9 -3
  40. package/src/exit-codes.ts +5 -2
  41. package/src/instances.ts +1 -1
  42. package/src/levels.ts +3 -2
  43. package/src/lexer.ts +5 -3
  44. package/src/liveness-checker.ts +572 -204
  45. package/src/liveness.ts +47 -32
  46. package/src/obligations/action.ts +10 -6
  47. package/src/obligations/anonymize.ts +33 -14
  48. package/src/obligations/enabled-axioms.ts +218 -0
  49. package/src/obligations/equality.ts +1 -3
  50. package/src/obligations/expression.ts +18 -6
  51. package/src/obligations/format.ts +0 -2
  52. package/src/obligations/generate.ts +22 -17
  53. package/src/obligations/index.ts +36 -6
  54. package/src/obligations/levels.ts +24 -11
  55. package/src/obligations/module.ts +1 -3
  56. package/src/obligations/normalize.ts +24 -13
  57. package/src/obligations/operators.ts +0 -2
  58. package/src/obligations/pragma.ts +53 -16
  59. package/src/obligations/printer.ts +43 -13
  60. package/src/obligations/proof.ts +3 -2
  61. package/src/obligations/regroup.ts +0 -2
  62. package/src/obligations/simplify.ts +17 -7
  63. package/src/obligations/source.ts +71 -17
  64. package/src/obligations/subexpression.ts +45 -18
  65. package/src/obligations/substitution.ts +1 -3
  66. package/src/obligations/temporal.ts +0 -2
  67. package/src/obligations/tuples.ts +0 -2
  68. package/src/parallel-worker.ts +8 -2
  69. package/src/parallel.ts +7 -2
  70. package/src/parser.ts +633 -186
  71. package/src/pretty-print.ts +1 -1
  72. package/src/prover/deciders.ts +11 -8
  73. package/src/prover/isabelle/decide.ts +3 -25
  74. package/src/prover/isabelle/encode.ts +71 -41
  75. package/src/prover/isabelle/isar/attrib.ts +250 -0
  76. package/src/prover/isabelle/isar/context.ts +335 -0
  77. package/src/prover/isabelle/isar/induct.ts +382 -0
  78. package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
  79. package/src/prover/isabelle/isar/method.ts +506 -198
  80. package/src/prover/isabelle/isar/proof.ts +570 -14
  81. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  82. package/src/prover/isabelle/isar/theory.ts +479 -69
  83. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  84. package/src/prover/isabelle/isar/type-check.ts +83 -8
  85. package/src/prover/isabelle/provers/blast/blast.ts +0 -2
  86. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  87. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  88. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  89. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  90. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  91. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  92. package/src/prover/isabelle/provers/classical.ts +45 -20
  93. package/src/prover/isabelle/provers/hypsubst.ts +2 -4
  94. package/src/prover/isabelle/pure/bicompose.ts +0 -2
  95. package/src/prover/isabelle/pure/consts.ts +0 -2
  96. package/src/prover/isabelle/pure/conv.ts +0 -2
  97. package/src/prover/isabelle/pure/drule.ts +63 -4
  98. package/src/prover/isabelle/pure/envir.ts +0 -2
  99. package/src/prover/isabelle/pure/goal.ts +1 -3
  100. package/src/prover/isabelle/pure/logic.ts +0 -2
  101. package/src/prover/isabelle/pure/name.ts +0 -2
  102. package/src/prover/isabelle/pure/net.ts +0 -2
  103. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  104. package/src/prover/isabelle/pure/pattern.ts +0 -2
  105. package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
  106. package/src/prover/isabelle/pure/rewriter.ts +1 -8
  107. package/src/prover/isabelle/pure/search.ts +0 -2
  108. package/src/prover/isabelle/pure/seq.ts +0 -2
  109. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  110. package/src/prover/isabelle/pure/table.ts +0 -2
  111. package/src/prover/isabelle/pure/tactic.ts +0 -2
  112. package/src/prover/isabelle/pure/tactical.ts +0 -2
  113. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  114. package/src/prover/isabelle/pure/term.ts +0 -2
  115. package/src/prover/isabelle/pure/thm.ts +0 -2
  116. package/src/prover/isabelle/pure/type.ts +0 -2
  117. package/src/prover/isabelle/pure/unify.ts +0 -2
  118. package/src/prover/isabelle/pure/variable.ts +0 -2
  119. package/src/prover/isabelle/tla/classical-setup.ts +1 -2
  120. package/src/prover/isabelle/tla/context.ts +51 -9
  121. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  122. package/src/prover/isabelle/tla/logic.ts +40 -1
  123. package/src/prover/isabelle/tla/simpdata.ts +0 -2
  124. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  125. package/src/prover/ocaml.ts +4 -1
  126. package/src/prover/prep/action.ts +19 -12
  127. package/src/prover/prep/enabled-axioms.ts +11 -2
  128. package/src/prover/prep/methods.ts +159 -50
  129. package/src/prover/prep/normalize.ts +38 -9
  130. package/src/prover/prove.ts +343 -65
  131. package/src/prover/ptl/decide.ts +95 -50
  132. package/src/prover/ptl/encode.ts +2 -3
  133. package/src/prover/ptl/tableau.ts +28 -2
  134. package/src/prover/smt/arithmetic.ts +310 -0
  135. package/src/prover/smt/axioms.ts +12 -8
  136. package/src/prover/smt/context.ts +42 -6
  137. package/src/prover/smt/data.ts +191 -84
  138. package/src/prover/smt/encode.ts +122 -43
  139. package/src/prover/smt/extensionality.ts +5 -3
  140. package/src/prover/smt/flatten.ts +4 -6
  141. package/src/prover/smt/format.ts +28 -4
  142. package/src/prover/smt/instances.ts +7 -1
  143. package/src/prover/smt/layout.ts +91 -0
  144. package/src/prover/smt/rewrite.ts +483 -116
  145. package/src/prover/smt/simplify.ts +441 -0
  146. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  147. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  148. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  149. package/src/prover/smt/solver/act-cache.ts +0 -1
  150. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  151. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  152. package/src/prover/smt/solver/aig.ts +889 -0
  153. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  154. package/src/prover/smt/solver/arith-terms.ts +121 -0
  155. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  156. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  157. package/src/prover/smt/solver/asserted-formulas.ts +93 -15
  158. package/src/prover/smt/solver/ast-lt.ts +165 -11
  159. package/src/prover/smt/solver/ast-util.ts +160 -2
  160. package/src/prover/smt/solver/ast.ts +1448 -41
  161. package/src/prover/smt/solver/auf-solver.ts +0 -1
  162. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  163. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  164. package/src/prover/smt/solver/bound-manager.ts +196 -0
  165. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  166. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  167. package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
  168. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  169. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  170. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  171. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  172. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  173. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  174. package/src/prover/smt/solver/card2bv.ts +109 -0
  175. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  176. package/src/prover/smt/solver/cg-table.ts +39 -25
  177. package/src/prover/smt/solver/check-logic.ts +330 -0
  178. package/src/prover/smt/solver/clause.ts +0 -1
  179. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  180. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  181. package/src/prover/smt/solver/context.ts +533 -114
  182. package/src/prover/smt/solver/ctx-simplify.ts +21 -12
  183. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  184. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  185. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  186. package/src/prover/smt/solver/demodulator.ts +786 -0
  187. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  188. package/src/prover/smt/solver/der.ts +38 -10
  189. package/src/prover/smt/solver/diff-neq.ts +205 -0
  190. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  191. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  192. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  193. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  194. package/src/prover/smt/solver/e-matching.ts +6 -7
  195. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  196. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  197. package/src/prover/smt/solver/enode.ts +100 -3
  198. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  199. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  200. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  201. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  202. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  203. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  204. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  205. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  206. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  207. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  208. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  209. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  210. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  211. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  212. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  213. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  214. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  215. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  216. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  217. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  218. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  219. package/src/prover/smt/solver/expr-ref.ts +0 -1
  220. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  221. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  222. package/src/prover/smt/solver/factor.ts +163 -0
  223. package/src/prover/smt/solver/fd-solver.ts +267 -0
  224. package/src/prover/smt/solver/fingerprints.ts +15 -15
  225. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  226. package/src/prover/smt/solver/flat-literals.ts +0 -1
  227. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  228. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  229. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  230. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  231. package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
  232. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  233. package/src/prover/smt/solver/goal.ts +177 -15
  234. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  235. package/src/prover/smt/solver/guard-set.ts +219 -0
  236. package/src/prover/smt/solver/hash.ts +0 -1
  237. package/src/prover/smt/solver/hashtable.ts +30 -16
  238. package/src/prover/smt/solver/inf-eps.ts +63 -0
  239. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  240. package/src/prover/smt/solver/internalizer.ts +109 -36
  241. package/src/prover/smt/solver/lackr.ts +381 -0
  242. package/src/prover/smt/solver/lbool.ts +0 -1
  243. package/src/prover/smt/solver/lia2card.ts +268 -0
  244. package/src/prover/smt/solver/lia2pb.ts +154 -0
  245. package/src/prover/smt/solver/literal.ts +0 -1
  246. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  247. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  248. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  249. package/src/prover/smt/solver/lp/containers.ts +7 -2
  250. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  251. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  252. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  253. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  254. package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
  255. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  256. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  257. package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
  258. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  259. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  260. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  261. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  262. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  263. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  264. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  265. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  266. package/src/prover/smt/solver/lp/nex.ts +2 -2
  267. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  268. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  269. package/src/prover/smt/solver/lp/nla-core.ts +66 -11
  270. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  271. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  272. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  273. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  274. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  275. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  276. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  277. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  278. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  279. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  280. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  281. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  282. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  283. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  284. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  285. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  286. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  287. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  288. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  289. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  290. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  291. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  292. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  293. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  294. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  295. package/src/prover/smt/solver/macro-finder.ts +530 -0
  296. package/src/prover/smt/solver/mam-compiler.ts +118 -88
  297. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  298. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  299. package/src/prover/smt/solver/max-cliques.ts +105 -0
  300. package/src/prover/smt/solver/maxcore.ts +309 -0
  301. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  302. package/src/prover/smt/solver/maxlex.ts +115 -0
  303. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  304. package/src/prover/smt/solver/maxsmt.ts +92 -0
  305. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  306. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  307. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  308. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  309. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  310. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  311. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  312. package/src/prover/smt/solver/model-checker.ts +17 -26
  313. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  314. package/src/prover/smt/solver/model-finder.ts +0 -1
  315. package/src/prover/smt/solver/model-generator.ts +59 -30
  316. package/src/prover/smt/solver/model-macro-solver.ts +38 -27
  317. package/src/prover/smt/solver/model-printer.ts +214 -0
  318. package/src/prover/smt/solver/mpf.ts +709 -0
  319. package/src/prover/smt/solver/mus.ts +50 -0
  320. package/src/prover/smt/solver/muz/dl-context.ts +410 -0
  321. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  322. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  323. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  324. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  325. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  326. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  327. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  328. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  329. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  330. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  331. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  332. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  333. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  334. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  335. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  336. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  337. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  338. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  339. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  340. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  341. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  342. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  343. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  344. package/src/prover/smt/solver/nlqsat.ts +484 -0
  345. package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
  346. package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
  347. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  348. package/src/prover/smt/solver/nlsat/explain.ts +424 -211
  349. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  350. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
  351. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  352. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
  353. package/src/prover/smt/solver/nlsat/solver.ts +282 -69
  354. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  355. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  356. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  357. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
  358. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  359. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  360. package/src/prover/smt/solver/nnf.ts +105 -23
  361. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  362. package/src/prover/smt/solver/occf.ts +97 -0
  363. package/src/prover/smt/solver/opt-context.ts +792 -0
  364. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  365. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  366. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  367. package/src/prover/smt/solver/opt-solver.ts +311 -0
  368. package/src/prover/smt/solver/opt-value.ts +55 -0
  369. package/src/prover/smt/solver/optsmt.ts +692 -0
  370. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  371. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  372. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  373. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  374. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  375. package/src/prover/smt/solver/probes.ts +511 -0
  376. package/src/prover/smt/solver/propagate-values.ts +37 -21
  377. package/src/prover/smt/solver/proto-model.ts +650 -17
  378. package/src/prover/smt/solver/pull-quant.ts +28 -12
  379. package/src/prover/smt/solver/purify-arith.ts +632 -0
  380. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  381. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  382. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  383. package/src/prover/smt/solver/qe-lite.ts +37 -17
  384. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  385. package/src/prover/smt/solver/qe.ts +1499 -0
  386. package/src/prover/smt/solver/qel.ts +25 -0
  387. package/src/prover/smt/solver/qi-queue.ts +0 -1
  388. package/src/prover/smt/solver/qsat.ts +814 -0
  389. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  390. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  391. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
  392. package/src/prover/smt/solver/quantifier-manager.ts +25 -24
  393. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  394. package/src/prover/smt/solver/random-gen.ts +0 -1
  395. package/src/prover/smt/solver/rational.ts +45 -1
  396. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  397. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  398. package/src/prover/smt/solver/reduce-args.ts +225 -0
  399. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  400. package/src/prover/smt/solver/ref-vector.ts +0 -1
  401. package/src/prover/smt/solver/relevancy.ts +1 -2
  402. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  403. package/src/prover/smt/solver/rewriter.ts +475 -36
  404. package/src/prover/smt/solver/rlimit.ts +38 -2
  405. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  406. package/src/prover/smt/solver/sat/big.ts +177 -0
  407. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  408. package/src/prover/smt/solver/sat/clause.ts +203 -0
  409. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  410. package/src/prover/smt/solver/sat/config.ts +122 -0
  411. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  412. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  413. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  414. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  415. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  416. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  417. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  418. package/src/prover/smt/solver/sat/probing.ts +170 -0
  419. package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
  420. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  421. package/src/prover/smt/solver/sat/scc.ts +142 -0
  422. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  423. package/src/prover/smt/solver/sat/solver.ts +2105 -0
  424. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  425. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  426. package/src/prover/smt/solver/search-tree.ts +284 -0
  427. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  428. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  429. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  430. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  431. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  432. package/src/prover/smt/solver/seq-factory.ts +89 -0
  433. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  434. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  435. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  436. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  437. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  438. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  439. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  440. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  441. package/src/prover/smt/solver/seq-subset.ts +165 -0
  442. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  443. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  444. package/src/prover/smt/solver/smt-kernel.ts +90 -0
  445. package/src/prover/smt/solver/smt-logics.ts +66 -0
  446. package/src/prover/smt/solver/smt-setup.ts +496 -0
  447. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  448. package/src/prover/smt/solver/smtlib-parser.ts +3154 -326
  449. package/src/prover/smt/solver/smtlib-script.ts +1702 -0
  450. package/src/prover/smt/solver/solve-eqs.ts +923 -0
  451. package/src/prover/smt/solver/solver.ts +113 -22
  452. package/src/prover/smt/solver/static-features.ts +314 -0
  453. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  454. package/src/prover/smt/solver/tactic.ts +1995 -0
  455. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  456. package/src/prover/smt/solver/theory-array.ts +1240 -0
  457. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  458. package/src/prover/smt/solver/theory-char.ts +355 -0
  459. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  460. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  461. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  462. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  463. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
  464. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
  465. package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
  466. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  467. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
  468. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  469. package/src/prover/smt/solver/theory-lra.ts +188 -2
  470. package/src/prover/smt/solver/theory-pb.ts +933 -0
  471. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  472. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  473. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  474. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  475. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  476. package/src/prover/smt/solver/theory-seq.ts +961 -0
  477. package/src/prover/smt/solver/theory.ts +189 -0
  478. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  479. package/src/prover/smt/solver/var-subst.ts +36 -14
  480. package/src/prover/smt/table.ts +3 -2
  481. package/src/prover/smt/types.ts +146 -0
  482. package/src/prover/tlapm/cache.ts +29 -8
  483. package/src/prover/tlapm-library.ts +3208 -0
  484. package/src/prover/verdict.ts +2 -0
  485. package/src/prover/zenon/decide.ts +10 -7
  486. package/src/prover/zenon/encode.ts +0 -2
  487. package/src/prover/zenon/eqrel.ts +0 -2
  488. package/src/prover/zenon/equality-rules.ts +24 -2
  489. package/src/prover/zenon/expr.ts +21 -2
  490. package/src/prover/zenon/index-table.ts +7 -4
  491. package/src/prover/zenon/isar-case.ts +1 -3
  492. package/src/prover/zenon/isar.ts +2 -4
  493. package/src/prover/zenon/llproof.ts +0 -2
  494. package/src/prover/zenon/mltoll.ts +0 -2
  495. package/src/prover/zenon/node.ts +20 -5
  496. package/src/prover/zenon/parse.ts +6 -2
  497. package/src/prover/zenon/phrase.ts +1 -3
  498. package/src/prover/zenon/proof.ts +0 -2
  499. package/src/prover/zenon/propositional-rules.ts +0 -2
  500. package/src/prover/zenon/rules.ts +2 -3
  501. package/src/prover/zenon/search.ts +7 -5
  502. package/src/prover/zenon/tla/functions.ts +0 -2
  503. package/src/prover/zenon/tla/llproof.ts +0 -2
  504. package/src/prover/zenon/tla/records.ts +0 -2
  505. package/src/prover/zenon/tla/rewrites.ts +0 -2
  506. package/src/prover/zenon/tla/sets.ts +7 -8
  507. package/src/prover/zenon/tla/terms.ts +0 -2
  508. package/src/prover/zenon/tla/tla.ts +0 -2
  509. package/src/resolve.ts +72 -36
  510. package/src/runtime.ts +6 -0
  511. package/src/sany/generation.ts +1 -13
  512. package/src/sany/generator-definitions.ts +1 -1
  513. package/src/sany/generator-expressions.ts +9 -17
  514. package/src/sany/generator-proofs.ts +1 -1
  515. package/src/sany/generator.ts +1 -1
  516. package/src/sany/levels.ts +0 -2
  517. package/src/sany/linter.ts +0 -2
  518. package/src/search.ts +198 -45
  519. package/src/simulate.ts +3 -0
  520. package/src/standard-definitions.ts +4 -0
  521. package/src/state-graph.ts +0 -2
  522. package/src/subexpressions.ts +4 -2
  523. package/src/successors.ts +1 -1
  524. package/src/symmetry.ts +2 -2
  525. package/src/tableau.ts +2 -2
  526. package/src/tlc/fingerprint.ts +81 -9
  527. package/src/tlc/jar-data.ts +12 -0
  528. package/src/tlc/order.ts +14 -3
  529. package/src/tlc/summary.ts +29 -14
  530. package/src/tlc/tlcext-operators.ts +61 -16
  531. package/src/tlc/trace-spec.ts +2 -3
  532. package/src/typed-tier.ts +6541 -0
  533. package/src/typescript/types.ts +2 -2
  534. package/src/values.ts +1 -1
  535. package/src/prover/isabelle/isar/statement.ts +0 -52
  536. package/src/prover/smt/solver/z3-license.txt +0 -10
  537. package/src/prover/tlaps-module.ts +0 -510
  538. package/src/prover/zenon/LICENSE +0 -32
@@ -0,0 +1,1618 @@
1
+ import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
2
+ import type { RandomGen } from "../random-gen";
3
+ import { type ClauseArena, NULL_LITERAL, UINT_MAX } from "./clause";
4
+ import { UseList } from "./clause-use-list";
5
+ import { getBool, getNumber, type SatParams } from "./config";
6
+ import { MC_ABCE, MC_ACCE, MC_BCE, MC_CCE, MC_ELIM_VAR } from "./model-converter";
7
+ import type { Solver } from "./solver";
8
+ import { WATCH_CLAUSE, type WatchList } from "./watch-list";
9
+
10
+ const BCE_T = 0;
11
+ const CCE_T = 1;
12
+ const ACCE_T = 2;
13
+ const ABCE_T = 3;
14
+ const ATE_T = 4;
15
+ const NO_T = 5;
16
+
17
+ const isApproxSubset = (first: number, second: number) => (first | second) === second;
18
+
19
+ const shuffle = (lits: number[], rand: RandomGen) => {
20
+ let size = lits.length;
21
+ while (size-- > 0) {
22
+ const position = rand.next() % (size + 1);
23
+ const lit = lits[size];
24
+ lits[size] = lits[position];
25
+ lits[position] = lit;
26
+ }
27
+ };
28
+
29
+ class ClauseSet {
30
+ private idToPos = new Int32Array(0);
31
+ private clauses: number[] = [];
32
+
33
+ isEmpty() {
34
+ return this.clauses.length === 0;
35
+ }
36
+
37
+ insert(clause: number) {
38
+ if (clause >= this.idToPos.length) {
39
+ const idToPos = new Int32Array(Math.max(clause + 1, 2 * this.idToPos.length)).fill(-1);
40
+ idToPos.set(this.idToPos);
41
+ this.idToPos = idToPos;
42
+ }
43
+ if (this.idToPos[clause] !== -1) return;
44
+ this.idToPos[clause] = this.clauses.length;
45
+ this.clauses.push(clause);
46
+ }
47
+
48
+ erase(clause: number) {
49
+ if (clause >= this.idToPos.length || this.clauses.length === 0) return;
50
+ const position = this.idToPos[clause];
51
+ if (position === -1) return;
52
+ this.idToPos[clause] = -1;
53
+ const lastPosition = this.clauses.length - 1;
54
+ if (position !== lastPosition) {
55
+ const last = this.clauses[lastPosition];
56
+ this.clauses[position] = last;
57
+ this.idToPos[last] = position;
58
+ }
59
+ this.clauses.length = lastPosition;
60
+ }
61
+
62
+ eraseLast() {
63
+ const clause = this.clauses[this.clauses.length - 1];
64
+ this.idToPos[clause] = -1;
65
+ this.clauses.length--;
66
+ return clause;
67
+ }
68
+
69
+ reset() {
70
+ this.idToPos = new Int32Array(0);
71
+ this.clauses = [];
72
+ }
73
+ }
74
+
75
+ class LiteralQueue {
76
+ private values = [-1];
77
+ private indices = new Int32Array(128);
78
+
79
+ constructor(
80
+ private useList: UseList,
81
+ private watches: WatchList[],
82
+ ) {}
83
+
84
+ private getWeight(lit: number) {
85
+ return 2 * this.useList.size[lit ^ 1] + this.watches[lit].size;
86
+ }
87
+
88
+ private isLess(first: number, second: number) {
89
+ return this.getWeight(first) < this.getWeight(second);
90
+ }
91
+
92
+ private moveUp(start: number) {
93
+ const values = this.values;
94
+ const lit = values[start];
95
+ let index = start;
96
+ for (;;) {
97
+ const parentIndex = index >> 1;
98
+ if (parentIndex === 0 || !this.isLess(lit, values[parentIndex])) break;
99
+ values[index] = values[parentIndex];
100
+ this.indices[values[index]] = index;
101
+ index = parentIndex;
102
+ }
103
+ values[index] = lit;
104
+ this.indices[lit] = index;
105
+ }
106
+
107
+ private moveDown(start: number) {
108
+ const values = this.values;
109
+ const lit = values[start];
110
+ const size = values.length;
111
+ let index = start;
112
+ for (;;) {
113
+ const leftIndex = index << 1;
114
+ if (leftIndex >= size) break;
115
+ const rightIndex = leftIndex + 1;
116
+ const minIndex =
117
+ rightIndex < size && this.isLess(values[rightIndex], values[leftIndex])
118
+ ? rightIndex
119
+ : leftIndex;
120
+ const minValue = values[minIndex];
121
+ if (!this.isLess(minValue, lit)) break;
122
+ values[index] = minValue;
123
+ this.indices[minValue] = index;
124
+ index = minIndex;
125
+ }
126
+ values[index] = lit;
127
+ this.indices[lit] = index;
128
+ }
129
+
130
+ private reserve(size: number) {
131
+ if (size <= this.indices.length) return;
132
+ const indices = new Int32Array(size);
133
+ indices.set(this.indices);
134
+ this.indices = indices;
135
+ }
136
+
137
+ private contains(lit: number) {
138
+ return lit < this.indices.length && this.indices[lit] !== 0;
139
+ }
140
+
141
+ private heapInsert(lit: number) {
142
+ const index = this.values.length;
143
+ this.indices[lit] = index;
144
+ this.values.push(lit);
145
+ this.moveUp(index);
146
+ }
147
+
148
+ isEmpty() {
149
+ return this.values.length === 1;
150
+ }
151
+
152
+ insert(lit: number) {
153
+ this.reserve(lit + 1);
154
+ this.heapInsert(lit);
155
+ }
156
+
157
+ decreased(lit: number) {
158
+ if (this.contains(lit)) this.moveUp(this.indices[lit]);
159
+ else this.insert(lit);
160
+ }
161
+
162
+ next() {
163
+ const values = this.values;
164
+ const result = values[1];
165
+ if (values.length === 2) {
166
+ this.indices[result] = 0;
167
+ values.pop();
168
+ return result;
169
+ }
170
+ const last = values[values.length - 1];
171
+ values[1] = last;
172
+ this.indices[last] = 1;
173
+ this.indices[result] = 0;
174
+ values.pop();
175
+ this.moveDown(1);
176
+ return result;
177
+ }
178
+
179
+ reset() {
180
+ if (this.isEmpty()) return;
181
+ this.indices.fill(0);
182
+ this.values = [-1];
183
+ }
184
+ }
185
+
186
+ class BlockedClauseElim {
187
+ private counter: number;
188
+ private queue: LiteralQueue;
189
+ private coveredClause: number[] = [];
190
+ private anteLit: number[] = [];
191
+ private anteClause: number[] = [];
192
+ private isAnteFromRi: boolean[] = [];
193
+ private intersection: number[] = [];
194
+ private tautology: number[] = [];
195
+ private newIntersection: number[] = [];
196
+ private isInIntersection: Uint8Array;
197
+ private alaQhead = 0;
198
+ private clauseFirst = NULL_LITERAL;
199
+ private clauseSecond = NULL_LITERAL;
200
+ private alaCost = 0;
201
+ private alaBenefit = 0;
202
+ private alaMaxCost: number;
203
+ private blocked = NULL_LITERAL;
204
+ private kind = MC_BCE;
205
+
206
+ constructor(
207
+ private simplifier: Simplifier,
208
+ limit: number,
209
+ ) {
210
+ const solver = simplifier.solver;
211
+ this.counter = limit;
212
+ this.queue = new LiteralQueue(simplifier.useList, solver.watches);
213
+ this.isInIntersection = new Uint8Array(2 * solver.numVars());
214
+ this.alaMaxCost = Math.trunc((solver.clauses.length * simplifier.numCalls) / 5);
215
+ }
216
+
217
+ private isProcessVar(boolVar: number) {
218
+ const solver = this.simplifier.solver;
219
+ return (
220
+ !solver.isAssumption(boolVar) &&
221
+ !solver.wasEliminated(boolVar) &&
222
+ !this.simplifier.isExternal(boolVar) &&
223
+ solver.valueVar(boolVar) === L_UNDEF
224
+ );
225
+ }
226
+
227
+ private isReachedMaxCost() {
228
+ return this.alaBenefit <= this.alaCost * 100 && this.alaCost > this.alaMaxCost;
229
+ }
230
+
231
+ run() {
232
+ const simplifier = this.simplifier;
233
+ if (simplifier.isAcceEnabled()) this.cce(ACCE_T);
234
+ if (simplifier.isAteEnabled() && !simplifier.isAbceEnabled() && !simplifier.isAcceEnabled())
235
+ this.cce(ATE_T);
236
+ if (simplifier.isCceEnabled() && !simplifier.isAcceEnabled()) this.cce(CCE_T);
237
+ if (simplifier.isAbceEnabled() && !simplifier.isAcceEnabled()) this.cce(ABCE_T);
238
+ if (simplifier.isBceEnabled() && !simplifier.isCceEnabled() && !simplifier.isAbceEnabled())
239
+ this.cce(BCE_T);
240
+ }
241
+
242
+ private insertQueue() {
243
+ this.queue.reset();
244
+ const numVars = this.simplifier.solver.numVars();
245
+ for (let boolVar = 0; boolVar < numVars; boolVar++)
246
+ if (this.isProcessVar(boolVar)) {
247
+ this.queue.insert(2 * boolVar);
248
+ this.queue.insert(2 * boolVar + 1);
249
+ }
250
+ }
251
+
252
+ private resetIntersection() {
253
+ for (const lit of this.intersection) this.isInIntersection[lit] = 0;
254
+ this.intersection.length = 0;
255
+ }
256
+
257
+ private addIntersection(lit: number) {
258
+ this.intersection.push(lit);
259
+ this.isInIntersection[lit] = 1;
260
+ }
261
+
262
+ private resolutionIntersection(lit: number) {
263
+ const simplifier = this.simplifier;
264
+ const arena = simplifier.solver.arena;
265
+ const visited = simplifier.visited;
266
+ const notLit = lit ^ 1;
267
+ const tautologySize = this.tautology.length;
268
+ this.resetIntersection();
269
+ if (!this.isProcessVar(lit >> 1)) return false;
270
+ let isFirst = true;
271
+ const wlist = simplifier.solver.watches[lit];
272
+ for (let index = 0; index < wlist.size; index++) {
273
+ if (!wlist.isBinary(index) || wlist.isLearned(index)) continue;
274
+ const other = wlist.getLiteral(index);
275
+ if (visited[other ^ 1] && other !== notLit) {
276
+ this.tautology.push(other ^ 1);
277
+ continue;
278
+ }
279
+ if (!isFirst || visited[other]) {
280
+ this.resetIntersection();
281
+ this.tautology.length = tautologySize;
282
+ return false;
283
+ }
284
+ isFirst = false;
285
+ this.addIntersection(other);
286
+ }
287
+ for (const clause of simplifier.useList.get(notLit)) {
288
+ if (arena.isLearned(clause) || arena.wasRemoved(clause)) continue;
289
+ const size = arena.size[clause];
290
+ let isTautology = false;
291
+ for (let index = 0; index < size; index++) {
292
+ const other = arena.get(clause, index);
293
+ if (visited[other ^ 1] && other !== notLit) {
294
+ this.tautology.push(other ^ 1);
295
+ isTautology = true;
296
+ break;
297
+ }
298
+ }
299
+ if (isTautology) continue;
300
+ if (isFirst) {
301
+ for (let index = 0; index < size; index++) {
302
+ const other = arena.get(clause, index);
303
+ if (other !== notLit && !visited[other]) this.addIntersection(other);
304
+ }
305
+ isFirst = false;
306
+ } else {
307
+ this.newIntersection.length = 0;
308
+ for (let index = 0; index < size; index++) {
309
+ const other = arena.get(clause, index);
310
+ if (this.isInIntersection[other]) this.newIntersection.push(other);
311
+ }
312
+ this.resetIntersection();
313
+ for (const other of this.newIntersection) this.addIntersection(other);
314
+ }
315
+ if (this.intersection.length === 0) {
316
+ this.tautology.length = tautologySize;
317
+ return false;
318
+ }
319
+ }
320
+ if (this.intersection.length === 0 && !isFirst) this.tautology.length = tautologySize;
321
+ return isFirst;
322
+ }
323
+
324
+ private checkAbceTautology(lit: number) {
325
+ const simplifier = this.simplifier;
326
+ const arena = simplifier.solver.arena;
327
+ const visited = simplifier.visited;
328
+ const notLit = lit ^ 1;
329
+ const tautologySize = this.tautology.length;
330
+ if (!this.isProcessVar(lit >> 1)) return false;
331
+ const wlist = simplifier.solver.watches[lit];
332
+ for (let index = 0; index < wlist.size; index++) {
333
+ if (!wlist.isBinary(index) || wlist.isLearned(index)) continue;
334
+ const other = wlist.getLiteral(index);
335
+ if (!visited[other ^ 1]) {
336
+ this.tautology.length = tautologySize;
337
+ return false;
338
+ }
339
+ this.tautology.push(other ^ 1);
340
+ }
341
+ for (const clause of simplifier.useList.get(notLit)) {
342
+ if (arena.isLearned(clause) || arena.wasRemoved(clause)) continue;
343
+ let isTautology = false;
344
+ for (let index = 0; index < arena.size[clause]; index++) {
345
+ const other = arena.get(clause, index);
346
+ if (visited[other ^ 1] && other !== notLit) {
347
+ isTautology = true;
348
+ this.tautology.push(other ^ 1);
349
+ break;
350
+ }
351
+ }
352
+ if (!isTautology) {
353
+ this.tautology.length = tautologySize;
354
+ return false;
355
+ }
356
+ }
357
+ return true;
358
+ }
359
+
360
+ private isRevisitBinary(first: number, second: number) {
361
+ return (
362
+ this.clauseSecond !== NULL_LITERAL &&
363
+ ((this.clauseFirst === first && this.clauseSecond === second) ||
364
+ (this.clauseFirst === second && this.clauseSecond === first))
365
+ );
366
+ }
367
+
368
+ private isRevisitClause(clause: number) {
369
+ return this.clauseSecond === NULL_LITERAL && this.clauseFirst === clause;
370
+ }
371
+
372
+ private minimizeCoveredClause(start: number) {
373
+ const simplifier = this.simplifier;
374
+ const arena = simplifier.solver.arena;
375
+ const visited = simplifier.visited;
376
+ const covered = this.coveredClause;
377
+ let last = start;
378
+ for (const lit of covered) visited[lit] = 0;
379
+ for (const lit of this.tautology) visited[lit] = 1;
380
+ visited[covered[last]] = 1;
381
+ for (let index = 0; index < covered.length; index++) {
382
+ const lit = covered[index];
383
+ if (this.anteLit[index] === NULL_LITERAL && this.anteClause[index] === -1) visited[lit] = 1;
384
+ if (visited[lit]) last = index;
385
+ }
386
+ for (let index = last; index > 0; index--) {
387
+ const lit = covered[index];
388
+ if (!visited[lit]) continue;
389
+ const clause = this.anteClause[index];
390
+ if (clause !== -1)
391
+ for (let position = 0; position < arena.size[clause]; position++) {
392
+ const other = arena.get(clause, position);
393
+ if (other !== (lit ^ 1)) visited[other] = 1;
394
+ }
395
+ if (this.anteLit[index] !== NULL_LITERAL) visited[this.anteLit[index]] = 1;
396
+ }
397
+ let next = 0;
398
+ let blocked = NULL_LITERAL;
399
+ const elimStack = simplifier.solver.mc.elimStack;
400
+ for (let index = 0; index <= last; index++) {
401
+ const lit = covered[index];
402
+ if (!visited[lit]) continue;
403
+ if (this.isAnteFromRi[index] && blocked !== this.anteLit[index]) {
404
+ blocked = this.anteLit[index];
405
+ elimStack.push(next, blocked);
406
+ }
407
+ covered[next++] = lit;
408
+ visited[lit] = 0;
409
+ }
410
+ covered.length = next;
411
+ }
412
+
413
+ private pushCovered(lit: number, anteLit: number, anteClause: number, isFromRi: boolean) {
414
+ this.coveredClause.push(lit);
415
+ this.anteLit.push(anteLit);
416
+ this.anteClause.push(anteClause);
417
+ this.isAnteFromRi.push(isFromRi);
418
+ }
419
+
420
+ private addAla() {
421
+ const simplifier = this.simplifier;
422
+ const solver = simplifier.solver;
423
+ const arena = solver.arena;
424
+ const visited = simplifier.visited;
425
+ const covered = this.coveredClause;
426
+ const initSize = covered.length;
427
+ for (
428
+ ;
429
+ this.alaQhead < covered.length && this.alaQhead < 5 * initSize && !this.isReachedMaxCost();
430
+ this.alaQhead++
431
+ ) {
432
+ this.alaCost++;
433
+ const lit = covered[this.alaQhead];
434
+ const wlist = solver.watches[lit ^ 1];
435
+ for (let index = 0; index < wlist.size; index++) {
436
+ if (!wlist.isBinary(index) || wlist.isLearned(index)) continue;
437
+ const other = wlist.getLiteral(index);
438
+ if (this.isRevisitBinary(lit, other)) continue;
439
+ if (visited[other]) {
440
+ this.alaBenefit++;
441
+ return true;
442
+ }
443
+ if (!visited[other ^ 1]) {
444
+ this.pushCovered(other ^ 1, lit, -1, false);
445
+ visited[other ^ 1] = 1;
446
+ }
447
+ }
448
+ for (const clause of simplifier.useList.get(lit)) {
449
+ if (arena.isLearned(clause) || arena.wasRemoved(clause)) continue;
450
+ if (this.isRevisitClause(clause)) continue;
451
+ let lit1 = NULL_LITERAL;
452
+ let isOk = true;
453
+ for (let index = 0; index < arena.size[clause]; index++) {
454
+ const other = arena.get(clause, index);
455
+ if (other === lit || visited[other]) continue;
456
+ if (!visited[other ^ 1] && lit1 === NULL_LITERAL) lit1 = other;
457
+ else {
458
+ isOk = false;
459
+ break;
460
+ }
461
+ }
462
+ if (!isOk) continue;
463
+ if (lit1 === NULL_LITERAL) {
464
+ this.alaBenefit++;
465
+ return true;
466
+ }
467
+ this.pushCovered(lit1 ^ 1, NULL_LITERAL, clause, false);
468
+ visited[lit1 ^ 1] = 1;
469
+ }
470
+ }
471
+ return false;
472
+ }
473
+
474
+ private addCla() {
475
+ const visited = this.simplifier.visited;
476
+ const covered = this.coveredClause;
477
+ for (let index = 0; index < covered.length; index++) {
478
+ const lit = covered[index];
479
+ if (this.resolutionIntersection(lit)) {
480
+ this.blocked = covered[index];
481
+ this.minimizeCoveredClause(index);
482
+ return true;
483
+ }
484
+ for (const other of this.intersection)
485
+ if (!visited[other]) {
486
+ visited[other] = 1;
487
+ this.pushCovered(other, lit, -1, true);
488
+ }
489
+ }
490
+ return false;
491
+ }
492
+
493
+ private resetMark() {
494
+ const visited = this.simplifier.visited;
495
+ for (const lit of this.coveredClause) visited[lit] = 0;
496
+ }
497
+
498
+ private cceCore(elimType: number) {
499
+ const simplifier = this.simplifier;
500
+ const solver = simplifier.solver;
501
+ const visited = simplifier.visited;
502
+ const covered = this.coveredClause;
503
+ let isFirst = true;
504
+ let size = 0;
505
+ const size0 = covered.length;
506
+ for (const lit of covered) visited[lit] = 1;
507
+ shuffle(covered, solver.rand);
508
+ this.tautology.length = 0;
509
+ solver.mc.elimStack.length = 0;
510
+ this.alaQhead = 0;
511
+ this.kind = elimType === CCE_T ? MC_CCE : elimType === ACCE_T ? MC_ACCE : MC_BCE;
512
+ if (elimType === ATE_T) {
513
+ const isAla = this.addAla();
514
+ this.resetMark();
515
+ covered.length = size0;
516
+ return isAla ? ATE_T : NO_T;
517
+ }
518
+ while (covered.length > size && size0 * 400 >= covered.length) {
519
+ if ((elimType === ABCE_T || elimType === ACCE_T) && this.addAla()) {
520
+ this.resetMark();
521
+ if (isFirst) covered.length = size0;
522
+ else {
523
+ for (const lit of covered) {
524
+ this.tautology.push(lit);
525
+ visited[lit] = 1;
526
+ }
527
+ this.minimizeCoveredClause(covered.length - 1);
528
+ }
529
+ return ATE_T;
530
+ }
531
+ if (isFirst)
532
+ for (let index = 0; index < size0; index++)
533
+ if (this.checkAbceTautology(covered[index])) {
534
+ this.blocked = covered[index];
535
+ this.resetMark();
536
+ covered.length = size0;
537
+ if (elimType === BCE_T) return BCE_T;
538
+ this.kind = MC_ABCE;
539
+ return ABCE_T;
540
+ }
541
+ isFirst = false;
542
+ if (elimType === ABCE_T || elimType === BCE_T) break;
543
+ size = covered.length;
544
+ if ((elimType === CCE_T || elimType === ACCE_T) && this.addCla()) {
545
+ this.resetMark();
546
+ return elimType;
547
+ }
548
+ }
549
+ this.resetMark();
550
+ return NO_T;
551
+ }
552
+
553
+ private resetCovered() {
554
+ this.coveredClause.length = 0;
555
+ this.anteLit.length = 0;
556
+ this.anteClause.length = 0;
557
+ this.isAnteFromRi.length = 0;
558
+ }
559
+
560
+ private cceClause(clause: number, elimType: number) {
561
+ const arena = this.simplifier.solver.arena;
562
+ this.clauseFirst = clause;
563
+ this.clauseSecond = NULL_LITERAL;
564
+ this.resetCovered();
565
+ for (let index = 0; index < arena.size[clause]; index++)
566
+ this.pushCovered(arena.get(clause, index), NULL_LITERAL, -1, false);
567
+ return this.cceCore(elimType);
568
+ }
569
+
570
+ private cceBinary(first: number, second: number, elimType: number) {
571
+ this.clauseFirst = first;
572
+ this.clauseSecond = second;
573
+ this.resetCovered();
574
+ this.pushCovered(first, NULL_LITERAL, -1, false);
575
+ this.pushCovered(second, NULL_LITERAL, -1, false);
576
+ return this.cceCore(elimType);
577
+ }
578
+
579
+ private cce(elimType: number) {
580
+ this.insertQueue();
581
+ this.cceClauses(elimType);
582
+ this.cceBinaries(elimType);
583
+ }
584
+
585
+ private cceBinaries(elimType: number) {
586
+ this.alaCost = 0;
587
+ this.alaBenefit = 0;
588
+ while (!this.queue.isEmpty() && this.counter >= 0 && !this.isReachedMaxCost()) {
589
+ this.simplifier.solver.checkpoint();
590
+ this.processCceBinary(this.queue.next(), elimType);
591
+ }
592
+ }
593
+
594
+ private processCceBinary(lit: number, elimType: number) {
595
+ const solver = this.simplifier.solver;
596
+ const wlist = solver.watches[lit ^ 1];
597
+ const size = wlist.size;
598
+ this.counter -= size;
599
+ for (let index = 0; index < size; index++) {
600
+ if (!wlist.isBinary(index) || wlist.isLearned(index)) continue;
601
+ if (!this.isSelectClause(2)) continue;
602
+ const other = wlist.getLiteral(index);
603
+ const result = this.cceBinary(lit, other, elimType);
604
+ if (result === ATE_T) {
605
+ wlist.setLearned(index, true);
606
+ solver.setLearned1(other, lit, true);
607
+ solver.mc.addAte(this.coveredClause);
608
+ } else if (result !== NO_T) {
609
+ wlist.setLearned(index, true);
610
+ solver.setLearned1(other, lit, true);
611
+ this.blockCoveredBinary(other, lit);
612
+ }
613
+ solver.checkpoint();
614
+ }
615
+ }
616
+
617
+ private cceClauses(elimType: number) {
618
+ const simplifier = this.simplifier;
619
+ const solver = simplifier.solver;
620
+ const arena = solver.arena;
621
+ this.alaCost = 0;
622
+ this.alaBenefit = 0;
623
+ const start = solver.rand.next();
624
+ const size = solver.clauses.length;
625
+ for (let index = 0; index < size; index++) {
626
+ const clause = solver.clauses[(index + start) % size];
627
+ if (arena.wasRemoved(clause) || arena.isLearned(clause)) continue;
628
+ if (!this.isSelectClause(arena.size[clause])) continue;
629
+ const result = this.cceClause(clause, elimType);
630
+ if (result === ATE_T) {
631
+ solver.mc.addAte(this.coveredClause);
632
+ simplifier.setLearnedClause(clause);
633
+ } else if (result !== NO_T) {
634
+ this.blockCoveredClause(clause);
635
+ simplifier.setLearnedClause(clause);
636
+ }
637
+ solver.checkpoint();
638
+ if (this.isReachedMaxCost()) break;
639
+ }
640
+ }
641
+
642
+ private isSelectClause(size: number) {
643
+ return size > 3 || this.simplifier.solver.rand.next() % 4 === 0;
644
+ }
645
+
646
+ private blockCoveredClause(clause: number) {
647
+ const solver = this.simplifier.solver;
648
+ const arena = solver.arena;
649
+ const entry = solver.mc.mk(this.kind, this.blocked >> 1);
650
+ for (let index = 0; index < arena.size[clause]; index++) {
651
+ const lit = arena.get(clause, index);
652
+ if (lit !== this.blocked && this.isProcessVar(lit >> 1)) this.queue.decreased(lit ^ 1);
653
+ }
654
+ solver.mc.insert(entry, this.coveredClause);
655
+ }
656
+
657
+ private blockCoveredBinary(other: number, lit: number) {
658
+ const solver = this.simplifier.solver;
659
+ const entry = solver.mc.mk(this.kind, this.blocked >> 1);
660
+ this.simplifier.setLearnedBinary(lit, other);
661
+ solver.mc.insert(entry, this.coveredClause);
662
+ if (this.isProcessVar(other >> 1)) this.queue.decreased(other ^ 1);
663
+ }
664
+ }
665
+
666
+ export class Simplifier {
667
+ numCalls = 0;
668
+ useList: UseList;
669
+ private readonly extUseVars = new Set<number>();
670
+ private subTodo = new ClauseSet();
671
+ private subBinTodo: number[] = [];
672
+ private lastSubTrailSize = 0;
673
+ private elimTodo: number[] = [];
674
+ private isInElimTodo = new Uint8Array(0);
675
+ private isNeedingCleanup = false;
676
+ private dummy = -1;
677
+ private dummyArena: ClauseArena | undefined;
678
+ visited = new Uint8Array(0);
679
+ private subCounter = 0;
680
+ private elimCounter = 0;
681
+ private resolventLit = NULL_LITERAL;
682
+ private isAbce: boolean;
683
+ private isCce: boolean;
684
+ private isAcce: boolean;
685
+ private bceDelay: number;
686
+ private isBce: boolean;
687
+ private isAte: boolean;
688
+ private bceAt: number;
689
+ private blockedClauseLimit: number;
690
+ readonly isIncrementalMode: boolean;
691
+ private resLimit: number;
692
+ private resOccCutoff: number;
693
+ private resOccCutoff1: number;
694
+ private resOccCutoff2: number;
695
+ private resOccCutoff3: number;
696
+ private resLitCutoff1: number;
697
+ private resLitCutoff2: number;
698
+ private resLitCutoff3: number;
699
+ private resClsCutoff1: number;
700
+ private resClsCutoff2: number;
701
+ private isSubsumption: boolean;
702
+ private subsumptionLimit: number;
703
+ readonly isElimVars: boolean;
704
+ numElimVars = 0;
705
+ private isLearnedInUseLists = false;
706
+ private oldNumElimVars = 0;
707
+ private bsClauses: number[] = [];
708
+ private bsLits: number[] = [];
709
+ private posClauses: number[] = [];
710
+ private negClauses: number[] = [];
711
+ private newClause: number[] = [];
712
+
713
+ constructor(
714
+ readonly solver: Solver,
715
+ params: SatParams,
716
+ ) {
717
+ this.useList = new UseList(solver.arena, 0);
718
+ this.isCce = getBool(params, "cce", false);
719
+ this.isAcce = getBool(params, "acce", false);
720
+ this.isAbce = getBool(params, "abce", false);
721
+ this.isAte = getBool(params, "ate", true);
722
+ this.bceDelay = getNumber(params, "bce_delay", 2);
723
+ this.isBce = getBool(params, "bce", false);
724
+ this.bceAt = getNumber(params, "bce_at", 2);
725
+ this.blockedClauseLimit = getNumber(params, "blocked_clause_limit", 100000000);
726
+ this.resLimit = getNumber(params, "resolution.limit", 500000000);
727
+ this.resOccCutoff = getNumber(params, "resolution.occ_cutoff", 10);
728
+ this.resOccCutoff1 = getNumber(params, "resolution.occ_cutoff_range1", 8);
729
+ this.resOccCutoff2 = getNumber(params, "resolution.occ_cutoff_range2", 5);
730
+ this.resOccCutoff3 = getNumber(params, "resolution.occ_cutoff_range3", 3);
731
+ this.resLitCutoff1 = getNumber(params, "resolution.lit_cutoff_range1", 700);
732
+ this.resLitCutoff2 = getNumber(params, "resolution.lit_cutoff_range2", 400);
733
+ this.resLitCutoff3 = getNumber(params, "resolution.lit_cutoff_range3", 300);
734
+ this.resClsCutoff1 = getNumber(params, "resolution.cls_cutoff1", 100000000);
735
+ this.resClsCutoff2 = getNumber(params, "resolution.cls_cutoff2", 700000000);
736
+ this.isSubsumption = getBool(params, "subsumption", true);
737
+ this.subsumptionLimit = getNumber(params, "subsumption.limit", 100000000);
738
+ this.isElimVars = getBool(params, "elim_vars", true);
739
+ this.isIncrementalMode =
740
+ solver.isIncremental() && !getBool(params, "override_incremental", false);
741
+ }
742
+
743
+ isExternal(boolVar: number) {
744
+ const solver = this.solver;
745
+ if (!solver.isExternal(boolVar)) return solver.isAssumption(boolVar);
746
+ return (
747
+ solver.isIncremental() ||
748
+ solver.ext?.isExternal?.(boolVar) === true ||
749
+ this.extUseVars.has(boolVar)
750
+ );
751
+ }
752
+
753
+ private isBceEnabledBase() {
754
+ return (
755
+ !this.isIncrementalMode &&
756
+ !this.solver.trackingAssumptions() &&
757
+ !this.isLearnedInUseLists &&
758
+ this.numCalls >= this.bceDelay
759
+ );
760
+ }
761
+
762
+ isAteEnabled() {
763
+ return this.numCalls >= this.bceDelay && this.isAte;
764
+ }
765
+
766
+ isBceEnabled() {
767
+ return (
768
+ this.isBceEnabledBase() &&
769
+ (this.isBce || this.bceAt === this.numCalls || this.isAcce || this.isAbce || this.isCce)
770
+ );
771
+ }
772
+
773
+ isAcceEnabled() {
774
+ return this.isBceEnabledBase() && this.isAcce;
775
+ }
776
+
777
+ isCceEnabled() {
778
+ return this.isBceEnabledBase() && (this.isCce || this.isAcce);
779
+ }
780
+
781
+ isAbceEnabled() {
782
+ return this.isBceEnabledBase() && this.isAbce;
783
+ }
784
+
785
+ private isElimVarsEnabled() {
786
+ return !this.isIncrementalMode && !this.solver.trackingAssumptions() && this.isElimVars;
787
+ }
788
+
789
+ insertElimTodo(boolVar: number) {
790
+ if (boolVar >= this.isInElimTodo.length) {
791
+ const isInElimTodo = new Uint8Array(Math.max(boolVar + 1, 2 * this.isInElimTodo.length));
792
+ isInElimTodo.set(this.isInElimTodo);
793
+ this.isInElimTodo = isInElimTodo;
794
+ }
795
+ if (this.isInElimTodo[boolVar]) return;
796
+ this.isInElimTodo[boolVar] = 1;
797
+ this.elimTodo.push(boolVar);
798
+ }
799
+
800
+ resetTodos() {
801
+ this.resetElimTodo();
802
+ this.subTodo.reset();
803
+ this.subBinTodo = [];
804
+ }
805
+
806
+ private resetElimTodo() {
807
+ for (const boolVar of this.elimTodo) this.isInElimTodo[boolVar] = 0;
808
+ this.elimTodo.length = 0;
809
+ }
810
+
811
+ initSearch() {
812
+ this.numCalls = 0;
813
+ }
814
+
815
+ private registerClauses(clauses: number[]) {
816
+ const arena = this.solver.arena;
817
+ clauses.sort((first, second) => arena.size[second] - arena.size[first]);
818
+ for (const clause of clauses) {
819
+ if (arena.isFrozen(clause)) continue;
820
+ this.useList.insert(clause);
821
+ if (arena.isStrengthened(clause)) this.subTodo.insert(clause);
822
+ }
823
+ }
824
+
825
+ private removeClause(clause: number) {
826
+ const arena = this.solver.arena;
827
+ if (arena.wasRemoved(clause)) return;
828
+ for (let index = 0; index < arena.size[clause]; index++)
829
+ this.insertElimTodo(arena.get(clause, index) >> 1);
830
+ this.subTodo.erase(clause);
831
+ arena.setRemoved(clause, true);
832
+ this.isNeedingCleanup = true;
833
+ this.useList.erase(clause);
834
+ }
835
+
836
+ setLearnedClause(clause: number) {
837
+ this.isNeedingCleanup = true;
838
+ this.solver.arena.setLearned(clause, true);
839
+ this.useList.block(clause);
840
+ }
841
+
842
+ setLearnedBinary(first: number, second: number) {
843
+ this.eraseSubBin(first, second, false);
844
+ this.eraseSubBin(second, first, false);
845
+ this.subBinTodo.push(first, (second << 1) | 1, second, (first << 1) | 1);
846
+ }
847
+
848
+ private eraseSubBin(first: number, second: number, isLearned: boolean) {
849
+ const todo = this.subBinTodo;
850
+ const encoded = (second << 1) | (isLearned ? 1 : 0);
851
+ const swapped = (first << 1) | (isLearned ? 1 : 0);
852
+ for (let index = 0; index < todo.length; index += 2) {
853
+ const isEqual =
854
+ (todo[index] === first && todo[index + 1] === encoded) ||
855
+ (todo[index] === second && todo[index + 1] === swapped);
856
+ if (!isEqual) continue;
857
+ todo.splice(index, 2);
858
+ return;
859
+ }
860
+ }
861
+
862
+ private initVisited() {
863
+ this.visited = new Uint8Array(2 * this.solver.numVars());
864
+ }
865
+
866
+ private finalize() {
867
+ this.useList = new UseList(this.solver.arena, 0);
868
+ this.extUseVars.clear();
869
+ this.subTodo.reset();
870
+ this.subBinTodo = [];
871
+ this.resetElimTodo();
872
+ this.visited = new Uint8Array(0);
873
+ this.bsClauses = [];
874
+ this.bsLits = [];
875
+ }
876
+
877
+ private initialize() {
878
+ const solver = this.solver;
879
+ this.isNeedingCleanup = false;
880
+ solver.cleaner.run(true);
881
+ this.lastSubTrailSize = solver.trail.length;
882
+ this.useList = new UseList(solver.arena, solver.numVars());
883
+ solver.ext?.initUseList(this.extUseVars);
884
+ this.subTodo.reset();
885
+ this.subBinTodo.length = 0;
886
+ this.resetElimTodo();
887
+ this.initVisited();
888
+ }
889
+
890
+ run(isLearned: boolean) {
891
+ const solver = this.solver;
892
+ if (solver.isInconsistent) return;
893
+ if (!this.isSubsumption && !this.isBceEnabled() && !this.isElimVarsEnabled()) return;
894
+ this.initialize();
895
+ solver.cleaner.run(true);
896
+ this.isNeedingCleanup = false;
897
+ this.useList = new UseList(solver.arena, solver.numVars());
898
+ this.isLearnedInUseLists = isLearned;
899
+ if (isLearned) this.registerClauses(solver.learned);
900
+ this.registerClauses(solver.clauses);
901
+ if (!isLearned && (this.isBceEnabled() || this.isAteEnabled()))
902
+ new BlockedClauseElim(this, this.blockedClauseLimit).run();
903
+ if (!isLearned) this.numCalls++;
904
+ this.subCounter = this.subsumptionLimit;
905
+ this.elimCounter = this.resLimit;
906
+ this.oldNumElimVars = this.numElimVars;
907
+ for (let boolVar = 0; boolVar < solver.numVars(); boolVar++)
908
+ if (!solver.eliminated[boolVar] && !this.isExternal(boolVar)) this.insertElimTodo(boolVar);
909
+ let count = 0;
910
+ do {
911
+ if (this.isSubsumption) this.subsume();
912
+ if (solver.isInconsistent) return;
913
+ if (!isLearned && this.isElimVarsEnabled()) this.elimVars();
914
+ if (solver.isInconsistent) return;
915
+ if (!this.isSubsumption || this.subCounter < 0) break;
916
+ count++;
917
+ } while (!this.subTodo.isEmpty() && count < 20);
918
+ const isVarsEliminated = this.numElimVars > this.oldNumElimVars;
919
+ if (this.isNeedingCleanup || isVarsEliminated) {
920
+ this.cleanupWatches();
921
+ this.moveClauses(solver.learned, true);
922
+ this.moveClauses(solver.clauses, false);
923
+ this.cleanupClauses(solver.learned, true, isVarsEliminated);
924
+ this.cleanupClauses(solver.clauses, false, isVarsEliminated);
925
+ }
926
+ this.finalize();
927
+ }
928
+
929
+ private cleanupWatches() {
930
+ for (const wlist of this.solver.watches) {
931
+ let next = 0;
932
+ for (let index = 0; index < wlist.size; index++)
933
+ if (wlist.getKind(index) !== WATCH_CLAUSE) wlist.copy(next++, index);
934
+ wlist.setEnd(next);
935
+ }
936
+ }
937
+
938
+ private moveClauses(clauses: number[], isLearned: boolean) {
939
+ const solver = this.solver;
940
+ const arena = solver.arena;
941
+ const size = clauses.length;
942
+ let next = 0;
943
+ for (let index = 0; index < size; index++) {
944
+ const clause = clauses[index];
945
+ if (isLearned && !arena.isLearned(clause)) solver.clauses.push(clause);
946
+ else if (!isLearned && arena.isLearned(clause)) solver.learned.push(clause);
947
+ else clauses[next++] = clause;
948
+ }
949
+ clauses.length = next;
950
+ }
951
+
952
+ private cleanupClauses(clauses: number[], isLearned: boolean, isVarsEliminated: boolean) {
953
+ const solver = this.solver;
954
+ const arena = solver.arena;
955
+ let next = 0;
956
+ for (let index = 0; index < clauses.length; index++) {
957
+ const clause = clauses[index];
958
+ if (arena.wasRemoved(clause)) {
959
+ solver.delClause(clause);
960
+ continue;
961
+ }
962
+ if (isLearned && isVarsEliminated) {
963
+ let isEliminated = false;
964
+ for (let position = 0; position < arena.size[clause] && !isEliminated; position++)
965
+ isEliminated = solver.wasEliminated(arena.get(clause, position) >> 1);
966
+ if (isEliminated) {
967
+ solver.delClause(clause);
968
+ continue;
969
+ }
970
+ }
971
+ const size0 = arena.size[clause];
972
+ if (this.cleanupClause(clause)) {
973
+ solver.delClause(clause);
974
+ continue;
975
+ }
976
+ switch (arena.size[clause]) {
977
+ case 0:
978
+ solver.setConflict();
979
+ for (; index < clauses.length; index++, next++) clauses[next] = clauses[index];
980
+ clauses.length = next;
981
+ return;
982
+ case 1:
983
+ solver.assignUnit(arena.get(clause, 0));
984
+ arena.restore(clause, size0);
985
+ solver.delClause(clause);
986
+ break;
987
+ case 2:
988
+ solver.mkBinClause(arena.get(clause, 0), arena.get(clause, 1), arena.isLearned(clause));
989
+ arena.restore(clause, size0);
990
+ solver.delClause(clause);
991
+ break;
992
+ default:
993
+ solver.shrink(clause, size0, arena.size[clause]);
994
+ clauses[next++] = clause;
995
+ if (!arena.isFrozen(clause)) solver.attachClause(clause);
996
+ }
997
+ }
998
+ clauses.length = next;
999
+ }
1000
+
1001
+ private getMinOccVar(clause: number) {
1002
+ const arena = this.solver.arena;
1003
+ const sizes = this.useList.size;
1004
+ let bestLit = NULL_LITERAL;
1005
+ let best = UINT_MAX;
1006
+ for (let index = 0; index < arena.size[clause]; index++) {
1007
+ const lit = arena.get(clause, index);
1008
+ const count = sizes[lit] + sizes[lit ^ 1];
1009
+ if (count < best) {
1010
+ bestLit = lit;
1011
+ best = count;
1012
+ }
1013
+ }
1014
+ return bestLit >> 1;
1015
+ }
1016
+
1017
+ private isSubsumes1(first: number, second: number) {
1018
+ const arena = this.solver.arena;
1019
+ const visited = this.visited;
1020
+ const secondSize = arena.size[second];
1021
+ for (let index = 0; index < secondSize; index++) visited[arena.get(second, index)] = 1;
1022
+ let isSubsumed = true;
1023
+ let resolventLit = NULL_LITERAL;
1024
+ for (let index = 0; index < arena.size[first]; index++) {
1025
+ const lit = arena.get(first, index);
1026
+ if (visited[lit]) continue;
1027
+ if (resolventLit === NULL_LITERAL && visited[lit ^ 1]) resolventLit = lit ^ 1;
1028
+ else {
1029
+ resolventLit = NULL_LITERAL;
1030
+ isSubsumed = false;
1031
+ break;
1032
+ }
1033
+ }
1034
+ for (let index = 0; index < secondSize; index++) visited[arena.get(second, index)] = 0;
1035
+ this.resolventLit = resolventLit;
1036
+ return isSubsumed;
1037
+ }
1038
+
1039
+ private collectSubsumed1Core(first: number, target: number) {
1040
+ const arena = this.solver.arena;
1041
+ for (const second of this.useList.get(target)) {
1042
+ if (arena.wasRemoved(second)) continue;
1043
+ if (
1044
+ second !== first &&
1045
+ arena.size[first] <= arena.size[second] &&
1046
+ isApproxSubset(arena.approx[first], arena.approx[second])
1047
+ ) {
1048
+ this.subCounter -= arena.size[first] + arena.size[second];
1049
+ if (this.isSubsumes1(first, second)) {
1050
+ this.bsClauses.push(second);
1051
+ this.bsLits.push(this.resolventLit);
1052
+ }
1053
+ }
1054
+ }
1055
+ }
1056
+
1057
+ private backSubsumption1(first: number) {
1058
+ const solver = this.solver;
1059
+ const arena = solver.arena;
1060
+ this.bsClauses.length = 0;
1061
+ this.bsLits.length = 0;
1062
+ const boolVar = this.getMinOccVar(first);
1063
+ this.collectSubsumed1Core(first, 2 * boolVar);
1064
+ this.collectSubsumed1Core(first, 2 * boolVar + 1);
1065
+ for (let index = 0; index < this.bsClauses.length; index++) {
1066
+ const second = this.bsClauses[index];
1067
+ const lit = this.bsLits[index];
1068
+ if (!arena.wasRemoved(second) && lit === NULL_LITERAL) {
1069
+ if (arena.isLearned(first) && !arena.isLearned(second)) arena.setLearned(first, false);
1070
+ this.removeClause(second);
1071
+ } else if (!arena.wasRemoved(second)) {
1072
+ this.elimLit(second, lit);
1073
+ }
1074
+ if (solver.isInconsistent) break;
1075
+ }
1076
+ }
1077
+
1078
+ // tmp_clause::set computes the approximation only when it allocates the clause, so every later
1079
+ // binary is filtered with the approximation of the first one.
1080
+ private setDummy(first: number, second: number, isLearned: boolean) {
1081
+ const arena = this.solver.arena;
1082
+ const previousArena = this.dummyArena;
1083
+ if (previousArena !== arena) {
1084
+ const previous = this.dummy;
1085
+ this.dummyArena = arena;
1086
+ this.dummy = arena.mkClause([first, second], 2, isLearned);
1087
+ if (previousArena !== undefined) arena.approx[this.dummy] = previousArena.approx[previous];
1088
+ return this.dummy;
1089
+ }
1090
+ arena.set(this.dummy, 0, first);
1091
+ arena.set(this.dummy, 1, second);
1092
+ arena.setLearned(this.dummy, isLearned);
1093
+ return this.dummy;
1094
+ }
1095
+
1096
+ private getMinOccVar0(clause: number) {
1097
+ const arena = this.solver.arena;
1098
+ const sizes = this.useList.size;
1099
+ let bestLit = NULL_LITERAL;
1100
+ let best = UINT_MAX;
1101
+ for (let index = 0; index < arena.size[clause]; index++) {
1102
+ const lit = arena.get(clause, index);
1103
+ if (sizes[lit] < best) {
1104
+ bestLit = lit;
1105
+ best = sizes[lit];
1106
+ }
1107
+ }
1108
+ return bestLit;
1109
+ }
1110
+
1111
+ private isSubsumes0(first: number, second: number) {
1112
+ const arena = this.solver.arena;
1113
+ const visited = this.visited;
1114
+ const secondSize = arena.size[second];
1115
+ for (let index = 0; index < secondSize; index++) visited[arena.get(second, index)] = 1;
1116
+ let isSubsumed = true;
1117
+ for (let index = 0; index < arena.size[first] && isSubsumed; index++)
1118
+ isSubsumed = visited[arena.get(first, index)] === 1;
1119
+ for (let index = 0; index < secondSize; index++) visited[arena.get(second, index)] = 0;
1120
+ return isSubsumed;
1121
+ }
1122
+
1123
+ private backSubsumption0(first: number) {
1124
+ const arena = this.solver.arena;
1125
+ this.bsClauses.length = 0;
1126
+ for (const second of this.useList.get(this.getMinOccVar0(first))) {
1127
+ if (arena.wasRemoved(second)) continue;
1128
+ if (
1129
+ second !== first &&
1130
+ arena.size[first] <= arena.size[second] &&
1131
+ isApproxSubset(arena.approx[first], arena.approx[second])
1132
+ ) {
1133
+ this.subCounter -= arena.size[first] + arena.size[second];
1134
+ if (this.isSubsumes0(first, second)) this.bsClauses.push(second);
1135
+ }
1136
+ }
1137
+ for (const second of this.bsClauses) {
1138
+ if (arena.isLearned(first) && !arena.isLearned(second)) arena.setLearned(first, false);
1139
+ this.removeClause(second);
1140
+ }
1141
+ }
1142
+
1143
+ private cleanupClause(clause: number) {
1144
+ const solver = this.solver;
1145
+ const arena = solver.arena;
1146
+ let isSatisfied = false;
1147
+ const size = arena.size[clause];
1148
+ let next = 0;
1149
+ for (let index = 0; index < size; index++) {
1150
+ const value = solver.value(arena.get(clause, index));
1151
+ if (value === L_FALSE) {
1152
+ this.isNeedingCleanup = true;
1153
+ continue;
1154
+ }
1155
+ if (value === L_TRUE) isSatisfied = true;
1156
+ if (index !== next) arena.swap(clause, next, index);
1157
+ next++;
1158
+ }
1159
+ if (next < size && !isSatisfied) {
1160
+ if (next > 2) solver.shrink(clause, size, next);
1161
+ else arena.shrink(clause, next);
1162
+ }
1163
+ return isSatisfied;
1164
+ }
1165
+
1166
+ private cleanupLits(lits: number[]) {
1167
+ const solver = this.solver;
1168
+ let next = 0;
1169
+ for (let index = 0; index < lits.length; index++) {
1170
+ const lit = lits[index];
1171
+ const value = solver.value(lit);
1172
+ if (value === L_TRUE) return true;
1173
+ if (value === L_FALSE) continue;
1174
+ if (index !== next) {
1175
+ lits[index] = lits[next];
1176
+ lits[next] = lit;
1177
+ }
1178
+ next++;
1179
+ }
1180
+ lits.length = next;
1181
+ return false;
1182
+ }
1183
+
1184
+ private propagateUnit(lit: number) {
1185
+ const solver = this.solver;
1186
+ const arena = solver.arena;
1187
+ const oldTrailSize = solver.trail.length;
1188
+ const numClauses = solver.clauses.length;
1189
+ solver.assignScoped(lit);
1190
+ solver.propagate(false);
1191
+ if (solver.isInconsistent) return;
1192
+ const newTrailSize = solver.trail.length;
1193
+ for (let index = oldTrailSize; index < newTrailSize; index++) {
1194
+ const trueLit = solver.trail[index];
1195
+ for (const clause of this.useList.get(trueLit ^ 1))
1196
+ if (!arena.wasRemoved(clause)) this.subTodo.insert(clause);
1197
+ for (const clause of this.useList.get(trueLit))
1198
+ if (!arena.wasRemoved(clause)) this.removeClause(clause);
1199
+ this.useList.reset(trueLit);
1200
+ }
1201
+ for (let index = numClauses; index < solver.clauses.length; index++)
1202
+ this.useList.insert(solver.clauses[index]);
1203
+ }
1204
+
1205
+ private elimLit(clause: number, lit: number) {
1206
+ const solver = this.solver;
1207
+ const arena = solver.arena;
1208
+ this.isNeedingCleanup = true;
1209
+ this.insertElimTodo(lit >> 1);
1210
+ arena.elim(clause, lit);
1211
+ this.useList.eraseNotRemoved(lit, clause);
1212
+ this.subCounter -= Math.trunc(this.useList.size[lit] / 2);
1213
+ const size0 = arena.size[clause];
1214
+ if (this.cleanupClause(clause)) {
1215
+ this.removeClause(clause);
1216
+ return;
1217
+ }
1218
+ switch (arena.size[clause]) {
1219
+ case 0:
1220
+ solver.setConflict();
1221
+ break;
1222
+ case 1:
1223
+ arena.restore(clause, size0);
1224
+ this.propagateUnit(arena.get(clause, 0));
1225
+ break;
1226
+ case 2: {
1227
+ arena.restore(clause, size0);
1228
+ const first = arena.get(clause, 0);
1229
+ const second = arena.get(clause, 1);
1230
+ const isLearned = arena.isLearned(clause);
1231
+ solver.mkBinClause(first, second, isLearned);
1232
+ this.subBinTodo.push(first, (second << 1) | (isLearned ? 1 : 0));
1233
+ this.removeClause(clause);
1234
+ break;
1235
+ }
1236
+ default:
1237
+ this.subTodo.insert(clause);
1238
+ }
1239
+ }
1240
+
1241
+ private subsumeWithBinaries() {
1242
+ const solver = this.solver;
1243
+ const init = solver.rand.next();
1244
+ const numLits = solver.watches.length;
1245
+ for (let index = 0; index < numLits; index++) {
1246
+ const litIndex = (index + init) % numLits;
1247
+ const wlist = solver.watches[litIndex];
1248
+ const lit = litIndex ^ 1;
1249
+ for (let position = 0; position < wlist.size; position++) {
1250
+ if (!wlist.isBinary(position) || wlist.isLearned(position)) continue;
1251
+ const other = wlist.getLiteral(position);
1252
+ if (lit >= other) continue;
1253
+ this.backSubsumption1(this.setDummy(lit, other, false));
1254
+ if (solver.isInconsistent) return;
1255
+ }
1256
+ if (this.subCounter < 0) break;
1257
+ }
1258
+ }
1259
+
1260
+ private markAsNotLearnedCore(wlist: WatchList, lit: number) {
1261
+ for (let index = 0; index < wlist.size; index++)
1262
+ if (wlist.isBinary(index) && wlist.getLiteral(index) === lit && wlist.isLearned(index)) {
1263
+ wlist.setLearned(index, false);
1264
+ return;
1265
+ }
1266
+ }
1267
+
1268
+ private elimDupBins() {
1269
+ const solver = this.solver;
1270
+ for (const wlist of solver.watches) {
1271
+ solver.checkpoint();
1272
+ const size = wlist.size;
1273
+ const order = Array.from({ length: size }, (_value, index) => index);
1274
+ const getRank = (index: number) =>
1275
+ wlist.isBinary(index)
1276
+ ? 2 * wlist.getLiteral(index) + (wlist.isLearned(index) ? 1 : 0)
1277
+ : Number.MAX_SAFE_INTEGER;
1278
+ order.sort((first, second) => getRank(first) - getRank(second));
1279
+ const data = wlist.data.slice(0, 2 * size);
1280
+ let next = 0;
1281
+ let lastLit = NULL_LITERAL;
1282
+ for (const index of order) {
1283
+ const val1 = data[2 * index];
1284
+ const val2 = data[2 * index + 1];
1285
+ if ((val2 & 3) === 0) {
1286
+ if (val1 === lastLit) continue;
1287
+ lastLit = val1;
1288
+ }
1289
+ wlist.data[2 * next] = val1;
1290
+ wlist.data[2 * next + 1] = val2;
1291
+ next++;
1292
+ }
1293
+ wlist.setEnd(next);
1294
+ }
1295
+ }
1296
+
1297
+ private subsume() {
1298
+ const solver = this.solver;
1299
+ const arena = solver.arena;
1300
+ this.elimDupBins();
1301
+ this.subsumeWithBinaries();
1302
+ for (;;) {
1303
+ this.subCounter -= this.subBinTodo.length / 2;
1304
+ while (this.subBinTodo.length > 0) {
1305
+ solver.checkpoint();
1306
+ const encoded = this.subBinTodo[this.subBinTodo.length - 1];
1307
+ const first = this.subBinTodo[this.subBinTodo.length - 2];
1308
+ this.subBinTodo.length -= 2;
1309
+ const isLearned = (encoded & 1) === 1;
1310
+ const dummy = this.setDummy(first, encoded >> 1, isLearned);
1311
+ this.backSubsumption1(dummy);
1312
+ if (isLearned && !arena.isLearned(dummy)) {
1313
+ this.markAsNotLearnedCore(solver.watches[first ^ 1], encoded >> 1);
1314
+ this.markAsNotLearnedCore(solver.watches[(encoded >> 1) ^ 1], first);
1315
+ }
1316
+ }
1317
+ solver.checkpoint();
1318
+ if (this.subTodo.isEmpty()) {
1319
+ this.lastSubTrailSize = solver.trail.length;
1320
+ break;
1321
+ }
1322
+ if (this.subCounter < 0) break;
1323
+ const clause = this.subTodo.eraseLast();
1324
+ arena.unmarkStrengthened(clause);
1325
+ this.subCounter--;
1326
+ if (solver.trail.length > this.lastSubTrailSize) {
1327
+ const size0 = arena.size[clause];
1328
+ if (this.cleanupClause(clause)) {
1329
+ this.removeClause(clause);
1330
+ continue;
1331
+ }
1332
+ const size = arena.size[clause];
1333
+ if (size === 0) {
1334
+ solver.setConflict();
1335
+ return;
1336
+ }
1337
+ if (size === 1) {
1338
+ arena.restore(clause, size0);
1339
+ this.propagateUnit(arena.get(clause, 0));
1340
+ continue;
1341
+ }
1342
+ if (size === 2) {
1343
+ const first = arena.get(clause, 0);
1344
+ const second = arena.get(clause, 1);
1345
+ const isLearned = arena.isLearned(clause);
1346
+ solver.mkBinClause(first, second, isLearned);
1347
+ this.subBinTodo.push(first, (second << 1) | (isLearned ? 1 : 0));
1348
+ arena.restore(clause, size0);
1349
+ this.removeClause(clause);
1350
+ continue;
1351
+ }
1352
+ }
1353
+ this.backSubsumption1(clause);
1354
+ }
1355
+ }
1356
+
1357
+ private orderVarsForElim() {
1358
+ const solver = this.solver;
1359
+ const sizes = this.useList.size;
1360
+ const vars: number[] = [];
1361
+ const costs: number[] = [];
1362
+ for (const boolVar of this.elimTodo) {
1363
+ if (this.isExternal(boolVar)) continue;
1364
+ if (solver.wasEliminated(boolVar)) continue;
1365
+ if (solver.valueVar(boolVar) !== L_UNDEF) continue;
1366
+ const numPos = sizes[2 * boolVar];
1367
+ const numNeg = sizes[2 * boolVar + 1];
1368
+ const numBinPos = solver.watches[2 * boolVar + 1].numNonlearnedBin();
1369
+ const numBinNeg = solver.watches[2 * boolVar].numNonlearnedBin();
1370
+ costs[boolVar] =
1371
+ (Math.imul(2 * numPos, numNeg) +
1372
+ Math.imul(numPos, numBinNeg) +
1373
+ Math.imul(numNeg, numBinPos)) >>>
1374
+ 0;
1375
+ vars.push(boolVar);
1376
+ }
1377
+ this.resetElimTodo();
1378
+ return vars.sort((first, second) => costs[first] - costs[second]);
1379
+ }
1380
+
1381
+ private collectClauses(lit: number, wrappers: number[]) {
1382
+ const solver = this.solver;
1383
+ const arena = solver.arena;
1384
+ for (const clause of this.useList.get(lit))
1385
+ if (!arena.isLearned(clause) && !arena.wasRemoved(clause))
1386
+ wrappers.push(clause, NULL_LITERAL);
1387
+ const wlist = solver.watches[lit ^ 1];
1388
+ for (let index = 0; index < wlist.size; index++)
1389
+ if (wlist.isBinary(index) && !wlist.isLearned(index))
1390
+ wrappers.push(lit, wlist.getLiteral(index));
1391
+ }
1392
+
1393
+ private getWrapperSize(first: number, second: number) {
1394
+ return second === NULL_LITERAL ? this.solver.arena.size[first] : 2;
1395
+ }
1396
+
1397
+ private getWrapperLit(first: number, second: number, index: number) {
1398
+ if (second === NULL_LITERAL) return this.solver.arena.get(first, index);
1399
+ return index === 0 ? first : second;
1400
+ }
1401
+
1402
+ private isWrapperRemoved(first: number, second: number) {
1403
+ return second === NULL_LITERAL && this.solver.arena.wasRemoved(first);
1404
+ }
1405
+
1406
+ private isWrapperContaining(first: number, second: number, lit: number) {
1407
+ const size = this.getWrapperSize(first, second);
1408
+ for (let index = 0; index < size; index++)
1409
+ if (this.getWrapperLit(first, second, index) === lit) return true;
1410
+ return false;
1411
+ }
1412
+
1413
+ private getWrapperLits(first: number, second: number) {
1414
+ return second === NULL_LITERAL ? this.solver.arena.getLits(first) : [first, second];
1415
+ }
1416
+
1417
+ private resolve(
1418
+ first1: number,
1419
+ second1: number,
1420
+ first2: number,
1421
+ second2: number,
1422
+ lit: number,
1423
+ result: number[],
1424
+ ) {
1425
+ const visited = this.visited;
1426
+ const notLit = lit ^ 1;
1427
+ if (this.isWrapperRemoved(first1, second1) && !this.isWrapperContaining(first1, second1, lit))
1428
+ return false;
1429
+ if (
1430
+ this.isWrapperRemoved(first2, second2) &&
1431
+ !this.isWrapperContaining(first2, second2, notLit)
1432
+ )
1433
+ return false;
1434
+ let isResolvent = true;
1435
+ const size1 = this.getWrapperSize(first1, second1);
1436
+ const size2 = this.getWrapperSize(first2, second2);
1437
+ this.elimCounter -= size1 + size2;
1438
+ for (let index = 0; index < size1; index++) {
1439
+ const lit1 = this.getWrapperLit(first1, second1, index);
1440
+ if (lit1 === lit) continue;
1441
+ visited[lit1] = 1;
1442
+ result.push(lit1);
1443
+ }
1444
+ for (let index = 0; index < size2; index++) {
1445
+ const lit2 = this.getWrapperLit(first2, second2, index);
1446
+ if (lit2 === notLit) continue;
1447
+ if (visited[lit2 ^ 1]) {
1448
+ isResolvent = false;
1449
+ break;
1450
+ }
1451
+ if (!visited[lit2]) result.push(lit2);
1452
+ }
1453
+ for (let index = 0; index < size1; index++)
1454
+ visited[this.getWrapperLit(first1, second1, index)] = 0;
1455
+ return isResolvent;
1456
+ }
1457
+
1458
+ private removeBinClauses(lit: number) {
1459
+ const wlist = this.solver.watches[lit ^ 1];
1460
+ for (let index = 0; index < wlist.size; index++) {
1461
+ if (!wlist.isBinary(index)) continue;
1462
+ const other = wlist.getLiteral(index);
1463
+ const wlist2 = this.solver.watches[other ^ 1];
1464
+ let next = 0;
1465
+ for (let position = 0; position < wlist2.size; position++) {
1466
+ if (wlist2.isBinary(position) && wlist2.getLiteral(position) === lit) {
1467
+ this.eraseSubBin(other, lit, wlist2.isLearned(position));
1468
+ continue;
1469
+ }
1470
+ wlist2.copy(next++, position);
1471
+ }
1472
+ wlist2.setEnd(next);
1473
+ this.eraseSubBin(lit, other, wlist.isLearned(index));
1474
+ }
1475
+ wlist.finalize();
1476
+ }
1477
+
1478
+ private removeClauses(lit: number) {
1479
+ const arena = this.solver.arena;
1480
+ for (const clause of this.useList.get(lit)) {
1481
+ if (arena.wasRemoved(clause)) continue;
1482
+ arena.setRemoved(clause, true);
1483
+ this.useList.erase(clause, lit);
1484
+ this.subTodo.erase(clause);
1485
+ this.isNeedingCleanup = true;
1486
+ }
1487
+ }
1488
+
1489
+ private tryEliminate(boolVar: number) {
1490
+ const solver = this.solver;
1491
+ const arena = solver.arena;
1492
+ if (solver.valueVar(boolVar) !== L_UNDEF) return false;
1493
+ const posLit = 2 * boolVar;
1494
+ const negLit = 2 * boolVar + 1;
1495
+ const numBinPos = solver.watches[negLit].numNonlearnedBin();
1496
+ const numBinNeg = solver.watches[posLit].numNonlearnedBin();
1497
+ const numPos = this.useList.numIrredundant(posLit) + numBinPos;
1498
+ const numNeg = this.useList.numIrredundant(negLit) + numBinNeg;
1499
+ if (numPos >= this.resOccCutoff && numNeg >= this.resOccCutoff) return false;
1500
+ let beforeLits = numBinPos * 2 + numBinNeg * 2;
1501
+ for (const clause of this.useList.get(posLit))
1502
+ if (!arena.wasRemoved(clause) && !arena.isLearned(clause)) beforeLits += arena.size[clause];
1503
+ for (const clause of this.useList.get(negLit))
1504
+ if (!arena.wasRemoved(clause) && !arena.isLearned(clause)) beforeLits += arena.size[clause];
1505
+ const numClauses = solver.clauses.length;
1506
+ if (
1507
+ numPos >= this.resOccCutoff3 &&
1508
+ numNeg >= this.resOccCutoff3 &&
1509
+ beforeLits > this.resLitCutoff3 &&
1510
+ numClauses > this.resClsCutoff2
1511
+ )
1512
+ return false;
1513
+ if (
1514
+ numPos >= this.resOccCutoff2 &&
1515
+ numNeg >= this.resOccCutoff2 &&
1516
+ beforeLits > this.resLitCutoff2 &&
1517
+ numClauses > this.resClsCutoff1 &&
1518
+ numClauses <= this.resClsCutoff2
1519
+ )
1520
+ return false;
1521
+ if (
1522
+ numPos >= this.resOccCutoff1 &&
1523
+ numNeg >= this.resOccCutoff1 &&
1524
+ beforeLits > this.resLitCutoff1 &&
1525
+ numClauses <= this.resClsCutoff1
1526
+ )
1527
+ return false;
1528
+ const posClauses = this.posClauses;
1529
+ const negClauses = this.negClauses;
1530
+ const newClause = this.newClause;
1531
+ posClauses.length = 0;
1532
+ negClauses.length = 0;
1533
+ this.collectClauses(posLit, posClauses);
1534
+ this.collectClauses(negLit, negClauses);
1535
+ const beforeClauses = numPos + numNeg;
1536
+ let afterClauses = 0;
1537
+ for (let first = 0; first < posClauses.length; first += 2)
1538
+ for (let second = 0; second < negClauses.length; second += 2) {
1539
+ newClause.length = 0;
1540
+ if (
1541
+ this.resolve(
1542
+ posClauses[first],
1543
+ posClauses[first + 1],
1544
+ negClauses[second],
1545
+ negClauses[second + 1],
1546
+ posLit,
1547
+ newClause,
1548
+ )
1549
+ ) {
1550
+ afterClauses++;
1551
+ if (afterClauses > beforeClauses) return false;
1552
+ }
1553
+ }
1554
+ this.elimCounter -= numPos * numNeg + beforeLits;
1555
+ this.elimCounter -= numPos * numNeg + beforeLits;
1556
+ const entry = solver.mc.mk(MC_ELIM_VAR, boolVar);
1557
+ for (let first = 0; first < posClauses.length; first += 2)
1558
+ solver.mc.insert(entry, this.getWrapperLits(posClauses[first], posClauses[first + 1]));
1559
+ for (let second = 0; second < negClauses.length; second += 2)
1560
+ solver.mc.insert(entry, this.getWrapperLits(negClauses[second], negClauses[second + 1]));
1561
+ solver.setEliminated(boolVar, true);
1562
+ this.elimCounter -= numPos * numNeg + beforeLits;
1563
+ for (let first = 0; first < posClauses.length; first += 2) {
1564
+ const first1 = posClauses[first];
1565
+ const second1 = posClauses[first + 1];
1566
+ if (
1567
+ this.isWrapperRemoved(first1, second1) &&
1568
+ !this.isWrapperContaining(first1, second1, posLit)
1569
+ )
1570
+ continue;
1571
+ for (let second = 0; second < negClauses.length; second += 2) {
1572
+ newClause.length = 0;
1573
+ if (
1574
+ !this.resolve(
1575
+ first1,
1576
+ second1,
1577
+ negClauses[second],
1578
+ negClauses[second + 1],
1579
+ posLit,
1580
+ newClause,
1581
+ )
1582
+ )
1583
+ continue;
1584
+ if (this.cleanupLits(newClause)) continue;
1585
+ if (newClause.length === 0) solver.setConflict();
1586
+ else if (newClause.length === 1) this.propagateUnit(newClause[0]);
1587
+ else if (newClause.length === 2) {
1588
+ solver.mkBinClause(newClause[0], newClause[1], false);
1589
+ this.backSubsumption1(this.setDummy(newClause[0], newClause[1], false));
1590
+ } else {
1591
+ const clause = solver.arena.mkClause(newClause, newClause.length, false);
1592
+ solver.clauses.push(clause);
1593
+ this.useList.insert(clause);
1594
+ if (this.subCounter > 0) this.backSubsumption1(clause);
1595
+ else this.backSubsumption0(clause);
1596
+ }
1597
+ if (solver.isInconsistent) return true;
1598
+ }
1599
+ }
1600
+ this.removeBinClauses(posLit);
1601
+ this.removeBinClauses(negLit);
1602
+ this.removeClauses(posLit);
1603
+ this.removeClauses(negLit);
1604
+ this.useList.reset(posLit);
1605
+ this.useList.reset(negLit);
1606
+ return true;
1607
+ }
1608
+
1609
+ private elimVars() {
1610
+ if (!this.isElimVarsEnabled()) return;
1611
+ for (const boolVar of this.orderVarsForElim()) {
1612
+ this.solver.checkpoint();
1613
+ if (this.elimCounter < 0) break;
1614
+ if (this.isExternal(boolVar)) continue;
1615
+ if (this.tryEliminate(boolVar)) this.numElimVars++;
1616
+ }
1617
+ }
1618
+ }