tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.94c3dd828

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (390) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +3 -3
  3. package/dist/compile.js +1 -1
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +58 -54
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +3 -0
  8. package/dist/index.d.ts +3 -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-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +2682 -426
  15. package/dist/prove.js +2678 -422
  16. package/dist/run.cjs +45 -42
  17. package/dist/run.js +47 -44
  18. package/dist/tlapm.cjs +1 -1
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +35 -32
  21. package/dist/transfer.js +39 -36
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +1 -1
  25. package/src/ast.ts +3 -3
  26. package/src/check.ts +203 -33
  27. package/src/cli/tlapm.ts +424 -62
  28. package/src/dependencies.ts +23 -2
  29. package/src/errors.ts +30 -3
  30. package/src/exit-codes.ts +1 -0
  31. package/src/lexer.ts +5 -3
  32. package/src/liveness-checker.ts +530 -201
  33. package/src/liveness.ts +47 -32
  34. package/src/obligations/action.ts +10 -4
  35. package/src/obligations/anonymize.ts +33 -12
  36. package/src/obligations/enabled-axioms.ts +218 -0
  37. package/src/obligations/equality.ts +1 -1
  38. package/src/obligations/expression.ts +18 -4
  39. package/src/obligations/generate.ts +22 -15
  40. package/src/obligations/index.ts +36 -6
  41. package/src/obligations/levels.ts +24 -9
  42. package/src/obligations/module.ts +1 -1
  43. package/src/obligations/normalize.ts +24 -11
  44. package/src/obligations/pragma.ts +53 -16
  45. package/src/obligations/printer.ts +43 -11
  46. package/src/obligations/proof.ts +3 -0
  47. package/src/obligations/simplify.ts +17 -5
  48. package/src/obligations/source.ts +71 -17
  49. package/src/obligations/subexpression.ts +45 -16
  50. package/src/obligations/substitution.ts +1 -1
  51. package/src/parallel.ts +2 -2
  52. package/src/parser.ts +561 -146
  53. package/src/prover/deciders.ts +11 -8
  54. package/src/prover/isabelle/decide.ts +3 -25
  55. package/src/prover/isabelle/encode.ts +71 -39
  56. package/src/prover/isabelle/isar/attrib.ts +254 -0
  57. package/src/prover/isabelle/isar/context.ts +339 -0
  58. package/src/prover/isabelle/isar/induct.ts +386 -0
  59. package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
  60. package/src/prover/isabelle/isar/method.ts +506 -196
  61. package/src/prover/isabelle/isar/proof.ts +571 -13
  62. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  63. package/src/prover/isabelle/isar/theory.ts +479 -69
  64. package/src/prover/isabelle/isar/toplevel.ts +335 -0
  65. package/src/prover/isabelle/isar/type-check.ts +83 -6
  66. package/src/prover/isabelle/provers/classical.ts +45 -18
  67. package/src/prover/isabelle/pure/drule.ts +63 -2
  68. package/src/prover/isabelle/pure/goal.ts +1 -1
  69. package/src/prover/isabelle/pure/object-logic.ts +13 -5
  70. package/src/prover/isabelle/pure/rewriter.ts +1 -6
  71. package/src/prover/isabelle/pure/simplifier.ts +26 -5
  72. package/src/prover/isabelle/tla/classical-setup.ts +1 -0
  73. package/src/prover/isabelle/tla/context.ts +51 -9
  74. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  75. package/src/prover/isabelle/tla/logic.ts +40 -1
  76. package/src/prover/isabelle/tools/intuitionistic.ts +28 -10
  77. package/src/prover/ocaml.ts +4 -1
  78. package/src/prover/prep/action.ts +19 -12
  79. package/src/prover/prep/enabled-axioms.ts +11 -2
  80. package/src/prover/prep/methods.ts +159 -50
  81. package/src/prover/prep/normalize.ts +38 -9
  82. package/src/prover/prove.ts +343 -65
  83. package/src/prover/ptl/decide.ts +95 -50
  84. package/src/prover/ptl/encode.ts +2 -3
  85. package/src/prover/ptl/tableau.ts +28 -2
  86. package/src/prover/smt/arithmetic.ts +310 -0
  87. package/src/prover/smt/axioms.ts +12 -8
  88. package/src/prover/smt/context.ts +42 -6
  89. package/src/prover/smt/data.ts +191 -84
  90. package/src/prover/smt/encode.ts +122 -43
  91. package/src/prover/smt/extensionality.ts +5 -3
  92. package/src/prover/smt/flatten.ts +4 -6
  93. package/src/prover/smt/format.ts +28 -4
  94. package/src/prover/smt/instances.ts +7 -1
  95. package/src/prover/smt/layout.ts +91 -0
  96. package/src/prover/smt/rewrite.ts +488 -116
  97. package/src/prover/smt/simplify.ts +441 -0
  98. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +63 -0
  99. package/src/prover/smt/solver/ackr-helper.ts +182 -0
  100. package/src/prover/smt/solver/ackr-model-converter.ts +106 -0
  101. package/src/prover/smt/solver/add-bounds-tactic.ts +60 -0
  102. package/src/prover/smt/solver/aig-tactic.ts +53 -0
  103. package/src/prover/smt/solver/aig.ts +890 -0
  104. package/src/prover/smt/solver/arith-rewriter.ts +613 -5
  105. package/src/prover/smt/solver/arith-terms.ts +123 -0
  106. package/src/prover/smt/solver/array-decl-plugin.ts +176 -0
  107. package/src/prover/smt/solver/array-rewriter.ts +310 -0
  108. package/src/prover/smt/solver/asserted-formulas.ts +87 -15
  109. package/src/prover/smt/solver/ast-lt.ts +166 -11
  110. package/src/prover/smt/solver/ast-util.ts +162 -2
  111. package/src/prover/smt/solver/ast.ts +1448 -39
  112. package/src/prover/smt/solver/bit-blast-tactic.ts +585 -0
  113. package/src/prover/smt/solver/bit-blaster.ts +874 -0
  114. package/src/prover/smt/solver/bound-manager.ts +197 -0
  115. package/src/prover/smt/solver/bound-simplifier.ts +602 -0
  116. package/src/prover/smt/solver/bv-bound-chk.ts +494 -0
  117. package/src/prover/smt/solver/bv-decl-plugin.ts +339 -0
  118. package/src/prover/smt/solver/bv-divrem-bounds.ts +97 -0
  119. package/src/prover/smt/solver/bv-rewriter.ts +1903 -0
  120. package/src/prover/smt/solver/bv1-blast.ts +216 -0
  121. package/src/prover/smt/solver/bv2fpa-converter.ts +175 -0
  122. package/src/prover/smt/solver/bv2int-rewriter.ts +545 -0
  123. package/src/prover/smt/solver/bv2real-rewriter.ts +534 -0
  124. package/src/prover/smt/solver/card2bv.ts +112 -0
  125. package/src/prover/smt/solver/cg-table.ts +41 -25
  126. package/src/prover/smt/solver/check-logic.ts +331 -0
  127. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +280 -0
  128. package/src/prover/smt/solver/conflict-resolution.ts +78 -1
  129. package/src/prover/smt/solver/context.ts +513 -111
  130. package/src/prover/smt/solver/ctx-simplify.ts +20 -9
  131. package/src/prover/smt/solver/ctx-solver-simplify.ts +124 -0
  132. package/src/prover/smt/solver/datatype-decl-plugin.ts +573 -0
  133. package/src/prover/smt/solver/datatype-rewriter.ts +83 -0
  134. package/src/prover/smt/solver/demodulator.ts +789 -0
  135. package/src/prover/smt/solver/dependent-expr-state.ts +84 -0
  136. package/src/prover/smt/solver/der.ts +38 -9
  137. package/src/prover/smt/solver/diff-neq.ts +207 -0
  138. package/src/prover/smt/solver/distribute-forall.ts +58 -0
  139. package/src/prover/smt/solver/dom-simplify.ts +513 -0
  140. package/src/prover/smt/solver/dt2bv-tactic.ts +262 -0
  141. package/src/prover/smt/solver/e-matching.ts +6 -6
  142. package/src/prover/smt/solver/elim-small-bv-tactic.ts +130 -0
  143. package/src/prover/smt/solver/elim-uncnstr.ts +547 -0
  144. package/src/prover/smt/solver/enode.ts +100 -2
  145. package/src/prover/smt/solver/eq2bv-tactic.ts +219 -0
  146. package/src/prover/smt/solver/euf/arith-axioms.ts +404 -0
  147. package/src/prover/smt/solver/euf/arith-internalize.ts +655 -0
  148. package/src/prover/smt/solver/euf/arith-solver.ts +890 -0
  149. package/src/prover/smt/solver/euf/array-axioms.ts +528 -0
  150. package/src/prover/smt/solver/euf/array-internalize.ts +430 -0
  151. package/src/prover/smt/solver/euf/array-solver.ts +308 -0
  152. package/src/prover/smt/solver/euf/bv-ackerman.ts +164 -0
  153. package/src/prover/smt/solver/euf/bv-internalize.ts +750 -0
  154. package/src/prover/smt/solver/euf/bv-solver.ts +451 -0
  155. package/src/prover/smt/solver/euf/dt-solver.ts +620 -0
  156. package/src/prover/smt/solver/euf/egraph.ts +909 -0
  157. package/src/prover/smt/solver/euf/euf-solver.ts +1208 -0
  158. package/src/prover/smt/solver/euf/fpa-solver.ts +319 -0
  159. package/src/prover/smt/solver/euf/mam.ts +1052 -0
  160. package/src/prover/smt/solver/euf/q-ematch.ts +832 -0
  161. package/src/prover/smt/solver/euf/q-mbi.ts +589 -0
  162. package/src/prover/smt/solver/euf/q-model-fixer.ts +299 -0
  163. package/src/prover/smt/solver/euf/q-solver.ts +363 -0
  164. package/src/prover/smt/solver/euf/th-solver.ts +337 -0
  165. package/src/prover/smt/solver/euf/th-solvers.ts +31 -0
  166. package/src/prover/smt/solver/expr-safe-replace.ts +26 -1
  167. package/src/prover/smt/solver/expr2polynomial.ts +147 -0
  168. package/src/prover/smt/solver/factor.ts +142 -0
  169. package/src/prover/smt/solver/fd-solver.ts +268 -0
  170. package/src/prover/smt/solver/fingerprints.ts +15 -14
  171. package/src/prover/smt/solver/fix-dl-var.ts +149 -0
  172. package/src/prover/smt/solver/fm-tactic.ts +885 -0
  173. package/src/prover/smt/solver/fpa-decl-plugin.ts +619 -0
  174. package/src/prover/smt/solver/fpa-rewriter.ts +641 -0
  175. package/src/prover/smt/solver/fpa2bv-converter.ts +2250 -0
  176. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  177. package/src/prover/smt/solver/fpa2bv-tactic.ts +75 -0
  178. package/src/prover/smt/solver/goal.ts +175 -14
  179. package/src/prover/smt/solver/goal2nlsat.ts +191 -0
  180. package/src/prover/smt/solver/guard-set.ts +220 -0
  181. package/src/prover/smt/solver/hashtable.ts +30 -15
  182. package/src/prover/smt/solver/inf-eps.ts +64 -0
  183. package/src/prover/smt/solver/inj-axiom.ts +102 -0
  184. package/src/prover/smt/solver/internalizer.ts +109 -35
  185. package/src/prover/smt/solver/lackr.ts +383 -0
  186. package/src/prover/smt/solver/lia2card.ts +269 -0
  187. package/src/prover/smt/solver/lia2pb.ts +155 -0
  188. package/src/prover/smt/solver/logic-tactics.ts +349 -0
  189. package/src/prover/smt/solver/lp/core-solver.ts +18 -0
  190. package/src/prover/smt/solver/lp/int-cube.ts +3 -3
  191. package/src/prover/smt/solver/lp/lar-solver.ts +40 -3
  192. package/src/prover/smt/solver/lp/maximize-term.ts +59 -7
  193. package/src/prover/smt/solver/lp/nla-core.ts +40 -4
  194. package/src/prover/smt/solver/lp/nla-grobner.ts +9 -3
  195. package/src/prover/smt/solver/lp/nla-powers.ts +221 -0
  196. package/src/prover/smt/solver/lp/nla-transcendentals.ts +326 -0
  197. package/src/prover/smt/solver/lp/nra-solver.ts +25 -2
  198. package/src/prover/smt/solver/lp/union-find.ts +7 -1
  199. package/src/prover/smt/solver/macro-finder.ts +533 -0
  200. package/src/prover/smt/solver/mam-compiler.ts +118 -87
  201. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +19 -0
  202. package/src/prover/smt/solver/max-cliques.ts +107 -0
  203. package/src/prover/smt/solver/maxcore.ts +310 -0
  204. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -5
  205. package/src/prover/smt/solver/maxlex.ts +116 -0
  206. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  207. package/src/prover/smt/solver/maxsmt.ts +93 -0
  208. package/src/prover/smt/solver/mbp/mbp-arith.ts +468 -0
  209. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +102 -0
  210. package/src/prover/smt/solver/mbp/mbp-plugin.ts +289 -0
  211. package/src/prover/smt/solver/mbp/mbp-qel.ts +49 -0
  212. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +272 -0
  213. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +607 -0
  214. package/src/prover/smt/solver/model-based-opt.ts +845 -0
  215. package/src/prover/smt/solver/model-checker.ts +17 -25
  216. package/src/prover/smt/solver/model-evaluator.ts +188 -11
  217. package/src/prover/smt/solver/model-generator.ts +56 -28
  218. package/src/prover/smt/solver/model-macro-solver.ts +38 -26
  219. package/src/prover/smt/solver/model-printer.ts +215 -0
  220. package/src/prover/smt/solver/mpf.ts +712 -0
  221. package/src/prover/smt/solver/mus.ts +52 -0
  222. package/src/prover/smt/solver/muz/dl-context.ts +406 -0
  223. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +98 -0
  224. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +169 -0
  225. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +127 -0
  226. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +301 -0
  227. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +456 -0
  228. package/src/prover/smt/solver/muz/dl-mk-slice.ts +341 -0
  229. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +165 -0
  230. package/src/prover/smt/solver/muz/dl-rule-set.ts +274 -0
  231. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +125 -0
  232. package/src/prover/smt/solver/muz/dl-rule.ts +498 -0
  233. package/src/prover/smt/solver/muz/hnf.ts +202 -0
  234. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
  235. package/src/prover/smt/solver/muz/horn-tactic.ts +203 -0
  236. package/src/prover/smt/solver/muz/rule-properties.ts +338 -0
  237. package/src/prover/smt/solver/muz/spacer-context.ts +1407 -0
  238. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +53 -0
  239. package/src/prover/smt/solver/muz/spacer-generalizers.ts +244 -0
  240. package/src/prover/smt/solver/muz/spacer-manager.ts +129 -0
  241. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  242. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +334 -0
  243. package/src/prover/smt/solver/muz/spacer-util.ts +283 -0
  244. package/src/prover/smt/solver/muz/substitution.ts +205 -0
  245. package/src/prover/smt/solver/nla2bv-tactic.ts +286 -0
  246. package/src/prover/smt/solver/nlqsat.ts +484 -0
  247. package/src/prover/smt/solver/nlsat/algebraic.ts +116 -1
  248. package/src/prover/smt/solver/nlsat/explain.ts +56 -0
  249. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -1
  250. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -0
  251. package/src/prover/smt/solver/nlsat/polynomial.ts +1 -1
  252. package/src/prover/smt/solver/nlsat/solver.ts +223 -12
  253. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +311 -0
  254. package/src/prover/smt/solver/nlsat/transcendentals.ts +369 -0
  255. package/src/prover/smt/solver/nlsat-tactic.ts +83 -0
  256. package/src/prover/smt/solver/nnf.ts +105 -22
  257. package/src/prover/smt/solver/normalize-bounds.ts +54 -0
  258. package/src/prover/smt/solver/occf.ts +98 -0
  259. package/src/prover/smt/solver/opt-context.ts +788 -0
  260. package/src/prover/smt/solver/opt-nlsat.ts +376 -0
  261. package/src/prover/smt/solver/opt-pareto.ts +284 -0
  262. package/src/prover/smt/solver/opt-preprocess.ts +102 -0
  263. package/src/prover/smt/solver/opt-solver.ts +309 -0
  264. package/src/prover/smt/solver/opt-value.ts +56 -0
  265. package/src/prover/smt/solver/optsmt.ts +694 -0
  266. package/src/prover/smt/solver/parallel-tactic.ts +301 -0
  267. package/src/prover/smt/solver/pattern-inference.ts +19 -10
  268. package/src/prover/smt/solver/pb-rewriter.ts +287 -0
  269. package/src/prover/smt/solver/pb2bv-tactic.ts +542 -0
  270. package/src/prover/smt/solver/poly-rewriter.ts +202 -56
  271. package/src/prover/smt/solver/probes.ts +514 -0
  272. package/src/prover/smt/solver/propagate-values.ts +37 -20
  273. package/src/prover/smt/solver/proto-model.ts +651 -17
  274. package/src/prover/smt/solver/pull-quant.ts +28 -11
  275. package/src/prover/smt/solver/purify-arith.ts +633 -0
  276. package/src/prover/smt/solver/qe-arith-plugin.ts +1100 -0
  277. package/src/prover/smt/solver/qe-lite-der.ts +2 -2
  278. package/src/prover/smt/solver/qe-lite-fm.ts +3 -3
  279. package/src/prover/smt/solver/qe-lite.ts +37 -16
  280. package/src/prover/smt/solver/qe-mbp.ts +271 -0
  281. package/src/prover/smt/solver/qe.ts +1500 -0
  282. package/src/prover/smt/solver/qel.ts +26 -0
  283. package/src/prover/smt/solver/qsat.ts +815 -0
  284. package/src/prover/smt/solver/quant-hoist.ts +197 -0
  285. package/src/prover/smt/solver/quant-tactics.ts +16 -55
  286. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
  287. package/src/prover/smt/solver/quantifier-manager.ts +11 -14
  288. package/src/prover/smt/solver/quasi-macros.ts +245 -0
  289. package/src/prover/smt/solver/rational.ts +45 -0
  290. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  291. package/src/prover/smt/solver/recfun-rewriter.ts +108 -0
  292. package/src/prover/smt/solver/reduce-args.ts +226 -0
  293. package/src/prover/smt/solver/reduce-bv-size.ts +120 -0
  294. package/src/prover/smt/solver/relevancy.ts +1 -1
  295. package/src/prover/smt/solver/rewriter-tpl.ts +77 -9
  296. package/src/prover/smt/solver/rewriter.ts +475 -35
  297. package/src/prover/smt/solver/rlimit.ts +25 -1
  298. package/src/prover/smt/solver/sat/asymm-branch.ts +327 -0
  299. package/src/prover/smt/solver/sat/big.ts +178 -0
  300. package/src/prover/smt/solver/sat/clause-use-list.ts +73 -0
  301. package/src/prover/smt/solver/sat/clause.ts +206 -0
  302. package/src/prover/smt/solver/sat/cleaner.ts +96 -0
  303. package/src/prover/smt/solver/sat/config.ts +125 -0
  304. package/src/prover/smt/solver/sat/consequences.ts +204 -0
  305. package/src/prover/smt/solver/sat/elim-eqs.ts +144 -0
  306. package/src/prover/smt/solver/sat/goal2sat.ts +528 -0
  307. package/src/prover/smt/solver/sat/inc-sat-solver.ts +379 -0
  308. package/src/prover/smt/solver/sat/model-converter.ts +138 -0
  309. package/src/prover/smt/solver/sat/pb-constraint.ts +264 -0
  310. package/src/prover/smt/solver/sat/pb-solver.ts +1579 -0
  311. package/src/prover/smt/solver/sat/probing.ts +172 -0
  312. package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
  313. package/src/prover/smt/solver/sat/sat2goal.ts +167 -0
  314. package/src/prover/smt/solver/sat/scc.ts +143 -0
  315. package/src/prover/smt/solver/sat/simplifier.ts +1621 -0
  316. package/src/prover/smt/solver/sat/solver.ts +2129 -0
  317. package/src/prover/smt/solver/sat/var-queue.ts +119 -0
  318. package/src/prover/smt/solver/sat/watch-list.ts +143 -0
  319. package/src/prover/smt/solver/search-tree.ts +285 -0
  320. package/src/prover/smt/solver/seq-axioms.ts +1011 -0
  321. package/src/prover/smt/solver/seq-decl-plugin.ts +820 -0
  322. package/src/prover/smt/solver/seq-derive.ts +1303 -0
  323. package/src/prover/smt/solver/seq-eq-approx.ts +238 -0
  324. package/src/prover/smt/solver/seq-eq-solver.ts +440 -0
  325. package/src/prover/smt/solver/seq-factory.ts +90 -0
  326. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  327. package/src/prover/smt/solver/seq-range-predicate.ts +237 -0
  328. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  329. package/src/prover/smt/solver/seq-re-util.ts +760 -0
  330. package/src/prover/smt/solver/seq-regex-bisim.ts +145 -0
  331. package/src/prover/smt/solver/seq-regex-live.ts +202 -0
  332. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  333. package/src/prover/smt/solver/seq-skolem.ts +318 -0
  334. package/src/prover/smt/solver/seq-subset.ts +166 -0
  335. package/src/prover/smt/solver/seq-view-witness.ts +355 -0
  336. package/src/prover/smt/solver/smt-consequences.ts +299 -0
  337. package/src/prover/smt/solver/smt-kernel.ts +85 -0
  338. package/src/prover/smt/solver/smt-logics.ts +67 -0
  339. package/src/prover/smt/solver/smt-setup.ts +498 -0
  340. package/src/prover/smt/solver/smt2-printer.ts +767 -0
  341. package/src/prover/smt/solver/smtlib-parser.ts +3154 -326
  342. package/src/prover/smt/solver/smtlib-script.ts +1633 -0
  343. package/src/prover/smt/solver/solve-eqs.ts +931 -0
  344. package/src/prover/smt/solver/solver.ts +113 -21
  345. package/src/prover/smt/solver/static-features.ts +316 -0
  346. package/src/prover/smt/solver/tactic.ts +1988 -0
  347. package/src/prover/smt/solver/term-enumeration.ts +206 -0
  348. package/src/prover/smt/solver/theory-array.ts +1242 -0
  349. package/src/prover/smt/solver/theory-bv.ts +1202 -0
  350. package/src/prover/smt/solver/theory-char.ts +356 -0
  351. package/src/prover/smt/solver/theory-datatype.ts +599 -0
  352. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  353. package/src/prover/smt/solver/theory-fpa.ts +390 -0
  354. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -1
  355. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -4
  356. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -69
  357. package/src/prover/smt/solver/theory-lra-internalize.ts +81 -10
  358. package/src/prover/smt/solver/theory-lra-model.ts +20 -34
  359. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -25
  360. package/src/prover/smt/solver/theory-lra-state.ts +6 -21
  361. package/src/prover/smt/solver/theory-lra.ts +188 -0
  362. package/src/prover/smt/solver/theory-pb.ts +936 -0
  363. package/src/prover/smt/solver/theory-polymorphism.ts +59 -0
  364. package/src/prover/smt/solver/theory-recfun.ts +308 -0
  365. package/src/prover/smt/solver/theory-seq-regex.ts +868 -0
  366. package/src/prover/smt/solver/theory-seq-solve.ts +1375 -0
  367. package/src/prover/smt/solver/theory-seq-state.ts +873 -0
  368. package/src/prover/smt/solver/theory-seq.ts +962 -0
  369. package/src/prover/smt/solver/theory.ts +190 -0
  370. package/src/prover/smt/solver/tseitin-cnf.ts +487 -0
  371. package/src/prover/smt/solver/var-subst.ts +36 -13
  372. package/src/prover/smt/table.ts +3 -2
  373. package/src/prover/smt/types.ts +146 -0
  374. package/src/prover/tlapm/cache.ts +29 -8
  375. package/src/prover/tlapm-library.ts +3208 -0
  376. package/src/prover/verdict.ts +2 -0
  377. package/src/prover/zenon/decide.ts +10 -5
  378. package/src/prover/zenon/node.ts +20 -3
  379. package/src/prover/zenon/parse.ts +6 -0
  380. package/src/prover/zenon/search.ts +7 -3
  381. package/src/prover/zenon/tla/sets.ts +7 -6
  382. package/src/search.ts +131 -16
  383. package/src/successors.ts +1 -1
  384. package/src/symmetry.ts +2 -2
  385. package/src/tableau.ts +2 -2
  386. package/src/tlc/fingerprint.ts +81 -9
  387. package/src/tlc/summary.ts +29 -14
  388. package/src/typed-tier.ts +6535 -0
  389. package/src/prover/isabelle/isar/statement.ts +0 -52
  390. package/src/prover/tlaps-module.ts +0 -510
@@ -0,0 +1,936 @@
1
+ // Ported from Z3 (src/smt/theory_pb.h, src/smt/theory_pb.cpp, src/ast/rewriter/pb_rewriter_def.h),
2
+ // MIT license, see z3-license.txt.
3
+ import { SmtInvariantError, SmtUnsupportedError } from "../../../errors";
4
+ import { FAMILY_PB, OP_AT_LEAST_K, OP_AT_MOST_K, OP_PB_EQ, OP_PB_GE, OP_PB_LE } from "./ast";
5
+ import { mkNot } from "./ast-util";
6
+ import { BinJustification, CLS_TH_LEMMA } from "./clause";
7
+ import type { Context } from "./context";
8
+ import {
9
+ type Antecedents,
10
+ Justification,
11
+ TheoryJustification,
12
+ UnitResolutionJustification,
13
+ } from "./enode";
14
+ import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
15
+ import {
16
+ type BoolVar,
17
+ FALSE_LITERAL,
18
+ getVar,
19
+ isNegated,
20
+ type Literal,
21
+ mkLiteral,
22
+ negate,
23
+ TRUE_BOOL_VAR,
24
+ TRUE_LITERAL,
25
+ } from "./literal";
26
+ import { getPbCoeff, getPbK, hasUnitCoefficients, mkPbGe } from "./pb-rewriter";
27
+ import { getGcd, Rational } from "./rational";
28
+ import { Theory } from "./theory";
29
+
30
+ interface PbArg {
31
+ lit: Literal;
32
+ coeff: Rational;
33
+ }
34
+
35
+ interface PbArgs {
36
+ items: PbArg[];
37
+ k: Rational;
38
+ }
39
+
40
+ // pb_rewriter_util over literals. Only inequalities reach it: equalities split into two at internalization.
41
+ const unique = (args: PbArgs) => {
42
+ for (const arg of args.items)
43
+ if (isNegated(arg.lit)) {
44
+ arg.lit = negate(arg.lit);
45
+ args.k = args.k.sub(arg.coeff);
46
+ arg.coeff = arg.coeff.neg();
47
+ }
48
+ const kept: PbArg[] = [];
49
+ for (const arg of args.items) {
50
+ if (arg.lit === TRUE_LITERAL) args.k = args.k.sub(arg.coeff);
51
+ else if (arg.lit !== FALSE_LITERAL) kept.push(arg);
52
+ }
53
+ kept.sort((first, second) => first.lit - second.lit);
54
+ const merged: PbArg[] = [];
55
+ for (const arg of kept) {
56
+ const last = merged[merged.length - 1];
57
+ if (last !== undefined && last.lit === arg.lit) last.coeff = last.coeff.add(arg.coeff);
58
+ else merged.push(arg);
59
+ }
60
+ args.items = merged.filter((arg) => !arg.coeff.isZero());
61
+ };
62
+
63
+ const normalize = (args: PbArgs) => {
64
+ let sum = Rational.zero;
65
+ for (const arg of args.items) {
66
+ const coeff = arg.coeff;
67
+ if (coeff.isNegative()) {
68
+ arg.coeff = coeff.neg();
69
+ arg.lit = negate(arg.lit);
70
+ args.k = args.k.sub(coeff);
71
+ }
72
+ sum = sum.add(arg.coeff);
73
+ }
74
+ if (args.k.compare(Rational.zero) <= 0) {
75
+ args.items = [];
76
+ args.k = Rational.zero;
77
+ return L_TRUE;
78
+ }
79
+ if (sum.compare(args.k) < 0) {
80
+ args.items = [];
81
+ args.k = Rational.one;
82
+ return L_FALSE;
83
+ }
84
+ if (!args.items.every((arg) => arg.coeff.isInt())) {
85
+ let lcm = args.k.den;
86
+ for (const arg of args.items) lcm = (lcm * arg.coeff.den) / getGcd(lcm, arg.coeff.den);
87
+ const scale = Rational.of(lcm);
88
+ args.k = args.k.mul(scale);
89
+ for (const arg of args.items) arg.coeff = arg.coeff.mul(scale);
90
+ }
91
+ const k = args.k;
92
+ sum = Rational.zero;
93
+ for (const arg of args.items) {
94
+ if (arg.coeff.compare(k) > 0) arg.coeff = k;
95
+ sum = sum.add(arg.coeff);
96
+ }
97
+ if (sum.equals(k)) {
98
+ for (const arg of args.items) arg.coeff = Rational.one;
99
+ args.k = Rational.of(BigInt(args.items.length));
100
+ }
101
+ let gcd = 0n;
102
+ for (let index = 0; gcd !== 1n && index < args.items.length; index++) {
103
+ const coeff = args.items[index].coeff;
104
+ if (!coeff.equals(args.k)) gcd = gcd === 0n ? coeff.num : getGcd(gcd, coeff.num);
105
+ }
106
+ if (gcd === 0n) {
107
+ for (const arg of args.items) arg.coeff = Rational.one;
108
+ args.k = Rational.one;
109
+ } else if (gcd > 1n) {
110
+ const bound = args.k.num;
111
+ const newK = bound / gcd + (bound % gcd === 0n ? 0n : 1n);
112
+ for (const arg of args.items)
113
+ arg.coeff = Rational.of(arg.coeff.equals(args.k) ? newK : arg.coeff.num / gcd);
114
+ args.k = Rational.of(newK);
115
+ }
116
+ if (!args.k.equals(Rational.one)) {
117
+ let min = args.items[0].coeff;
118
+ let max = min;
119
+ for (const arg of args.items) {
120
+ if (arg.coeff.compare(min) < 0) min = arg.coeff;
121
+ if (arg.coeff.compare(max) > 0) max = arg.coeff;
122
+ }
123
+ const n0 = args.k.div(max);
124
+ const n1 = n0.floor();
125
+ const n2 = args.k.div(min).ceil().sub(Rational.one);
126
+ if (n1.equals(n2) && !n0.isInt()) {
127
+ for (const arg of args.items) arg.coeff = Rational.one;
128
+ args.k = n1.add(Rational.one);
129
+ }
130
+ }
131
+ return L_UNDEF;
132
+ };
133
+
134
+ const prune = (args: PbArgs) => {
135
+ let nlt = Rational.zero;
136
+ let occ = 0;
137
+ for (let index = 0; nlt.compare(args.k) < 0 && index < args.items.length; index++) {
138
+ const coeff = args.items[index].coeff;
139
+ if (coeff.compare(args.k) < 0) {
140
+ nlt = nlt.add(coeff);
141
+ occ++;
142
+ }
143
+ }
144
+ if (occ === 0 || nlt.compare(args.k) >= 0) return;
145
+ const items = args.items;
146
+ for (let index = 0; index < items.length; index++)
147
+ if (items[index].coeff.compare(args.k) < 0) {
148
+ items[index] = items[items.length - 1];
149
+ items.pop();
150
+ index--;
151
+ }
152
+ unique(args);
153
+ normalize(args);
154
+ };
155
+
156
+ const negateArgs = (args: PbArgs) => {
157
+ let sum = Rational.zero;
158
+ for (const arg of args.items) {
159
+ arg.lit = negate(arg.lit);
160
+ sum = sum.add(arg.coeff);
161
+ }
162
+ args.k = sum.sub(args.k).add(Rational.one);
163
+ if (normalize(args) !== L_UNDEF) throw new SmtInvariantError("a negated inequality is trivial");
164
+ };
165
+
166
+ class Ineq {
167
+ args: [PbArgs, PbArgs] = [
168
+ { items: [], k: Rational.zero },
169
+ { items: [], k: Rational.zero },
170
+ ];
171
+ maxWatch = 0n;
172
+ watchSize = 0;
173
+ watchSum = 0n;
174
+
175
+ constructor(public lit: Literal) {}
176
+
177
+ getArgs() {
178
+ return this.args[isNegated(this.lit) ? 1 : 0];
179
+ }
180
+
181
+ getK() {
182
+ return this.getArgs().k.num;
183
+ }
184
+
185
+ getLit(index: number) {
186
+ return this.getArgs().items[index].lit;
187
+ }
188
+
189
+ getCoeff(index: number) {
190
+ return this.getArgs().items[index].coeff.num;
191
+ }
192
+
193
+ get size() {
194
+ return this.getArgs().items.length;
195
+ }
196
+
197
+ swap(first: number, second: number) {
198
+ const items = this.getArgs().items;
199
+ const arg = items[first];
200
+ items[first] = items[second];
201
+ items[second] = arg;
202
+ }
203
+
204
+ findLit(boolVar: BoolVar, begin: number) {
205
+ let index = begin;
206
+ while (getVar(this.getLit(index)) !== boolVar) index++;
207
+ return index;
208
+ }
209
+
210
+ postPrune() {
211
+ const first = this.args[0];
212
+ if (first.items.length === 0) return;
213
+ negateArgs(first);
214
+ negateArgs(first);
215
+ this.args[1] = { items: first.items.map((arg) => ({ ...arg })), k: first.k };
216
+ negateArgs(this.args[1]);
217
+ }
218
+ }
219
+
220
+ class Card {
221
+ args: Literal[] = [];
222
+
223
+ constructor(
224
+ public lit: Literal,
225
+ public k: number,
226
+ readonly isAux: boolean,
227
+ ) {}
228
+
229
+ get size() {
230
+ return this.args.length;
231
+ }
232
+
233
+ swap(first: number, second: number) {
234
+ const lit = this.args[first];
235
+ this.args[first] = this.args[second];
236
+ this.args[second] = lit;
237
+ }
238
+
239
+ negate() {
240
+ this.lit = negate(this.lit);
241
+ for (let index = 0; index < this.args.length; index++)
242
+ this.args[index] = negate(this.args[index]);
243
+ this.k = this.args.length - this.k + 1;
244
+ }
245
+
246
+ addArg(lit: Literal) {
247
+ if (lit === FALSE_LITERAL) return;
248
+ if (lit === TRUE_LITERAL) {
249
+ if (this.k > 0) this.k--;
250
+ } else this.args.push(lit);
251
+ }
252
+ }
253
+
254
+ class CardJustification extends Justification {
255
+ constructor(
256
+ readonly fromTheory: number,
257
+ readonly card: Card,
258
+ ) {
259
+ super();
260
+ }
261
+
262
+ getAntecedents(antecedents: Antecedents) {
263
+ const card = this.card;
264
+ antecedents.markLiteral(card.lit);
265
+ for (let index = card.k; index < card.size; index++)
266
+ antecedents.markLiteral(negate(card.args[index]));
267
+ }
268
+ }
269
+
270
+ export class TheoryPb extends Theory {
271
+ readonly name = "pb";
272
+ private ineqs: (Ineq | undefined)[] = [];
273
+ private cards: (Card | undefined)[] = [];
274
+ private ineqWatches: Ineq[][] = [];
275
+ private cardWatches: Card[][] = [];
276
+ private ineqsTrail: BoolVar[] = [];
277
+ private ineqsLim: number[] = [];
278
+ private cardTrail: BoolVar[] = [];
279
+ private cardLim: number[] = [];
280
+ private numMarks = 0;
281
+ private conflictLvl = 0;
282
+ private coeffs: number[] = [];
283
+ private activeVars: BoolVar[] = [];
284
+ private readonly activeVarSet = new Set<BoolVar>();
285
+ private bound = 0;
286
+ private antecedents: Literal[] = [];
287
+
288
+ constructor(context: Context) {
289
+ super(context, FAMILY_PB);
290
+ }
291
+
292
+ internalizeTerm(): boolean {
293
+ throw new SmtInvariantError("theory_pb has no terms");
294
+ }
295
+
296
+ newEqEh() {
297
+ throw new SmtInvariantError("theory_pb has no equalities");
298
+ }
299
+
300
+ newDiseqEh() {}
301
+
302
+ override useDiseqs() {
303
+ return false;
304
+ }
305
+
306
+ override buildModels() {
307
+ return false;
308
+ }
309
+
310
+ internalizeAtom(atom: number) {
311
+ const context = this.context;
312
+ const manager = this.manager;
313
+ if (context.isBInternalized(atom)) return true;
314
+ if (this.internalizeCard(atom)) return true;
315
+ const boolVar = context.mkBoolVar(atom);
316
+ context.setVarTheory(boolVar, this.id);
317
+ const lit = mkLiteral(boolVar);
318
+ const decl = manager.decls[atom];
319
+ const args = manager.getArgs(atom);
320
+ const op = manager.getOp(atom);
321
+ if (op === OP_PB_EQ) {
322
+ const coeffs = args.map((_, index) => getPbCoeff(manager, decl, index));
323
+ const sum = coeffs.reduce((total, coeff) => total.add(coeff), Rational.zero);
324
+ const k = getPbK(manager, decl);
325
+ const le = mkPbGe(
326
+ manager,
327
+ coeffs,
328
+ args.map((arg) => mkNot(manager, arg)),
329
+ sum.sub(k),
330
+ );
331
+ const ge = mkPbGe(manager, coeffs, [...args], k);
332
+ context.internalize(le, false);
333
+ context.internalize(ge, false);
334
+ const leLit = context.getLiteral(le);
335
+ const geLit = context.getLiteral(ge);
336
+ context.markLiteralAsRelevant(leLit);
337
+ context.markLiteralAsRelevant(geLit);
338
+ context.mkThAxiom([negate(lit), leLit]);
339
+ context.mkThAxiom([negate(lit), geLit]);
340
+ context.mkThAxiom([negate(leLit), negate(geLit), lit]);
341
+ return true;
342
+ }
343
+ const ineq = new Ineq(lit);
344
+ const first = ineq.args[0];
345
+ first.k = getPbK(manager, decl);
346
+ for (const [index, arg] of args.entries()) {
347
+ const argLit = this.compileArg(arg);
348
+ const coeff = getPbCoeff(manager, decl, index);
349
+ const value = context.getAssignment(argLit);
350
+ if (value === L_TRUE) first.k = first.k.sub(coeff);
351
+ else if (value === L_UNDEF) first.items.push({ lit: argLit, coeff });
352
+ }
353
+ if (op === OP_AT_MOST_K || op === OP_PB_LE) {
354
+ first.k = first.k.neg();
355
+ for (const arg of first.items) {
356
+ arg.lit = negate(arg.lit);
357
+ first.k = first.k.add(arg.coeff);
358
+ }
359
+ }
360
+ unique(first);
361
+ const isTrue = normalize(first);
362
+ prune(first);
363
+ ineq.postPrune();
364
+ if (isTrue !== L_UNDEF) {
365
+ context.mkThAxiom([isTrue === L_FALSE ? negate(lit) : lit]);
366
+ return true;
367
+ }
368
+ if (ineq.getK() === 1n) {
369
+ const lits = [negate(lit)];
370
+ for (let index = 0; index < ineq.size; index++) {
371
+ lits.push(ineq.getLit(index));
372
+ context.mkThAxiom([lit, negate(ineq.getLit(index))]);
373
+ }
374
+ context.mkThAxiom(lits);
375
+ return true;
376
+ }
377
+ this.ineqs[boolVar] = ineq;
378
+ this.ineqsTrail.push(boolVar);
379
+ return true;
380
+ }
381
+
382
+ private compileArg(input: number) {
383
+ const context = this.context;
384
+ const manager = this.manager;
385
+ let isNot = manager.isNot(input);
386
+ const arg = isNot ? manager.getArg(input, 0) : input;
387
+ if (!context.isBInternalized(arg)) context.internalize(arg, false);
388
+ let boolVar = TRUE_BOOL_VAR;
389
+ let hasBoolVar = false;
390
+ if (context.isBInternalized(arg)) {
391
+ boolVar = context.getBoolVar(arg);
392
+ if (manager.isUninterpreted(arg) && context.getBoolVarTheory(boolVar) === -1)
393
+ context.setVarTheory(boolVar, this.id);
394
+ hasBoolVar = context.getBoolVarTheory(boolVar) === this.id;
395
+ } else if (manager.isTrue(arg)) hasBoolVar = true;
396
+ else if (manager.isFalse(arg)) {
397
+ hasBoolVar = true;
398
+ isNot = !isNot;
399
+ }
400
+ if (!hasBoolVar)
401
+ throw new SmtUnsupportedError("pseudo-Boolean arguments that another theory owns");
402
+ return mkLiteral(boolVar, isNot);
403
+ }
404
+
405
+ private delWatch(watch: Ineq[], index: number, ineq: Ineq, ineqIndex: number) {
406
+ watch[index] = watch[watch.length - 1];
407
+ watch.pop();
408
+ let coeff = ineq.getCoeff(ineqIndex);
409
+ if (ineqIndex + 1 < ineq.watchSize) ineq.swap(ineqIndex, ineq.watchSize - 1);
410
+ ineq.watchSize--;
411
+ ineq.watchSum -= coeff;
412
+ if (coeff === ineq.maxWatch) {
413
+ coeff = ineq.getCoeff(0);
414
+ for (let position = 1; coeff !== ineq.maxWatch && position < ineq.watchSize; position++)
415
+ if (coeff < ineq.getCoeff(position)) coeff = ineq.getCoeff(position);
416
+ ineq.maxWatch = coeff;
417
+ }
418
+ }
419
+
420
+ private addWatch(ineq: Ineq, index: number) {
421
+ const lit = ineq.getLit(index);
422
+ const coeff = ineq.getCoeff(index);
423
+ ineq.watchSum += coeff;
424
+ if (index > ineq.watchSize) ineq.swap(index, ineq.watchSize);
425
+ ineq.watchSize++;
426
+ if (coeff > ineq.maxWatch) ineq.maxWatch = coeff;
427
+ (this.ineqWatches[lit] ??= []).push(ineq);
428
+ }
429
+
430
+ private unwatchIneq(lit: Literal, ineq: Ineq) {
431
+ const watch = this.ineqWatches[lit];
432
+ if (watch === undefined) return;
433
+ const position = watch.indexOf(ineq);
434
+ if (position === -1) return;
435
+ watch[position] = watch[watch.length - 1];
436
+ watch.pop();
437
+ }
438
+
439
+ private watchCard(lit: Literal, card: Card) {
440
+ (this.cardWatches[lit] ??= []).push(card);
441
+ }
442
+
443
+ private unwatchCard(lit: Literal, card: Card) {
444
+ const watch = this.cardWatches[lit];
445
+ if (watch === undefined) return;
446
+ const position = watch.indexOf(card);
447
+ if (position === -1) return;
448
+ watch[position] = watch[watch.length - 1];
449
+ watch.pop();
450
+ }
451
+
452
+ private isCardinalityConstraint(atom: number) {
453
+ const manager = this.manager;
454
+ const op = manager.getOp(atom);
455
+ return (
456
+ (op === OP_PB_GE && hasUnitCoefficients(manager, manager.decls[atom])) || op === OP_AT_LEAST_K
457
+ );
458
+ }
459
+
460
+ private internalizeCard(atom: number) {
461
+ const context = this.context;
462
+ const manager = this.manager;
463
+ if (context.isBInternalized(atom)) return true;
464
+ if (!this.isCardinalityConstraint(atom)) return false;
465
+ const args = manager.getArgs(atom);
466
+ const boolVar = context.mkBoolVar(atom);
467
+ context.setVarTheory(boolVar, this.id);
468
+ const bound = Number(getPbK(manager, manager.decls[atom]).num);
469
+ const lit = mkLiteral(boolVar);
470
+ if (bound === 0) {
471
+ context.mkThAxiom([lit]);
472
+ return true;
473
+ }
474
+ if (bound > args.length) {
475
+ context.mkThAxiom([negate(lit)]);
476
+ return true;
477
+ }
478
+ const card = new Card(lit, bound, manager.getOp(atom) === OP_AT_LEAST_K);
479
+ for (const arg of args) card.addArg(this.compileArg(arg));
480
+ if (bound === card.size) this.card2conjunction(card);
481
+ else if (card.size === 1) this.card2disjunction(card);
482
+ else {
483
+ this.cards[boolVar] = card;
484
+ this.cardTrail.push(boolVar);
485
+ }
486
+ return true;
487
+ }
488
+
489
+ private card2conjunction(card: Card) {
490
+ const context = this.context;
491
+ const lits = card.args.map((arg) => negate(arg));
492
+ lits.push(card.lit);
493
+ context.mkThAxiom(lits);
494
+ for (const arg of card.args) context.mkThAxiom([negate(card.lit), arg]);
495
+ }
496
+
497
+ private card2disjunction(card: Card) {
498
+ const context = this.context;
499
+ const lits = [...card.args, negate(card.lit)];
500
+ context.mkThAxiom(lits);
501
+ for (const arg of card.args) context.mkThAxiom([card.lit, negate(arg)]);
502
+ }
503
+
504
+ private addCardClause(card: Card, lits: Literal[]) {
505
+ if (!this.resolveConflict(card, lits)) this.context.mkClause(lits, null, CLS_TH_LEMMA);
506
+ }
507
+
508
+ private addCardAssign(card: Card, lit: Literal) {
509
+ const context = this.context;
510
+ if (context.getAssignment(lit) === L_TRUE) return;
511
+ context.assign(lit, new CardJustification(this.id, card));
512
+ }
513
+
514
+ private clearCardWatch(card: Card) {
515
+ const size = Math.min(card.k + 1, card.size);
516
+ for (let index = 0; index < size; index++) this.unwatchCard(card.args[index], card);
517
+ }
518
+
519
+ private setCardConflict(card: Card, lit: Literal) {
520
+ const lits = [negate(card.lit), lit];
521
+ for (let index = card.k; index < card.size; index++) lits.push(card.args[index]);
522
+ this.addCardClause(card, lits);
523
+ }
524
+
525
+ private assignCard(card: Card, alit: Literal) {
526
+ const context = this.context;
527
+ const size = card.size;
528
+ const bound = card.k;
529
+ let index = 0;
530
+ for (; index <= bound; index++) if (card.args[index] === alit) break;
531
+ if (index === bound + 1) return L_UNDEF;
532
+ for (let position = bound + 1; position < size; position++) {
533
+ const lit2 = card.args[position];
534
+ if (context.getAssignment(lit2) !== L_FALSE) {
535
+ card.swap(index, position);
536
+ this.watchCard(lit2, card);
537
+ return L_UNDEF;
538
+ }
539
+ }
540
+ if (bound !== index && context.getAssignment(card.args[bound]) === L_FALSE) {
541
+ this.setCardConflict(card, alit);
542
+ return L_FALSE;
543
+ }
544
+ if (index !== bound) card.swap(index, bound);
545
+ for (let position = 0; position < bound && !context.isInconsistent(); position++)
546
+ this.addCardAssign(card, card.args[position]);
547
+ return context.isInconsistent() ? L_FALSE : L_TRUE;
548
+ }
549
+
550
+ private initCardWatch(card: Card, isTrue: boolean) {
551
+ const context = this.context;
552
+ this.clearCardWatch(card);
553
+ if (isNegated(card.lit) === isTrue) card.negate();
554
+ const size = card.size;
555
+ const bound = card.k;
556
+ if (bound === size) {
557
+ for (let index = 0; index < size && !context.isInconsistent(); index++)
558
+ this.addCardAssign(card, card.args[index]);
559
+ return;
560
+ }
561
+ let next = 0;
562
+ for (let index = 0; index < size; index++)
563
+ if (context.getAssignment(card.args[index]) !== L_FALSE) {
564
+ if (next !== index) card.swap(index, next);
565
+ next++;
566
+ }
567
+ if (next < bound) {
568
+ let alit = card.args[next];
569
+ // The asserting literal has the highest level, so conflict resolution can start from it.
570
+ for (let index = bound; index < size; index++)
571
+ if (context.getAssignLevel(alit) < context.getAssignLevel(card.args[index])) {
572
+ card.swap(next, index);
573
+ alit = card.args[next];
574
+ }
575
+ this.setCardConflict(card, alit);
576
+ } else if (next === bound) {
577
+ for (let index = 0; index < bound && !context.isInconsistent(); index++)
578
+ this.addCardAssign(card, card.args[index]);
579
+ } else for (let index = 0; index <= bound; index++) this.watchCard(card.args[index], card);
580
+ }
581
+
582
+ override assignEh(boolVar: BoolVar, isTrue: boolean) {
583
+ const context = this.context;
584
+ const falseLit = mkLiteral(boolVar, isTrue);
585
+ const ineqs = this.ineqWatches[falseLit];
586
+ if (ineqs !== undefined)
587
+ for (let index = 0; index < ineqs.length; index++)
588
+ if (this.assignWatchGe(boolVar, ineqs, index)) index--;
589
+ const ineq = this.ineqs[boolVar];
590
+ if (ineq !== undefined) this.assignIneq(ineq, isTrue);
591
+ const cards = this.cardWatches[falseLit];
592
+ if (cards !== undefined && cards.length > 0 && !context.isInconsistent()) {
593
+ let next = 0;
594
+ for (let index = 0; index < cards.length; index++) {
595
+ const card = cards[index];
596
+ if (context.getAssignment(card.lit) !== L_TRUE) continue;
597
+ const result = this.assignCard(card, falseLit);
598
+ if (result === L_FALSE) {
599
+ for (; index < cards.length; index++, next++) cards[next] = cards[index];
600
+ cards.length = next;
601
+ return;
602
+ }
603
+ if (result === L_TRUE) cards[next++] = card;
604
+ }
605
+ cards.length = next;
606
+ }
607
+ const card = this.cards[boolVar];
608
+ if (card !== undefined && !context.isInconsistent()) this.initCardWatch(card, isTrue);
609
+ }
610
+
611
+ private getUnhelpfulLiterals(ineq: Ineq, isNegating: boolean) {
612
+ const context = this.context;
613
+ const lits: Literal[] = [];
614
+ for (let index = 0; index < ineq.size; index++) {
615
+ const lit = ineq.getLit(index);
616
+ if (context.getAssignment(lit) === L_FALSE) lits.push(isNegating ? negate(lit) : lit);
617
+ }
618
+ return lits;
619
+ }
620
+
621
+ private assignIneq(ineq: Ineq, isTrue: boolean) {
622
+ const context = this.context;
623
+ if (isNegated(ineq.lit) === isTrue) {
624
+ ineq.lit = negate(ineq.lit);
625
+ context.pushTrail(() => {
626
+ ineq.lit = negate(ineq.lit);
627
+ });
628
+ }
629
+ const size = ineq.size;
630
+ let maxSum = 0n;
631
+ let minInc = 0n;
632
+ for (let index = 0; index < size; index++) {
633
+ const value = context.getAssignment(ineq.getLit(index));
634
+ if (value !== L_FALSE) maxSum += ineq.getCoeff(index);
635
+ if (value === L_UNDEF && (minInc === 0n || minInc > ineq.getCoeff(index)))
636
+ minInc = ineq.getCoeff(index);
637
+ }
638
+ const k = ineq.getK();
639
+ if (maxSum < k) {
640
+ const lits = this.getUnhelpfulLiterals(ineq, false);
641
+ lits.push(negate(ineq.lit));
642
+ context.mkClause(lits, null, CLS_TH_LEMMA);
643
+ } else this.initWatchLiteral(ineq);
644
+ if (maxSum >= k && maxSum - minInc < k) {
645
+ const lits = this.getUnhelpfulLiterals(ineq, true);
646
+ lits.push(ineq.lit);
647
+ for (let index = 0; index < size; index++) {
648
+ const lit = ineq.getLit(index);
649
+ if (context.getAssignment(lit) === L_UNDEF) this.addIneqAssign(lits, lit);
650
+ }
651
+ }
652
+ }
653
+
654
+ private assignWatchGe(boolVar: BoolVar, watch: Ineq[], watchIndex: number) {
655
+ const context = this.context;
656
+ const ineq = watch[watchIndex];
657
+ const position = ineq.findLit(boolVar, 0);
658
+ const k = ineq.getK();
659
+ const kCoeff = k + ineq.getCoeff(position);
660
+ let isAddingMore = ineq.watchSum < kCoeff + ineq.maxWatch;
661
+ for (let index = ineq.watchSize; isAddingMore && index < ineq.size; index++)
662
+ if (context.getAssignment(ineq.getLit(index)) !== L_FALSE) {
663
+ this.addWatch(ineq, index);
664
+ isAddingMore = ineq.watchSum < kCoeff + ineq.maxWatch;
665
+ }
666
+ if (ineq.watchSum < kCoeff) {
667
+ const lits = this.getUnhelpfulLiterals(ineq, false);
668
+ lits.push(negate(ineq.lit));
669
+ context.mkClause(lits, null, CLS_TH_LEMMA);
670
+ return false;
671
+ }
672
+ this.delWatch(watch, watchIndex, ineq, position);
673
+ if (ineq.watchSum < k + ineq.maxWatch) {
674
+ const lits = this.getUnhelpfulLiterals(ineq, true);
675
+ lits.push(ineq.lit);
676
+ const deficit = ineq.watchSum - k;
677
+ for (let index = 0; index < ineq.size; index++)
678
+ if (context.getAssignment(ineq.getLit(index)) === L_UNDEF && deficit < ineq.getCoeff(index))
679
+ this.addIneqAssign(lits, ineq.getLit(index));
680
+ }
681
+ return true;
682
+ }
683
+
684
+ private addIneqAssign(lits: Literal[], lit: Literal) {
685
+ this.context.assign(lit, new TheoryJustification(this.id, [...lits], []));
686
+ }
687
+
688
+ override pushScopeEh() {
689
+ super.pushScopeEh();
690
+ this.ineqsLim.push(this.ineqsTrail.length);
691
+ this.cardLim.push(this.cardTrail.length);
692
+ }
693
+
694
+ override popScopeEh(numScopes: number) {
695
+ let newLim = this.ineqsLim.length - numScopes;
696
+ let size = this.ineqsLim[newLim];
697
+ for (let index = this.ineqsTrail.length - 1; index >= size; index--) {
698
+ const boolVar = this.ineqsTrail[index];
699
+ const ineq = this.ineqs[boolVar];
700
+ if (ineq !== undefined) this.clearIneqWatch(ineq);
701
+ this.ineqs[boolVar] = undefined;
702
+ }
703
+ this.ineqsTrail.length = size;
704
+ this.ineqsLim.length = newLim;
705
+ newLim = this.cardLim.length - numScopes;
706
+ size = this.cardLim[newLim];
707
+ for (let index = this.cardTrail.length - 1; index >= size; index--) {
708
+ const boolVar = this.cardTrail[index];
709
+ const card = this.cards[boolVar];
710
+ if (card !== undefined) this.clearCardWatch(card);
711
+ this.cards[boolVar] = undefined;
712
+ }
713
+ this.cardTrail.length = size;
714
+ this.cardLim.length = newLim;
715
+ super.popScopeEh(numScopes);
716
+ }
717
+
718
+ private clearIneqWatch(ineq: Ineq) {
719
+ for (let index = 0; index < ineq.size; index++) this.unwatchIneq(ineq.getLit(index), ineq);
720
+ ineq.watchSum = 0n;
721
+ ineq.watchSize = 0;
722
+ ineq.maxWatch = 0n;
723
+ }
724
+
725
+ private initWatchLiteral(ineq: Ineq) {
726
+ ineq.watchSum = 0n;
727
+ ineq.watchSize = 0;
728
+ ineq.maxWatch = 0n;
729
+ let isWatchingMore = true;
730
+ for (let index = 0; isWatchingMore && index < ineq.size; index++)
731
+ if (this.context.getAssignment(ineq.getLit(index)) !== L_FALSE) {
732
+ this.addWatch(ineq, index);
733
+ isWatchingMore = ineq.watchSum < ineq.getK() + ineq.maxWatch;
734
+ }
735
+ this.context.pushTrail(() => {
736
+ for (let index = 0; index < ineq.watchSize; index++)
737
+ this.unwatchIneq(ineq.getLit(index), ineq);
738
+ ineq.watchSize = 0;
739
+ ineq.watchSum = 0n;
740
+ ineq.maxWatch = 0n;
741
+ });
742
+ }
743
+
744
+ private getCoeffOf(boolVar: BoolVar) {
745
+ return this.coeffs[boolVar] ?? 0;
746
+ }
747
+
748
+ private getAbsCoeff(boolVar: BoolVar) {
749
+ return Math.abs(this.getCoeffOf(boolVar));
750
+ }
751
+
752
+ private resetCoeffs() {
753
+ for (const boolVar of this.activeVars) this.coeffs[boolVar] = 0;
754
+ this.activeVars = [];
755
+ }
756
+
757
+ private processAntecedent(lit: Literal, offset: number) {
758
+ const context = this.context;
759
+ const boolVar = getVar(lit);
760
+ const level = context.getAssignLevel(lit);
761
+ if (level > context.baseLevel && !context.isMarked(boolVar) && level === this.conflictLvl) {
762
+ context.setMark(boolVar, true);
763
+ this.numMarks++;
764
+ }
765
+ this.incCoeff(lit, offset);
766
+ }
767
+
768
+ private processCard(card: Card, offset: number) {
769
+ for (let index = card.k; index < card.size; index++)
770
+ this.processAntecedent(card.args[index], offset);
771
+ for (let index = 0; index < card.k; index++) this.incCoeff(card.args[index], offset);
772
+ if (this.context.getAssignLevel(card.lit) > this.context.baseLevel)
773
+ this.antecedents.push(card.lit);
774
+ }
775
+
776
+ // Z3 never raises the level it compares against from 0, so this picks the last false active
777
+ // literal, not the one with the highest level.
778
+ private getAssertingLiteral(input: Literal) {
779
+ const context = this.context;
780
+ const boolVar = getVar(input);
781
+ if (
782
+ context.getAssignment(input) === L_FALSE &&
783
+ this.getAbsCoeff(boolVar) !== 0 &&
784
+ input === mkLiteral(boolVar, this.getCoeffOf(boolVar) < 0)
785
+ )
786
+ return input;
787
+ let lit = input;
788
+ for (const active of this.activeVars) {
789
+ const candidate = mkLiteral(active, this.getCoeffOf(active) < 0);
790
+ if (context.getAssignment(candidate) === L_FALSE && context.getAssignLevel(candidate) > 0)
791
+ lit = candidate;
792
+ }
793
+ return lit;
794
+ }
795
+
796
+ private normalizeActiveCoeffs() {
797
+ this.activeVarSet.clear();
798
+ let next = 0;
799
+ for (const boolVar of this.activeVars)
800
+ if (!this.activeVarSet.has(boolVar) && this.getCoeffOf(boolVar) !== 0) {
801
+ this.activeVarSet.add(boolVar);
802
+ this.activeVars[next++] = boolVar;
803
+ }
804
+ this.activeVars.length = next;
805
+ }
806
+
807
+ private incCoeff(lit: Literal, offset: number) {
808
+ const boolVar = getVar(lit);
809
+ const coeff0 = this.getCoeffOf(boolVar);
810
+ if (coeff0 === 0) this.activeVars.push(boolVar);
811
+ const inc = isNegated(lit) ? -offset : offset;
812
+ const coeff1 = inc + coeff0;
813
+ this.coeffs[boolVar] = coeff1;
814
+ if (coeff0 > 0 && inc < 0) this.bound -= coeff0 - Math.max(0, coeff1);
815
+ else if (coeff0 < 0 && inc > 0) this.bound -= Math.min(0, coeff1) - coeff0;
816
+ }
817
+
818
+ private cut() {
819
+ let gcd = 0;
820
+ for (let index = 0; gcd !== 1 && index < this.activeVars.length; index++) {
821
+ const boolVar = this.activeVars[index];
822
+ let coeff = this.getAbsCoeff(boolVar);
823
+ if (coeff === 0) continue;
824
+ if (this.bound < coeff) {
825
+ this.coeffs[boolVar] = this.getCoeffOf(boolVar) > 0 ? this.bound : -this.bound;
826
+ coeff = this.bound;
827
+ }
828
+ gcd = gcd === 0 ? coeff : Number(getGcd(BigInt(gcd), BigInt(coeff)));
829
+ }
830
+ if (gcd < 2) return;
831
+ this.normalizeActiveCoeffs();
832
+ for (const boolVar of this.activeVars)
833
+ this.coeffs[boolVar] = Math.trunc(this.coeffs[boolVar] / gcd);
834
+ // The bound is added to the unsigned divisor as an unsigned number.
835
+ this.bound = Math.floor(((this.bound + gcd - 1) >>> 0) / gcd) | 0;
836
+ }
837
+
838
+ private resolveConflict(card: Card, conflict: Literal[]) {
839
+ const context = this.context;
840
+ this.conflictLvl = 0;
841
+ for (const lit of conflict)
842
+ this.conflictLvl = Math.max(this.conflictLvl, context.getAssignLevel(lit));
843
+ if (
844
+ this.conflictLvl < context.getAssignLevel(card.lit) ||
845
+ this.conflictLvl === context.baseLevel
846
+ )
847
+ return false;
848
+ this.resetCoeffs();
849
+ this.numMarks = 0;
850
+ this.bound = card.k;
851
+ this.antecedents = [];
852
+ this.processCard(card, 1);
853
+ const lits = context.assignedLiterals;
854
+ let index = lits.length - 1;
855
+ let consequent = negate(conflict[2]);
856
+ const clearMarks = () => {
857
+ while (this.numMarks > 0 && index > 0) {
858
+ const boolVar = getVar(lits[index]);
859
+ if (context.isMarked(boolVar)) context.setMark(boolVar, false);
860
+ index--;
861
+ }
862
+ };
863
+ while (this.numMarks > 0) {
864
+ const offset = this.getAbsCoeff(getVar(consequent));
865
+ if (offset > 1000) {
866
+ clearMarks();
867
+ return false;
868
+ }
869
+ if (offset !== 0) {
870
+ const justification = context.justifications[getVar(consequent)];
871
+ let bound = 1;
872
+ if (justification instanceof Justification) {
873
+ if (justification.fromTheory === this.id && justification instanceof CardJustification) {
874
+ this.processCard(justification.card, offset);
875
+ bound = justification.card.k;
876
+ } else bound = 0;
877
+ } else if (justification instanceof BinJustification) {
878
+ this.incCoeff(consequent, offset);
879
+ this.processAntecedent(negate(justification.literal), offset);
880
+ } else if (justification === null || justification === "axiom") bound = 0;
881
+ else {
882
+ this.incCoeff(consequent, offset);
883
+ const clauses = context.clauses;
884
+ const clauseJustification = clauses.getJustification(justification);
885
+ if (clauseJustification instanceof UnitResolutionJustification) {
886
+ clearMarks();
887
+ return false;
888
+ }
889
+ if (clauseJustification === null) {
890
+ const numLiterals = clauses.getNumLiterals(justification);
891
+ this.processAntecedent(
892
+ clauses.getLiteral(
893
+ justification,
894
+ clauses.getLiteral(justification, 0) === consequent ? 1 : 0,
895
+ ),
896
+ offset,
897
+ );
898
+ for (let position = 2; position < numLiterals; position++)
899
+ this.processAntecedent(clauses.getLiteral(justification, position), offset);
900
+ }
901
+ }
902
+ this.bound += offset * bound;
903
+ this.cut();
904
+ }
905
+ for (;;) {
906
+ consequent = lits[index];
907
+ if (context.isMarked(getVar(consequent))) break;
908
+ index--;
909
+ }
910
+ context.setMark(getVar(consequent), false);
911
+ index--;
912
+ this.numMarks--;
913
+ }
914
+ this.normalizeActiveCoeffs();
915
+ if (this.bound > 0 && this.activeVars.length === 0) return false;
916
+ let slack = -this.bound;
917
+ for (const boolVar of this.activeVars) slack += this.getAbsCoeff(boolVar);
918
+ const alit = this.getAssertingLiteral(negate(consequent));
919
+ slack -= this.getAbsCoeff(getVar(alit));
920
+ for (let position = lits.length; 0 <= slack && position-- > 0;) {
921
+ const lit = lits[position];
922
+ const boolVar = getVar(lit);
923
+ if (!this.activeVarSet.has(boolVar) || boolVar === getVar(alit)) continue;
924
+ const coeff = this.getCoeffOf(boolVar);
925
+ if (coeff < 0 && !isNegated(lit)) {
926
+ slack += coeff;
927
+ this.antecedents.push(lit);
928
+ } else if (coeff > 0 && isNegated(lit)) {
929
+ slack -= coeff;
930
+ this.antecedents.push(lit);
931
+ }
932
+ }
933
+ context.assign(alit, new TheoryJustification(this.id, [...this.antecedents], []));
934
+ return true;
935
+ }
936
+ }