tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.6b2a6741a

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 (551) 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 +45 -41
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +5 -1
  8. package/dist/index.d.ts +5 -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 +44 -43
  18. package/dist/tlapm.cjs +1 -1
  19. package/dist/tlapm.js +1 -1
  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 +4 -3
  26. package/src/bags.ts +46 -28
  27. package/src/check-trace.ts +2 -16
  28. package/src/check.ts +349 -91
  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/cli/xml-exporter.ts +1 -1
  36. package/src/codegen.ts +9 -5
  37. package/src/dependencies.ts +72 -11
  38. package/src/dfid.ts +9 -2
  39. package/src/environment.ts +65 -36
  40. package/src/errors.ts +38 -3
  41. package/src/evaluate.ts +92 -32
  42. package/src/exit-codes.ts +5 -2
  43. package/src/instances.ts +5 -5
  44. package/src/java-overrides.ts +2 -2
  45. package/src/levels.ts +138 -90
  46. package/src/lexer.ts +5 -3
  47. package/src/liveness-checker.ts +572 -204
  48. package/src/liveness.ts +47 -32
  49. package/src/obligations/action.ts +10 -6
  50. package/src/obligations/anonymize.ts +33 -14
  51. package/src/obligations/enabled-axioms.ts +218 -0
  52. package/src/obligations/equality.ts +1 -3
  53. package/src/obligations/expression.ts +18 -6
  54. package/src/obligations/format.ts +0 -2
  55. package/src/obligations/generate.ts +22 -17
  56. package/src/obligations/index.ts +37 -7
  57. package/src/obligations/levels.ts +24 -11
  58. package/src/obligations/module.ts +1 -3
  59. package/src/obligations/normalize.ts +25 -17
  60. package/src/obligations/operators.ts +0 -2
  61. package/src/obligations/pragma.ts +53 -16
  62. package/src/obligations/printer.ts +48 -18
  63. package/src/obligations/proof.ts +3 -2
  64. package/src/obligations/regroup.ts +0 -2
  65. package/src/obligations/simplify.ts +17 -7
  66. package/src/obligations/source.ts +71 -17
  67. package/src/obligations/subexpression.ts +45 -18
  68. package/src/obligations/substitution.ts +1 -3
  69. package/src/obligations/temporal.ts +0 -2
  70. package/src/obligations/tuples.ts +0 -2
  71. package/src/parallel-worker.ts +8 -2
  72. package/src/parallel.ts +7 -2
  73. package/src/parser.ts +664 -287
  74. package/src/pretty-print.ts +1 -1
  75. package/src/prover/deciders.ts +11 -8
  76. package/src/prover/isabelle/decide.ts +3 -25
  77. package/src/prover/isabelle/encode.ts +71 -41
  78. package/src/prover/isabelle/isar/attrib.ts +250 -0
  79. package/src/prover/isabelle/isar/context.ts +335 -0
  80. package/src/prover/isabelle/isar/induct.ts +382 -0
  81. package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
  82. package/src/prover/isabelle/isar/method.ts +506 -198
  83. package/src/prover/isabelle/isar/proof.ts +570 -14
  84. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  85. package/src/prover/isabelle/isar/theory.ts +479 -69
  86. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  87. package/src/prover/isabelle/isar/type-check.ts +83 -8
  88. package/src/prover/isabelle/provers/blast/blast.ts +0 -2
  89. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  90. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  91. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  92. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  93. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  94. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  95. package/src/prover/isabelle/provers/classical.ts +45 -20
  96. package/src/prover/isabelle/provers/hypsubst.ts +2 -4
  97. package/src/prover/isabelle/pure/bicompose.ts +0 -2
  98. package/src/prover/isabelle/pure/consts.ts +0 -2
  99. package/src/prover/isabelle/pure/conv.ts +0 -2
  100. package/src/prover/isabelle/pure/drule.ts +63 -4
  101. package/src/prover/isabelle/pure/envir.ts +0 -2
  102. package/src/prover/isabelle/pure/goal.ts +1 -3
  103. package/src/prover/isabelle/pure/logic.ts +0 -2
  104. package/src/prover/isabelle/pure/name.ts +0 -2
  105. package/src/prover/isabelle/pure/net.ts +0 -2
  106. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  107. package/src/prover/isabelle/pure/pattern.ts +0 -2
  108. package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
  109. package/src/prover/isabelle/pure/rewriter.ts +4 -11
  110. package/src/prover/isabelle/pure/search.ts +0 -2
  111. package/src/prover/isabelle/pure/seq.ts +0 -2
  112. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  113. package/src/prover/isabelle/pure/table.ts +0 -2
  114. package/src/prover/isabelle/pure/tactic.ts +0 -2
  115. package/src/prover/isabelle/pure/tactical.ts +0 -2
  116. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  117. package/src/prover/isabelle/pure/term.ts +3 -5
  118. package/src/prover/isabelle/pure/thm.ts +0 -2
  119. package/src/prover/isabelle/pure/type.ts +0 -2
  120. package/src/prover/isabelle/pure/unify.ts +0 -2
  121. package/src/prover/isabelle/pure/variable.ts +0 -2
  122. package/src/prover/isabelle/tla/classical-setup.ts +1 -2
  123. package/src/prover/isabelle/tla/context.ts +51 -9
  124. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  125. package/src/prover/isabelle/tla/logic.ts +40 -1
  126. package/src/prover/isabelle/tla/simpdata.ts +0 -2
  127. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  128. package/src/prover/ocaml.ts +4 -1
  129. package/src/prover/prep/action.ts +19 -12
  130. package/src/prover/prep/enabled-axioms.ts +11 -2
  131. package/src/prover/prep/md5.ts +26 -29
  132. package/src/prover/prep/methods.ts +159 -50
  133. package/src/prover/prep/normalize.ts +38 -9
  134. package/src/prover/prove.ts +343 -65
  135. package/src/prover/ptl/decide.ts +95 -50
  136. package/src/prover/ptl/encode.ts +2 -3
  137. package/src/prover/ptl/tableau.ts +28 -2
  138. package/src/prover/smt/arithmetic.ts +310 -0
  139. package/src/prover/smt/axioms.ts +12 -8
  140. package/src/prover/smt/context.ts +42 -6
  141. package/src/prover/smt/data.ts +191 -84
  142. package/src/prover/smt/encode.ts +122 -43
  143. package/src/prover/smt/extensionality.ts +5 -3
  144. package/src/prover/smt/flatten.ts +4 -6
  145. package/src/prover/smt/format.ts +28 -4
  146. package/src/prover/smt/instances.ts +7 -1
  147. package/src/prover/smt/layout.ts +91 -0
  148. package/src/prover/smt/rewrite.ts +483 -116
  149. package/src/prover/smt/simplify.ts +441 -0
  150. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  151. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  152. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  153. package/src/prover/smt/solver/act-cache.ts +0 -1
  154. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  155. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  156. package/src/prover/smt/solver/aig.ts +889 -0
  157. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  158. package/src/prover/smt/solver/arith-terms.ts +121 -0
  159. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  160. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  161. package/src/prover/smt/solver/asserted-formulas.ts +93 -15
  162. package/src/prover/smt/solver/ast-lt.ts +165 -11
  163. package/src/prover/smt/solver/ast-util.ts +160 -2
  164. package/src/prover/smt/solver/ast.ts +1449 -41
  165. package/src/prover/smt/solver/auf-solver.ts +0 -1
  166. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  167. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  168. package/src/prover/smt/solver/bound-manager.ts +196 -0
  169. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  170. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  171. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  172. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  173. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  174. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  175. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  176. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  177. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  178. package/src/prover/smt/solver/card2bv.ts +109 -0
  179. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  180. package/src/prover/smt/solver/cg-table.ts +39 -25
  181. package/src/prover/smt/solver/check-logic.ts +330 -0
  182. package/src/prover/smt/solver/clause.ts +0 -1
  183. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  184. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  185. package/src/prover/smt/solver/context.ts +533 -114
  186. package/src/prover/smt/solver/ctx-simplify.ts +21 -12
  187. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  188. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  189. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  190. package/src/prover/smt/solver/demodulator.ts +786 -0
  191. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  192. package/src/prover/smt/solver/der.ts +38 -10
  193. package/src/prover/smt/solver/diff-neq.ts +205 -0
  194. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  195. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  196. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  197. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  198. package/src/prover/smt/solver/e-matching.ts +6 -7
  199. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  200. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  201. package/src/prover/smt/solver/enode.ts +100 -3
  202. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  203. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  204. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  205. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  206. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  207. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  208. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  209. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  210. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  211. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  212. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  213. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  214. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  215. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  216. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  217. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  218. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  219. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  220. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  221. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  222. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  223. package/src/prover/smt/solver/expr-ref.ts +0 -1
  224. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  225. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  226. package/src/prover/smt/solver/factor.ts +163 -0
  227. package/src/prover/smt/solver/fd-solver.ts +267 -0
  228. package/src/prover/smt/solver/fingerprints.ts +15 -15
  229. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  230. package/src/prover/smt/solver/flat-literals.ts +0 -1
  231. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  232. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  233. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  234. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  235. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  236. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  237. package/src/prover/smt/solver/goal.ts +177 -15
  238. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  239. package/src/prover/smt/solver/guard-set.ts +219 -0
  240. package/src/prover/smt/solver/hash.ts +0 -1
  241. package/src/prover/smt/solver/hashtable.ts +30 -16
  242. package/src/prover/smt/solver/inf-eps.ts +63 -0
  243. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  244. package/src/prover/smt/solver/internalizer.ts +109 -36
  245. package/src/prover/smt/solver/lackr.ts +381 -0
  246. package/src/prover/smt/solver/lbool.ts +0 -1
  247. package/src/prover/smt/solver/lia2card.ts +268 -0
  248. package/src/prover/smt/solver/lia2pb.ts +154 -0
  249. package/src/prover/smt/solver/literal.ts +0 -1
  250. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  251. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  252. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  253. package/src/prover/smt/solver/lp/containers.ts +7 -2
  254. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  255. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  256. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  257. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  258. package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
  259. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  260. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  261. package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
  262. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  263. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  264. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  265. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  266. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  267. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  268. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  269. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  270. package/src/prover/smt/solver/lp/nex.ts +2 -2
  271. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  272. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  273. package/src/prover/smt/solver/lp/nla-core.ts +66 -11
  274. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  275. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  276. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  277. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  278. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  279. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  280. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  281. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  282. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  283. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  284. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  285. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  287. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  288. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  289. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  290. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  291. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  292. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  293. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  294. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  295. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  296. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  297. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  298. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  299. package/src/prover/smt/solver/macro-finder.ts +530 -0
  300. package/src/prover/smt/solver/mam-compiler.ts +118 -88
  301. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  302. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  303. package/src/prover/smt/solver/max-cliques.ts +105 -0
  304. package/src/prover/smt/solver/maxcore.ts +309 -0
  305. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  306. package/src/prover/smt/solver/maxlex.ts +115 -0
  307. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  308. package/src/prover/smt/solver/maxsmt.ts +92 -0
  309. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  310. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  311. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  312. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  313. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  314. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  315. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  316. package/src/prover/smt/solver/model-checker.ts +17 -26
  317. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  318. package/src/prover/smt/solver/model-finder.ts +0 -1
  319. package/src/prover/smt/solver/model-generator.ts +59 -30
  320. package/src/prover/smt/solver/model-macro-solver.ts +38 -27
  321. package/src/prover/smt/solver/model-printer.ts +214 -0
  322. package/src/prover/smt/solver/mpf.ts +709 -0
  323. package/src/prover/smt/solver/mus.ts +50 -0
  324. package/src/prover/smt/solver/muz/dl-context.ts +410 -0
  325. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  326. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  327. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  328. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  329. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  330. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  331. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  332. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  333. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  334. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  335. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  336. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  337. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  338. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  339. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  340. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  341. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  342. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  343. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  344. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  345. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  346. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  347. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  348. package/src/prover/smt/solver/nlqsat.ts +484 -0
  349. package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
  350. package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
  351. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  352. package/src/prover/smt/solver/nlsat/explain.ts +424 -211
  353. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  354. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
  355. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  356. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
  357. package/src/prover/smt/solver/nlsat/solver.ts +282 -69
  358. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  359. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  360. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  361. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
  362. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  363. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  364. package/src/prover/smt/solver/nnf.ts +105 -23
  365. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  366. package/src/prover/smt/solver/occf.ts +97 -0
  367. package/src/prover/smt/solver/opt-context.ts +792 -0
  368. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  369. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  370. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  371. package/src/prover/smt/solver/opt-solver.ts +311 -0
  372. package/src/prover/smt/solver/opt-value.ts +55 -0
  373. package/src/prover/smt/solver/optsmt.ts +692 -0
  374. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  375. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  376. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  377. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  378. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  379. package/src/prover/smt/solver/probes.ts +511 -0
  380. package/src/prover/smt/solver/propagate-values.ts +37 -21
  381. package/src/prover/smt/solver/proto-model.ts +650 -17
  382. package/src/prover/smt/solver/pull-quant.ts +28 -12
  383. package/src/prover/smt/solver/purify-arith.ts +632 -0
  384. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  385. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  386. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  387. package/src/prover/smt/solver/qe-lite.ts +37 -17
  388. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  389. package/src/prover/smt/solver/qe.ts +1499 -0
  390. package/src/prover/smt/solver/qel.ts +25 -0
  391. package/src/prover/smt/solver/qi-queue.ts +0 -1
  392. package/src/prover/smt/solver/qsat.ts +814 -0
  393. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  394. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  395. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
  396. package/src/prover/smt/solver/quantifier-manager.ts +25 -24
  397. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  398. package/src/prover/smt/solver/random-gen.ts +0 -1
  399. package/src/prover/smt/solver/rational.ts +45 -1
  400. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  401. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  402. package/src/prover/smt/solver/reduce-args.ts +225 -0
  403. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  404. package/src/prover/smt/solver/ref-vector.ts +0 -1
  405. package/src/prover/smt/solver/relevancy.ts +1 -2
  406. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  407. package/src/prover/smt/solver/rewriter.ts +475 -36
  408. package/src/prover/smt/solver/rlimit.ts +38 -2
  409. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  410. package/src/prover/smt/solver/sat/big.ts +177 -0
  411. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  412. package/src/prover/smt/solver/sat/clause.ts +203 -0
  413. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  414. package/src/prover/smt/solver/sat/config.ts +122 -0
  415. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  416. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  417. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  418. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  419. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  420. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  421. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  422. package/src/prover/smt/solver/sat/probing.ts +170 -0
  423. package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
  424. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  425. package/src/prover/smt/solver/sat/scc.ts +142 -0
  426. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  427. package/src/prover/smt/solver/sat/solver.ts +2105 -0
  428. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  429. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  430. package/src/prover/smt/solver/search-tree.ts +284 -0
  431. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  432. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  433. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  434. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  435. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  436. package/src/prover/smt/solver/seq-factory.ts +89 -0
  437. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  438. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  439. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  440. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  441. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  442. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  443. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  444. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  445. package/src/prover/smt/solver/seq-subset.ts +165 -0
  446. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  447. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  448. package/src/prover/smt/solver/smt-kernel.ts +90 -0
  449. package/src/prover/smt/solver/smt-logics.ts +66 -0
  450. package/src/prover/smt/solver/smt-setup.ts +544 -0
  451. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  452. package/src/prover/smt/solver/smtlib-parser.ts +3228 -327
  453. package/src/prover/smt/solver/smtlib-script.ts +1843 -0
  454. package/src/prover/smt/solver/solve-eqs.ts +923 -0
  455. package/src/prover/smt/solver/solver.ts +113 -22
  456. package/src/prover/smt/solver/static-features.ts +314 -0
  457. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  458. package/src/prover/smt/solver/tactic.ts +2012 -0
  459. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  460. package/src/prover/smt/solver/theory-array.ts +1240 -0
  461. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  462. package/src/prover/smt/solver/theory-char.ts +355 -0
  463. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  464. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  465. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  466. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  467. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
  468. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
  469. package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
  470. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  471. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
  472. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  473. package/src/prover/smt/solver/theory-lra.ts +188 -2
  474. package/src/prover/smt/solver/theory-pb.ts +933 -0
  475. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  476. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  477. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  478. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  479. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  480. package/src/prover/smt/solver/theory-seq.ts +961 -0
  481. package/src/prover/smt/solver/theory.ts +189 -0
  482. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  483. package/src/prover/smt/solver/var-subst.ts +36 -14
  484. package/src/prover/smt/table.ts +3 -2
  485. package/src/prover/smt/types.ts +146 -0
  486. package/src/prover/tlapm/cache.ts +37 -16
  487. package/src/prover/tlapm-library.ts +3208 -0
  488. package/src/prover/verdict.ts +2 -0
  489. package/src/prover/zenon/decide.ts +10 -7
  490. package/src/prover/zenon/encode.ts +0 -2
  491. package/src/prover/zenon/eqrel.ts +0 -2
  492. package/src/prover/zenon/equality-rules.ts +24 -2
  493. package/src/prover/zenon/expr.ts +21 -2
  494. package/src/prover/zenon/index-table.ts +7 -4
  495. package/src/prover/zenon/isar-case.ts +1 -3
  496. package/src/prover/zenon/isar.ts +2 -4
  497. package/src/prover/zenon/llproof.ts +0 -2
  498. package/src/prover/zenon/mltoll.ts +0 -2
  499. package/src/prover/zenon/node.ts +20 -5
  500. package/src/prover/zenon/parse.ts +6 -2
  501. package/src/prover/zenon/phrase.ts +1 -3
  502. package/src/prover/zenon/proof.ts +0 -2
  503. package/src/prover/zenon/propositional-rules.ts +0 -2
  504. package/src/prover/zenon/rules.ts +2 -3
  505. package/src/prover/zenon/search.ts +7 -5
  506. package/src/prover/zenon/tla/functions.ts +0 -2
  507. package/src/prover/zenon/tla/llproof.ts +0 -2
  508. package/src/prover/zenon/tla/records.ts +0 -2
  509. package/src/prover/zenon/tla/rewrites.ts +0 -2
  510. package/src/prover/zenon/tla/sets.ts +7 -8
  511. package/src/prover/zenon/tla/terms.ts +0 -2
  512. package/src/prover/zenon/tla/tla.ts +0 -2
  513. package/src/resolve.ts +625 -189
  514. package/src/runtime.ts +7 -1
  515. package/src/sany/builtins.ts +10 -10
  516. package/src/sany/generation.ts +2 -13
  517. package/src/sany/generator-definitions.ts +3 -1
  518. package/src/sany/generator-expressions.ts +36 -30
  519. package/src/sany/generator-proofs.ts +5 -3
  520. package/src/sany/generator.ts +2 -1
  521. package/src/sany/levels.ts +0 -2
  522. package/src/sany/lexer.ts +3 -3
  523. package/src/sany/linter.ts +0 -2
  524. package/src/sany/modules.ts +4 -2
  525. package/src/sany/nodes.ts +1 -1
  526. package/src/sany/selectors.ts +11 -6
  527. package/src/sany/xml.ts +2 -3
  528. package/src/search.ts +209 -56
  529. package/src/simulate.ts +3 -0
  530. package/src/spec-description.ts +2 -2
  531. package/src/standard-definitions.ts +4 -0
  532. package/src/state-graph.ts +0 -2
  533. package/src/subexpressions.ts +265 -94
  534. package/src/successors.ts +2 -1
  535. package/src/symmetry.ts +3 -3
  536. package/src/tableau.ts +2 -2
  537. package/src/tlc/fingerprint.ts +81 -9
  538. package/src/tlc/jar-data.ts +10 -0
  539. package/src/tlc/messages.ts +3 -3
  540. package/src/tlc/order.ts +14 -3
  541. package/src/tlc/summary.ts +29 -14
  542. package/src/tlc/tlc-operators.ts +3 -1
  543. package/src/tlc/tlcext-operators.ts +61 -16
  544. package/src/tlc/trace-spec.ts +5 -5
  545. package/src/typed-tier.ts +6541 -0
  546. package/src/typescript/types.ts +2 -2
  547. package/src/values.ts +46 -27
  548. package/src/prover/isabelle/isar/statement.ts +0 -52
  549. package/src/prover/smt/solver/z3-license.txt +0 -10
  550. package/src/prover/tlaps-module.ts +0 -510
  551. package/src/prover/zenon/LICENSE +0 -32
@@ -0,0 +1,2105 @@
1
+ import { SmtCanceledError } from "../../../../errors";
2
+ import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
3
+ import { RandomGen } from "../random-gen";
4
+ import type { ResourceLimit } from "../rlimit";
5
+ import { AsymmBranch } from "./asymm-branch";
6
+ import { Cleaner } from "./cleaner";
7
+ import { ClauseArena, NULL_LITERAL, UINT_MAX } from "./clause";
8
+ import {
9
+ GC_DYN_PSM,
10
+ GC_GLUE,
11
+ GC_GLUE_PSM,
12
+ GC_PSM,
13
+ GC_PSM_GLUE,
14
+ getSatConfig,
15
+ PS_ALWAYS_FALSE,
16
+ PS_ALWAYS_TRUE,
17
+ PS_BASIC_CACHING,
18
+ PS_FROZEN,
19
+ PS_RANDOM,
20
+ PS_SAT_CACHING,
21
+ RS_EMA,
22
+ RS_GEOMETRIC,
23
+ RS_LUBY,
24
+ type SatConfig,
25
+ type SatParams,
26
+ } from "./config";
27
+ import { MaxCliques } from "../max-cliques";
28
+ import { ModelConverter } from "./model-converter";
29
+ import { Probing } from "./probing";
30
+ import { Scc } from "./scc";
31
+ import { Simplifier } from "./simplifier";
32
+ import { VarQueue } from "./var-queue";
33
+ import { WATCH_BINARY, WATCH_EXT_CONSTRAINT, WatchList, mkClauseWatch } from "./watch-list";
34
+
35
+ export const JUSTIFICATION_NONE = 0;
36
+ export const JUSTIFICATION_BINARY = 1;
37
+ export const JUSTIFICATION_CLAUSE = 2;
38
+ export const JUSTIFICATION_EXT = 3;
39
+
40
+ export const CR_DONE = 0;
41
+ export const CR_CONTINUE = 1;
42
+ export const CR_GIVEUP = 2;
43
+
44
+ export interface SatExtension {
45
+ propagated(lit: number, index: number): boolean;
46
+ unitPropagate?(): boolean;
47
+ canPropagate?(): boolean;
48
+ asserted?(lit: number): void;
49
+ check?(): number;
50
+ getReasonUnknown?(): string;
51
+ getPhase?(boolVar: number): number;
52
+ initSearch?(): void;
53
+ preSimplify?(): void;
54
+ isExternal?(boolVar: number): boolean;
55
+ setEliminated?(boolVar: number): void;
56
+ getAntecedents(lit: number, index: number, antecedents: number[]): void;
57
+ resolveConflict(): number;
58
+ push(): void;
59
+ pop(numScopes: number): void;
60
+ userPush?(): void;
61
+ userPop?(numScopes: number): void;
62
+ popReinit(): void;
63
+ simplify(): void;
64
+ gc(): void;
65
+ setRoot(lit: number, root: number): boolean;
66
+ flushRoots(): void;
67
+ initUseList(useVars: Set<number>): void;
68
+ findMutexes(lits: number[], mutexes: number[][]): void;
69
+ toFormulas(lit2expr: (lit: number) => number, formulas: number[]): void;
70
+ }
71
+
72
+ const RANDOM_MAX_VALUE = 0x7fff;
73
+
74
+ const S_SAT = 0;
75
+ const S_UNSAT = 1;
76
+
77
+ class Ema {
78
+ private beta = 1;
79
+ value = 0;
80
+ private period = 0;
81
+ private wait = 0;
82
+
83
+ constructor(private alpha = 0) {}
84
+
85
+ setAlpha(alpha: number) {
86
+ this.alpha = alpha;
87
+ }
88
+
89
+ update(sample: number) {
90
+ this.value += this.beta * (sample - this.value);
91
+ if (this.beta <= this.alpha || this.wait-- !== 0) return;
92
+ this.period = 2 * (this.period + 1) - 1;
93
+ this.wait = this.period;
94
+ this.beta *= 0.5;
95
+ if (this.beta < this.alpha) this.beta = this.alpha;
96
+ }
97
+ }
98
+
99
+ interface Scope {
100
+ trailLim: number;
101
+ clausesToReinitLim: number;
102
+ }
103
+
104
+ const getLuby = (index: number) => {
105
+ let size = 1;
106
+ let sequence = 0;
107
+ while (size < index) {
108
+ sequence++;
109
+ size = 2 * size + 1;
110
+ }
111
+ let remaining = index - 1;
112
+ while (size - 1 !== remaining) {
113
+ size = (size - 1) >> 1;
114
+ sequence--;
115
+ remaining %= size;
116
+ }
117
+ return 2 ** sequence;
118
+ };
119
+
120
+ const sortClauses = (clauses: number[], isLess: (first: number, second: number) => boolean) =>
121
+ clauses.sort((first, second) => (isLess(first, second) ? -1 : isLess(second, first) ? 1 : 0));
122
+
123
+ export class Solver {
124
+ config: SatConfig;
125
+ rand: RandomGen;
126
+ arena = new ClauseArena();
127
+ cleaner: Cleaner;
128
+ mc = new ModelConverter();
129
+ simplifier: Simplifier;
130
+ scc: Scc;
131
+ asymmBranch: AsymmBranch;
132
+ probing: Probing;
133
+ ext: SatExtension | null = null;
134
+ isProbing = false;
135
+ private isGivenUp = false;
136
+ private activeVars: number[] = [];
137
+ private varsLim: number[] = [];
138
+ varsToReinit: number[] = [];
139
+ model = new Int8Array(0);
140
+ isModelCurrent = false;
141
+ isInconsistent = false;
142
+ conflictJustLevel = 0;
143
+ conflictLevel = 0;
144
+ conflictVal = 0;
145
+ conflictKind = JUSTIFICATION_NONE;
146
+ notL = NULL_LITERAL;
147
+ clauses: number[] = [];
148
+ learned: number[] = [];
149
+ watches: WatchList[] = [];
150
+ assignment = new Int8Array(16);
151
+ justLevel = new Uint32Array(8);
152
+ private varCount = 0;
153
+ justVal: number[] = [];
154
+ justKind: number[] = [];
155
+ mark: boolean[] = [];
156
+ litMark: boolean[] = [];
157
+ eliminated: boolean[] = [];
158
+ external: boolean[] = [];
159
+ varScope: number[] = [];
160
+ touched: number[] = [];
161
+ touchIndex = 0;
162
+ replayAssign: number[] = [];
163
+ activity: number[] = [];
164
+ activityInc = 128;
165
+ phase: boolean[] = [];
166
+ bestPhase: boolean[] = [];
167
+ prevPhase: boolean[] = [];
168
+ phaseBirthdate: number[] = [];
169
+ bestPhaseBirthdate: number[] = [];
170
+ assignedSinceGc: boolean[] = [];
171
+ searchState = S_UNSAT;
172
+ searchUnsatConflicts = 0;
173
+ searchSatConflicts = 0;
174
+ searchNextToggle = 0;
175
+ phaseCounter = 0;
176
+ bestPhaseSize = 0;
177
+ rephaseLim = 0;
178
+ rephaseInc = 0;
179
+ rephaseCount = 0;
180
+ caseSplitQueue: VarQueue;
181
+ qhead = 0;
182
+ scopeLvl = 0;
183
+ searchLvl = 0;
184
+ fastGlueAvg = new Ema();
185
+ slowGlueAvg = new Ema();
186
+ fastGlueBackup = new Ema();
187
+ slowGlueBackup = new Ema();
188
+ trailAvg = new Ema();
189
+ trail: number[] = [];
190
+ clausesToReinit: number[] = [];
191
+ reasonUnknown = "";
192
+ visited: number[] = [];
193
+ visitedTimestamp = 0;
194
+ scopes: Scope[] = [];
195
+ core: number[] = [];
196
+ conflicts = 0;
197
+ conflictsSinceInit = 0;
198
+ restarts = 0;
199
+ conflictsSinceRestart = 0;
200
+ isForcingConflictAnalysis = false;
201
+ simplifications = 0;
202
+ restartThreshold = 0;
203
+ lubyIndex = 0;
204
+ conflictsSinceGc = 0;
205
+ gcThreshold = 0;
206
+ defragThreshold = 0;
207
+ gcClauses = 0;
208
+ minDTk = 0;
209
+ nextSimplify = 0;
210
+ isSimplifyEnabled = true;
211
+ isRestartEnabled = true;
212
+ lemma: number[] = [];
213
+ private incremental: boolean;
214
+ private assumptions: number[] = [];
215
+ private assumptionSet = new Set<number>();
216
+ readonly userScopeLiterals: number[] = [];
217
+ private diffLevels: boolean[] = [];
218
+ private unmark: number[] = [];
219
+ private lvlSet = 0;
220
+ private lemmaMinStack: number[] = [];
221
+
222
+ constructor(
223
+ readonly params: SatParams,
224
+ readonly limit: ResourceLimit,
225
+ isIncremental = false,
226
+ ) {
227
+ this.incremental = isIncremental;
228
+ this.config = getSatConfig(params);
229
+ this.rand = new RandomGen(this.config.randomSeed);
230
+ this.caseSplitQueue = new VarQueue(this.activity);
231
+ this.cleaner = new Cleaner(this);
232
+ this.simplifier = new Simplifier(this, params);
233
+ this.scc = new Scc(this, this.config);
234
+ this.asymmBranch = new AsymmBranch(this, params);
235
+ this.probing = new Probing(this, params);
236
+ this.updateParams();
237
+ this.mkVar(false);
238
+ }
239
+
240
+ private updateParams() {
241
+ this.fastGlueAvg.setAlpha(this.config.fastGlueAvg);
242
+ this.slowGlueAvg.setAlpha(this.config.slowGlueAvg);
243
+ this.fastGlueBackup.setAlpha(this.config.fastGlueAvg);
244
+ this.slowGlueBackup.setAlpha(this.config.slowGlueAvg);
245
+ this.trailAvg.setAlpha(this.config.slowGlueAvg);
246
+ }
247
+
248
+ numVars() {
249
+ return this.varCount;
250
+ }
251
+
252
+ value(lit: number) {
253
+ return this.assignment[lit];
254
+ }
255
+
256
+ valueVar(boolVar: number) {
257
+ return this.assignment[2 * boolVar];
258
+ }
259
+
260
+ lvl(lit: number) {
261
+ return this.justLevel[lit >> 1];
262
+ }
263
+
264
+ lvlVar(boolVar: number) {
265
+ return this.justLevel[boolVar];
266
+ }
267
+
268
+ atBaseLvl() {
269
+ return this.scopeLvl === 0;
270
+ }
271
+
272
+ isExternal(boolVar: number) {
273
+ return this.external[boolVar];
274
+ }
275
+
276
+ wasEliminated(boolVar: number) {
277
+ return this.eliminated[boolVar];
278
+ }
279
+
280
+ getWlist(lit: number) {
281
+ return this.watches[lit];
282
+ }
283
+
284
+ initTrailSize() {
285
+ return this.atBaseLvl() ? this.trail.length : this.scopes[0].trailLim;
286
+ }
287
+
288
+ isAssumption(boolVar: number) {
289
+ return this.isAssumptionLit(2 * boolVar) || this.isAssumptionLit(2 * boolVar + 1);
290
+ }
291
+
292
+ private isAssumptionLit(lit: number) {
293
+ return this.trackingAssumptions() && this.assumptionSet.has(lit);
294
+ }
295
+
296
+ isIncremental() {
297
+ return this.incremental;
298
+ }
299
+
300
+ trackingAssumptions() {
301
+ return this.assumptions.length > 0 || this.userScopeLiterals.length > 0;
302
+ }
303
+
304
+ setExternal(boolVar: number) {
305
+ this.external[boolVar] = true;
306
+ }
307
+
308
+ initVisited() {
309
+ const size = 2 * this.numVars();
310
+ while (this.visited.length < size) this.visited.push(0);
311
+ this.visitedTimestamp++;
312
+ }
313
+
314
+ isVisited(lit: number) {
315
+ return this.visited[lit] === this.visitedTimestamp;
316
+ }
317
+
318
+ markVisited(lit: number) {
319
+ this.visited[lit] = this.visitedTimestamp;
320
+ }
321
+
322
+ checkpoint() {
323
+ if (!this.limit.inc()) {
324
+ this.isModelCurrent = false;
325
+ this.reasonUnknown = "sat.canceled";
326
+ throw new SmtCanceledError();
327
+ }
328
+ }
329
+
330
+ mkVar(isExternal: boolean) {
331
+ this.isModelCurrent = false;
332
+ const boolVar = this.varCount++;
333
+ this.activeVars.push(boolVar);
334
+ if (boolVar === this.justLevel.length) {
335
+ const assignment = new Int8Array(4 * boolVar);
336
+ assignment.set(this.assignment);
337
+ this.assignment = assignment;
338
+ const justLevel = new Uint32Array(2 * boolVar);
339
+ justLevel.set(this.justLevel);
340
+ this.justLevel = justLevel;
341
+ }
342
+ this.watches.push(new WatchList(), new WatchList());
343
+ this.justLevel[boolVar] = UINT_MAX;
344
+ this.justVal.push(0);
345
+ this.justKind.push(JUSTIFICATION_NONE);
346
+ this.eliminated.push(false);
347
+ this.external.push(isExternal);
348
+ this.varScope.push(this.scopeLvl);
349
+ this.touched.push(0);
350
+ this.activity.push(0);
351
+ this.mark.push(false);
352
+ this.litMark.push(false, false);
353
+ this.phase.push(false);
354
+ this.bestPhase.push(false);
355
+ this.prevPhase.push(false);
356
+ this.phaseBirthdate.push(0);
357
+ this.bestPhaseBirthdate.push(0);
358
+ this.assignedSinceGc.push(false);
359
+ this.caseSplitQueue.mkVar(boolVar);
360
+ this.simplifier.insertElimTodo(boolVar);
361
+ return boolVar;
362
+ }
363
+
364
+ setEliminated(boolVar: number, isEliminated: boolean) {
365
+ if (this.eliminated[boolVar] === isEliminated) return;
366
+ this.eliminated[boolVar] = isEliminated;
367
+ if (isEliminated) this.ext?.setEliminated?.(boolVar);
368
+ }
369
+
370
+ setNonExternal(boolVar: number) {
371
+ this.external[boolVar] = false;
372
+ }
373
+
374
+ private isExtPropagating() {
375
+ return this.ext !== null && (!this.isProbing || this.atBaseLvl());
376
+ }
377
+
378
+ get numUserScopes() {
379
+ return this.userScopeLiterals.length;
380
+ }
381
+
382
+ mkClause(lits: number[], isLearned = false, isTheory = false) {
383
+ this.isModelCurrent = false;
384
+ return this.mkClauseCore(
385
+ this.userScopeLiterals.length === 0 ? lits : [...lits, ...this.userScopeLiterals],
386
+ isLearned,
387
+ isTheory,
388
+ );
389
+ }
390
+
391
+ delClause(clause: number) {
392
+ this.arena.delClause(clause);
393
+ }
394
+
395
+ mkClauseCore(lits: number[], isRedundant: boolean, isTheory = false): number {
396
+ if ((!isRedundant || isTheory) && !this.simplifyClause(lits)) return -1;
397
+ switch (lits.length) {
398
+ case 0:
399
+ this.setConflict();
400
+ return -1;
401
+ case 1:
402
+ this.assign(lits[0], 0, JUSTIFICATION_NONE, 0);
403
+ return -1;
404
+ case 2:
405
+ this.mkBinClause(lits[0], lits[1], isRedundant);
406
+ return -1;
407
+ default:
408
+ return this.mkNaryClause(lits, isRedundant, isTheory);
409
+ }
410
+ }
411
+
412
+ mkBinClause(first: number, second: number, isRedundant: boolean) {
413
+ this.touched[first >> 1] = this.touchIndex;
414
+ this.touched[second >> 1] = this.touchIndex;
415
+ if (
416
+ isRedundant &&
417
+ this.getWlist(first ^ 1).findBinary(second ^ 1) !== -1 &&
418
+ this.value(first) === L_UNDEF
419
+ ) {
420
+ this.assignUnit(first);
421
+ return;
422
+ }
423
+ if (
424
+ isRedundant &&
425
+ this.getWlist(second ^ 1).findBinary(first ^ 1) !== -1 &&
426
+ this.value(second) === L_UNDEF
427
+ ) {
428
+ this.assignUnit(second);
429
+ return;
430
+ }
431
+ const found = isRedundant ? this.getWlist(first ^ 1).findBinary(second) : -1;
432
+ if (found !== -1) {
433
+ if (this.propagateBinClause(first, second) && !this.atBaseLvl() && !isRedundant)
434
+ this.pushReinitBinary(first, second);
435
+ else if (this.hasVariablesToReinitBinary(first, second)) this.pushReinitBinary(first, second);
436
+ return;
437
+ }
438
+ if (this.propagateBinClause(first, second)) {
439
+ if (!this.atBaseLvl()) this.pushReinitBinary(first, second);
440
+ else return;
441
+ } else if (this.hasVariablesToReinitBinary(first, second)) this.pushReinitBinary(first, second);
442
+ this.getWlist(first ^ 1).pushBinary(second, isRedundant);
443
+ this.getWlist(second ^ 1).pushBinary(first, isRedundant);
444
+ }
445
+
446
+ private hasVariablesToReinit(clause: number) {
447
+ const arena = this.arena;
448
+ for (let index = 0; index < arena.size[clause]; index++)
449
+ if (this.varScope[arena.get(clause, index) >> 1] > 0) return true;
450
+ return false;
451
+ }
452
+
453
+ private hasVariablesToReinitBinary(first: number, second: number) {
454
+ if (this.atBaseLvl()) return false;
455
+ return this.varScope[first >> 1] > 0 || this.varScope[second >> 1] > 0;
456
+ }
457
+
458
+ propagateBinClause(first: number, second: number) {
459
+ if (this.value(second) === L_FALSE && this.value(first) !== L_TRUE) {
460
+ this.assign(first, this.lvl(second), JUSTIFICATION_BINARY, second);
461
+ return true;
462
+ }
463
+ if (this.value(first) === L_FALSE && this.value(second) !== L_TRUE) {
464
+ this.assign(second, this.lvl(first), JUSTIFICATION_BINARY, first);
465
+ return true;
466
+ }
467
+ return false;
468
+ }
469
+
470
+ pushReinitStack(clause: number) {
471
+ this.clausesToReinit.push(clause, NULL_LITERAL);
472
+ this.arena.setReinitStack(clause, true);
473
+ }
474
+
475
+ private pushReinitBinary(first: number, second: number) {
476
+ this.clausesToReinit.push(first, second);
477
+ }
478
+
479
+ private mkNaryClause(lits: number[], isRedundant: boolean, isTheory: boolean) {
480
+ const clause = this.arena.mkClause(lits, lits.length, isRedundant);
481
+ const isReinit = this.attachNaryClause(clause, isRedundant && !isTheory);
482
+ if (isReinit || this.hasVariablesToReinit(clause)) this.pushReinitStack(clause);
483
+ if (isRedundant) this.learned.push(clause);
484
+ else this.clauses.push(clause);
485
+ for (const lit of lits) this.touched[lit >> 1] = this.touchIndex;
486
+ return clause;
487
+ }
488
+
489
+ private attachNaryClause(clause: number, isAsserting: boolean) {
490
+ const arena = this.arena;
491
+ let isReinit = false;
492
+ if (!this.atBaseLvl()) {
493
+ if (isAsserting) arena.swap(clause, 1, this.selectLearnedWatchLit(clause));
494
+ else {
495
+ arena.swap(clause, 0, this.selectWatchLit(clause, 0));
496
+ arena.swap(clause, 1, this.selectWatchLit(clause, 1));
497
+ }
498
+ const size = arena.size[clause];
499
+ if (this.value(arena.get(clause, 0)) === L_FALSE) {
500
+ let level = this.lvl(arena.get(clause, 0));
501
+ for (let index = size; index-- > 2;)
502
+ level = Math.max(level, this.lvl(arena.get(clause, index)));
503
+ this.assign(arena.get(clause, 1), level, JUSTIFICATION_CLAUSE, clause);
504
+ isReinit ||= !arena.isLearned(clause);
505
+ } else if (this.value(arena.get(clause, 1)) === L_FALSE) {
506
+ let level = this.lvl(arena.get(clause, 1));
507
+ for (let index = size; index-- > 2;)
508
+ level = Math.max(level, this.lvl(arena.get(clause, index)));
509
+ this.assign(arena.get(clause, 0), level, JUSTIFICATION_CLAUSE, clause);
510
+ isReinit ||= !arena.isLearned(clause);
511
+ }
512
+ }
513
+ const blockedLit = arena.get(clause, arena.size[clause] >> 1);
514
+ this.watches[arena.get(clause, 0) ^ 1].pushClause(blockedLit, clause);
515
+ this.watches[arena.get(clause, 1) ^ 1].pushClause(blockedLit, clause);
516
+ return isReinit;
517
+ }
518
+
519
+ attachClause(clause: number) {
520
+ return this.attachNaryClause(
521
+ clause,
522
+ this.arena.isLearned(clause) && !this.arena.isOnReinitStack(clause),
523
+ );
524
+ }
525
+
526
+ shrink(clause: number, oldSize: number, newSize: number) {
527
+ if (oldSize === newSize) return;
528
+ this.arena.shrink(clause, newSize);
529
+ for (let index = 0; index < newSize; index++)
530
+ this.touched[this.arena.get(clause, index) >> 1] = this.touchIndex;
531
+ }
532
+
533
+ setPhase(boolVar: number, isPositive: boolean) {
534
+ if (this.phase[boolVar] !== isPositive) this.phaseBirthdate[boolVar] = this.conflicts;
535
+ this.phase[boolVar] = isPositive;
536
+ }
537
+
538
+ setBestPhase(boolVar: number, isPositive: boolean) {
539
+ if (this.bestPhase[boolVar] !== isPositive) this.bestPhaseBirthdate[boolVar] = this.conflicts;
540
+ this.bestPhase[boolVar] = isPositive;
541
+ }
542
+
543
+ setPhaseLiteral(lit: number) {
544
+ if (lit >> 1 >= this.numVars()) return;
545
+ this.setPhase(lit >> 1, (lit & 1) === 0);
546
+ this.setBestPhase(lit >> 1, (lit & 1) === 0);
547
+ }
548
+
549
+ private shouldDefrag() {
550
+ if (this.defragThreshold > 0) this.defragThreshold--;
551
+ return this.defragThreshold === 0 && this.config.isGcDefrag;
552
+ }
553
+
554
+ private defragClauses() {
555
+ this.defragThreshold = 2;
556
+ this.pop(this.scopeLvl);
557
+ const source = this.arena;
558
+ const target = new ClauseArena();
559
+ const newClauses: number[] = [];
560
+ const newLearned: number[] = [];
561
+ const newIds = new Map<number, number>();
562
+ for (const clause of this.clauses) source.unmarkUsed(clause);
563
+ for (const clause of this.learned) source.unmarkUsed(clause);
564
+ const vars: number[] = [];
565
+ for (let boolVar = 0; boolVar < this.numVars(); boolVar++) vars.push(boolVar);
566
+ vars.sort((first, second) => this.activity[second] - this.activity[first]);
567
+ const copy = (clause: number) => {
568
+ const id = target.copyClause(source, clause);
569
+ (source.isLearned(clause) ? newLearned : newClauses).push(id);
570
+ return id;
571
+ };
572
+ for (const boolVar of vars)
573
+ for (const lit of [2 * boolVar, 2 * boolVar + 1]) {
574
+ const wlist = this.watches[lit];
575
+ for (let index = 0; index < wlist.size; index++) {
576
+ if (!wlist.isClause(index)) continue;
577
+ const clause = wlist.getClause(index);
578
+ const id = newIds.get(clause) ?? copy(clause);
579
+ newIds.set(clause, id);
580
+ wlist.setClause(index, wlist.getBlockedLiteral(index), id);
581
+ }
582
+ }
583
+ for (const clause of this.clauses) if (!newIds.has(clause)) copy(clause);
584
+ for (const clause of this.learned) if (!newIds.has(clause)) copy(clause);
585
+ this.clauses = newClauses;
586
+ this.learned = newLearned;
587
+ this.arena = target;
588
+ this.reinitAssumptions();
589
+ }
590
+
591
+ private selectWatchLit(clause: number, startingAt: number) {
592
+ const arena = this.arena;
593
+ let minTrueIndex = -1;
594
+ let maxFalseIndex = -1;
595
+ let unknownIndex = -1;
596
+ for (let index = startingAt; index < arena.size[clause]; index++) {
597
+ const lit = arena.get(clause, index);
598
+ switch (this.value(lit)) {
599
+ case L_FALSE:
600
+ if (maxFalseIndex === -1 || this.lvl(lit) > this.lvl(arena.get(clause, maxFalseIndex)))
601
+ maxFalseIndex = index;
602
+ break;
603
+ case L_UNDEF:
604
+ unknownIndex = index;
605
+ break;
606
+ case L_TRUE:
607
+ if (minTrueIndex === -1 || this.lvl(lit) < this.lvl(arena.get(clause, minTrueIndex)))
608
+ minTrueIndex = index;
609
+ break;
610
+ }
611
+ }
612
+ if (minTrueIndex !== -1) return minTrueIndex;
613
+ if (unknownIndex !== -1) return unknownIndex;
614
+ return maxFalseIndex;
615
+ }
616
+
617
+ private selectLearnedWatchLit(clause: number) {
618
+ const arena = this.arena;
619
+ let maxFalseIndex = -1;
620
+ for (let index = 1; index < arena.size[clause]; index++)
621
+ if (
622
+ maxFalseIndex === -1 ||
623
+ this.lvl(arena.get(clause, index)) > this.lvl(arena.get(clause, maxFalseIndex))
624
+ )
625
+ maxFalseIndex = index;
626
+ return maxFalseIndex;
627
+ }
628
+
629
+ private simplifyClause(lits: number[]) {
630
+ const isLvl0 = this.atBaseLvl();
631
+ lits.sort((first, second) => first - second);
632
+ let previous = NULL_LITERAL;
633
+ let next = 0;
634
+ for (let index = 0; index < lits.length; index++) {
635
+ const current = lits[index];
636
+ const value = !isLvl0 && this.lvl(current) > 0 ? L_UNDEF : this.value(current);
637
+ if (value === L_TRUE) return false;
638
+ if (value === L_FALSE) continue;
639
+ if (current === (previous ^ 1)) return false;
640
+ if (current !== previous) {
641
+ previous = current;
642
+ if (index !== next) {
643
+ lits[index] = lits[next];
644
+ lits[next] = current;
645
+ }
646
+ next++;
647
+ }
648
+ }
649
+ lits.length = next;
650
+ return true;
651
+ }
652
+
653
+ setLearned1(first: number, second: number, isRedundant: boolean) {
654
+ const wlist = this.getWlist(first ^ 1);
655
+ for (let index = 0; index < wlist.size; index++)
656
+ if (wlist.isBinary(index) && wlist.getLiteral(index) === second && !wlist.isLearned(index)) {
657
+ wlist.setLearned(index, isRedundant);
658
+ return;
659
+ }
660
+ }
661
+
662
+ detachClause(clause: number) {
663
+ this.getWlist(this.arena.get(clause, 0) ^ 1).eraseClause(clause);
664
+ this.getWlist(this.arena.get(clause, 1) ^ 1).eraseClause(clause);
665
+ }
666
+
667
+ setConflict(level = 0, kind = JUSTIFICATION_NONE, val = 0, notL = NULL_LITERAL) {
668
+ if (this.isInconsistent) return;
669
+ this.isInconsistent = true;
670
+ this.conflictJustLevel = level;
671
+ this.conflictKind = kind;
672
+ this.conflictVal = val;
673
+ this.notL = notL;
674
+ }
675
+
676
+ assign(lit: number, level: number, kind: number, val: number) {
677
+ switch (this.value(lit)) {
678
+ case L_FALSE:
679
+ this.setConflict(level, kind, val, lit ^ 1);
680
+ break;
681
+ case L_UNDEF:
682
+ this.assignCore(lit, level, kind, val);
683
+ break;
684
+ case L_TRUE:
685
+ if (level === 0 && this.lvl(lit) !== 0) {
686
+ this.justLevel[lit >> 1] = 0;
687
+ this.justKind[lit >> 1] = kind;
688
+ this.justVal[lit >> 1] = val;
689
+ }
690
+ break;
691
+ }
692
+ }
693
+
694
+ assignUnit(lit: number) {
695
+ this.assign(lit, 0, JUSTIFICATION_NONE, 0);
696
+ }
697
+
698
+ assignScoped(lit: number) {
699
+ this.assign(lit, this.scopeLvl, JUSTIFICATION_NONE, 0);
700
+ }
701
+
702
+ assignCore(lit: number, level: number, kind: number, val: number) {
703
+ const boolVar = lit >> 1;
704
+ this.assignment[lit] = L_TRUE;
705
+ this.assignment[lit ^ 1] = L_FALSE;
706
+ this.justLevel[boolVar] = level;
707
+ this.justKind[boolVar] = level === 0 ? JUSTIFICATION_NONE : kind;
708
+ this.justVal[boolVar] = level === 0 ? 0 : val;
709
+ this.setPhase(boolVar, (lit & 1) === 0);
710
+ this.assignedSinceGc[boolVar] = true;
711
+ this.trail.push(lit);
712
+ }
713
+
714
+ propagate(isUpdating: boolean) {
715
+ if (this.isExtPropagating()) this.ext?.unitPropagate?.();
716
+ while (this.qhead < this.trail.length && !this.isInconsistent) {
717
+ do {
718
+ this.checkpoint();
719
+ this.cleaner.dec();
720
+ const lit = this.trail[this.qhead];
721
+ this.qhead++;
722
+ if (!this.propagateLiteral(lit, isUpdating)) return false;
723
+ } while (this.qhead < this.trail.length);
724
+ if (this.isExtPropagating()) this.ext?.unitPropagate?.();
725
+ }
726
+ return !this.isInconsistent;
727
+ }
728
+
729
+ private propagateClause(clause: number, isUpdating: boolean, assignLevel: number, first: number) {
730
+ const arena = this.arena;
731
+ arena.markUsed(clause);
732
+ this.assignCore(first, assignLevel, JUSTIFICATION_CLAUSE, clause);
733
+ if (isUpdating && arena.isLearned(clause) && arena.glue[clause] > 2) {
734
+ const glue = this.numDiffLevelsBelow(clause, arena.glue[clause] - 1);
735
+ if (glue !== -1) arena.setGlue(clause, glue);
736
+ }
737
+ }
738
+
739
+ private propagateLiteral(lit: number, isUpdating: boolean) {
740
+ const arena = this.arena;
741
+ const lits = arena.lits;
742
+ const starts = arena.start;
743
+ const sizes = arena.size;
744
+ const assignment = this.assignment;
745
+ const justLevel = this.justLevel;
746
+ const currLevel = justLevel[lit >> 1];
747
+ const notL = lit ^ 1;
748
+ const wlist = this.watches[lit];
749
+ let data = wlist.data;
750
+ this.asymmBranch.dec(wlist.size);
751
+ this.probing.dec(wlist.size);
752
+ const end = wlist.size;
753
+ let target = 0;
754
+ for (let index = 0; index < end; index++) {
755
+ const val1 = data[2 * index];
756
+ const val2 = data[2 * index + 1];
757
+ if ((val2 & 3) === WATCH_BINARY) {
758
+ const value = assignment[val1];
759
+ if (value === L_FALSE) {
760
+ for (; index < end; index++, target++) wlist.copy(target, index);
761
+ wlist.setEnd(target);
762
+ this.setConflict(currLevel, JUSTIFICATION_BINARY, notL, val1 ^ 1);
763
+ return false;
764
+ }
765
+ if (value === L_UNDEF) this.assignCore(val1, currLevel, JUSTIFICATION_BINARY, notL);
766
+ data[2 * target] = val1;
767
+ data[2 * target + 1] = val2;
768
+ target++;
769
+ continue;
770
+ }
771
+ if ((val2 & 3) === WATCH_EXT_CONSTRAINT) {
772
+ const isKept = (this.ext as SatExtension).propagated(lit, val1);
773
+ data = wlist.data;
774
+ if (this.isInconsistent) {
775
+ if (!isKept) index++;
776
+ for (; index < end; index++, target++) wlist.copy(target, index);
777
+ wlist.setEnd(target);
778
+ return false;
779
+ }
780
+ if (isKept) {
781
+ data[2 * target] = val1;
782
+ data[2 * target + 1] = val2;
783
+ target++;
784
+ }
785
+ continue;
786
+ }
787
+ if (assignment[val2 >> 2] === L_TRUE) {
788
+ data[2 * target] = val1;
789
+ data[2 * target + 1] = val2;
790
+ target++;
791
+ continue;
792
+ }
793
+ const clause = val1;
794
+ const base = starts[clause];
795
+ if (lits[base] === notL) {
796
+ lits[base] = lits[base + 1];
797
+ lits[base + 1] = notL;
798
+ }
799
+ const size = sizes[clause];
800
+ if (arena.wasRemoved(clause) || size === 1 || lits[base + 1] !== notL) {
801
+ data[2 * target] = val1;
802
+ data[2 * target + 1] = val2;
803
+ target++;
804
+ continue;
805
+ }
806
+ const first = lits[base];
807
+ const firstValue = assignment[first];
808
+ if (firstValue === L_TRUE) {
809
+ data[2 * target] = clause;
810
+ data[2 * target + 1] = mkClauseWatch(first);
811
+ target++;
812
+ continue;
813
+ }
814
+ let undefIndex = 0;
815
+ let assignLevel = currLevel;
816
+ let maxIndex = 1;
817
+ let numUndef = 0;
818
+ let isSatisfied = false;
819
+ for (let position = 2; position < size && numUndef <= 1; position++) {
820
+ const other = lits[base + position];
821
+ const value = assignment[other];
822
+ if (value === L_TRUE) {
823
+ data[2 * target] = clause;
824
+ data[2 * target + 1] = mkClauseWatch(other);
825
+ target++;
826
+ isSatisfied = true;
827
+ break;
828
+ }
829
+ if (value === L_UNDEF) {
830
+ undefIndex = position;
831
+ numUndef++;
832
+ continue;
833
+ }
834
+ const level = justLevel[other >> 1];
835
+ if (level > assignLevel) {
836
+ assignLevel = level;
837
+ maxIndex = position;
838
+ }
839
+ }
840
+ if (isSatisfied) continue;
841
+ if (firstValue === L_FALSE) assignLevel = Math.max(assignLevel, justLevel[first >> 1]);
842
+ if (undefIndex !== 0) {
843
+ this.setWatch(clause, undefIndex);
844
+ if (firstValue === L_FALSE && numUndef === 1) {
845
+ arena.swap(clause, 0, 1);
846
+ this.propagateClause(clause, isUpdating, assignLevel, lits[base]);
847
+ }
848
+ continue;
849
+ }
850
+ if (firstValue === L_FALSE) {
851
+ arena.markUsed(clause);
852
+ for (; index < end; index++, target++) wlist.copy(target, index);
853
+ wlist.setEnd(target);
854
+ this.setConflict(assignLevel, JUSTIFICATION_CLAUSE, clause);
855
+ return false;
856
+ }
857
+ if (maxIndex !== 1) this.setWatch(clause, maxIndex);
858
+ else {
859
+ data[2 * target] = val1;
860
+ data[2 * target + 1] = val2;
861
+ target++;
862
+ }
863
+ this.propagateClause(clause, isUpdating, assignLevel, first);
864
+ }
865
+ wlist.setEnd(target);
866
+ if (this.external[lit >> 1] && this.isExtPropagating()) this.ext?.asserted?.(lit);
867
+ return true;
868
+ }
869
+
870
+ private setWatch(clause: number, index: number) {
871
+ this.arena.swap(clause, 1, index);
872
+ this.watches[this.arena.get(clause, 1) ^ 1].pushClause(this.arena.get(clause, 0), clause);
873
+ }
874
+
875
+ check(assumptions: readonly number[] = []) {
876
+ this.reasonUnknown = "no reason given";
877
+ this.popToBaseLevel();
878
+ this.isGivenUp = false;
879
+ this.initSearch();
880
+ if (this.checkInconsistent()) return L_FALSE;
881
+ this.propagate(false);
882
+ if (this.checkInconsistent()) return L_FALSE;
883
+ this.initAssumptions(assumptions);
884
+ this.propagate(false);
885
+ if (this.checkInconsistent()) return L_FALSE;
886
+ if (this.config.isForcingCleanup) this.doCleanup(true);
887
+ if (this.config.isGcBurst) {
888
+ this.conflictsSinceGc = this.gcThreshold + 1;
889
+ this.doGc();
890
+ }
891
+ if (this.config.isEnablingPreSimplify) {
892
+ this.doSimplify();
893
+ if (this.checkInconsistent()) return L_FALSE;
894
+ }
895
+ if (this.config.maxConflicts === 0) return L_UNDEF;
896
+ if (this.config.maxConflicts > 0 && this.config.burstSearch > 0) {
897
+ this.restartThreshold = this.config.burstSearch;
898
+ const result = this.boundedSearch();
899
+ if (result !== L_UNDEF || this.isGivenUp) return result;
900
+ this.popReinit(this.scopeLvl);
901
+ this.conflictsSinceRestart = 0;
902
+ this.restartThreshold = this.config.restartInitial;
903
+ }
904
+ return this.basicSearch();
905
+ }
906
+
907
+ checkInconsistent() {
908
+ if (!this.isInconsistent) return false;
909
+ if (this.trackingAssumptions() && this.scopeLvl === this.searchLvl) this.resolveConflict();
910
+ return true;
911
+ }
912
+
913
+ resolveConflict() {
914
+ for (;;) {
915
+ if (this.resolveConflictCore() === L_FALSE) return false;
916
+ if (!this.isInconsistent) return true;
917
+ }
918
+ }
919
+
920
+ initAssumptions(lits: readonly number[]) {
921
+ if (lits.length === 0 && this.userScopeLiterals.length === 0) return;
922
+ this.resetAssumptions();
923
+ this.push();
924
+ this.propagate(false);
925
+ if (this.isInconsistent) return;
926
+ for (let index = 0; !this.isInconsistent && index < this.userScopeLiterals.length; index++)
927
+ this.assignScoped(this.userScopeLiterals[index] ^ 1);
928
+ for (let index = 0; !this.isInconsistent && index < lits.length; index++) {
929
+ const lit = lits[index];
930
+ this.setExternal(lit >> 1);
931
+ this.addAssumption(lit);
932
+ this.assignScoped(lit);
933
+ }
934
+ this.searchLvl = this.scopeLvl;
935
+ }
936
+
937
+ private resetAssumptions() {
938
+ this.assumptions = [];
939
+ this.assumptionSet.clear();
940
+ }
941
+
942
+ addAssumption(lit: number) {
943
+ this.assumptionSet.add(lit);
944
+ this.assumptions.push(lit);
945
+ this.setExternal(lit >> 1);
946
+ }
947
+
948
+ private reinitAssumptions() {
949
+ if (!this.trackingAssumptions() || !this.atBaseLvl() || this.isInconsistent) return;
950
+ if (!this.propagate(false)) return;
951
+ this.push();
952
+ for (const lit of this.userScopeLiterals) {
953
+ if (this.isInconsistent) break;
954
+ this.assignScoped(lit ^ 1);
955
+ }
956
+ for (const lit of this.assumptions) {
957
+ if (this.isInconsistent) break;
958
+ this.assignScoped(lit);
959
+ }
960
+ if (!this.isInconsistent) this.propagate(false);
961
+ }
962
+
963
+ private processAntecedentForUnsatCore(antecedent: number) {
964
+ const boolVar = antecedent >> 1;
965
+ if (this.mark[boolVar]) return;
966
+ this.mark[boolVar] = true;
967
+ this.unmark.push(boolVar);
968
+ if (this.isAssumptionLit(antecedent)) this.core.push(antecedent);
969
+ }
970
+
971
+ private processConsequentForUnsatCore(consequent: number, kind: number, val: number) {
972
+ if (kind === JUSTIFICATION_BINARY) {
973
+ this.processAntecedentForUnsatCore(val ^ 1);
974
+ return;
975
+ }
976
+ if (kind === JUSTIFICATION_EXT) {
977
+ for (const lit of this.getExtAntecedents(consequent, val))
978
+ this.processAntecedentForUnsatCore(lit);
979
+ return;
980
+ }
981
+ if (kind !== JUSTIFICATION_CLAUSE) return;
982
+ const arena = this.arena;
983
+ let position = 0;
984
+ if (consequent !== NULL_LITERAL) {
985
+ if (arena.get(val, 0) === consequent) position = 1;
986
+ else {
987
+ this.processAntecedentForUnsatCore(arena.get(val, 0) ^ 1);
988
+ position = 2;
989
+ }
990
+ }
991
+ for (; position < arena.size[val]; position++)
992
+ this.processAntecedentForUnsatCore(arena.get(val, position) ^ 1);
993
+ }
994
+
995
+ private resolveConflictForUnsatCore() {
996
+ this.core = [];
997
+ if (this.conflictLevel === 0) return;
998
+ const oldSize = this.unmark.length;
999
+ let index = this.skipLiteralsAboveConflictLevel();
1000
+ let consequent = this.notL;
1001
+ if (this.notL !== NULL_LITERAL) {
1002
+ const boolVar = this.notL >> 1;
1003
+ this.processAntecedentForUnsatCore(this.notL);
1004
+ if (this.isAssumptionLit(this.notL ^ 1)) this.core.push(this.notL ^ 1);
1005
+ else
1006
+ this.processConsequentForUnsatCore(
1007
+ this.notL,
1008
+ this.justKind[boolVar],
1009
+ this.justVal[boolVar],
1010
+ );
1011
+ consequent = this.notL ^ 1;
1012
+ }
1013
+ let kind = this.conflictKind;
1014
+ let val = this.conflictVal;
1015
+ const initSize = this.initTrailSize();
1016
+ for (;;) {
1017
+ this.processConsequentForUnsatCore(consequent, kind, val);
1018
+ while (index >= initSize) {
1019
+ consequent = this.trail[index];
1020
+ if (this.mark[consequent >> 1] && this.lvl(consequent) === this.conflictLevel) break;
1021
+ index--;
1022
+ }
1023
+ if (index < initSize) break;
1024
+ kind = this.justKind[consequent >> 1];
1025
+ val = this.justVal[consequent >> 1];
1026
+ index--;
1027
+ }
1028
+ this.resetUnmark(oldSize);
1029
+ if (this.core.length > 1) this.core = this.core.filter((lit) => this.lvl(lit) > 0);
1030
+ }
1031
+
1032
+ // max_cliques over the binary clauses, the largest mutexes first.
1033
+ findMutexes(lits: readonly number[]) {
1034
+ const remaining = [...lits];
1035
+ const extMutexes: number[][] = [];
1036
+ this.ext?.findMutexes(remaining, extMutexes);
1037
+ const cliques = new MaxCliques((index) => index ^ 1);
1038
+ const seen = new Set<string>();
1039
+ for (let index = 0; index < this.watches.length; index++) {
1040
+ const first = index ^ 1;
1041
+ const wlist = this.watches[index];
1042
+ for (let position = 0; position < wlist.size; position++) {
1043
+ if (!wlist.isBinary(position)) continue;
1044
+ const second = wlist.getLiteral(position);
1045
+ const key = `${first},${second}`;
1046
+ if (first > second || seen.has(key)) continue;
1047
+ seen.add(key);
1048
+ cliques.addEdge(first, second);
1049
+ }
1050
+ }
1051
+ const mutexes = cliques.cliques2(remaining);
1052
+ const sorted: number[][][] = [];
1053
+ for (const mutex of mutexes) (sorted[mutex.length] ??= []).push(mutex);
1054
+ const result = extMutexes;
1055
+ for (let size = sorted.length; size-- > 0;) result.push(...(sorted[size] ?? []));
1056
+ return result;
1057
+ }
1058
+
1059
+ private shouldCancel() {
1060
+ if (!this.limit.inc()) {
1061
+ this.isModelCurrent = false;
1062
+ this.reasonUnknown = "sat.canceled";
1063
+ return true;
1064
+ }
1065
+ if (this.config.restartMax <= this.restarts) {
1066
+ this.reasonUnknown = "sat.max.restarts";
1067
+ return true;
1068
+ }
1069
+ if (this.config.inprocessMax <= this.simplifications) {
1070
+ this.reasonUnknown = "sat.max.inprocess";
1071
+ return true;
1072
+ }
1073
+ return this.reachedMaxConflicts();
1074
+ }
1075
+
1076
+ private reachedMaxConflicts() {
1077
+ if (this.config.maxConflicts === 0 || this.conflictsSinceInit > this.config.maxConflicts) {
1078
+ this.reasonUnknown = "sat.max.conflicts";
1079
+ return !this.isInconsistent;
1080
+ }
1081
+ return false;
1082
+ }
1083
+
1084
+ private nextVar() {
1085
+ if (this.rand.next() < Math.trunc(this.config.randomFreq * RANDOM_MAX_VALUE)) {
1086
+ if (this.numVars() === 0) return -1;
1087
+ const next = this.rand.next() % this.numVars();
1088
+ if (this.valueVar(next) === L_UNDEF && !this.wasEliminated(next)) return next;
1089
+ }
1090
+ while (!this.caseSplitQueue.isEmpty()) {
1091
+ const next = this.caseSplitQueue.nextVar();
1092
+ if (this.valueVar(next) === L_UNDEF && !this.wasEliminated(next)) return next;
1093
+ }
1094
+ return -1;
1095
+ }
1096
+
1097
+ private guess(next: number) {
1098
+ const extPhase = this.ext?.getPhase?.(next) ?? L_UNDEF;
1099
+ if (extPhase !== L_UNDEF) return extPhase === L_TRUE;
1100
+ switch (this.config.phase) {
1101
+ case PS_ALWAYS_TRUE:
1102
+ return true;
1103
+ case PS_ALWAYS_FALSE:
1104
+ return false;
1105
+ case PS_BASIC_CACHING:
1106
+ return this.phase[next];
1107
+ case PS_FROZEN:
1108
+ return this.bestPhase[next];
1109
+ case PS_SAT_CACHING:
1110
+ return this.searchState === S_UNSAT ? this.phase[next] : this.bestPhase[next];
1111
+ default:
1112
+ return this.rand.next() % 2 === 0;
1113
+ }
1114
+ }
1115
+
1116
+ private decide() {
1117
+ const next = this.nextVar();
1118
+ if (next === -1) return false;
1119
+ this.push();
1120
+ this.assignScoped(2 * next + (this.guess(next) ? 0 : 1));
1121
+ return true;
1122
+ }
1123
+
1124
+ boundedSearch() {
1125
+ this.isSimplifyEnabled = false;
1126
+ this.isRestartEnabled = false;
1127
+ try {
1128
+ return this.basicSearch();
1129
+ } finally {
1130
+ this.isSimplifyEnabled = true;
1131
+ this.isRestartEnabled = true;
1132
+ }
1133
+ }
1134
+
1135
+ private basicSearch() {
1136
+ let result = L_UNDEF;
1137
+ while (result === L_UNDEF && !this.isGivenUp && !this.shouldCancel()) {
1138
+ if (this.isInconsistent) result = this.resolveConflictCore();
1139
+ else if (this.qhead < this.trail.length || this.ext?.canPropagate?.() === true)
1140
+ this.propagate(true);
1141
+ else if (this.doCleanup(false)) continue;
1142
+ else if (this.shouldGc()) this.doGc();
1143
+ else if (this.shouldRephase()) this.doRephase();
1144
+ else if (this.shouldRestart()) {
1145
+ if (!this.isRestartEnabled) return L_UNDEF;
1146
+ this.doRestart(!this.config.isRestartFast);
1147
+ } else if (this.shouldSimplify()) this.doSimplify();
1148
+ else if (!this.decide()) result = this.finalCheck();
1149
+ }
1150
+ return result;
1151
+ }
1152
+
1153
+ private finalCheck() {
1154
+ const ext = this.ext;
1155
+ if (ext?.check === undefined) {
1156
+ this.mkModel();
1157
+ return L_TRUE;
1158
+ }
1159
+ switch (ext.check()) {
1160
+ case CR_DONE:
1161
+ this.mkModel();
1162
+ return L_TRUE;
1163
+ case CR_GIVEUP:
1164
+ this.reasonUnknown = ext.getReasonUnknown?.() ?? "unknown";
1165
+ this.isGivenUp = true;
1166
+ return L_UNDEF;
1167
+ default:
1168
+ return L_UNDEF;
1169
+ }
1170
+ }
1171
+
1172
+ initSearch() {
1173
+ this.isModelCurrent = false;
1174
+ this.phaseCounter = 0;
1175
+ this.searchState = S_UNSAT;
1176
+ this.searchUnsatConflicts = this.config.searchUnsatConflicts;
1177
+ this.searchSatConflicts = this.config.searchSatConflicts;
1178
+ this.searchNextToggle = this.searchUnsatConflicts;
1179
+ this.bestPhaseSize = 0;
1180
+ this.rephaseLim = 0;
1181
+ this.rephaseInc = 0;
1182
+ this.conflictsSinceRestart = 0;
1183
+ this.isForcingConflictAnalysis = false;
1184
+ this.restartThreshold = this.config.restartInitial;
1185
+ this.lubyIndex = 1;
1186
+ this.gcThreshold = this.config.gcInitial;
1187
+ this.defragThreshold = 2;
1188
+ this.restarts = 0;
1189
+ this.simplifications = 0;
1190
+ this.conflictsSinceInit = 0;
1191
+ this.nextSimplify = this.config.simplifyDelay;
1192
+ this.minDTk = 1;
1193
+ this.searchLvl = 0;
1194
+ if (this.learned.length <= 2 * this.clauses.length) this.conflictsSinceGc = 0;
1195
+ this.asymmBranch.initSearch();
1196
+ this.core = [];
1197
+ this.simplifier.initSearch();
1198
+ this.ext?.initSearch?.();
1199
+ }
1200
+
1201
+ private shouldSimplify() {
1202
+ return this.conflictsSinceInit >= this.nextSimplify && this.isSimplifyEnabled;
1203
+ }
1204
+
1205
+ doSimplify() {
1206
+ if (!this.shouldSimplify()) return;
1207
+ this.simplifications++;
1208
+ this.pop(this.scopeLvl);
1209
+ this.cleaner.run(this.config.isForcingCleanup);
1210
+ this.scc.run();
1211
+ this.ext?.preSimplify?.();
1212
+ this.simplifier.run(false);
1213
+ if (this.learned.length > 0) this.simplifier.run(true);
1214
+ this.sortWatchLits();
1215
+ this.ext?.simplify();
1216
+ this.probing.run(false);
1217
+ this.asymmBranch.run(false);
1218
+ this.reinitAssumptions();
1219
+ if (this.isInconsistent) return;
1220
+ if (this.nextSimplify === 0) this.nextSimplify = this.config.nextSimplify1;
1221
+ else {
1222
+ this.nextSimplify = Math.trunc(this.conflictsSinceInit * this.config.simplifyMult2);
1223
+ if (this.nextSimplify > this.conflictsSinceInit + this.config.simplifyMax)
1224
+ this.nextSimplify = this.conflictsSinceInit + this.config.simplifyMax;
1225
+ }
1226
+ }
1227
+
1228
+ private sortWatchLits() {
1229
+ for (const wlist of this.watches) wlist.sortBinariesFirst();
1230
+ }
1231
+
1232
+ private mkModel() {
1233
+ this.isModelCurrent = true;
1234
+ const numVars = this.numVars();
1235
+ this.model = new Int8Array(numVars);
1236
+ for (let boolVar = 0; boolVar < numVars; boolVar++) {
1237
+ if (this.wasEliminated(boolVar)) continue;
1238
+ this.model[boolVar] = this.valueVar(boolVar);
1239
+ const isTrue = this.valueVar(boolVar) === L_TRUE;
1240
+ this.setPhase(boolVar, isTrue);
1241
+ this.setBestPhase(boolVar, isTrue);
1242
+ }
1243
+ this.mc.apply(this.model);
1244
+ }
1245
+
1246
+ private shouldRestart() {
1247
+ if (this.conflictsSinceRestart <= this.restartThreshold) return false;
1248
+ if (this.scopeLvl < 2 + this.searchLvl) return false;
1249
+ if (this.caseSplitQueue.isEmpty()) return false;
1250
+ if (this.config.restart !== RS_EMA) return true;
1251
+ return (
1252
+ this.fastGlueAvg.value + this.searchLvl <= this.scopeLvl &&
1253
+ this.config.restartMargin * this.slowGlueAvg.value <= this.fastGlueAvg.value
1254
+ );
1255
+ }
1256
+
1257
+ doRestart(isToBase: boolean) {
1258
+ this.restarts++;
1259
+ this.popReinit(this.restartLevel(isToBase));
1260
+ this.setNextRestart();
1261
+ }
1262
+
1263
+ private restartLevel(isToBase: boolean) {
1264
+ if (isToBase || this.scopeLvl === this.searchLvl) return this.scopeLvl - this.searchLvl;
1265
+ const next = this.caseSplitQueue.minVar();
1266
+ let level = this.searchLvl;
1267
+ while (
1268
+ level < this.scopeLvl &&
1269
+ this.caseSplitQueue.isMoreActive(this.trail[this.scopes[level].trailLim] >> 1, next)
1270
+ )
1271
+ level++;
1272
+ return level - this.searchLvl;
1273
+ }
1274
+
1275
+ private setNextRestart() {
1276
+ this.conflictsSinceRestart = 0;
1277
+ switch (this.config.restart) {
1278
+ case RS_GEOMETRIC:
1279
+ this.restartThreshold = Math.trunc(this.restartThreshold * this.config.restartFactor);
1280
+ break;
1281
+ case RS_LUBY:
1282
+ this.lubyIndex++;
1283
+ this.restartThreshold = this.config.restartInitial * getLuby(this.lubyIndex);
1284
+ break;
1285
+ case RS_EMA:
1286
+ this.restartThreshold = this.config.restartInitial;
1287
+ break;
1288
+ }
1289
+ }
1290
+
1291
+ private resolveConflictCore() {
1292
+ this.conflictsSinceInit++;
1293
+ this.conflictsSinceRestart++;
1294
+ this.conflictsSinceGc++;
1295
+ this.conflicts++;
1296
+ const conflict = this.getMaxLvl(this.notL, this.conflictKind, this.conflictVal);
1297
+ this.conflictLevel = conflict.level;
1298
+ if (
1299
+ this.conflictLevel <= 1 &&
1300
+ (this.assumptions.length > 0 || this.userScopeLiterals.length > 0)
1301
+ ) {
1302
+ this.resolveConflictForUnsatCore();
1303
+ return L_FALSE;
1304
+ }
1305
+ if (this.conflictLevel === 0) return L_FALSE;
1306
+ if (this.allowBacktracking() && conflict.isUniqueMax && !this.isForcingConflictAnalysis) {
1307
+ this.popReinit(this.scopeLvl - this.conflictLevel + 1);
1308
+ this.isForcingConflictAnalysis = true;
1309
+ return L_UNDEF;
1310
+ }
1311
+ this.isForcingConflictAnalysis = false;
1312
+ this.updatePhaseOfVars();
1313
+ if (this.ext !== null) {
1314
+ const result = this.ext.resolveConflict();
1315
+ if (result === L_TRUE) {
1316
+ this.learnLemmaAndBackjump();
1317
+ return L_UNDEF;
1318
+ }
1319
+ if (result === L_FALSE) return L_UNDEF;
1320
+ }
1321
+ this.lemma = [NULL_LITERAL];
1322
+ let index = this.skipLiteralsAboveConflictLevel();
1323
+ let numMarks = 0;
1324
+ let consequent = NULL_LITERAL;
1325
+ let kind = this.conflictKind;
1326
+ let val = this.conflictVal;
1327
+ if (this.notL !== NULL_LITERAL) {
1328
+ numMarks = this.processAntecedent(this.notL, numMarks);
1329
+ consequent = this.notL ^ 1;
1330
+ }
1331
+ do {
1332
+ if (kind === JUSTIFICATION_BINARY) numMarks = this.processAntecedent(val ^ 1, numMarks);
1333
+ else if (kind === JUSTIFICATION_CLAUSE) {
1334
+ const arena = this.arena;
1335
+ let position = 0;
1336
+ if (consequent !== NULL_LITERAL) {
1337
+ if (arena.get(val, 0) === consequent) position = 1;
1338
+ else {
1339
+ numMarks = this.processAntecedent(arena.get(val, 0) ^ 1, numMarks);
1340
+ position = 2;
1341
+ }
1342
+ }
1343
+ for (; position < arena.size[val]; position++)
1344
+ numMarks = this.processAntecedent(arena.get(val, position) ^ 1, numMarks);
1345
+ } else if (kind === JUSTIFICATION_EXT)
1346
+ for (const lit of this.getExtAntecedents(consequent, val))
1347
+ numMarks = this.processAntecedent(lit, numMarks);
1348
+ let boolVar: number;
1349
+ for (;;) {
1350
+ consequent = this.trail[index];
1351
+ boolVar = consequent >> 1;
1352
+ if (this.mark[boolVar] && this.lvlVar(boolVar) === this.conflictLevel) break;
1353
+ index--;
1354
+ }
1355
+ kind = this.justKind[boolVar];
1356
+ val = this.justVal[boolVar];
1357
+ index--;
1358
+ numMarks--;
1359
+ this.mark[boolVar] = false;
1360
+ } while (numMarks > 0);
1361
+ this.lemma[0] = consequent ^ 1;
1362
+ this.learnLemmaAndBackjump();
1363
+ return L_UNDEF;
1364
+ }
1365
+
1366
+ private learnLemmaAndBackjump() {
1367
+ if (this.config.isMinimizingLemmas) {
1368
+ this.minimizeLemma();
1369
+ this.resetLemmaVarMarks();
1370
+ if (this.config.isDynSubRes) this.dynSubRes();
1371
+ } else this.resetLemmaVarMarks();
1372
+ const lemma = this.lemma;
1373
+ let backtrackLvl = this.lvl(lemma[0]);
1374
+ let backjumpLvl = 0;
1375
+ for (let index = lemma.length; index-- > 1;)
1376
+ backjumpLvl = Math.max(this.lvl(lemma[index]), backjumpLvl);
1377
+ if (backtrackLvl < backjumpLvl) {
1378
+ backtrackLvl = backjumpLvl;
1379
+ for (let index = lemma.length; index-- > 1;)
1380
+ if (this.lvl(lemma[index]) === backjumpLvl) {
1381
+ const lit = lemma[index];
1382
+ lemma[index] = lemma[0];
1383
+ lemma[0] = lit;
1384
+ break;
1385
+ }
1386
+ }
1387
+ const glue = this.numDiffLevels(lemma);
1388
+ this.fastGlueAvg.update(glue);
1389
+ this.slowGlueAvg.update(glue);
1390
+ const numScopes = this.scopeLvl - backjumpLvl;
1391
+ if (this.useBackjumping(numScopes)) this.popReinit(numScopes);
1392
+ else this.popReinit(this.scopeLvl - backtrackLvl + 1);
1393
+ const clause = this.mkClauseCore(lemma, true);
1394
+ if (clause !== -1) this.arena.setGlue(clause, glue);
1395
+ this.lemma = [];
1396
+ this.activityInc = Math.trunc(((this.activityInc * this.config.variableDecay) % 2 ** 32) / 100);
1397
+ this.updatePhaseCounters();
1398
+ }
1399
+
1400
+ private useBackjumping(numScopes: number) {
1401
+ return numScopes > 0 && (numScopes <= this.config.backtrackScopes || !this.allowBacktracking());
1402
+ }
1403
+
1404
+ private allowBacktracking() {
1405
+ return this.conflictsSinceInit > this.config.backtrackInitConflicts;
1406
+ }
1407
+
1408
+ getMaxLvl(notL: number, kind: number, val: number) {
1409
+ let isUniqueMax = true;
1410
+ let level = notL !== NULL_LITERAL ? this.lvl(notL) : 0;
1411
+ const update = (lit: number) => {
1412
+ const litLevel = this.lvl(lit);
1413
+ if (litLevel < level) return;
1414
+ isUniqueMax = litLevel > level;
1415
+ level = litLevel;
1416
+ };
1417
+ if (kind === JUSTIFICATION_NONE) level = Math.max(level, this.conflictJustLevel);
1418
+ else if (kind === JUSTIFICATION_BINARY) update(val);
1419
+ else if (kind === JUSTIFICATION_EXT)
1420
+ for (const lit of this.getExtAntecedents(notL === NULL_LITERAL ? notL : notL ^ 1, val))
1421
+ update(lit);
1422
+ else
1423
+ for (let index = 0; index < this.arena.size[val]; index++) update(this.arena.get(val, index));
1424
+ return { level, isUniqueMax };
1425
+ }
1426
+
1427
+ private getExtAntecedents(consequent: number, index: number) {
1428
+ const antecedents: number[] = [];
1429
+ (this.ext as SatExtension).getAntecedents(consequent, index, antecedents);
1430
+ return antecedents;
1431
+ }
1432
+
1433
+ private skipLiteralsAboveConflictLevel() {
1434
+ let index = this.trail.length;
1435
+ if (index === 0) return index;
1436
+ index--;
1437
+ while (this.lvl(this.trail[index]) > this.conflictLevel) index--;
1438
+ return index;
1439
+ }
1440
+
1441
+ private processAntecedent(antecedent: number, numMarks: number) {
1442
+ const boolVar = antecedent >> 1;
1443
+ const varLvl = this.lvlVar(boolVar);
1444
+ if (this.mark[boolVar] || varLvl <= 0) return numMarks;
1445
+ this.mark[boolVar] = true;
1446
+ this.incActivity(boolVar);
1447
+ if (varLvl === this.conflictLevel) return numMarks + 1;
1448
+ this.lemma.push(antecedent ^ 1);
1449
+ return numMarks;
1450
+ }
1451
+
1452
+ private isTwoPhase() {
1453
+ return this.config.phase === PS_SAT_CACHING;
1454
+ }
1455
+
1456
+ private isSatPhase() {
1457
+ return this.isTwoPhase() && this.searchState === S_SAT;
1458
+ }
1459
+
1460
+ private updatePhaseOfVars() {
1461
+ if (this.config.phase === PS_FROZEN) return;
1462
+ const fromLvl = this.conflictLevel;
1463
+ const head = fromLvl === 0 ? 0 : this.scopes[fromLvl - 1].trailLim;
1464
+ for (let index = head; index < this.trail.length; index++)
1465
+ this.setPhase(this.trail[index] >> 1, this.rand.next() % 2 === 0);
1466
+ if (this.isSatPhase() && head >= this.bestPhaseSize) {
1467
+ this.bestPhaseSize = head;
1468
+ for (let index = 0; index < head; index++) {
1469
+ const boolVar = this.trail[index] >> 1;
1470
+ this.setBestPhase(boolVar, this.phase[boolVar]);
1471
+ }
1472
+ }
1473
+ }
1474
+
1475
+ private shouldToggleSearchState() {
1476
+ if (this.searchState === S_UNSAT) this.trailAvg.update(this.trail.length);
1477
+ return (
1478
+ this.phaseCounter >= this.searchNextToggle &&
1479
+ (this.searchState === S_SAT || this.trail.length > 0.5 * this.trailAvg.value)
1480
+ );
1481
+ }
1482
+
1483
+ private doToggleSearchState() {
1484
+ if (this.isTwoPhase()) {
1485
+ this.bestPhaseSize = 0;
1486
+ [this.fastGlueBackup, this.fastGlueAvg] = [this.fastGlueAvg, this.fastGlueBackup];
1487
+ [this.slowGlueBackup, this.slowGlueAvg] = [this.slowGlueAvg, this.slowGlueBackup];
1488
+ if (this.searchState === S_SAT) this.searchUnsatConflicts += this.config.searchUnsatConflicts;
1489
+ else this.searchSatConflicts += this.config.searchSatConflicts;
1490
+ }
1491
+ if (this.searchState === S_UNSAT) {
1492
+ this.searchState = S_SAT;
1493
+ this.searchNextToggle = this.searchSatConflicts;
1494
+ } else {
1495
+ this.searchState = S_UNSAT;
1496
+ this.searchNextToggle = this.searchUnsatConflicts;
1497
+ }
1498
+ this.phaseCounter = 0;
1499
+ }
1500
+
1501
+ private shouldRephase() {
1502
+ return this.conflictsSinceInit > this.rephaseLim;
1503
+ }
1504
+
1505
+ private doRephase() {
1506
+ const size = this.phase.length;
1507
+ switch (this.config.phase) {
1508
+ case PS_ALWAYS_TRUE:
1509
+ for (let index = 0; index < size; index++) this.setPhase(index, true);
1510
+ break;
1511
+ case PS_ALWAYS_FALSE:
1512
+ for (let index = 0; index < size; index++) this.setPhase(index, false);
1513
+ break;
1514
+ case PS_BASIC_CACHING:
1515
+ switch (this.rephaseCount % 4) {
1516
+ case 0:
1517
+ for (let index = 0; index < size; index++)
1518
+ this.setPhase(index, this.rand.next() % 2 === 0);
1519
+ break;
1520
+ case 1:
1521
+ for (let index = 0; index < size; index++) this.setPhase(index, false);
1522
+ break;
1523
+ case 2:
1524
+ for (let index = 0; index < size; index++) this.setPhase(index, !this.phase[index]);
1525
+ break;
1526
+ }
1527
+ break;
1528
+ case PS_SAT_CACHING:
1529
+ if (this.searchState === S_SAT)
1530
+ for (let index = 0; index < size; index++) this.setPhase(index, this.bestPhase[index]);
1531
+ break;
1532
+ case PS_RANDOM:
1533
+ for (let index = 0; index < size; index++) this.setPhase(index, this.rand.next() % 2 === 0);
1534
+ break;
1535
+ }
1536
+ this.rephaseInc += this.config.rephaseBase;
1537
+ this.rephaseLim += this.rephaseInc;
1538
+ this.rephaseCount++;
1539
+ }
1540
+
1541
+ private updatePhaseCounters() {
1542
+ this.phaseCounter++;
1543
+ if (this.shouldToggleSearchState()) this.doToggleSearchState();
1544
+ }
1545
+
1546
+ numDiffLevels(lits: number[]) {
1547
+ let result = 0;
1548
+ for (const lit of lits) {
1549
+ const litLvl = this.lvl(lit);
1550
+ if (!this.diffLevels[litLvl]) {
1551
+ this.diffLevels[litLvl] = true;
1552
+ result++;
1553
+ }
1554
+ }
1555
+ for (const lit of lits) this.diffLevels[this.lvl(lit)] = false;
1556
+ return result;
1557
+ }
1558
+
1559
+ numDiffFalseLevelsBelow(lits: number[], maxGlue: number) {
1560
+ let glue = 0;
1561
+ let index = 0;
1562
+ for (; index < lits.length && glue < maxGlue; index++) {
1563
+ if (this.value(lits[index]) !== L_FALSE) continue;
1564
+ const litLvl = this.lvl(lits[index]);
1565
+ if (!this.diffLevels[litLvl]) {
1566
+ this.diffLevels[litLvl] = true;
1567
+ glue++;
1568
+ }
1569
+ }
1570
+ while (index-- > 0)
1571
+ if (this.value(lits[index]) === L_FALSE) this.diffLevels[this.lvl(lits[index])] = false;
1572
+ return glue < maxGlue ? glue : -1;
1573
+ }
1574
+
1575
+ private numDiffLevelsBelow(clause: number, maxGlue: number) {
1576
+ const arena = this.arena;
1577
+ let glue = 0;
1578
+ let index = 0;
1579
+ for (; index < arena.size[clause] && glue < maxGlue; index++) {
1580
+ const litLvl = this.lvl(arena.get(clause, index));
1581
+ if (!this.diffLevels[litLvl]) {
1582
+ this.diffLevels[litLvl] = true;
1583
+ glue++;
1584
+ }
1585
+ }
1586
+ while (index-- > 0) this.diffLevels[this.lvl(arena.get(clause, index))] = false;
1587
+ return glue < maxGlue ? glue : -1;
1588
+ }
1589
+
1590
+ private processAntecedentForMinimization(antecedent: number) {
1591
+ const boolVar = antecedent >> 1;
1592
+ const varLvl = this.lvlVar(boolVar);
1593
+ if (!this.mark[boolVar] && varLvl > 0) {
1594
+ if ((this.lvlSet & (1 << (varLvl & 31))) === 0) return false;
1595
+ this.mark[boolVar] = true;
1596
+ this.unmark.push(boolVar);
1597
+ this.lemmaMinStack.push(antecedent);
1598
+ }
1599
+ return true;
1600
+ }
1601
+
1602
+ private impliedByMarked(start: number) {
1603
+ this.lemmaMinStack = [start];
1604
+ const oldSize = this.unmark.length;
1605
+ while (this.lemmaMinStack.length > 0) {
1606
+ const boolVar = (this.lemmaMinStack.pop() as number) >> 1;
1607
+ const kind = this.justKind[boolVar];
1608
+ const val = this.justVal[boolVar];
1609
+ let isImplied = true;
1610
+ if (kind === JUSTIFICATION_NONE) isImplied = this.lvlVar(boolVar) <= 0;
1611
+ else if (kind === JUSTIFICATION_BINARY)
1612
+ isImplied = this.processAntecedentForMinimization(val ^ 1);
1613
+ else if (kind === JUSTIFICATION_EXT) {
1614
+ const consequent = 2 * boolVar + (this.valueVar(boolVar) === L_FALSE ? 1 : 0);
1615
+ for (const lit of this.getExtAntecedents(consequent, val))
1616
+ if (!(isImplied = this.processAntecedentForMinimization(lit))) break;
1617
+ } else {
1618
+ const arena = this.arena;
1619
+ let position = 1;
1620
+ if (arena.get(val, 0) >> 1 !== boolVar) {
1621
+ isImplied = this.processAntecedentForMinimization(arena.get(val, 0) ^ 1);
1622
+ position = 2;
1623
+ }
1624
+ for (; isImplied && position < arena.size[val]; position++)
1625
+ isImplied = this.processAntecedentForMinimization(arena.get(val, position) ^ 1);
1626
+ }
1627
+ if (!isImplied) {
1628
+ this.resetUnmark(oldSize);
1629
+ return false;
1630
+ }
1631
+ }
1632
+ return true;
1633
+ }
1634
+
1635
+ private resetUnmark(oldSize: number) {
1636
+ for (let index = oldSize; index < this.unmark.length; index++)
1637
+ this.mark[this.unmark[index]] = false;
1638
+ this.unmark.length = oldSize;
1639
+ }
1640
+
1641
+ private minimizeLemma() {
1642
+ this.lvlSet = 0;
1643
+ for (const lit of this.lemma) this.lvlSet |= 1 << (this.lvl(lit) & 31);
1644
+ const size = this.lemma.length;
1645
+ let next = 1;
1646
+ for (let index = 1; index < size; index++) {
1647
+ const lit = this.lemma[index];
1648
+ if (this.impliedByMarked(lit)) this.unmark.push(lit >> 1);
1649
+ else this.lemma[next++] = lit;
1650
+ }
1651
+ this.resetUnmark(0);
1652
+ this.lemma.length = next;
1653
+ }
1654
+
1655
+ private resetLemmaVarMarks() {
1656
+ this.updateLrbReasoned();
1657
+ for (let index = 1; index < this.lemma.length; index++)
1658
+ this.mark[this.lemma[index] >> 1] = false;
1659
+ }
1660
+
1661
+ private updateLrbReasoned() {
1662
+ const lemma = this.lemma;
1663
+ const size = lemma.length;
1664
+ this.mark[lemma[0] >> 1] = true;
1665
+ const reason = (lit: number) => {
1666
+ const boolVar = lit >> 1;
1667
+ if (this.mark[boolVar]) return;
1668
+ this.mark[boolVar] = true;
1669
+ this.incActivity(boolVar);
1670
+ lemma.push(lit);
1671
+ };
1672
+ for (let index = lemma.length; index-- > 0;) {
1673
+ const boolVar = lemma[index] >> 1;
1674
+ const kind = this.justKind[boolVar];
1675
+ const val = this.justVal[boolVar];
1676
+ if (kind === JUSTIFICATION_BINARY) reason(val);
1677
+ else if (kind === JUSTIFICATION_CLAUSE)
1678
+ for (let position = 0; position < this.arena.size[val]; position++)
1679
+ reason(this.arena.get(val, position));
1680
+ else if (kind === JUSTIFICATION_EXT)
1681
+ for (const lit of this.getExtAntecedents(lemma[index] ^ 1, val)) reason(lit);
1682
+ }
1683
+ this.mark[lemma[0] >> 1] = false;
1684
+ for (let index = lemma.length; index-- > size;) this.mark[lemma[index] >> 1] = false;
1685
+ lemma.length = size;
1686
+ }
1687
+
1688
+ private dynSubRes() {
1689
+ const lemma = this.lemma;
1690
+ const size = lemma.length;
1691
+ for (const lit of lemma) this.litMark[lit] = true;
1692
+ const first = lemma[0];
1693
+ for (let index = 0; index < size; index++) {
1694
+ const lit = lemma[index];
1695
+ if (!this.litMark[lit]) continue;
1696
+ const wlist = this.getWlist(lit ^ 1);
1697
+ for (let position = 0; position < wlist.size && wlist.isBinary(position); position++) {
1698
+ const other = wlist.getLiteral(position);
1699
+ if (this.litMark[other ^ 1] && first !== (other ^ 1)) this.litMark[other ^ 1] = false;
1700
+ }
1701
+ const impliedLits = this.probing.cachedImpliedLits(lit ^ 1);
1702
+ if (impliedLits !== undefined)
1703
+ for (const other of impliedLits)
1704
+ if (this.litMark[other ^ 1] && first !== (other ^ 1)) this.litMark[other ^ 1] = false;
1705
+ }
1706
+ let next = 0;
1707
+ for (let index = 0; index < size; index++) {
1708
+ const lit = lemma[index];
1709
+ if (this.litMark[lit]) {
1710
+ this.litMark[lit] = false;
1711
+ lemma[next++] = lit;
1712
+ }
1713
+ }
1714
+ lemma.length = next;
1715
+ }
1716
+
1717
+ push() {
1718
+ this.scopes.push({
1719
+ trailLim: this.trail.length,
1720
+ clausesToReinitLim: this.clausesToReinit.length,
1721
+ });
1722
+ this.scopeLvl++;
1723
+ if (this.ext !== null) {
1724
+ this.varsLim.push(this.activeVars.length);
1725
+ this.ext.push();
1726
+ }
1727
+ }
1728
+
1729
+ popReinit(numScopes: number) {
1730
+ this.pop(numScopes);
1731
+ this.reinitAssumptions();
1732
+ }
1733
+
1734
+ // pop_vars keeps every variable made in the popped scopes: no variable is freed for reuse.
1735
+ private popVars(numScopes: number) {
1736
+ this.varsToReinit = [];
1737
+ const oldNumVars = this.varsLim[this.varsLim.length - numScopes];
1738
+ this.varsLim.length -= numScopes;
1739
+ const newLvl = this.scopes.length - numScopes;
1740
+ for (let index = oldNumVars; index < this.activeVars.length; index++) {
1741
+ const boolVar = this.activeVars[index];
1742
+ this.varsToReinit.push(boolVar);
1743
+ this.varScope[boolVar] = newLvl;
1744
+ }
1745
+ }
1746
+
1747
+ pop(numScopes: number) {
1748
+ if (numScopes === 0) return;
1749
+ if (this.ext !== null) {
1750
+ this.popVars(numScopes);
1751
+ this.ext.pop(numScopes);
1752
+ }
1753
+ const newLvl = this.scopeLvl - numScopes;
1754
+ const scope = this.scopes[newLvl];
1755
+ this.isInconsistent = false;
1756
+ this.unassignVars(scope.trailLim, newLvl);
1757
+ this.scopeLvl -= numScopes;
1758
+ this.reinitClauses(scope.clausesToReinitLim);
1759
+ this.scopes.length = newLvl;
1760
+ this.ext?.popReinit();
1761
+ }
1762
+
1763
+ private unassignVars(oldSize: number, newLvl: number) {
1764
+ for (let index = this.trail.length; index-- > oldSize;) {
1765
+ const lit = this.trail[index];
1766
+ const boolVar = lit >> 1;
1767
+ if (this.lvlVar(boolVar) <= newLvl) {
1768
+ this.replayAssign.push(lit);
1769
+ continue;
1770
+ }
1771
+ this.assignment[lit] = L_UNDEF;
1772
+ this.assignment[lit ^ 1] = L_UNDEF;
1773
+ this.caseSplitQueue.unassignVar(boolVar);
1774
+ }
1775
+ this.trail.length = oldSize;
1776
+ this.qhead = oldSize;
1777
+ for (let index = this.replayAssign.length; index-- > 0;)
1778
+ this.trail.push(this.replayAssign[index]);
1779
+ this.replayAssign.length = 0;
1780
+ }
1781
+
1782
+ private reinitClauses(oldSize: number) {
1783
+ const stack = this.clausesToReinit;
1784
+ let next = oldSize;
1785
+ for (let index = oldSize; index < stack.length; index += 2) {
1786
+ const first = stack[index];
1787
+ const second = stack[index + 1];
1788
+ if (second !== NULL_LITERAL) {
1789
+ if (
1790
+ (this.propagateBinClause(first, second) && !this.atBaseLvl()) ||
1791
+ (this.hasVariablesToReinitBinary(first, second) && !this.atBaseLvl())
1792
+ ) {
1793
+ stack[next++] = first;
1794
+ stack[next++] = second;
1795
+ }
1796
+ continue;
1797
+ }
1798
+ this.detachClause(first);
1799
+ const isReinit = this.attachClause(first);
1800
+ if (
1801
+ (isReinit && !this.atBaseLvl()) ||
1802
+ (this.hasVariablesToReinit(first) && !this.atBaseLvl())
1803
+ ) {
1804
+ stack[next++] = first;
1805
+ stack[next++] = second;
1806
+ } else this.arena.setReinitStack(first, false);
1807
+ }
1808
+ stack.length = next;
1809
+ }
1810
+
1811
+ popToBaseLevel() {
1812
+ this.resetAssumptions();
1813
+ this.pop(this.scopeLvl);
1814
+ this.isModelCurrent = false;
1815
+ }
1816
+
1817
+ // user_push: every clause added in the scope is guarded by the scope's literal. Without free
1818
+ // variables, the scope variable is the last one.
1819
+ userPush() {
1820
+ this.popToBaseLevel();
1821
+ this.userScopeLiterals.push(2 * this.mkVar(true));
1822
+ this.ext?.userPush?.();
1823
+ }
1824
+
1825
+ userPop(numScopes: number) {
1826
+ if (this.userScopeLiterals.length === 0) return;
1827
+ const oldSize = this.userScopeLiterals.length - numScopes;
1828
+ const maxVar = this.userScopeLiterals[oldSize] >> 1;
1829
+ this.userScopeLiterals.length = oldSize;
1830
+ this.popToBaseLevel();
1831
+ this.ext?.userPop?.(numScopes);
1832
+ this.gcVars(maxVar);
1833
+ this.qhead = 0;
1834
+ const wasSuspended = this.limit.isSuspended;
1835
+ this.limit.isSuspended = true;
1836
+ this.propagate(false);
1837
+ this.limit.isSuspended = wasSuspended;
1838
+ }
1839
+
1840
+ // gc_vars: drop the variables from maxVar on, with their watches and clauses.
1841
+ private gcVars(maxVar: number) {
1842
+ this.initVisited();
1843
+ const others: number[] = [];
1844
+ for (let lit = 2 * maxVar; lit < 2 * this.varCount; lit++) {
1845
+ const wlist = this.watches[lit];
1846
+ for (let index = 0; index < wlist.size; index++) {
1847
+ const other = wlist.getLiteral(index);
1848
+ if (wlist.isBinary(index) && other >> 1 < maxVar && !this.isVisited(other)) {
1849
+ others.push(other);
1850
+ this.markVisited(other);
1851
+ }
1852
+ }
1853
+ wlist.size = 0;
1854
+ }
1855
+ for (const lit of others) {
1856
+ const wlist = this.watches[lit ^ 1];
1857
+ let next = 0;
1858
+ for (let index = 0; index < wlist.size; index++)
1859
+ if (!wlist.isBinary(index) || wlist.getLiteral(index) >> 1 < maxVar) {
1860
+ wlist.data[2 * next] = wlist.data[2 * index];
1861
+ wlist.data[2 * next + 1] = wlist.data[2 * index + 1];
1862
+ next++;
1863
+ }
1864
+ wlist.size = next;
1865
+ }
1866
+ const gcClauses = (clauses: number[]) => {
1867
+ let next = 0;
1868
+ for (const clause of clauses) {
1869
+ if (this.arena.getLits(clause).some((lit) => lit >> 1 >= maxVar)) {
1870
+ this.detachClause(clause);
1871
+ this.delClause(clause);
1872
+ } else clauses[next++] = clause;
1873
+ }
1874
+ clauses.length = next;
1875
+ };
1876
+ gcClauses(this.learned);
1877
+ gcClauses(this.clauses);
1878
+ let next = 0;
1879
+ for (const lit of this.trail) if (lit >> 1 < maxVar) this.trail[next++] = lit;
1880
+ this.trail.length = next;
1881
+ this.shrinkVars(maxVar);
1882
+ }
1883
+
1884
+ private shrinkVars(boolVar: number) {
1885
+ for (let index = this.varCount; index-- > boolVar;) {
1886
+ this.caseSplitQueue.delVar(index);
1887
+ this.probing.resetCache(2 * index + 1);
1888
+ this.probing.resetCache(2 * index);
1889
+ }
1890
+ this.varCount = boolVar;
1891
+ this.watches.length = 2 * boolVar;
1892
+ this.assignment.fill(L_UNDEF, 2 * boolVar);
1893
+ for (const values of [
1894
+ this.justVal,
1895
+ this.justKind,
1896
+ this.eliminated,
1897
+ this.external,
1898
+ this.varScope,
1899
+ this.touched,
1900
+ this.activity,
1901
+ this.mark,
1902
+ this.phase,
1903
+ this.bestPhase,
1904
+ this.prevPhase,
1905
+ this.phaseBirthdate,
1906
+ this.bestPhaseBirthdate,
1907
+ this.assignedSinceGc,
1908
+ ])
1909
+ values.length = boolVar;
1910
+ this.litMark.length = 2 * boolVar;
1911
+ this.simplifier.resetTodos();
1912
+ }
1913
+
1914
+ incActivity(boolVar: number) {
1915
+ this.activity[boolVar] += this.activityInc;
1916
+ this.caseSplitQueue.activityIncreased(boolVar);
1917
+ if (this.activity[boolVar] > 1 << 24) this.rescaleActivity();
1918
+ }
1919
+
1920
+ private rescaleActivity() {
1921
+ for (let index = 0; index < this.activity.length; index++) this.activity[index] >>>= 14;
1922
+ this.activityInc >>>= 14;
1923
+ }
1924
+
1925
+ doCleanup(isForced: boolean) {
1926
+ if (this.conflictsSinceInit === 0 && !isForced) return false;
1927
+ return this.atBaseLvl() && !this.isInconsistent && this.cleaner.run(isForced);
1928
+ }
1929
+
1930
+ private shouldGc() {
1931
+ return (
1932
+ this.conflictsSinceGc > this.gcThreshold &&
1933
+ (this.config.gcStrategy !== GC_DYN_PSM || this.atBaseLvl())
1934
+ );
1935
+ }
1936
+
1937
+ private doGc() {
1938
+ if (!this.shouldGc()) return;
1939
+ const gc = this.gcClauses;
1940
+ this.conflictsSinceGc = 0;
1941
+ this.gcThreshold += this.config.gcIncrement;
1942
+ const arena = this.arena;
1943
+ const glue = (clause: number) => arena.glue[clause];
1944
+ const psm = (clause: number) => arena.psm[clause];
1945
+ const size = (clause: number) => arena.size[clause];
1946
+ const lex =
1947
+ (...keys: ((clause: number) => number)[]) =>
1948
+ (first: number, second: number) => {
1949
+ for (const key of keys) {
1950
+ if (key(first) < key(second)) return true;
1951
+ if (key(first) > key(second)) return false;
1952
+ }
1953
+ return false;
1954
+ };
1955
+ switch (this.config.gcStrategy) {
1956
+ case GC_GLUE:
1957
+ sortClauses(this.learned, lex(glue, size));
1958
+ this.gcHalf();
1959
+ break;
1960
+ case GC_PSM:
1961
+ this.savePsm();
1962
+ sortClauses(this.learned, lex(psm, size));
1963
+ this.gcHalf();
1964
+ break;
1965
+ case GC_GLUE_PSM:
1966
+ this.savePsm();
1967
+ sortClauses(this.learned, lex(glue, psm, size));
1968
+ this.gcHalf();
1969
+ break;
1970
+ case GC_PSM_GLUE:
1971
+ this.savePsm();
1972
+ sortClauses(this.learned, lex(psm, glue, size));
1973
+ this.gcHalf();
1974
+ break;
1975
+ case GC_DYN_PSM:
1976
+ if (!this.atBaseLvl()) return;
1977
+ this.gcDynPsm();
1978
+ break;
1979
+ }
1980
+ this.ext?.gc();
1981
+ if (gc > 0 && this.shouldDefrag()) this.defragClauses();
1982
+ }
1983
+
1984
+ private savePsm() {
1985
+ for (const clause of this.learned) this.arena.setPsm(clause, this.psm(clause));
1986
+ }
1987
+
1988
+ private gcHalf() {
1989
+ const size = this.learned.length;
1990
+ let next = size >>> 1;
1991
+ for (let index = size >>> 1; index < size; index++) {
1992
+ const clause = this.learned[index];
1993
+ if (this.canDelete(clause)) {
1994
+ this.detachClause(clause);
1995
+ this.delClause(clause);
1996
+ } else this.learned[next++] = clause;
1997
+ }
1998
+ this.gcClauses += size - next;
1999
+ this.learned.length = next;
2000
+ }
2001
+
2002
+ canDelete(clause: number) {
2003
+ if (this.arena.isOnReinitStack(clause)) return false;
2004
+ const first = this.arena.get(clause, 0);
2005
+ if (this.value(first) !== L_TRUE) return true;
2006
+ return (
2007
+ this.justKind[first >> 1] !== JUSTIFICATION_CLAUSE || this.justVal[first >> 1] !== clause
2008
+ );
2009
+ }
2010
+
2011
+ private gcDynPsm() {
2012
+ let flips = 0;
2013
+ let assigned = 0;
2014
+ for (let boolVar = 0; boolVar < this.numVars(); boolVar++) {
2015
+ if (this.assignedSinceGc[boolVar]) {
2016
+ assigned++;
2017
+ this.assignedSinceGc[boolVar] = false;
2018
+ }
2019
+ if (this.phase[boolVar] !== this.prevPhase[boolVar]) {
2020
+ flips++;
2021
+ this.prevPhase[boolVar] = this.phase[boolVar];
2022
+ }
2023
+ }
2024
+ const dTk = assigned === 0 ? this.numVars() + 1 : flips / assigned;
2025
+ if (dTk < this.minDTk) this.minDTk = dTk;
2026
+ const arena = this.arena;
2027
+ let next = 0;
2028
+ for (const clause of this.learned) {
2029
+ if (!arena.isFrozen(clause)) {
2030
+ if (arena.glue[clause] > this.config.gcSmallLbd) {
2031
+ if (arena.wasUsed(clause)) arena.inactRounds[clause] = 0;
2032
+ else {
2033
+ arena.incInactRounds(clause);
2034
+ if (arena.inactRounds[clause] > this.config.gcK) {
2035
+ this.detachClause(clause);
2036
+ this.delClause(clause);
2037
+ this.gcClauses++;
2038
+ continue;
2039
+ }
2040
+ }
2041
+ arena.unmarkUsed(clause);
2042
+ if (this.psm(clause) > Math.trunc(arena.size[clause] * this.minDTk)) {
2043
+ this.detachClause(clause);
2044
+ arena.inactRounds[clause] = 0;
2045
+ arena.setFrozen(clause, true);
2046
+ }
2047
+ }
2048
+ } else if (this.psm(clause) <= Math.trunc(arena.size[clause] * this.minDTk)) {
2049
+ arena.setFrozen(clause, false);
2050
+ if (!this.activateFrozenClause(clause)) {
2051
+ this.delClause(clause);
2052
+ continue;
2053
+ }
2054
+ } else {
2055
+ arena.incInactRounds(clause);
2056
+ if (arena.inactRounds[clause] > this.config.gcK) {
2057
+ this.delClause(clause);
2058
+ this.gcClauses++;
2059
+ continue;
2060
+ }
2061
+ }
2062
+ this.learned[next++] = clause;
2063
+ }
2064
+ this.learned.length = next;
2065
+ }
2066
+
2067
+ private activateFrozenClause(clause: number) {
2068
+ const arena = this.arena;
2069
+ const size = arena.size[clause];
2070
+ let next = 0;
2071
+ for (let index = 0; index < size; index++) {
2072
+ const value = this.value(arena.get(clause, index));
2073
+ if (value === L_TRUE) return false;
2074
+ if (value === L_UNDEF) {
2075
+ if (index !== next) arena.swap(clause, index, next);
2076
+ next++;
2077
+ }
2078
+ }
2079
+ switch (next) {
2080
+ case 0:
2081
+ this.setConflict();
2082
+ return false;
2083
+ case 1:
2084
+ this.assignUnit(arena.get(clause, 0));
2085
+ return false;
2086
+ case 2:
2087
+ this.mkBinClause(arena.get(clause, 0), arena.get(clause, 1), true);
2088
+ return false;
2089
+ default:
2090
+ this.shrink(clause, size, next);
2091
+ this.attachClause(clause);
2092
+ return true;
2093
+ }
2094
+ }
2095
+
2096
+ private psm(clause: number) {
2097
+ const arena = this.arena;
2098
+ let result = 0;
2099
+ for (let index = 0; index < arena.size[clause]; index++) {
2100
+ const lit = arena.get(clause, index);
2101
+ if (((lit & 1) === 1) !== this.phase[lit >> 1]) result++;
2102
+ }
2103
+ return result;
2104
+ }
2105
+ }