tla-ts 0.0.10-dev.b4a856304 → 0.0.10-dev.c92e6a4ea

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 (586) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +57 -53
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +37 -0
  8. package/dist/index.d.ts +37 -0
  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.cjs +2683 -427
  13. package/dist/prove.js +2681 -425
  14. package/dist/run.cjs +45 -44
  15. package/dist/run.js +45 -44
  16. package/dist/tlapm.cjs +2 -2
  17. package/dist/tlapm.js +2 -2
  18. package/dist/transfer.cjs +44 -41
  19. package/dist/transfer.js +45 -42
  20. package/dist/worker.cjs +7 -7
  21. package/dist/worker.js +7 -7
  22. package/package.json +1 -1
  23. package/src/ast.ts +41 -41
  24. package/src/bags.ts +2 -5
  25. package/src/builtins.ts +5 -21
  26. package/src/check-failure.ts +116 -0
  27. package/src/check-trace.ts +268 -0
  28. package/src/check.ts +578 -757
  29. package/src/cli/options.ts +6 -31
  30. package/src/cli/run.ts +0 -2
  31. package/src/cli/runtime-invariants.ts +27 -62
  32. package/src/cli/shared.ts +1 -5
  33. package/src/cli/tlapm.ts +433 -70
  34. package/src/cli/tlc-arguments.ts +246 -240
  35. package/src/cli/tlc-output.ts +686 -0
  36. package/src/cli/tlc-usage.ts +3 -5
  37. package/src/cli/tlc.ts +59 -707
  38. package/src/cli/xml-exporter.ts +23 -33
  39. package/src/codegen.ts +5 -10
  40. package/src/coverage.ts +3 -10
  41. package/src/dependencies.ts +30 -14
  42. package/src/dfid.ts +16 -16
  43. package/src/environment-config.ts +315 -0
  44. package/src/environment.ts +73 -338
  45. package/src/errors.ts +33 -5
  46. package/src/evaluate.ts +34 -107
  47. package/src/exit-codes.ts +3 -0
  48. package/src/fingerprints.ts +65 -1
  49. package/src/instances.ts +47 -10
  50. package/src/java-hash.ts +7 -0
  51. package/src/java-overrides.ts +4 -9
  52. package/src/json-reader.ts +1 -2
  53. package/src/json.ts +8 -18
  54. package/src/levels.ts +46 -57
  55. package/src/lexer.ts +76 -85
  56. package/src/liveness-checker.ts +634 -306
  57. package/src/liveness.ts +104 -120
  58. package/src/obligations/action.ts +14 -17
  59. package/src/obligations/anonymize.ts +37 -16
  60. package/src/obligations/enabled-axioms.ts +218 -0
  61. package/src/obligations/equality.ts +1 -3
  62. package/src/obligations/expression.ts +36 -8
  63. package/src/obligations/format.ts +0 -2
  64. package/src/obligations/generate.ts +66 -54
  65. package/src/obligations/index.ts +38 -8
  66. package/src/obligations/levels.ts +24 -11
  67. package/src/obligations/module.ts +28 -41
  68. package/src/obligations/normalize.ts +26 -14
  69. package/src/obligations/operators.ts +0 -2
  70. package/src/obligations/pragma.ts +53 -16
  71. package/src/obligations/printer.ts +43 -13
  72. package/src/obligations/proof.ts +3 -2
  73. package/src/obligations/regroup.ts +0 -2
  74. package/src/obligations/simplify.ts +55 -50
  75. package/src/obligations/source.ts +118 -74
  76. package/src/obligations/subexpression.ts +45 -18
  77. package/src/obligations/substitution.ts +1 -3
  78. package/src/obligations/temporal.ts +5 -7
  79. package/src/obligations/tuples.ts +0 -2
  80. package/src/parallel-worker.ts +17 -31
  81. package/src/parallel.ts +55 -80
  82. package/src/parser.ts +722 -385
  83. package/src/pcal/ast.ts +53 -65
  84. package/src/pcal/parse.ts +144 -191
  85. package/src/pcal/tokenize.ts +91 -115
  86. package/src/pcal/translate.ts +83 -98
  87. package/src/pcal/validate.ts +48 -50
  88. package/src/pretty-print.ts +7 -7
  89. package/src/prover/decide-pool.ts +3 -3
  90. package/src/prover/deciders.ts +12 -9
  91. package/src/prover/isabelle/decide.ts +3 -25
  92. package/src/prover/isabelle/encode.ts +72 -42
  93. package/src/prover/isabelle/isar/attrib.ts +250 -0
  94. package/src/prover/isabelle/isar/context.ts +335 -0
  95. package/src/prover/isabelle/isar/induct.ts +382 -0
  96. package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
  97. package/src/prover/isabelle/isar/method.ts +509 -212
  98. package/src/prover/isabelle/isar/proof.ts +570 -14
  99. package/src/prover/isabelle/isar/rule-cases.ts +224 -0
  100. package/src/prover/isabelle/isar/theory.ts +487 -76
  101. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  102. package/src/prover/isabelle/isar/type-check.ts +89 -14
  103. package/src/prover/isabelle/provers/blast/blast.ts +7 -65
  104. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  105. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  106. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  107. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  108. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  109. package/src/prover/isabelle/provers/clasimp.ts +0 -2
  110. package/src/prover/isabelle/provers/classical.ts +45 -20
  111. package/src/prover/isabelle/provers/hypsubst.ts +17 -28
  112. package/src/prover/isabelle/pure/bicompose.ts +9 -27
  113. package/src/prover/isabelle/pure/consts.ts +0 -2
  114. package/src/prover/isabelle/pure/conv.ts +2 -10
  115. package/src/prover/isabelle/pure/drule.ts +72 -6
  116. package/src/prover/isabelle/pure/envir.ts +0 -2
  117. package/src/prover/isabelle/pure/goal.ts +1 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -3
  119. package/src/prover/isabelle/pure/name.ts +0 -2
  120. package/src/prover/isabelle/pure/net.ts +0 -2
  121. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  122. package/src/prover/isabelle/pure/pattern.ts +0 -2
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
  124. package/src/prover/isabelle/pure/rewriter.ts +6 -17
  125. package/src/prover/isabelle/pure/search.ts +0 -2
  126. package/src/prover/isabelle/pure/seq.ts +0 -2
  127. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  128. package/src/prover/isabelle/pure/table.ts +2 -3
  129. package/src/prover/isabelle/pure/tactic.ts +0 -2
  130. package/src/prover/isabelle/pure/tactical.ts +42 -37
  131. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  132. package/src/prover/isabelle/pure/term.ts +0 -2
  133. package/src/prover/isabelle/pure/thm.ts +14 -13
  134. package/src/prover/isabelle/pure/type.ts +0 -2
  135. package/src/prover/isabelle/pure/unify.ts +0 -2
  136. package/src/prover/isabelle/pure/variable.ts +0 -2
  137. package/src/prover/isabelle/tla/classical-setup.ts +18 -16
  138. package/src/prover/isabelle/tla/context.ts +58 -11
  139. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  140. package/src/prover/isabelle/tla/logic.ts +49 -21
  141. package/src/prover/isabelle/tla/simpdata.ts +1 -12
  142. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  143. package/src/prover/ocaml.ts +4 -1
  144. package/src/prover/prep/action.ts +30 -31
  145. package/src/prover/prep/enabled-axioms.ts +11 -2
  146. package/src/prover/prep/fingerprint.ts +2 -5
  147. package/src/prover/prep/methods.ts +181 -51
  148. package/src/prover/prep/normalize.ts +38 -9
  149. package/src/prover/prove.ts +395 -94
  150. package/src/prover/ptl/decide.ts +95 -50
  151. package/src/prover/ptl/encode.ts +2 -3
  152. package/src/prover/ptl/tableau.ts +28 -2
  153. package/src/prover/smt/arithmetic.ts +310 -0
  154. package/src/prover/smt/axioms.ts +12 -8
  155. package/src/prover/smt/context.ts +43 -8
  156. package/src/prover/smt/data.ts +498 -379
  157. package/src/prover/smt/encode.ts +148 -57
  158. package/src/prover/smt/extensionality.ts +5 -3
  159. package/src/prover/smt/flatten.ts +4 -6
  160. package/src/prover/smt/format.ts +28 -4
  161. package/src/prover/smt/instances.ts +7 -1
  162. package/src/prover/smt/layout.ts +91 -0
  163. package/src/prover/smt/rewrite.ts +1021 -618
  164. package/src/prover/smt/simplify.ts +441 -0
  165. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  166. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  167. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  168. package/src/prover/smt/solver/act-cache.ts +0 -1
  169. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  170. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  171. package/src/prover/smt/solver/aig.ts +889 -0
  172. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  173. package/src/prover/smt/solver/arith-terms.ts +121 -0
  174. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  175. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  176. package/src/prover/smt/solver/asserted-formulas.ts +87 -16
  177. package/src/prover/smt/solver/ast-lt.ts +166 -12
  178. package/src/prover/smt/solver/ast-util.ts +160 -2
  179. package/src/prover/smt/solver/ast.ts +1427 -41
  180. package/src/prover/smt/solver/auf-solver.ts +2 -6
  181. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  182. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  183. package/src/prover/smt/solver/bound-manager.ts +196 -0
  184. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  185. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  186. package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
  187. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  188. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  189. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  190. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  191. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  192. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  193. package/src/prover/smt/solver/card2bv.ts +110 -0
  194. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  195. package/src/prover/smt/solver/cg-table.ts +39 -25
  196. package/src/prover/smt/solver/check-logic.ts +330 -0
  197. package/src/prover/smt/solver/clause.ts +0 -1
  198. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  199. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  200. package/src/prover/smt/solver/context.ts +516 -115
  201. package/src/prover/smt/solver/ctx-simplify.ts +20 -10
  202. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  203. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  204. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  205. package/src/prover/smt/solver/demodulator.ts +786 -0
  206. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  207. package/src/prover/smt/solver/der.ts +38 -10
  208. package/src/prover/smt/solver/diff-neq.ts +206 -0
  209. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  210. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  211. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  212. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  213. package/src/prover/smt/solver/e-matching.ts +7 -8
  214. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  215. package/src/prover/smt/solver/elim-uncnstr.ts +545 -0
  216. package/src/prover/smt/solver/enode.ts +100 -3
  217. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  218. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  219. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  220. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  221. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  222. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  223. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  224. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  225. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  226. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  227. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  228. package/src/prover/smt/solver/euf/egraph.ts +908 -0
  229. package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
  230. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  231. package/src/prover/smt/solver/euf/mam.ts +1050 -0
  232. package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
  233. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  234. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  235. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  236. package/src/prover/smt/solver/euf/th-solver.ts +335 -0
  237. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  238. package/src/prover/smt/solver/expr-ref.ts +0 -1
  239. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  240. package/src/prover/smt/solver/expr2polynomial.ts +146 -0
  241. package/src/prover/smt/solver/factor.ts +141 -0
  242. package/src/prover/smt/solver/fd-solver.ts +265 -0
  243. package/src/prover/smt/solver/fingerprints.ts +15 -15
  244. package/src/prover/smt/solver/fix-dl-var.ts +148 -0
  245. package/src/prover/smt/solver/flat-literals.ts +0 -1
  246. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  247. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  248. package/src/prover/smt/solver/fpa-rewriter.ts +640 -0
  249. package/src/prover/smt/solver/fpa2bv-converter.ts +2249 -0
  250. package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
  251. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  252. package/src/prover/smt/solver/goal.ts +175 -15
  253. package/src/prover/smt/solver/goal2nlsat.ts +189 -0
  254. package/src/prover/smt/solver/guard-set.ts +219 -0
  255. package/src/prover/smt/solver/hash.ts +0 -1
  256. package/src/prover/smt/solver/hashtable.ts +30 -16
  257. package/src/prover/smt/solver/inf-eps.ts +63 -0
  258. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  259. package/src/prover/smt/solver/internalizer.ts +110 -38
  260. package/src/prover/smt/solver/lackr.ts +381 -0
  261. package/src/prover/smt/solver/lbool.ts +0 -1
  262. package/src/prover/smt/solver/lia2card.ts +268 -0
  263. package/src/prover/smt/solver/lia2pb.ts +154 -0
  264. package/src/prover/smt/solver/literal.ts +0 -1
  265. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  266. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  267. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  268. package/src/prover/smt/solver/lp/containers.ts +7 -2
  269. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  270. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  271. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  272. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  273. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
  274. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  275. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  276. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
  277. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  278. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  279. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  280. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  281. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  282. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  283. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  284. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  285. package/src/prover/smt/solver/lp/nex.ts +2 -2
  286. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  287. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  288. package/src/prover/smt/solver/lp/nla-core.ts +67 -16
  289. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  290. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  291. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  292. package/src/prover/smt/solver/lp/nla-grobner.ts +165 -83
  293. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  294. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  295. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  296. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  297. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  298. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  299. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  300. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  301. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  302. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  303. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  304. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  305. package/src/prover/smt/solver/lp/nra-solver.ts +122 -64
  306. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  307. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  308. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  309. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  310. package/src/prover/smt/solver/lp/pdd.ts +725 -289
  311. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  312. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  313. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  314. package/src/prover/smt/solver/macro-finder.ts +530 -0
  315. package/src/prover/smt/solver/mam-compiler.ts +122 -90
  316. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  317. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  318. package/src/prover/smt/solver/max-cliques.ts +105 -0
  319. package/src/prover/smt/solver/maxcore.ts +309 -0
  320. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  321. package/src/prover/smt/solver/maxlex.ts +115 -0
  322. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  323. package/src/prover/smt/solver/maxsmt.ts +92 -0
  324. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  325. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  326. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  327. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  328. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  329. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  330. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  331. package/src/prover/smt/solver/model-checker.ts +18 -27
  332. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  333. package/src/prover/smt/solver/model-finder.ts +12 -18
  334. package/src/prover/smt/solver/model-generator.ts +56 -29
  335. package/src/prover/smt/solver/model-macro-solver.ts +49 -46
  336. package/src/prover/smt/solver/model-printer.ts +214 -0
  337. package/src/prover/smt/solver/mpf.ts +711 -0
  338. package/src/prover/smt/solver/mus.ts +51 -0
  339. package/src/prover/smt/solver/muz/dl-context.ts +404 -0
  340. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  341. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  342. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  343. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  344. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  345. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  346. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  347. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  348. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  349. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  350. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  351. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  352. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  353. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  354. package/src/prover/smt/solver/muz/spacer-context.ts +1406 -0
  355. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  356. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  357. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  358. package/src/prover/smt/solver/muz/spacer-pdr.ts +218 -0
  359. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  360. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  361. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  362. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  363. package/src/prover/smt/solver/nlqsat.ts +484 -0
  364. package/src/prover/smt/solver/nlsat/algebraic.ts +125 -12
  365. package/src/prover/smt/solver/nlsat/atoms.ts +20 -6
  366. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  367. package/src/prover/smt/solver/nlsat/explain.ts +63 -23
  368. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  369. package/src/prover/smt/solver/nlsat/levelwise.ts +3 -9
  370. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  371. package/src/prover/smt/solver/nlsat/polynomial.ts +13 -6
  372. package/src/prover/smt/solver/nlsat/solver.ts +236 -45
  373. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  374. package/src/prover/smt/solver/nlsat/transcendentals.ts +367 -0
  375. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  376. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -4
  377. package/src/prover/smt/solver/nlsat/upolynomial.ts +0 -2
  378. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  379. package/src/prover/smt/solver/nnf.ts +105 -23
  380. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  381. package/src/prover/smt/solver/occf.ts +97 -0
  382. package/src/prover/smt/solver/opt-context.ts +787 -0
  383. package/src/prover/smt/solver/opt-nlsat.ts +375 -0
  384. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  385. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  386. package/src/prover/smt/solver/opt-solver.ts +308 -0
  387. package/src/prover/smt/solver/opt-value.ts +55 -0
  388. package/src/prover/smt/solver/optsmt.ts +692 -0
  389. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  390. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  391. package/src/prover/smt/solver/pb-rewriter.ts +284 -0
  392. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  393. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  394. package/src/prover/smt/solver/probes.ts +512 -0
  395. package/src/prover/smt/solver/propagate-values.ts +37 -21
  396. package/src/prover/smt/solver/proto-model.ts +648 -19
  397. package/src/prover/smt/solver/pull-quant.ts +28 -12
  398. package/src/prover/smt/solver/purify-arith.ts +632 -0
  399. package/src/prover/smt/solver/qe-arith-plugin.ts +1098 -0
  400. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  401. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  402. package/src/prover/smt/solver/qe-lite.ts +37 -17
  403. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  404. package/src/prover/smt/solver/qe.ts +1498 -0
  405. package/src/prover/smt/solver/qel.ts +25 -0
  406. package/src/prover/smt/solver/qi-queue.ts +0 -1
  407. package/src/prover/smt/solver/qsat.ts +814 -0
  408. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  409. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  410. package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
  411. package/src/prover/smt/solver/quantifier-manager.ts +8 -16
  412. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  413. package/src/prover/smt/solver/random-gen.ts +0 -1
  414. package/src/prover/smt/solver/rational.ts +45 -1
  415. package/src/prover/smt/solver/recfun-decl-plugin.ts +261 -0
  416. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  417. package/src/prover/smt/solver/reduce-args.ts +225 -0
  418. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  419. package/src/prover/smt/solver/ref-vector.ts +0 -1
  420. package/src/prover/smt/solver/relevancy.ts +1 -2
  421. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  422. package/src/prover/smt/solver/rewriter.ts +475 -36
  423. package/src/prover/smt/solver/rlimit.ts +38 -2
  424. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  425. package/src/prover/smt/solver/sat/big.ts +177 -0
  426. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  427. package/src/prover/smt/solver/sat/clause.ts +203 -0
  428. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  429. package/src/prover/smt/solver/sat/config.ts +122 -0
  430. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  431. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  432. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  433. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  434. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  435. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  436. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  437. package/src/prover/smt/solver/sat/probing.ts +170 -0
  438. package/src/prover/smt/solver/sat/sat-tactic.ts +43 -0
  439. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  440. package/src/prover/smt/solver/sat/scc.ts +142 -0
  441. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  442. package/src/prover/smt/solver/sat/solver.ts +2127 -0
  443. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  444. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  445. package/src/prover/smt/solver/search-tree.ts +284 -0
  446. package/src/prover/smt/solver/seq-axioms.ts +1010 -0
  447. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  448. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  449. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  450. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  451. package/src/prover/smt/solver/seq-factory.ts +89 -0
  452. package/src/prover/smt/solver/seq-monadic.ts +728 -0
  453. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  454. package/src/prover/smt/solver/seq-re-rewriter.ts +1170 -0
  455. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  456. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  457. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  458. package/src/prover/smt/solver/seq-rewriter.ts +2402 -0
  459. package/src/prover/smt/solver/seq-skolem.ts +317 -0
  460. package/src/prover/smt/solver/seq-subset.ts +165 -0
  461. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  462. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  463. package/src/prover/smt/solver/smt-kernel.ts +83 -0
  464. package/src/prover/smt/solver/smt-logics.ts +66 -0
  465. package/src/prover/smt/solver/smt-setup.ts +496 -0
  466. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  467. package/src/prover/smt/solver/smtlib-parser.ts +3126 -316
  468. package/src/prover/smt/solver/smtlib-script.ts +1631 -0
  469. package/src/prover/smt/solver/solve-eqs.ts +929 -0
  470. package/src/prover/smt/solver/solver.ts +113 -22
  471. package/src/prover/smt/solver/static-features.ts +314 -0
  472. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  473. package/src/prover/smt/solver/tactic.ts +1986 -0
  474. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  475. package/src/prover/smt/solver/theory-array.ts +1240 -0
  476. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  477. package/src/prover/smt/solver/theory-char.ts +355 -0
  478. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  479. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  480. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  481. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  482. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
  483. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -70
  484. package/src/prover/smt/solver/theory-lra-internalize.ts +94 -27
  485. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  486. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -26
  487. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  488. package/src/prover/smt/solver/theory-lra.ts +188 -1
  489. package/src/prover/smt/solver/theory-pb.ts +934 -0
  490. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  491. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  492. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  493. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  494. package/src/prover/smt/solver/theory-seq-state.ts +871 -0
  495. package/src/prover/smt/solver/theory-seq.ts +961 -0
  496. package/src/prover/smt/solver/theory.ts +189 -0
  497. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  498. package/src/prover/smt/solver/var-subst.ts +36 -14
  499. package/src/prover/smt/table.ts +3 -2
  500. package/src/prover/smt/types.ts +146 -0
  501. package/src/prover/tlapm/cache.ts +50 -19
  502. package/src/prover/tlapm/tlapm.ts +15 -9
  503. package/src/prover/tlapm-library.ts +3208 -0
  504. package/src/prover/verdict.ts +9 -0
  505. package/src/prover/zenon/check/check.ts +1 -2
  506. package/src/prover/zenon/check/records.ts +1 -1
  507. package/src/prover/zenon/check/relations.ts +2 -1
  508. package/src/prover/zenon/check/rewrites.ts +2 -15
  509. package/src/prover/zenon/check/sets.ts +40 -58
  510. package/src/prover/zenon/check/terms.ts +1 -2
  511. package/src/prover/zenon/decide.ts +10 -7
  512. package/src/prover/zenon/encode.ts +0 -2
  513. package/src/prover/zenon/eqrel.ts +2 -2
  514. package/src/prover/zenon/equality-rules.ts +24 -2
  515. package/src/prover/zenon/expr.ts +28 -2
  516. package/src/prover/zenon/index-table.ts +11 -21
  517. package/src/prover/zenon/isar-case.ts +0 -2
  518. package/src/prover/zenon/isar.ts +35 -37
  519. package/src/prover/zenon/llproof.ts +2 -13
  520. package/src/prover/zenon/mltoll.ts +12 -30
  521. package/src/prover/zenon/node.ts +20 -5
  522. package/src/prover/zenon/parse.ts +9 -8
  523. package/src/prover/zenon/phrase.ts +0 -2
  524. package/src/prover/zenon/proof.ts +0 -2
  525. package/src/prover/zenon/propositional-rules.ts +0 -2
  526. package/src/prover/zenon/rules.ts +2 -3
  527. package/src/prover/zenon/search.ts +11 -19
  528. package/src/prover/zenon/tla/functions.ts +2 -4
  529. package/src/prover/zenon/tla/llproof.ts +9 -13
  530. package/src/prover/zenon/tla/records.ts +1 -8
  531. package/src/prover/zenon/tla/rewrites.ts +0 -2
  532. package/src/prover/zenon/tla/sets.ts +22 -22
  533. package/src/prover/zenon/tla/terms.ts +0 -2
  534. package/src/prover/zenon/tla/tla.ts +7 -8
  535. package/src/randomization.ts +1 -4
  536. package/src/resolve.ts +67 -143
  537. package/src/runtime.ts +17 -18
  538. package/src/sany/builtins.ts +1 -3
  539. package/src/sany/generation.ts +394 -0
  540. package/src/sany/generator-def-entries.ts +210 -0
  541. package/src/sany/generator-definitions.ts +686 -0
  542. package/src/sany/generator-expressions.ts +1100 -0
  543. package/src/sany/generator-proofs.ts +662 -0
  544. package/src/sany/generator.ts +160 -2683
  545. package/src/sany/levels.ts +5 -11
  546. package/src/sany/lexer.ts +57 -60
  547. package/src/sany/linter.ts +0 -3
  548. package/src/sany/nodes.ts +6 -13
  549. package/src/sany/report.ts +3 -6
  550. package/src/sany/selectors.ts +35 -38
  551. package/src/sany/xml.ts +23 -55
  552. package/src/search.ts +244 -53
  553. package/src/simulate.ts +202 -184
  554. package/src/spec-description.ts +56 -82
  555. package/src/standard-definitions.ts +4 -3
  556. package/src/standard-modules.ts +17 -44
  557. package/src/state-graph.ts +3 -17
  558. package/src/subexpressions.ts +38 -47
  559. package/src/substitution-levels.ts +5 -4
  560. package/src/successors.ts +20 -43
  561. package/src/symmetry.ts +6 -21
  562. package/src/tableau.ts +2 -2
  563. package/src/tlc/fingerprint.ts +96 -30
  564. package/src/tlc/jar-data.ts +0 -1
  565. package/src/tlc/messages.ts +22 -36
  566. package/src/tlc/order.ts +36 -50
  567. package/src/tlc/random.ts +22 -34
  568. package/src/tlc/replay.ts +21 -48
  569. package/src/tlc/summary.ts +64 -58
  570. package/src/tlc/tlc-operators.ts +6 -17
  571. package/src/tlc/tlcext-operators.ts +70 -29
  572. package/src/tlc/trace-spec.ts +26 -51
  573. package/src/tlc/value-stream.ts +9 -13
  574. package/src/tlc/version.ts +0 -1
  575. package/src/typed-tier.ts +6535 -0
  576. package/src/typescript/actions.ts +2 -4
  577. package/src/typescript/collections.ts +34 -20
  578. package/src/typescript/compile.ts +1 -3
  579. package/src/typescript/formula.ts +5 -3
  580. package/src/typescript/model.ts +4 -5
  581. package/src/typescript/steps.ts +20 -18
  582. package/src/values.ts +136 -338
  583. package/src/prover/isabelle/isar/statement.ts +0 -52
  584. package/src/prover/smt/solver/z3-license.txt +0 -10
  585. package/src/prover/tlaps-module.ts +0 -510
  586. package/src/prover/zenon/LICENSE +0 -32
@@ -0,0 +1,1577 @@
1
+ import { SmtTacticError } from "../../../../errors";
2
+ import {
3
+ type AstManager,
4
+ OP_AT_LEAST_K,
5
+ OP_AT_MOST_K,
6
+ OP_PB_EQ,
7
+ OP_PB_GE,
8
+ OP_PB_LE,
9
+ SORT_BOOL,
10
+ } from "../ast";
11
+ import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
12
+ import { getPbCoeff, getPbK, hasUnitCoefficients, mkPbGe } from "../pb-rewriter";
13
+ import { Rational } from "../rational";
14
+ import { NULL_LITERAL, UINT_MAX } from "./clause";
15
+ import { Card, type Constraint, type ConstraintHost, Pbc } from "./pb-constraint";
16
+ import {
17
+ JUSTIFICATION_BINARY,
18
+ JUSTIFICATION_CLAUSE,
19
+ JUSTIFICATION_EXT,
20
+ JUSTIFICATION_NONE,
21
+ type SatExtension,
22
+ type Solver,
23
+ } from "./solver";
24
+
25
+ const INT_MAX = 2147483647;
26
+ const INT_MIN = -2147483648;
27
+
28
+ export interface SatInternalizer {
29
+ internalize(expr: number): number;
30
+ getCached(expr: number): number;
31
+ cache(expr: number, lit: number): void;
32
+ }
33
+
34
+ const getGcd = (first: number, second: number) => {
35
+ let left = first;
36
+ let right = second;
37
+ while (right !== 0) [left, right] = [right, left % right];
38
+ return left;
39
+ };
40
+
41
+ // Literals with their weights, the parallel arrays of a svector<wliteral>.
42
+ interface WLits {
43
+ coeffs: number[];
44
+ lits: number[];
45
+ }
46
+
47
+ export class PbSolver implements SatExtension, ConstraintHost {
48
+ private readonly table = new Map<number, Constraint>();
49
+ private nextIndex = 0;
50
+ private constraints: Constraint[] = [];
51
+ private learned: Constraint[] = [];
52
+ private constraintToReinit: Constraint[] = [];
53
+ private constraintToReinitLim: number[] = [];
54
+ private constraintToReinitLastSize = 0;
55
+ private numMarks = 0;
56
+ private conflictLvl = 0;
57
+ private coeffs: number[] = [];
58
+ private activeVars: number[] = [];
59
+ private bound = 0;
60
+ private readonly activeVarSet = new Set<number>();
61
+ private numPropagationsSincePop = 0;
62
+ private pbUndef: number[] = [];
63
+ private aMax = 0;
64
+ private isOverflow = false;
65
+ private cnstrUseList: Constraint[][] = [];
66
+ private clauseUseCounts = new Int32Array(0);
67
+ private clauseUseLists: number[][] = [];
68
+ private isSimplifyChange = false;
69
+ private isClauseRemoved = false;
70
+ private isConstraintRemoved = false;
71
+ private roots: number[] = [];
72
+ private rootVars: boolean[] = [];
73
+ private weights: number[] = [];
74
+
75
+ constructor(
76
+ private readonly manager: AstManager,
77
+ private readonly si: SatInternalizer,
78
+ private readonly solver: Solver,
79
+ ) {}
80
+
81
+ value(lit: number) {
82
+ return this.solver.value(lit);
83
+ }
84
+
85
+ lvl(lit: number) {
86
+ return this.solver.lvl(lit);
87
+ }
88
+
89
+ getWlist(lit: number) {
90
+ return this.solver.getWlist(lit);
91
+ }
92
+
93
+ private getConstraint(index: number) {
94
+ return this.table.get(index) as Constraint;
95
+ }
96
+
97
+ private isInconsistent() {
98
+ return this.solver.isInconsistent;
99
+ }
100
+
101
+ setConflictBy(constraint: Constraint, lit: number) {
102
+ const solver = this.solver;
103
+ solver.setConflict(solver.scopeLvl, JUSTIFICATION_EXT, constraint.index, lit ^ 1);
104
+ }
105
+
106
+ assignBy(constraint: Constraint, lit: number) {
107
+ if (this.isInconsistent()) return;
108
+ const value = this.value(lit);
109
+ if (value === L_TRUE) return;
110
+ if (value === L_FALSE) {
111
+ this.setConflictBy(constraint, lit);
112
+ return;
113
+ }
114
+ this.numPropagationsSincePop++;
115
+ const solver = this.solver;
116
+ solver.assign(lit, solver.scopeLvl, JUSTIFICATION_EXT, constraint.index);
117
+ }
118
+
119
+ private mkClause(lits: number[], isLearned: boolean) {
120
+ this.solver.mkClause(lits, isLearned);
121
+ }
122
+
123
+ private simplifyConstraint(constraint: Constraint) {
124
+ const solver = this.solver;
125
+ if (constraint.lit !== NULL_LITERAL && this.value(constraint.lit) === L_FALSE) return;
126
+ if (constraint.lit !== NULL_LITERAL && this.value(constraint.lit) === L_TRUE) {
127
+ constraint.nullifyTrackingLiteral(this);
128
+ this.initWatch(constraint);
129
+ }
130
+ let trueVal = 0;
131
+ let slack = 0;
132
+ let numFalse = 0;
133
+ for (let index = 0; index < constraint.size; index++) {
134
+ const lit = constraint.lits[index];
135
+ if (solver.wasEliminated(lit >> 1)) {
136
+ this.removeConstraint(constraint);
137
+ return;
138
+ }
139
+ const value = this.value(lit);
140
+ if (value === L_TRUE) trueVal += constraint.getCoeff(index);
141
+ else if (value === L_FALSE) numFalse++;
142
+ else slack += constraint.getCoeff(index);
143
+ }
144
+ if (constraint.k === 1 && constraint.lit === NULL_LITERAL) {
145
+ this.mkClause([...constraint.lits], constraint.isLearned);
146
+ this.removeConstraint(constraint);
147
+ } else if (trueVal === 0 && numFalse === 0) {
148
+ if (constraint.lit === NULL_LITERAL || this.value(constraint.lit) === L_TRUE)
149
+ this.initWatch(constraint);
150
+ } else if (trueVal >= constraint.k) {
151
+ if (constraint.lit !== NULL_LITERAL) solver.assignScoped(constraint.lit);
152
+ else this.removeConstraint(constraint);
153
+ } else if (slack + trueVal < constraint.k) {
154
+ if (constraint.lit !== NULL_LITERAL) solver.assignScoped(constraint.lit ^ 1);
155
+ else solver.setConflict();
156
+ } else if (slack + trueVal === constraint.k) {
157
+ this.assertUnconstrained(constraint.lit, [...constraint.lits]);
158
+ this.removeConstraint(constraint);
159
+ } else {
160
+ constraint.clearWatch(this);
161
+ let next = 0;
162
+ for (let index = 0; index < constraint.size; index++) {
163
+ if (this.value(constraint.lits[index]) !== L_UNDEF) continue;
164
+ if (index !== next) constraint.swap(index, next);
165
+ next++;
166
+ }
167
+ const k = constraint.k - trueVal;
168
+ if (k === 1 && constraint.lit === NULL_LITERAL) {
169
+ this.mkClause(constraint.lits.slice(0, next), constraint.isLearned);
170
+ this.removeConstraint(constraint);
171
+ return;
172
+ }
173
+ constraint.setSize(next);
174
+ constraint.setK(k);
175
+ if (constraint.lit === NULL_LITERAL || this.value(constraint.lit) === L_TRUE)
176
+ this.initWatch(constraint);
177
+ this.isSimplifyChange = true;
178
+ }
179
+ }
180
+
181
+ // x <=> a*x + B*y >= k splits into k*~x + a*x + B*y >= k and its negation.
182
+ private splitRoot(constraint: Constraint) {
183
+ const weights = this.weights;
184
+ const numLits = 2 * this.solver.numVars();
185
+ while (weights.length < numLits) weights.push(0);
186
+ let k = constraint.k;
187
+ const root = constraint.lit;
188
+ weights[root ^ 1] = k;
189
+ for (let index = 0; index < constraint.size; index++)
190
+ weights[constraint.lits[index]] += constraint.getCoeff(index);
191
+ const lits = [...constraint.lits, root ^ 1];
192
+ for (const lit of lits) {
193
+ const w1 = weights[lit];
194
+ const w2 = weights[lit ^ 1];
195
+ if (w1 < w2) continue;
196
+ if (w2 >= k) {
197
+ for (const other of lits) weights[other] = 0;
198
+ return;
199
+ }
200
+ k -= w2;
201
+ weights[lit ^ 1] = 0;
202
+ weights[lit] = w1 - w2;
203
+ }
204
+ const wlits: WLits = { coeffs: [], lits: [] };
205
+ for (const lit of lits) {
206
+ const weight = weights[lit];
207
+ if (weight !== 0) {
208
+ wlits.coeffs.push(weight);
209
+ wlits.lits.push(lit);
210
+ }
211
+ weights[lit] = 0;
212
+ }
213
+ this.addPbGe(NULL_LITERAL, wlits, k, false);
214
+ }
215
+
216
+ private addIndex(constraint: Pbc, index: number, lit: number) {
217
+ if (this.value(lit) !== L_UNDEF) return;
218
+ this.pbUndef.push(index);
219
+ if (constraint.coeffs[index] > this.aMax) this.aMax = constraint.coeffs[index];
220
+ }
221
+
222
+ private addAssignPb(constraint: Pbc, alit: number) {
223
+ const lits = constraint.lits;
224
+ const coeffs = constraint.coeffs;
225
+ const size = constraint.size;
226
+ const bound = constraint.k;
227
+ let numWatch = constraint.numWatch;
228
+ let slack = constraint.slack;
229
+ let index = 0;
230
+ this.aMax = 0;
231
+ this.pbUndef = [];
232
+ for (; index < numWatch; index++) {
233
+ if (lits[index] === alit) break;
234
+ this.addIndex(constraint, index, lits[index]);
235
+ }
236
+ if (index === numWatch || numWatch === 0) return L_UNDEF;
237
+ for (let index1 = index + 1; this.aMax === 0 && index1 < numWatch; index1++)
238
+ this.addIndex(constraint, index1, lits[index1]);
239
+ const val = coeffs[index];
240
+ slack -= val;
241
+ for (let position = numWatch; position < size && slack < bound + this.aMax; position++) {
242
+ const lit = lits[position];
243
+ if (this.value(lit) === L_FALSE) continue;
244
+ slack += coeffs[position];
245
+ constraint.watchLiteral(this, lit);
246
+ constraint.swap(numWatch, position);
247
+ this.addIndex(constraint, numWatch, lit);
248
+ numWatch++;
249
+ }
250
+ if (slack < bound) {
251
+ constraint.slack = slack + val;
252
+ constraint.numWatch = numWatch;
253
+ this.setConflictBy(constraint, alit);
254
+ return L_FALSE;
255
+ }
256
+ numWatch--;
257
+ constraint.slack = slack;
258
+ constraint.numWatch = numWatch;
259
+ constraint.swap(numWatch, index);
260
+ if (slack < bound + this.aMax)
261
+ for (const undef of this.pbUndef) {
262
+ const position = undef === numWatch ? index : undef;
263
+ if (slack < bound + coeffs[position]) this.assignBy(constraint, lits[position]);
264
+ }
265
+ return L_UNDEF;
266
+ }
267
+
268
+ private normalize(wlits: WLits, k: number) {
269
+ const weights = this.weights;
270
+ const numLits = 2 * this.solver.numVars();
271
+ while (weights.length < numLits) weights.push(0);
272
+ const size = wlits.lits.length;
273
+ for (let index = 0; index < size; index++) weights[wlits.lits[index]] += wlits.coeffs[index];
274
+ let bound = k;
275
+ let next = 0;
276
+ for (let index = 0; index < size; index++) {
277
+ const lit = wlits.lits[index];
278
+ let w1 = weights[lit];
279
+ const w2 = weights[lit ^ 1];
280
+ if (w1 === 0 || w1 < w2) continue;
281
+ if (bound <= w2) {
282
+ bound = 0;
283
+ break;
284
+ }
285
+ bound -= w2;
286
+ w1 -= w2;
287
+ weights[lit] = 0;
288
+ weights[lit ^ 1] = 0;
289
+ if (w1 === 0) continue;
290
+ wlits.coeffs[next] = w1;
291
+ wlits.lits[next] = lit;
292
+ next++;
293
+ }
294
+ for (let index = 0; index < size; index++) {
295
+ const lit = wlits.lits[index];
296
+ weights[lit] = 0;
297
+ weights[lit ^ 1] = 0;
298
+ }
299
+ return { size: next, k: bound };
300
+ }
301
+
302
+ private recompilePb(constraint: Pbc) {
303
+ const wlits = { coeffs: constraint.coeffs, lits: constraint.lits };
304
+ const normalized = this.normalize(wlits, constraint.k);
305
+ constraint.setSize(normalized.size);
306
+ const k = normalized.k;
307
+ const isAllUnits = constraint.coeffs.every((coeff) => coeff === 1);
308
+ if (k === 0) {
309
+ if (constraint.lit !== NULL_LITERAL) this.solver.assignScoped(constraint.lit);
310
+ this.removeConstraint(constraint);
311
+ return;
312
+ }
313
+ if (k === 1 && constraint.lit === NULL_LITERAL) {
314
+ this.mkClause([...constraint.lits], constraint.isLearned);
315
+ this.removeConstraint(constraint);
316
+ return;
317
+ }
318
+ if (isAllUnits) {
319
+ this.addAtLeast(constraint.lit, [...constraint.lits], k, constraint.isLearned);
320
+ this.removeConstraint(constraint);
321
+ return;
322
+ }
323
+ constraint.updateMaxSum();
324
+ if (constraint.maxSum < k) {
325
+ if (constraint.lit === NULL_LITERAL) this.solver.setConflict();
326
+ else this.solver.assignScoped(constraint.lit ^ 1);
327
+ this.removeConstraint(constraint);
328
+ return;
329
+ }
330
+ constraint.setK(k);
331
+ if (constraint.lit === NULL_LITERAL || this.value(constraint.lit) === L_TRUE)
332
+ this.initWatch(constraint);
333
+ }
334
+
335
+ private incCoeff(lit: number, offset: number) {
336
+ const boolVar = lit >> 1;
337
+ const coeffs = this.coeffs;
338
+ while (coeffs.length <= boolVar) coeffs.push(0);
339
+ const coeff0 = coeffs[boolVar];
340
+ if (coeff0 === 0) this.activeVars.push(boolVar);
341
+ const inc = lit & 1 ? -offset : offset;
342
+ const coeff1 = inc + coeff0;
343
+ coeffs[boolVar] = coeff1;
344
+ if (coeff1 > INT_MAX || coeff1 < INT_MIN) {
345
+ this.isOverflow = true;
346
+ return;
347
+ }
348
+ if (coeff0 > 0 && inc < 0) this.incBound(Math.max(0, coeff1) - coeff0);
349
+ else if (coeff0 < 0 && inc > 0) this.incBound(coeff0 - Math.min(0, coeff1));
350
+ const bound = this.bound;
351
+ if (coeff1 > bound) coeffs[boolVar] = bound;
352
+ else if (coeff1 < 0 && -coeff1 > bound) coeffs[boolVar] = -bound;
353
+ }
354
+
355
+ private getCoeff(boolVar: number) {
356
+ return this.coeffs[boolVar] ?? 0;
357
+ }
358
+
359
+ private getAbsCoeff(boolVar: number) {
360
+ const abs = Math.abs(this.getCoeff(boolVar));
361
+ const coeff = abs >>> 0;
362
+ if (coeff !== abs) this.isOverflow = true;
363
+ return coeff;
364
+ }
365
+
366
+ private incBound(inc: number) {
367
+ const bound = this.bound + inc;
368
+ const truncated = bound >>> 0;
369
+ if (bound < 0 || truncated !== bound) this.isOverflow = true;
370
+ this.bound = truncated;
371
+ }
372
+
373
+ private resetCoeffs() {
374
+ for (let index = this.activeVars.length; index-- > 0;) this.coeffs[this.activeVars[index]] = 0;
375
+ this.activeVars = [];
376
+ }
377
+
378
+ private bailResolveConflict(start: number) {
379
+ const solver = this.solver;
380
+ const trail = solver.trail;
381
+ for (let index = start; this.numMarks > 0; index--) {
382
+ const boolVar = trail[index] >> 1;
383
+ if (solver.mark[boolVar]) {
384
+ solver.mark[boolVar] = false;
385
+ this.numMarks--;
386
+ }
387
+ }
388
+ }
389
+
390
+ resolveConflict() {
391
+ if (this.numPropagationsSincePop === 0) return L_UNDEF;
392
+ const solver = this.solver;
393
+ this.isOverflow = false;
394
+ this.resetCoeffs();
395
+ this.numMarks = 0;
396
+ this.bound = 0;
397
+ let consequent = solver.notL;
398
+ let kind = solver.conflictKind;
399
+ let val = solver.conflictVal;
400
+ this.conflictLvl = solver.getMaxLvl(consequent, kind, val).level;
401
+ if (this.conflictLvl === 0) return L_UNDEF;
402
+ if (consequent !== NULL_LITERAL) {
403
+ consequent ^= 1;
404
+ this.processAntecedent(consequent, 1);
405
+ }
406
+ const trail = solver.trail;
407
+ let index = trail.length - 1;
408
+ let offset = 1;
409
+ const bailOut = () => {
410
+ this.isOverflow = false;
411
+ this.bailResolveConflict(index);
412
+ return L_UNDEF;
413
+ };
414
+ do {
415
+ if (this.isOverflow || offset > 1 << 12) return bailOut();
416
+ if (offset !== 0) {
417
+ switch (kind) {
418
+ case JUSTIFICATION_NONE:
419
+ this.incBound(offset);
420
+ break;
421
+ case JUSTIFICATION_BINARY:
422
+ this.incBound(offset);
423
+ this.incCoeff(consequent, offset);
424
+ this.processAntecedent(val, offset);
425
+ break;
426
+ case JUSTIFICATION_CLAUSE: {
427
+ this.incBound(offset);
428
+ const arena = solver.arena;
429
+ let position = 0;
430
+ if (consequent !== NULL_LITERAL) {
431
+ this.incCoeff(consequent, offset);
432
+ if (arena.get(val, 0) === consequent) position = 1;
433
+ else {
434
+ this.processAntecedent(arena.get(val, 0), offset);
435
+ position = 2;
436
+ }
437
+ }
438
+ for (; position < arena.size[val]; position++)
439
+ this.processAntecedent(arena.get(val, position), offset);
440
+ break;
441
+ }
442
+ default: {
443
+ const constraint = this.getConstraint(val);
444
+ if (constraint.isCard()) {
445
+ this.incBound(offset * constraint.k);
446
+ this.processCard(constraint, offset);
447
+ } else {
448
+ const antecedents: number[] = [];
449
+ this.incBound(offset);
450
+ this.incCoeff(consequent, offset);
451
+ this.getPbAntecedents(consequent, constraint as Pbc, antecedents);
452
+ for (const lit of antecedents) this.processAntecedent(lit ^ 1, offset);
453
+ }
454
+ }
455
+ }
456
+ this.cut();
457
+ }
458
+ let boolVar: number;
459
+ for (;;) {
460
+ consequent = trail[index];
461
+ boolVar = consequent >> 1;
462
+ if (solver.mark[boolVar] && solver.lvlVar(boolVar) === this.conflictLvl) break;
463
+ if (index === 0) return bailOut();
464
+ index--;
465
+ }
466
+ solver.mark[boolVar] = false;
467
+ index--;
468
+ this.numMarks--;
469
+ kind = solver.justKind[boolVar];
470
+ val = solver.justVal[boolVar];
471
+ offset = this.getAbsCoeff(boolVar);
472
+ if (offset > this.bound) {
473
+ this.coeffs[boolVar] = this.getCoeff(boolVar) < 0 ? -this.bound : this.bound;
474
+ offset = this.bound;
475
+ }
476
+ } while (this.numMarks > 0);
477
+ if (!this.createAssertingLemma()) return bailOut();
478
+ this.active2card();
479
+ return L_TRUE;
480
+ }
481
+
482
+ private createAssertingLemma() {
483
+ const solver = this.solver;
484
+ let slack = -this.bound;
485
+ this.activeVarSet.clear();
486
+ let next = 0;
487
+ for (const boolVar of this.activeVars) {
488
+ const coeff = this.getAbsCoeff(boolVar);
489
+ if (this.activeVarSet.has(boolVar) || coeff === 0) continue;
490
+ this.activeVarSet.add(boolVar);
491
+ slack += coeff;
492
+ this.activeVars[next++] = boolVar;
493
+ }
494
+ this.activeVars.length = next;
495
+ const lemma = [NULL_LITERAL];
496
+ let assertingCoeff = 0;
497
+ for (let index = 0; slack >= 0 && index < this.activeVars.length; index++) {
498
+ const boolVar = this.activeVars[index];
499
+ const coeff = this.getCoeff(boolVar);
500
+ const value = solver.valueVar(boolVar);
501
+ const isTrue = value === L_TRUE;
502
+ if (coeff === 0 || value === L_UNDEF || coeff < 0 !== isTrue) continue;
503
+ const lit = 2 * boolVar + (isTrue ? 0 : 1);
504
+ if (this.lvl(lit) === this.conflictLvl) {
505
+ if (lemma[0] === NULL_LITERAL) {
506
+ assertingCoeff = Math.abs(coeff);
507
+ slack -= assertingCoeff;
508
+ lemma[0] = lit ^ 1;
509
+ } else if (assertingCoeff < Math.abs(coeff)) {
510
+ lemma[0] = lit ^ 1;
511
+ slack -= Math.abs(coeff) - assertingCoeff;
512
+ assertingCoeff = Math.abs(coeff);
513
+ }
514
+ } else if (this.lvl(lit) < this.conflictLvl) {
515
+ slack -= Math.abs(coeff);
516
+ lemma.push(lit ^ 1);
517
+ }
518
+ }
519
+ if (slack >= 0 || this.isOverflow) return false;
520
+ if (lemma[0] === NULL_LITERAL) {
521
+ if (lemma.length === 1) solver.setConflict();
522
+ return false;
523
+ }
524
+ solver.lemma = [...lemma];
525
+ for (let index = 1; index < lemma.length; index++) solver.mark[lemma[index] >> 1] = true;
526
+ return true;
527
+ }
528
+
529
+ private cut() {
530
+ for (const boolVar of this.activeVars) if (this.getAbsCoeff(boolVar) === 1) return;
531
+ let gcd = 0;
532
+ for (let index = 0; gcd !== 1 && index < this.activeVars.length; index++) {
533
+ const boolVar = this.activeVars[index];
534
+ let coeff = this.getAbsCoeff(boolVar);
535
+ if (coeff === 0) continue;
536
+ if (this.bound < coeff) {
537
+ this.coeffs[boolVar] = this.getCoeff(boolVar) > 0 ? this.bound : -this.bound;
538
+ coeff = this.bound;
539
+ }
540
+ gcd = gcd === 0 ? coeff : getGcd(gcd, coeff);
541
+ }
542
+ if (gcd < 2) return;
543
+ this.activeVarSet.clear();
544
+ let next = 0;
545
+ for (const boolVar of this.activeVars) {
546
+ const coeff = this.coeffs[boolVar];
547
+ if (this.activeVarSet.has(boolVar) || coeff === 0) continue;
548
+ this.activeVarSet.add(boolVar);
549
+ this.coeffs[boolVar] = Math.trunc(coeff / gcd);
550
+ this.activeVars[next++] = boolVar;
551
+ }
552
+ this.activeVars.length = next;
553
+ this.bound = Math.floor((this.bound + gcd - 1) / gcd);
554
+ }
555
+
556
+ private processCard(constraint: Card, offset: number) {
557
+ const lit = constraint.lit;
558
+ for (let index = constraint.k; index < constraint.size; index++)
559
+ this.processAntecedent(constraint.lits[index], offset);
560
+ for (let index = 0; index < constraint.k; index++)
561
+ this.incCoeff(constraint.lits[index], offset);
562
+ if (lit === NULL_LITERAL) return;
563
+ const offset1 = offset * constraint.k;
564
+ if (offset1 > UINT_MAX) this.isOverflow = true;
565
+ this.processAntecedent(this.value(lit) === L_TRUE ? lit ^ 1 : lit, offset1 % 2 ** 32);
566
+ }
567
+
568
+ private processAntecedent(lit: number, offset: number) {
569
+ const solver = this.solver;
570
+ const boolVar = lit >> 1;
571
+ if (!solver.mark[boolVar] && solver.lvlVar(boolVar) === this.conflictLvl) {
572
+ solver.mark[boolVar] = true;
573
+ this.numMarks++;
574
+ }
575
+ this.incCoeff(lit, offset);
576
+ }
577
+
578
+ addAtLeast(lit: number, lits: number[], k: number, isLearned: boolean): Constraint | null {
579
+ const solver = this.solver;
580
+ if (k === 1 && lit === NULL_LITERAL) {
581
+ this.mkClause(lits, isLearned);
582
+ return null;
583
+ }
584
+ if (k === 0) {
585
+ if (lit !== NULL_LITERAL) this.mkClause([lit], false);
586
+ return null;
587
+ }
588
+ if (k > lits.length) {
589
+ this.mkClause(lit === NULL_LITERAL ? [] : [lit ^ 1], false);
590
+ return null;
591
+ }
592
+ solver.initVisited();
593
+ for (const other of lits) {
594
+ if (solver.isVisited(other & ~1))
595
+ return this.addPbGe(lit, { coeffs: lits.map(() => 1), lits: [...lits] }, k, isLearned);
596
+ solver.markVisited(other & ~1);
597
+ }
598
+ const constraint = new Card(this.nextIndex++, lit, [...lits], k);
599
+ constraint.isLearned = isLearned;
600
+ this.addConstraint(constraint);
601
+ return constraint;
602
+ }
603
+
604
+ private addConstraint(constraint: Constraint) {
605
+ const solver = this.solver;
606
+ this.table.set(constraint.index, constraint);
607
+ (constraint.isLearned ? this.learned : this.constraints).push(constraint);
608
+ const lit = constraint.lit;
609
+ if (constraint.isLearned && !solver.atBaseLvl()) this.constraintToReinit.push(constraint);
610
+ else if (lit === NULL_LITERAL) this.initWatch(constraint);
611
+ else {
612
+ solver.setExternal(lit >> 1);
613
+ constraint.watchLiteral(this, lit);
614
+ constraint.watchLiteral(this, lit ^ 1);
615
+ }
616
+ }
617
+
618
+ private initWatch(constraint: Constraint) {
619
+ return !this.isInconsistent() && constraint.initWatch(this);
620
+ }
621
+
622
+ private addPbGe(lit: number, wlits: WLits, k: number, isLearned: boolean): Constraint | null {
623
+ const solver = this.solver;
624
+ const isUnits = wlits.coeffs.every((coeff) => coeff === 1);
625
+ if (k === 0) {
626
+ if (lit !== NULL_LITERAL) this.mkClause([lit], false);
627
+ return null;
628
+ }
629
+ if (wlits.coeffs.reduce((sum, coeff) => sum + coeff, 0) < k) {
630
+ this.mkClause(lit === NULL_LITERAL ? [] : [lit ^ 1], false);
631
+ return null;
632
+ }
633
+ solver.initVisited();
634
+ for (const other of wlits.lits) {
635
+ if (solver.isVisited(other & ~1)) {
636
+ const copy = { coeffs: [...wlits.coeffs], lits: [...wlits.lits] };
637
+ const normalized = this.normalize(copy, k);
638
+ copy.coeffs.length = normalized.size;
639
+ copy.lits.length = normalized.size;
640
+ return this.addPbGe(lit, copy, normalized.k, isLearned);
641
+ }
642
+ solver.markVisited(other & ~1);
643
+ }
644
+ if (!isLearned) for (const other of wlits.lits) solver.setExternal(other >> 1);
645
+ if (isUnits || k === 1) return this.addAtLeast(lit, [...wlits.lits], k, isLearned);
646
+ const constraint = new Pbc(this.nextIndex++, lit, [...wlits.lits], [...wlits.coeffs], k);
647
+ constraint.isLearned = isLearned;
648
+ this.addConstraint(constraint);
649
+ return constraint;
650
+ }
651
+
652
+ propagated(lit: number, index: number) {
653
+ const constraint = this.getConstraint(index);
654
+ if (constraint.lit !== NULL_LITERAL && lit >> 1 === constraint.lit >> 1) {
655
+ this.initWatch(constraint);
656
+ return true;
657
+ }
658
+ if (constraint.lit !== NULL_LITERAL && this.value(constraint.lit) !== L_TRUE) return true;
659
+ const result = constraint.isCard()
660
+ ? this.addAssignCard(constraint, lit ^ 1)
661
+ : this.addAssignPb(constraint as Pbc, lit ^ 1);
662
+ return result !== L_UNDEF;
663
+ }
664
+
665
+ private isAssignedAbove(above: number, below: number) {
666
+ const solver = this.solver;
667
+ const level = this.lvl(above);
668
+ if (level === 0) return false;
669
+ const start = solver.scopes[level - 1].trailLim;
670
+ const trail = solver.trail;
671
+ for (let index = trail.length; index-- > start;) {
672
+ if (trail[index] === above) return true;
673
+ if (trail[index] === below) return false;
674
+ }
675
+ return false;
676
+ }
677
+
678
+ private getPbAntecedents(lit: number, constraint: Pbc, antecedents: number[]) {
679
+ if (constraint.lit !== NULL_LITERAL) antecedents.push(constraint.lit);
680
+ const k = constraint.k;
681
+ const lits = constraint.lits;
682
+ const coeffs = constraint.coeffs;
683
+ if (this.value(lit) === L_FALSE) {
684
+ let slack = 0;
685
+ for (let index = 0; index < constraint.size; index++)
686
+ if (this.value(lits[index]) !== L_FALSE) slack += coeffs[index];
687
+ for (let index = 0; index < constraint.size; index++) {
688
+ const other = lits[index];
689
+ if (other === lit || this.value(other) !== L_FALSE) continue;
690
+ if (slack + coeffs[index] < k) slack += coeffs[index];
691
+ else antecedents.push(other ^ 1);
692
+ }
693
+ return;
694
+ }
695
+ let coeff = 0;
696
+ let position = 0;
697
+ for (; position < constraint.size; position++)
698
+ if (lits[position] === lit) {
699
+ coeff = coeffs[position];
700
+ break;
701
+ }
702
+ position = Math.max(position + 1, constraint.numWatch);
703
+ let slack = constraint.maxSum - coeff;
704
+ for (; position < constraint.size; position++) {
705
+ const other = lits[position];
706
+ if (this.value(other) !== L_FALSE || this.lvl(other) > this.lvl(lit)) continue;
707
+ if (this.lvl(other) === this.lvl(lit) && this.isAssignedAbove(other ^ 1, lit)) continue;
708
+ if (slack + coeffs[position] < k) slack += coeffs[position];
709
+ else antecedents.push(other ^ 1);
710
+ }
711
+ }
712
+
713
+ private getCardAntecedents(lit: number, constraint: Card, antecedents: number[]) {
714
+ if (lit === (constraint.lit ^ 1)) {
715
+ for (let index = constraint.k - 1; index < constraint.size; index++)
716
+ antecedents.push(constraint.lits[index] ^ 1);
717
+ return;
718
+ }
719
+ if (constraint.lit !== NULL_LITERAL)
720
+ antecedents.push(this.value(constraint.lit) === L_TRUE ? constraint.lit : constraint.lit ^ 1);
721
+ for (let index = constraint.k; index < constraint.size; index++)
722
+ antecedents.push(constraint.lits[index] ^ 1);
723
+ }
724
+
725
+ getAntecedents(lit: number, index: number, antecedents: number[]) {
726
+ const constraint = this.getConstraint(index);
727
+ if (constraint.isCard()) this.getCardAntecedents(lit, constraint, antecedents);
728
+ else this.getPbAntecedents(lit, constraint as Pbc, antecedents);
729
+ }
730
+
731
+ private removeConstraint(constraint: Constraint) {
732
+ constraint.nullifyTrackingLiteral(this);
733
+ constraint.clearWatch(this);
734
+ constraint.isRemoved = true;
735
+ this.isConstraintRemoved = true;
736
+ }
737
+
738
+ private deallocate(constraint: Constraint) {
739
+ this.table.delete(constraint.index);
740
+ }
741
+
742
+ private updatePsm(constraint: Constraint) {
743
+ const phase = this.solver.phase;
744
+ let psm = 0;
745
+ for (const lit of constraint.lits) if (phase[lit >> 1] === ((lit & 1) === 0)) psm++;
746
+ constraint.psm = psm;
747
+ }
748
+
749
+ gc() {
750
+ const solver = this.solver;
751
+ if (
752
+ this.learned.length < 2 * this.constraints.length ||
753
+ !(solver.scopeLvl === solver.searchLvl || solver.atBaseLvl())
754
+ )
755
+ return;
756
+ for (const constraint of this.learned) this.updatePsm(constraint);
757
+ const isLess = (first: Constraint, second: Constraint) =>
758
+ first.glue < second.glue ||
759
+ (first.glue === second.glue &&
760
+ (first.psm < second.psm || (first.psm === second.psm && first.size < second.size)));
761
+ this.learned.sort((first, second) =>
762
+ isLess(first, second) ? -1 : isLess(second, first) ? 1 : 0,
763
+ );
764
+ this.gcHalf();
765
+ this.cleanupConstraintList(this.learned, true);
766
+ }
767
+
768
+ private gcHalf() {
769
+ const learned = this.learned;
770
+ const size = learned.length;
771
+ let next = size >>> 1;
772
+ for (let index = next; index < size; index++) {
773
+ const constraint = learned[index];
774
+ if (!this.constraintToReinit.includes(constraint)) {
775
+ this.removeConstraint(constraint);
776
+ this.deallocate(constraint);
777
+ } else learned[next++] = constraint;
778
+ }
779
+ learned.length = next;
780
+ }
781
+
782
+ private addAssignCard(constraint: Card, alit: number) {
783
+ const lits = constraint.lits;
784
+ const size = constraint.size;
785
+ const bound = constraint.k;
786
+ const lit = constraint.lit;
787
+ if (bound === size) {
788
+ if (lit !== NULL_LITERAL && this.value(lit) === L_UNDEF) {
789
+ this.assignBy(constraint, lit ^ 1);
790
+ return this.isInconsistent() ? L_FALSE : L_TRUE;
791
+ }
792
+ this.setConflictBy(constraint, alit);
793
+ return L_FALSE;
794
+ }
795
+ let index = 0;
796
+ for (; index <= bound; index++) if (lits[index] === alit) break;
797
+ if (index === bound + 1) return L_UNDEF;
798
+ for (let position = bound + 1; position < size; position++) {
799
+ const lit2 = lits[position];
800
+ if (this.value(lit2) === L_FALSE) continue;
801
+ constraint.swap(index, position);
802
+ constraint.watchLiteral(this, lit2);
803
+ return L_UNDEF;
804
+ }
805
+ if (bound !== index && this.value(lits[bound]) === L_FALSE) {
806
+ if (lit !== NULL_LITERAL && this.value(lit) === L_UNDEF) {
807
+ if (index + 1 < bound) constraint.swap(index, bound - 1);
808
+ this.assignBy(constraint, lit ^ 1);
809
+ return this.isInconsistent() ? L_FALSE : L_TRUE;
810
+ }
811
+ this.setConflictBy(constraint, alit);
812
+ return L_FALSE;
813
+ }
814
+ if (index !== bound) constraint.swap(index, bound);
815
+ if (lit !== NULL_LITERAL && this.value(lit) === L_UNDEF) return L_TRUE;
816
+ for (let position = 0; position < bound; position++) this.assignBy(constraint, lits[position]);
817
+ if (constraint.isLearned && constraint.glue > 2) {
818
+ const glue = this.solver.numDiffFalseLevelsBelow(lits, constraint.glue - 1);
819
+ if (glue !== -1) constraint.glue = glue;
820
+ }
821
+ return this.isInconsistent() ? L_FALSE : L_TRUE;
822
+ }
823
+
824
+ push() {
825
+ this.constraintToReinitLim.push(this.constraintToReinit.length);
826
+ }
827
+
828
+ pop(numScopes: number) {
829
+ const newLim = this.constraintToReinitLim.length - numScopes;
830
+ this.constraintToReinitLastSize = this.constraintToReinitLim[newLim];
831
+ this.constraintToReinitLim.length = newLim;
832
+ this.numPropagationsSincePop = 0;
833
+ }
834
+
835
+ popReinit() {
836
+ const toReinit = this.constraintToReinit;
837
+ let size = this.constraintToReinitLastSize;
838
+ for (let index = size; index < toReinit.length; index++) {
839
+ const constraint = toReinit[index];
840
+ if (!this.initWatch(constraint) && !this.solver.atBaseLvl()) toReinit[size++] = constraint;
841
+ }
842
+ toReinit.length = size;
843
+ }
844
+
845
+ simplify() {
846
+ const solver = this.solver;
847
+ if (!solver.atBaseLvl()) solver.popToBaseLevel();
848
+ if (solver.isInconsistent) return;
849
+ let trailSize = 0;
850
+ let count = 0;
851
+ do {
852
+ trailSize = solver.initTrailSize();
853
+ this.isSimplifyChange = false;
854
+ this.isClauseRemoved = false;
855
+ this.isConstraintRemoved = false;
856
+ for (let index = 0, size = this.constraints.length; index < size; index++)
857
+ this.simplifyConstraint(this.constraints[index]);
858
+ for (let index = 0, size = this.learned.length; index < size; index++)
859
+ this.simplifyConstraint(this.learned[index]);
860
+ this.initUseLists();
861
+ this.setNonExternal();
862
+ this.elimPure();
863
+ for (let index = 0, size = this.constraints.length; index < size; index++)
864
+ this.subsumption(this.constraints[index]);
865
+ for (let index = 0, size = this.learned.length; index < size; index++)
866
+ this.subsumption(this.learned[index]);
867
+ this.cleanupClauses();
868
+ this.cleanupConstraints();
869
+ count++;
870
+ } while (count < 10 && (this.isSimplifyChange || trailSize < solver.initTrailSize()));
871
+ this.gc();
872
+ }
873
+
874
+ private reserveRoots() {
875
+ const numVars = this.solver.numVars();
876
+ while (this.rootVars.length < numVars) this.rootVars.push(false);
877
+ for (let lit = this.roots.length; lit < 2 * numVars; lit++) this.roots.push(lit);
878
+ }
879
+
880
+ setRoot(lit: number, root: number) {
881
+ if (this.solver.isAssumption(lit >> 1)) return false;
882
+ this.reserveRoots();
883
+ this.roots[lit] = root;
884
+ this.roots[lit ^ 1] = root ^ 1;
885
+ this.roots[root] = root;
886
+ this.roots[root ^ 1] = root ^ 1;
887
+ this.rootVars[lit >> 1] = true;
888
+ return true;
889
+ }
890
+
891
+ flushRoots() {
892
+ if (this.roots.length === 0) return;
893
+ this.reserveRoots();
894
+ this.isConstraintRemoved = false;
895
+ for (let index = 0, size = this.constraints.length; index < size; index++)
896
+ this.flushConstraintRoots(this.constraints[index]);
897
+ for (let index = 0, size = this.learned.length; index < size; index++)
898
+ this.flushConstraintRoots(this.learned[index]);
899
+ this.cleanupConstraints();
900
+ }
901
+
902
+ private recompile(constraint: Constraint) {
903
+ if (constraint.isCard()) this.recompileCard(constraint);
904
+ else this.recompilePb(constraint as Pbc);
905
+ }
906
+
907
+ private recompileCard(constraint: Card) {
908
+ const weights = this.weights;
909
+ const numLits = 2 * this.solver.numVars();
910
+ while (weights.length < numLits) weights.push(0);
911
+ for (const lit of constraint.lits) weights[lit]++;
912
+ let k = constraint.k;
913
+ let isAllUnits = true;
914
+ const coeffs: number[] = [];
915
+ const size = constraint.size;
916
+ const lits = constraint.lits;
917
+ let next = 0;
918
+ for (let index = 0; index < size && k > 0; index++) {
919
+ const lit = lits[index];
920
+ let weight = weights[lit];
921
+ const weight2 = weights[lit ^ 1];
922
+ if (weight === 0 || weight < weight2) continue;
923
+ if (k <= weight2) {
924
+ k = 0;
925
+ break;
926
+ }
927
+ k -= weight2;
928
+ weight -= weight2;
929
+ weights[lit ^ 1] = 0;
930
+ weights[lit] = 0;
931
+ if (weight === 0) continue;
932
+ isAllUnits &&= weight === 1;
933
+ coeffs.push(weight);
934
+ lits[next++] = lit;
935
+ }
936
+ for (const lit of lits) {
937
+ weights[lit] = 0;
938
+ weights[lit ^ 1] = 0;
939
+ }
940
+ const root = constraint.lit;
941
+ if (k === 0 && root === NULL_LITERAL) {
942
+ this.removeConstraint(constraint);
943
+ return;
944
+ }
945
+ if (k === 1 && root === NULL_LITERAL) {
946
+ this.mkClause(lits.slice(0, next), constraint.isLearned);
947
+ this.removeConstraint(constraint);
948
+ return;
949
+ }
950
+ if (next === 0) {
951
+ if (root === NULL_LITERAL) {
952
+ if (k > 0) this.mkClause([], false);
953
+ } else this.mkClause([k > 0 ? root ^ 1 : root], constraint.isLearned);
954
+ this.removeConstraint(constraint);
955
+ return;
956
+ }
957
+ if (isAllUnits && next < k) {
958
+ this.mkClause(root === NULL_LITERAL ? [] : [root ^ 1], constraint.isLearned);
959
+ this.removeConstraint(constraint);
960
+ return;
961
+ }
962
+ constraint.setSize(next);
963
+ constraint.setK(k);
964
+ if (!isAllUnits) {
965
+ const wlits = { coeffs, lits: [...constraint.lits] };
966
+ this.removeConstraint(constraint);
967
+ this.addPbGe(root, wlits, k, constraint.isLearned);
968
+ } else if (root === NULL_LITERAL || this.value(root) === L_TRUE) this.initWatch(constraint);
969
+ }
970
+
971
+ private flushConstraintRoots(constraint: Constraint) {
972
+ if (constraint.lit !== NULL_LITERAL && !constraint.isWatched(this, constraint.lit)) {
973
+ constraint.watchLiteral(this, constraint.lit);
974
+ constraint.watchLiteral(this, constraint.lit ^ 1);
975
+ }
976
+ let isFound = constraint.lit !== NULL_LITERAL && this.rootVars[constraint.lit >> 1];
977
+ for (let index = 0; !isFound && index < constraint.size; index++)
978
+ isFound = this.rootVars[constraint.lits[index] >> 1];
979
+ if (!isFound) return;
980
+ constraint.clearWatch(this);
981
+ for (let index = 0; index < constraint.size; index++)
982
+ constraint.lits[index] = this.roots[constraint.lits[index]];
983
+ let root = constraint.lit;
984
+ if (root !== NULL_LITERAL && this.roots[root] !== root) {
985
+ root = this.roots[root];
986
+ constraint.nullifyTrackingLiteral(this);
987
+ constraint.lit = root;
988
+ constraint.watchLiteral(this, root);
989
+ constraint.watchLiteral(this, root ^ 1);
990
+ }
991
+ const solver = this.solver;
992
+ let isDuplicate = false;
993
+ solver.initVisited();
994
+ for (const lit of constraint.lits) {
995
+ if (solver.isVisited(lit)) {
996
+ isDuplicate = true;
997
+ break;
998
+ }
999
+ solver.markVisited(lit);
1000
+ solver.markVisited(lit ^ 1);
1001
+ }
1002
+ const isRootFound = constraint.lits.some((lit) => lit >> 1 === root >> 1);
1003
+ if (isRootFound) {
1004
+ this.splitRoot(constraint);
1005
+ constraint.negate();
1006
+ this.splitRoot(constraint);
1007
+ this.removeConstraint(constraint);
1008
+ } else if (isDuplicate) this.recompile(constraint);
1009
+ else if (constraint.lit === NULL_LITERAL || this.value(constraint.lit) !== L_UNDEF)
1010
+ this.initWatch(constraint);
1011
+ }
1012
+
1013
+ private initUseLists() {
1014
+ const solver = this.solver;
1015
+ const arena = solver.arena;
1016
+ const numLits = 2 * solver.numVars();
1017
+ this.clauseUseCounts = new Int32Array(numLits);
1018
+ this.clauseUseLists = Array.from({ length: numLits }, () => []);
1019
+ this.cnstrUseList = Array.from({ length: numLits }, () => []);
1020
+ for (const clause of solver.clauses) {
1021
+ if (arena.isFrozen(clause)) continue;
1022
+ for (let index = 0; index < arena.size[clause]; index++) {
1023
+ const lit = arena.get(clause, index);
1024
+ this.clauseUseLists[lit].push(clause);
1025
+ this.clauseUseCounts[lit]++;
1026
+ }
1027
+ }
1028
+ for (const constraint of this.constraints) {
1029
+ const lit = constraint.lit;
1030
+ if (lit !== NULL_LITERAL) {
1031
+ this.cnstrUseList[lit].push(constraint);
1032
+ this.cnstrUseList[lit ^ 1].push(constraint);
1033
+ }
1034
+ for (const other of constraint.lits) {
1035
+ this.cnstrUseList[other].push(constraint);
1036
+ if (lit !== NULL_LITERAL) this.cnstrUseList[other ^ 1].push(constraint);
1037
+ }
1038
+ }
1039
+ }
1040
+
1041
+ private useCount(lit: number) {
1042
+ return this.cnstrUseList[lit].length + this.clauseUseCounts[lit];
1043
+ }
1044
+
1045
+ private isIncrementalMode() {
1046
+ return this.solver.simplifier.isIncrementalMode || this.solver.trackingAssumptions();
1047
+ }
1048
+
1049
+ private setNonExternal() {
1050
+ const solver = this.solver;
1051
+ if (!this.isIncrementalMode())
1052
+ for (let boolVar = 0; boolVar < solver.numVars(); boolVar++)
1053
+ if (
1054
+ solver.isExternal(boolVar) &&
1055
+ this.cnstrUseList[2 * boolVar].length === 0 &&
1056
+ this.cnstrUseList[2 * boolVar + 1].length === 0
1057
+ )
1058
+ solver.external[boolVar] = false;
1059
+ for (const constraint of this.learned) {
1060
+ if (constraint.isRemoved) continue;
1061
+ if (constraint.lits.some((lit) => solver.wasEliminated(lit >> 1)))
1062
+ this.removeConstraint(constraint);
1063
+ }
1064
+ }
1065
+
1066
+ private elimPureLit(lit: number) {
1067
+ if (
1068
+ this.value(lit) !== L_UNDEF ||
1069
+ this.cnstrUseList[lit].length === 0 ||
1070
+ this.useCount(lit ^ 1) !== 0 ||
1071
+ this.getWlist(lit).numNonlearnedBin() !== 0
1072
+ )
1073
+ return false;
1074
+ this.solver.assignScoped(lit);
1075
+ return true;
1076
+ }
1077
+
1078
+ private elimPure() {
1079
+ const solver = this.solver;
1080
+ if (!solver.simplifier.isElimVars || this.isIncrementalMode()) return;
1081
+ for (let boolVar = 0; boolVar < solver.numVars(); boolVar++) {
1082
+ const lit = 2 * boolVar;
1083
+ if (solver.valueVar(boolVar) !== L_UNDEF) continue;
1084
+ if (this.cnstrUseList[lit].length === 0 && this.cnstrUseList[lit + 1].length === 0) continue;
1085
+ if (!this.elimPureLit(lit)) this.elimPureLit(lit + 1);
1086
+ }
1087
+ }
1088
+
1089
+ private subsumption(constraint: Constraint) {
1090
+ if (constraint.isRemoved || constraint.k <= 1) return;
1091
+ if (constraint.isCard()) this.cardSubsumption(constraint);
1092
+ else this.pbSubsumption(constraint as Pbc);
1093
+ }
1094
+
1095
+ private cleanupClauses() {
1096
+ if (!this.isClauseRemoved) return;
1097
+ const solver = this.solver;
1098
+ for (const clauses of [solver.clauses, solver.learned]) {
1099
+ let next = 0;
1100
+ for (const clause of clauses) {
1101
+ if (solver.arena.wasRemoved(clause) && solver.canDelete(clause)) {
1102
+ solver.detachClause(clause);
1103
+ solver.delClause(clause);
1104
+ } else clauses[next++] = clause;
1105
+ }
1106
+ clauses.length = next;
1107
+ }
1108
+ }
1109
+
1110
+ private cleanupConstraints() {
1111
+ if (!this.isConstraintRemoved) return;
1112
+ this.cleanupConstraintList(this.constraints, false);
1113
+ this.cleanupConstraintList(this.learned, true);
1114
+ this.isConstraintRemoved = false;
1115
+ }
1116
+
1117
+ private cleanupConstraintList(list: Constraint[], isLearnedList: boolean) {
1118
+ let next = 0;
1119
+ for (const constraint of list) {
1120
+ if (constraint.isRemoved) {
1121
+ constraint.clearWatch(this);
1122
+ constraint.nullifyTrackingLiteral(this);
1123
+ this.deallocate(constraint);
1124
+ } else if (isLearnedList && !constraint.isLearned) this.constraints.push(constraint);
1125
+ else list[next++] = constraint;
1126
+ }
1127
+ list.length = next;
1128
+ }
1129
+
1130
+ // A >= k subsumes A + B >= k' when k' + |A'| + |comp| <= k.
1131
+ private isCardSubsumed(first: Card, second: Card, complements: number[]) {
1132
+ if (second.lit !== NULL_LITERAL) return false;
1133
+ const solver = this.solver;
1134
+ let common = 0;
1135
+ complements.length = 0;
1136
+ for (const lit of second.lits) {
1137
+ if (solver.isVisited(lit)) common++;
1138
+ else if (solver.isVisited(lit ^ 1)) complements.push(lit);
1139
+ }
1140
+ const exclusive = first.size - common - complements.length;
1141
+ return exclusive + second.k + complements.length <= first.k;
1142
+ }
1143
+
1144
+ private isClauseSubsumed(constraint: Card, clause: number) {
1145
+ const solver = this.solver;
1146
+ const arena = solver.arena;
1147
+ let common = 0;
1148
+ let complement = 0;
1149
+ let exclusive = 0;
1150
+ for (let index = 0; index < arena.size[clause]; index++) {
1151
+ const lit = arena.get(clause, index);
1152
+ if (solver.isVisited(lit)) common++;
1153
+ else if (solver.isVisited(lit ^ 1)) complement++;
1154
+ else exclusive++;
1155
+ }
1156
+ const cardExclusive = constraint.size - common - complement;
1157
+ if (complement > 0 && constraint.k + 1 > cardExclusive + exclusive + common)
1158
+ return { isSubsumed: true, isSelf: true };
1159
+ return { isSubsumed: constraint.size - common < constraint.k, isSelf: false };
1160
+ }
1161
+
1162
+ private isPbSubsumed(first: Pbc, second: Constraint) {
1163
+ if (first.k < second.k || first.size > second.size) return false;
1164
+ const solver = this.solver;
1165
+ let numSub = 0;
1166
+ for (let index = 0; index < second.size; index++) {
1167
+ const lit = second.lits[index];
1168
+ if (solver.isVisited(lit) && this.weights[lit] <= second.getCoeff(index)) numSub++;
1169
+ if (first.size + index > second.size + numSub) return false;
1170
+ }
1171
+ return numSub === first.size;
1172
+ }
1173
+
1174
+ private pbSubsumes(first: Pbc, lit: number) {
1175
+ for (const constraint of this.cnstrUseList[lit]) {
1176
+ if (constraint === first || constraint.isRemoved || constraint.lit !== NULL_LITERAL) continue;
1177
+ if (!this.isPbSubsumed(first, constraint)) continue;
1178
+ this.setNonLearned(first);
1179
+ this.removeConstraint(constraint);
1180
+ }
1181
+ }
1182
+
1183
+ private cardCardSubsumption(first: Card, lit: number) {
1184
+ const complements: number[] = [];
1185
+ for (const constraint of this.cnstrUseList[lit]) {
1186
+ if (!constraint.isCard() || constraint === first || constraint.isRemoved) continue;
1187
+ if (!this.isCardSubsumed(first, constraint, complements)) continue;
1188
+ if (complements.length === 0) {
1189
+ this.removeConstraint(constraint);
1190
+ this.setNonLearned(first);
1191
+ continue;
1192
+ }
1193
+ constraint.clearWatch(this);
1194
+ const solver = this.solver;
1195
+ let next = 0;
1196
+ for (let index = 0; index < constraint.size; index++)
1197
+ if (!solver.isVisited(constraint.lits[index] ^ 1))
1198
+ constraint.lits[next++] = constraint.lits[index];
1199
+ constraint.setSize(next);
1200
+ this.initWatch(constraint);
1201
+ this.isSimplifyChange = true;
1202
+ }
1203
+ }
1204
+
1205
+ private clauseSubsumption(constraint: Card, lit: number, removedClauses: number[]) {
1206
+ const arena = this.solver.arena;
1207
+ for (const clause of this.clauseUseLists[lit]) {
1208
+ if (arena.wasRemoved(clause)) continue;
1209
+ const subsumed = this.isClauseSubsumed(constraint, clause);
1210
+ if (!subsumed.isSubsumed || subsumed.isSelf) continue;
1211
+ removedClauses.push(clause);
1212
+ this.setNonLearned(constraint);
1213
+ }
1214
+ }
1215
+
1216
+ private setNonLearned(constraint: Constraint) {
1217
+ const solver = this.solver;
1218
+ if (constraint.lit !== NULL_LITERAL) solver.setExternal(constraint.lit >> 1);
1219
+ for (const lit of constraint.lits) solver.setExternal(lit >> 1);
1220
+ constraint.isLearned = false;
1221
+ }
1222
+
1223
+ private binarySubsumption(constraint: Card, lit: number) {
1224
+ if (constraint.k + 1 !== constraint.size) return;
1225
+ const solver = this.solver;
1226
+ const wlist = this.getWlist(lit ^ 1);
1227
+ let next = 0;
1228
+ for (let index = 0; index < wlist.size; index++) {
1229
+ if (wlist.isBinary(index) && solver.isVisited(wlist.getLiteral(index))) {
1230
+ if (!wlist.isLearned(index)) this.setNonLearned(constraint);
1231
+ continue;
1232
+ }
1233
+ wlist.copy(next++, index);
1234
+ }
1235
+ wlist.setEnd(next);
1236
+ }
1237
+
1238
+ private cardSubsumption(constraint: Card) {
1239
+ if (constraint.isRemoved || constraint.lit !== NULL_LITERAL) return;
1240
+ const solver = this.solver;
1241
+ const removedClauses: number[] = [];
1242
+ solver.initVisited();
1243
+ for (const lit of constraint.lits) solver.markVisited(lit);
1244
+ for (let index = 0; index < Math.min(constraint.size, constraint.k + 1); index++) {
1245
+ const lit = constraint.lits[index];
1246
+ this.cardCardSubsumption(constraint, lit);
1247
+ this.clauseSubsumption(constraint, lit, removedClauses);
1248
+ this.binarySubsumption(constraint, lit);
1249
+ }
1250
+ if (removedClauses.length > 0) this.isClauseRemoved = true;
1251
+ const arena = solver.arena;
1252
+ for (const clause of removedClauses) {
1253
+ arena.setRemoved(clause, true);
1254
+ for (let index = 0; index < arena.size[clause]; index++)
1255
+ this.clauseUseCounts[arena.get(clause, index)]--;
1256
+ }
1257
+ }
1258
+
1259
+ private pbSubsumption(constraint: Pbc) {
1260
+ if (constraint.isRemoved || constraint.lit !== NULL_LITERAL) return;
1261
+ const solver = this.solver;
1262
+ const weights = this.weights;
1263
+ solver.initVisited();
1264
+ for (let index = 0; index < constraint.size; index++) {
1265
+ const lit = constraint.lits[index];
1266
+ while (weights.length <= lit) weights.push(0);
1267
+ weights[lit] = constraint.coeffs[index];
1268
+ solver.markVisited(lit);
1269
+ }
1270
+ for (let index = 0; index < Math.min(10, constraint.numWatch); index++) {
1271
+ const position = solver.rand.next() % constraint.numWatch;
1272
+ this.pbSubsumes(constraint, constraint.lits[position]);
1273
+ }
1274
+ for (const lit of constraint.lits) weights[lit] = 0;
1275
+ }
1276
+
1277
+ // lit <=> the conjunction of the unassigned literals.
1278
+ private assertUnconstrained(lit: number, lits: number[]) {
1279
+ const solver = this.solver;
1280
+ if (lit === NULL_LITERAL) {
1281
+ for (const other of lits) if (this.value(other) === L_UNDEF) solver.assignScoped(other);
1282
+ return;
1283
+ }
1284
+ const clause = [lit];
1285
+ for (const other of lits)
1286
+ if (this.value(other) === L_UNDEF) {
1287
+ solver.mkClause([lit ^ 1, other]);
1288
+ clause.push(other ^ 1);
1289
+ }
1290
+ solver.mkClause(clause);
1291
+ }
1292
+
1293
+ initUseList(useVars: Set<number>) {
1294
+ useVars.clear();
1295
+ for (const constraint of this.constraints) {
1296
+ if (constraint.lit !== NULL_LITERAL) useVars.add(constraint.lit >> 1);
1297
+ for (const lit of constraint.lits) useVars.add(lit >> 1);
1298
+ }
1299
+ }
1300
+
1301
+ findMutexes(lits: number[], mutexes: number[][]) {
1302
+ const members = [...lits];
1303
+ const isMember = new Set(lits);
1304
+ const remove = (lit: number) => {
1305
+ if (!isMember.delete(lit)) return;
1306
+ const position = members.lastIndexOf(lit);
1307
+ members[position] = members[members.length - 1];
1308
+ members.pop();
1309
+ };
1310
+ let isChanged = false;
1311
+ for (const constraint of this.constraints) {
1312
+ if (!constraint.isCard() || constraint.lit !== NULL_LITERAL) continue;
1313
+ if (constraint.size !== constraint.k + 1) continue;
1314
+ const mutex = constraint.lits.map((lit) => lit ^ 1).filter((lit) => isMember.has(lit));
1315
+ if (mutex.length <= 1) continue;
1316
+ for (const lit of mutex) remove(lit);
1317
+ isChanged = true;
1318
+ mutexes.push(mutex);
1319
+ }
1320
+ if (isChanged) lits.splice(0, lits.length, ...members);
1321
+ }
1322
+
1323
+ toFormulas(lit2expr: (lit: number) => number, formulas: number[]) {
1324
+ const manager = this.manager;
1325
+ for (const constraint of this.constraints) {
1326
+ const args = constraint.lits.map(lit2expr);
1327
+ const formula =
1328
+ constraint instanceof Pbc
1329
+ ? mkPbGe(
1330
+ manager,
1331
+ constraint.coeffs.map((coeff) => Rational.fromNumber(coeff)),
1332
+ args,
1333
+ Rational.fromNumber(constraint.k),
1334
+ )
1335
+ : manager.mkApp(
1336
+ manager.mkPbDecl(
1337
+ OP_AT_LEAST_K,
1338
+ [Rational.fromNumber(constraint.k)],
1339
+ args.map(() => SORT_BOOL),
1340
+ ),
1341
+ args,
1342
+ SORT_BOOL,
1343
+ );
1344
+ formulas.push(
1345
+ constraint.lit === NULL_LITERAL ? formula : manager.mkEq(lit2expr(constraint.lit), formula),
1346
+ );
1347
+ }
1348
+ }
1349
+
1350
+ private active2card() {
1351
+ const wlits: { coeff: number; lit: number }[] = [];
1352
+ let sum = 0;
1353
+ this.activeVarSet.clear();
1354
+ for (const boolVar of this.activeVars) {
1355
+ if (this.activeVarSet.has(boolVar)) continue;
1356
+ this.activeVarSet.add(boolVar);
1357
+ const signed = this.getCoeff(boolVar);
1358
+ const abs = Math.abs(signed);
1359
+ const coeff = abs >>> 0;
1360
+ if (coeff !== abs) this.isOverflow = true;
1361
+ if (coeff === 0) continue;
1362
+ wlits.push({ coeff, lit: 2 * boolVar + (signed < 0 ? 1 : 0) });
1363
+ sum += coeff;
1364
+ }
1365
+ if (sum >= Math.floor(UINT_MAX / 2)) this.isOverflow = true;
1366
+ if (this.isOverflow) return;
1367
+ wlits.sort((first, second) => second.coeff - first.coeff || second.lit - first.lit);
1368
+ let k = 0;
1369
+ let total = 0;
1370
+ let total0 = 0;
1371
+ for (const wlit of wlits) {
1372
+ if (total >= this.bound) break;
1373
+ total0 = total;
1374
+ total += wlit.coeff;
1375
+ k++;
1376
+ }
1377
+ if (k === 1) return;
1378
+ while (wlits.length > 0) {
1379
+ if (wlits[wlits.length - 1].coeff + total0 >= this.bound) break;
1380
+ total0 += (wlits.pop() as { coeff: number }).coeff;
1381
+ }
1382
+ let slack = 0;
1383
+ for (const wlit of wlits) if (this.value(wlit.lit) !== L_FALSE) slack++;
1384
+ if (slack >= k) return;
1385
+ const constraint = this.addAtLeast(
1386
+ NULL_LITERAL,
1387
+ wlits.map((wlit) => wlit.lit),
1388
+ k,
1389
+ true,
1390
+ );
1391
+ if (constraint === null) return;
1392
+ const falseLits = wlits.map((wlit) => wlit.lit).filter((lit) => this.value(lit) === L_FALSE);
1393
+ constraint.glue = this.solver.numDiffLevels(falseLits);
1394
+ }
1395
+
1396
+ internalize(expr: number, isSign: boolean, isRoot: boolean) {
1397
+ const manager = this.manager;
1398
+ if (!isRoot) {
1399
+ const lit = this.si.getCached(expr);
1400
+ if (lit !== NULL_LITERAL) return isSign ? lit ^ 1 : lit;
1401
+ }
1402
+ const decl = manager.decls[expr];
1403
+ const k = getPbK(manager, decl);
1404
+ const isUnit = hasUnitCoefficients(manager, decl);
1405
+ switch (manager.getOp(expr)) {
1406
+ case OP_AT_MOST_K:
1407
+ return this.convertAtMostK(expr, k, isRoot, isSign);
1408
+ case OP_AT_LEAST_K:
1409
+ return this.convertAtLeastK(expr, k, isRoot, isSign);
1410
+ case OP_PB_LE:
1411
+ return isUnit
1412
+ ? this.convertAtMostK(expr, k, isRoot, isSign)
1413
+ : this.convertPbLe(expr, isRoot, isSign);
1414
+ case OP_PB_GE:
1415
+ return isUnit
1416
+ ? this.convertAtLeastK(expr, k, isRoot, isSign)
1417
+ : this.convertPbGe(expr, isRoot, isSign);
1418
+ case OP_PB_EQ:
1419
+ return isUnit
1420
+ ? this.convertEqK(expr, k, isRoot, isSign)
1421
+ : this.convertPbEq(expr, isRoot, isSign);
1422
+ default:
1423
+ throw new SmtTacticError("unexpected pseudo-Boolean operator");
1424
+ }
1425
+ }
1426
+
1427
+ private checkUnsigned(value: Rational) {
1428
+ if (!value.isInt() || value.num < 0n || value.num > BigInt(UINT_MAX))
1429
+ throw new SmtTacticError("unsigned coefficient expected");
1430
+ return Number(value.num);
1431
+ }
1432
+
1433
+ private convertPbArgs(expr: number) {
1434
+ const lits: number[] = [];
1435
+ for (const arg of this.manager.getArgs(expr)) {
1436
+ const lit = this.si.internalize(arg);
1437
+ lits.push(lit);
1438
+ this.solver.setExternal(lit >> 1);
1439
+ }
1440
+ return lits;
1441
+ }
1442
+
1443
+ private convertPbWlits(expr: number): WLits {
1444
+ const manager = this.manager;
1445
+ const lits = this.convertPbArgs(expr);
1446
+ const coeffs = lits.map((_, index) =>
1447
+ this.checkUnsigned(getPbCoeff(manager, manager.decls[expr], index)),
1448
+ );
1449
+ return { coeffs, lits };
1450
+ }
1451
+
1452
+ private addRootPbGe(wlits: WLits, k: number, isSign: boolean) {
1453
+ if (!isSign) {
1454
+ this.addPbGe(NULL_LITERAL, wlits, k, false);
1455
+ return;
1456
+ }
1457
+ let bound = 1 - k;
1458
+ for (let index = 0; index < wlits.lits.length; index++) {
1459
+ wlits.lits[index] ^= 1;
1460
+ bound += wlits.coeffs[index];
1461
+ }
1462
+ this.addPbGe(NULL_LITERAL, wlits, bound, false);
1463
+ }
1464
+
1465
+ private convertPbLe(expr: number, isRoot: boolean, isSign: boolean) {
1466
+ const wlits = this.convertPbWlits(expr);
1467
+ let k = getPbK(this.manager, this.manager.decls[expr]).neg();
1468
+ for (let index = 0; index < wlits.lits.length; index++) {
1469
+ wlits.lits[index] ^= 1;
1470
+ k = k.add(Rational.of(BigInt(wlits.coeffs[index])));
1471
+ }
1472
+ const bound = this.checkUnsigned(k);
1473
+ if (isRoot) {
1474
+ this.addRootPbGe(wlits, bound, isSign);
1475
+ return NULL_LITERAL;
1476
+ }
1477
+ const lit = 2 * this.solver.mkVar(true);
1478
+ this.addPbGe(lit, wlits, bound, false);
1479
+ return isSign ? lit ^ 1 : lit;
1480
+ }
1481
+
1482
+ private convertPbGe(expr: number, isRoot: boolean, isSign: boolean) {
1483
+ const bound = this.checkUnsigned(getPbK(this.manager, this.manager.decls[expr]));
1484
+ const wlits = this.convertPbWlits(expr);
1485
+ if (isRoot) {
1486
+ this.addRootPbGe(wlits, bound, isSign);
1487
+ return NULL_LITERAL;
1488
+ }
1489
+ const lit = 2 * this.solver.mkVar(true);
1490
+ this.addPbGe(lit, wlits, bound, false);
1491
+ return isSign ? lit ^ 1 : lit;
1492
+ }
1493
+
1494
+ private convertPbEq(expr: number, isRoot: boolean, isSign: boolean) {
1495
+ const solver = this.solver;
1496
+ let k = getPbK(this.manager, this.manager.decls[expr]);
1497
+ const wlits = this.convertPbWlits(expr);
1498
+ const isBaseAssert = isRoot && !isSign;
1499
+ const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1500
+ const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1501
+ this.addPbGe(lit1, wlits, Number(BigInt.asUintN(32, k.num)), false);
1502
+ k = k.neg();
1503
+ for (let index = 0; index < wlits.lits.length; index++) {
1504
+ wlits.lits[index] ^= 1;
1505
+ k = k.add(Rational.of(BigInt(wlits.coeffs[index])));
1506
+ }
1507
+ if (k.isNegative()) {
1508
+ const lit = 2 * solver.mkVar(false);
1509
+ solver.assignUnit(lit ^ 1);
1510
+ this.si.cache(expr, lit);
1511
+ return isSign ? lit ^ 1 : lit;
1512
+ }
1513
+ this.addPbGe(lit2, wlits, this.checkUnsigned(k), false);
1514
+ if (isBaseAssert) return NULL_LITERAL;
1515
+ return this.mkConjunction(expr, lit1, lit2, isSign);
1516
+ }
1517
+
1518
+ private mkConjunction(expr: number, lit1: number, lit2: number, isSign: boolean) {
1519
+ const solver = this.solver;
1520
+ const lit = 2 * solver.mkVar(false);
1521
+ solver.mkClause([lit ^ 1, lit1]);
1522
+ solver.mkClause([lit ^ 1, lit2]);
1523
+ solver.mkClause([lit1 ^ 1, lit2 ^ 1, lit]);
1524
+ this.si.cache(expr, lit);
1525
+ return isSign ? lit ^ 1 : lit;
1526
+ }
1527
+
1528
+ private convertAtLeastK(expr: number, k: Rational, isRoot: boolean, isSign: boolean) {
1529
+ const lits = this.convertPbArgs(expr);
1530
+ let bound = k.compare(Rational.of(BigInt(lits.length))) > 0 ? lits.length + 1 : Number(k.num);
1531
+ if (isRoot) {
1532
+ if (isSign) {
1533
+ for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
1534
+ bound = lits.length + 1 - bound;
1535
+ }
1536
+ this.addAtLeast(NULL_LITERAL, lits, bound, false);
1537
+ return NULL_LITERAL;
1538
+ }
1539
+ const lit = 2 * this.solver.mkVar(true);
1540
+ this.addAtLeast(lit, lits, bound, false);
1541
+ this.si.cache(expr, lit);
1542
+ return isSign ? lit ^ 1 : lit;
1543
+ }
1544
+
1545
+ private convertAtMostK(expr: number, k: Rational, isRoot: boolean, isSign: boolean) {
1546
+ const lits = this.convertPbArgs(expr);
1547
+ for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
1548
+ const bound1 = k.compare(Rational.of(BigInt(lits.length))) >= 0 ? lits.length : Number(k.num);
1549
+ let bound = lits.length - bound1;
1550
+ if (isRoot) {
1551
+ if (isSign) {
1552
+ for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
1553
+ bound = lits.length + 1 - bound;
1554
+ }
1555
+ this.addAtLeast(NULL_LITERAL, lits, bound, false);
1556
+ return NULL_LITERAL;
1557
+ }
1558
+ const lit = 2 * this.solver.mkVar(true);
1559
+ this.addAtLeast(lit, lits, bound, false);
1560
+ this.si.cache(expr, lit);
1561
+ return isSign ? lit ^ 1 : lit;
1562
+ }
1563
+
1564
+ private convertEqK(expr: number, k: Rational, isRoot: boolean, isSign: boolean) {
1565
+ const solver = this.solver;
1566
+ const lits = this.convertPbArgs(expr);
1567
+ const isBaseAssert = isRoot && !isSign;
1568
+ const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1569
+ const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1570
+ const bound = k.compare(Rational.of(BigInt(lits.length))) > 0 ? lits.length + 1 : Number(k.num);
1571
+ this.addAtLeast(lit1, lits, bound, false);
1572
+ for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
1573
+ this.addAtLeast(lit2, lits, bound > lits.length ? 0 : lits.length - bound, false);
1574
+ if (isBaseAssert) return NULL_LITERAL;
1575
+ return this.mkConjunction(expr, lit1, lit2, isSign);
1576
+ }
1577
+ }