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

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 +47 -44
  15. package/dist/run.js +47 -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 +44 -41
  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 +474 -718
  29. package/src/cli/options.ts +6 -31
  30. package/src/cli/run.ts +0 -2
  31. package/src/cli/runtime-invariants.ts +8 -7
  32. package/src/cli/shared.ts +1 -5
  33. package/src/cli/tlapm.ts +433 -70
  34. package/src/cli/tlc-arguments.ts +244 -238
  35. package/src/cli/tlc-output.ts +687 -0
  36. package/src/cli/tlc-usage.ts +3 -5
  37. package/src/cli/tlc.ts +49 -702
  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 +55 -338
  45. package/src/errors.ts +33 -5
  46. package/src/evaluate.ts +31 -106
  47. package/src/exit-codes.ts +2 -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 +616 -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 +10 -30
  81. package/src/parallel.ts +50 -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 +9 -5
  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 +0 -1
  308. package/src/prover/smt/solver/lp/pdd-simplifier.ts +0 -1
  309. package/src/prover/smt/solver/lp/pdd-solver.ts +0 -2
  310. package/src/prover/smt/solver/lp/pdd.ts +2 -2
  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 +15 -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 +206 -44
  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 +22 -47
  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 +54 -26
  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,1098 @@
1
+ import { SmtInvariantError } from "../../../errors";
2
+ import {
3
+ type AstManager,
4
+ FAMILY_ARITH,
5
+ OP_ADD,
6
+ OP_AND,
7
+ OP_DIV,
8
+ OP_EQ,
9
+ OP_GE,
10
+ OP_GT,
11
+ OP_LE,
12
+ OP_LT,
13
+ OP_MOD,
14
+ OP_MUL,
15
+ OP_NUM,
16
+ OP_SUB,
17
+ OP_UBV2INT,
18
+ OP_UMINUS,
19
+ SORT_BOOL,
20
+ SORT_INT,
21
+ SORT_REAL,
22
+ } from "./ast";
23
+ import { isAppOf } from "./ast-util";
24
+ import { ArithRewriter, TACTIC_ARITH_OPTIONS } from "./arith-rewriter";
25
+ import { mkBvApp } from "./bv-decl-plugin";
26
+ import { ExprSafeReplace } from "./expr-safe-replace";
27
+ import type { ContainsApp, QeSolverContext, QeSolverPlugin } from "./qe";
28
+ import { getEuclideanMod, getGcd, getLcm, Rational } from "./rational";
29
+ import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
30
+ import type { Rewrite } from "./rewriter-tpl";
31
+
32
+ const getExpr = (result: number | Rewrite | undefined, fallback: () => number) =>
33
+ result === undefined ? fallback() : typeof result === "number" ? result : result.expr;
34
+
35
+ const isOne = (value: Rational) => value.equals(Rational.one);
36
+
37
+ const isArith = (manager: AstManager, expr: number) =>
38
+ manager.sorts[expr] === SORT_INT || manager.sorts[expr] === SORT_REAL;
39
+
40
+ // k*x + rest, where k is not zero.
41
+ interface Coeff {
42
+ k: Rational;
43
+ rest: number;
44
+ }
45
+
46
+ class ArithQeUtil {
47
+ readonly manager: AstManager;
48
+ private rewriter: Rewriter;
49
+ private arithRewriter: ArithRewriter;
50
+ varsAdded: number[] = [];
51
+
52
+ constructor(readonly context: QeSolverContext) {
53
+ this.manager = context.manager;
54
+ this.rewriter = new Rewriter(this.manager, TACTIC_REWRITER_OPTIONS);
55
+ this.arithRewriter = new ArithRewriter(this.manager, TACTIC_ARITH_OPTIONS);
56
+ }
57
+
58
+ release() {
59
+ this.rewriter.release();
60
+ }
61
+
62
+ pin(expr: number) {
63
+ return this.context.pin(expr);
64
+ }
65
+
66
+ simplify(expr: number) {
67
+ return this.context.pinOwned(this.rewriter.rewrite(expr));
68
+ }
69
+
70
+ replace(source: number, target: number, formula: number) {
71
+ const replace = new ExprSafeReplace(this.manager);
72
+ replace.insert(source, target);
73
+ const result = this.context.pinOwned(replace.apply(formula));
74
+ replace.release();
75
+ return result;
76
+ }
77
+
78
+ getNumeral(expr: number) {
79
+ const manager = this.manager;
80
+ return manager.isNumeral(expr) && isArith(manager, expr)
81
+ ? manager.getRationalValue(expr)
82
+ : undefined;
83
+ }
84
+
85
+ mkNumeral(value: Rational, isInt = true) {
86
+ return this.pin(this.manager.mkNumeralOfSort(value, isInt ? SORT_INT : SORT_REAL));
87
+ }
88
+
89
+ mkApp(op: number, args: number[], sort: number) {
90
+ return this.pin(this.manager.mkApp(op, args, sort));
91
+ }
92
+
93
+ mkAddN(args: number[]) {
94
+ return args.length === 1 ? args[0] : this.mkApp(OP_ADD, args, this.manager.sorts[args[0]]);
95
+ }
96
+
97
+ mkAdd(first: number, second: number) {
98
+ return this.mkApp(OP_ADD, [first, second], this.manager.sorts[first]);
99
+ }
100
+
101
+ mkSub(first: number, second: number) {
102
+ return this.mkApp(OP_SUB, [first, second], this.manager.sorts[first]);
103
+ }
104
+
105
+ mkMulApp(first: number, second: number) {
106
+ return this.mkApp(OP_MUL, [first, second], this.manager.sorts[second]);
107
+ }
108
+
109
+ mkMul(value: Rational, expr: number) {
110
+ return isOne(value)
111
+ ? expr
112
+ : this.mkMulApp(this.mkNumeral(value, this.manager.isInt(expr)), expr);
113
+ }
114
+
115
+ mkUminus(expr: number) {
116
+ return this.mkApp(OP_UMINUS, [expr], this.manager.sorts[expr]);
117
+ }
118
+
119
+ mkLeApp(first: number, second: number) {
120
+ return this.mkApp(OP_LE, [first, second], SORT_BOOL);
121
+ }
122
+
123
+ mkZero(sort: number) {
124
+ return this.mkNumeral(Rational.zero, sort === SORT_INT);
125
+ }
126
+
127
+ mkOne(sort: number) {
128
+ return this.mkNumeral(Rational.one, sort === SORT_INT);
129
+ }
130
+
131
+ mkAnd(args: number[]) {
132
+ return this.context.pinOwned(this.manager.withTemporaries(() => this.rewriter.mkAnd(args)));
133
+ }
134
+
135
+ mkOr(args: number[]) {
136
+ return this.context.pinOwned(this.manager.withTemporaries(() => this.rewriter.mkOr(args)));
137
+ }
138
+
139
+ mkNotRewrite(expr: number) {
140
+ return this.context.pinOwned(this.manager.withTemporaries(() => this.rewriter.mkNot(expr)));
141
+ }
142
+
143
+ mkEqRewrite(first: number, second: number) {
144
+ return this.context.pinOwned(
145
+ this.manager.withTemporaries(() => this.rewriter.mkEq(first, second)),
146
+ );
147
+ }
148
+
149
+ // arith_rewriter's mk_le, which keeps a rewrite without rewriting it further.
150
+ mkLeRewrite(first: number, second: number) {
151
+ return this.pin(
152
+ getExpr(this.arithRewriter.mkLe(first, second), () =>
153
+ this.manager.mkApp(OP_LE, [first, second], SORT_BOOL),
154
+ ),
155
+ );
156
+ }
157
+
158
+ mkModRewrite(first: number, second: number) {
159
+ return this.pin(
160
+ getExpr(this.arithRewriter.mkMod(first, second), () =>
161
+ this.manager.mkApp(OP_MOD, [first, second], SORT_INT),
162
+ ),
163
+ );
164
+ }
165
+
166
+ mkSubRewrite(first: number, second: number) {
167
+ return this.pin(
168
+ getExpr(this.arithRewriter.mkSub([first, second]), () => this.mkSub(first, second)),
169
+ );
170
+ }
171
+
172
+ getCoeff(contains: ContainsApp, p: number): Coeff | undefined {
173
+ const manager = this.manager;
174
+ const x = contains.x;
175
+ const restList: number[] = [];
176
+ const todo = [p];
177
+ let k: Rational | undefined;
178
+ while (todo.length > 0) {
179
+ const expr = todo.pop() as number;
180
+ if (isAppOf(manager, expr, OP_ADD)) {
181
+ todo.push(...manager.getArgs(expr));
182
+ continue;
183
+ }
184
+ if (expr === x) {
185
+ k = Rational.one;
186
+ break;
187
+ }
188
+ if (isAppOf(manager, expr, OP_MUL) && manager.getNumArgs(expr) === 2) {
189
+ const [first, second] = manager.getArgs(expr);
190
+ const firstValue = this.getNumeral(first);
191
+ const secondValue = this.getNumeral(second);
192
+ if (first === x && secondValue !== undefined) {
193
+ k = secondValue;
194
+ break;
195
+ }
196
+ if (second === x && firstValue !== undefined) {
197
+ k = firstValue;
198
+ break;
199
+ }
200
+ }
201
+ restList.push(expr);
202
+ }
203
+ if (k === undefined) return undefined;
204
+ while (todo.length > 0) restList.push(todo.pop() as number);
205
+ const rest = restList.length === 0 ? this.mkZero(manager.sorts[x]) : this.mkAddN(restList);
206
+ return contains.has(rest) ? undefined : { k, rest };
207
+ }
208
+
209
+ // The p of an inequality written as p <= 0 for isLe, or as p >= 0 otherwise.
210
+ private getLeGe(expr: number, isLe: boolean) {
211
+ const manager = this.manager;
212
+ const first = isLe ? 0 : 1;
213
+ const second = 1 - first;
214
+ if (isAppOf(manager, expr, OP_LE))
215
+ return this.getSide(manager.getArg(expr, first), manager.getArg(expr, second));
216
+ if (isAppOf(manager, expr, OP_GE))
217
+ return this.getSide(manager.getArg(expr, second), manager.getArg(expr, first));
218
+ return undefined;
219
+ }
220
+
221
+ private getSide(p: number, other: number) {
222
+ return this.getNumeral(other)?.isZero() === true ? p : this.simplify(this.mkSub(p, other));
223
+ }
224
+
225
+ isLe(expr: number) {
226
+ return this.getLeGe(expr, true);
227
+ }
228
+
229
+ isGe(expr: number) {
230
+ return this.getLeGe(expr, false);
231
+ }
232
+
233
+ // The p of a strict inequality written as p < 0.
234
+ isLt(expr: number) {
235
+ const manager = this.manager;
236
+ if (isAppOf(manager, expr, OP_LT))
237
+ return this.getSide(manager.getArg(expr, 0), manager.getArg(expr, 1));
238
+ if (isAppOf(manager, expr, OP_GT))
239
+ return this.getSide(manager.getArg(expr, 1), manager.getArg(expr, 0));
240
+ return undefined;
241
+ }
242
+
243
+ // Matches 0 = p mod k and p mod k = 0.
244
+ isDivides(expr: number) {
245
+ const manager = this.manager;
246
+ if (!isAppOf(manager, expr, OP_EQ)) return undefined;
247
+ const [first, second] = manager.getArgs(expr);
248
+ return this.isDividesSides(first, second) ?? this.isDividesSides(second, first);
249
+ }
250
+
251
+ private isDividesSides(zero: number, mod: number) {
252
+ const manager = this.manager;
253
+ if (!isAppOf(manager, mod, OP_MOD) || this.getNumeral(zero)?.isZero() !== true)
254
+ return undefined;
255
+ const k = this.getNumeral(manager.getArg(mod, 1));
256
+ return k === undefined ? undefined : { k, p: manager.getArg(mod, 0) };
257
+ }
258
+
259
+ isNotDivides(expr: number) {
260
+ const manager = this.manager;
261
+ if (!manager.isNot(expr)) return undefined;
262
+ const atom = manager.getArg(expr, 0);
263
+ const divides = this.isDivides(atom);
264
+ return divides === undefined ? undefined : { ...divides, atom };
265
+ }
266
+
267
+ isReal(x: number) {
268
+ return this.manager.isReal(x);
269
+ }
270
+
271
+ // b*t <= a*s, or b*t < a*s when isStrict.
272
+ mkBoundAux(isStrict: boolean, a: Rational, t: number, b: Rational, s: number) {
273
+ const manager = this.manager;
274
+ const ss = this.mkMul(a.abs(), s);
275
+ const tt = this.mkMul(b.abs(), t);
276
+ const e = a.isNegative() ? this.mkSub(tt, ss) : this.mkSub(ss, tt);
277
+ if (!isStrict) return this.mkLe(e);
278
+ return manager.isInt(e) ? this.mkLe(this.mkAdd(e, this.mkOne(SORT_INT))) : this.mkLt(e);
279
+ }
280
+
281
+ mkDivides(n: Rational, expr: number) {
282
+ const simplified = this.simplify(expr);
283
+ const mod = this.mkModRewrite(simplified, this.mkNumeral(n));
284
+ return this.mkEqRewrite(this.mkZero(SORT_INT), mod);
285
+ }
286
+
287
+ mkDiv(expr: number, k: Rational) {
288
+ return this.simplify(this.mkApp(OP_DIV, [expr, this.mkNumeral(k, false)], SORT_REAL));
289
+ }
290
+
291
+ mkLe(expr: number) {
292
+ return this.mkLeRewrite(this.simplify(expr), this.mkZero(this.manager.sorts[expr]));
293
+ }
294
+
295
+ mkLt(expr: number) {
296
+ const manager = this.manager;
297
+ const value = this.getNumeral(expr);
298
+ if (value !== undefined) return value.isNegative() ? manager.trueExpr : manager.falseExpr;
299
+ const result = manager.isInt(expr)
300
+ ? this.mkLeApp(expr, this.mkNumeral(Rational.minusOne))
301
+ : this.pin(manager.mkNot(this.mkLeApp(this.mkZero(manager.sorts[expr]), expr)));
302
+ return this.simplify(result);
303
+ }
304
+
305
+ // a*x + t = 0
306
+ mkEq(a: Rational, x: number, t: number) {
307
+ return this.pin(
308
+ this.manager.mkEq(this.mkAdd(this.mkMul(a, x), t), this.mkZero(this.manager.sorts[x])),
309
+ );
310
+ }
311
+
312
+ mkFlatAnd(first: number, second: number) {
313
+ const manager = this.manager;
314
+ return this.mkAnd(
315
+ [first, second].flatMap((expr) =>
316
+ isAppOf(manager, expr, OP_AND) ? manager.getArgs(expr) : [expr],
317
+ ),
318
+ );
319
+ }
320
+
321
+ // b*t <= a*s, with the cases of integer resolution.
322
+ mkResolve(x: number, isStrict: boolean, a: Rational, t: number, b: Rational, s: number) {
323
+ const manager = this.manager;
324
+ const bt = this.mkMul(b.abs(), t);
325
+ const as = this.mkMul(a.abs(), s);
326
+ const asBt = this.mkAdd(as, bt);
327
+ const result = isStrict ? this.mkLt(asBt) : this.mkLe(asBt);
328
+ if (isOne(a.abs()) || isOne(b.abs())) return result;
329
+ // a*s + b*t + (a-1)(b-1) <= 0
330
+ const slack = this.mkNumeral(a.abs().sub(Rational.one).mul(b.abs().sub(Rational.one)));
331
+ const result1 = this.mkLe(this.mkApp(OP_ADD, [asBt, slack], manager.sorts[asBt]));
332
+ const isSwapped = a.abs().compare(b.abs()) < 0;
333
+ const a1 = isSwapped ? b : a;
334
+ const b1 = isSwapped ? a : b;
335
+ const s1 = isSwapped ? t : s;
336
+ const bt1 = isSwapped ? as : bt;
337
+ // exists z in [0 .. |b|-2] . |b| | (z + s) && a*n_sign(b)(s + z) + |b|t <= 0
338
+ const sum = this.mkAdd(s1, x);
339
+ const sz = b1.isPositive() ? this.mkUminus(sum) : sum;
340
+ const aszBtLe0 = this.mkLe(this.mkAdd(this.mkMul(a1, sz), bt1));
341
+ const isZBound =
342
+ manager.getNumArgs(aszBtLe0) === 2 &&
343
+ manager.getArg(aszBtLe0, 0) === x &&
344
+ this.getNumeral(manager.getArg(aszBtLe0, 1))?.isZero() === true;
345
+ const tmp2 = isZBound
346
+ ? this.mkDivides(b1.abs(), s1)
347
+ : this.mkBigOr(
348
+ b1.abs().sub(Rational.of(2n)),
349
+ x,
350
+ this.mkAnd([this.mkDivides(b1.abs(), sz), aszBtLe0]),
351
+ );
352
+ return this.simplify(this.mkOr([result1, this.mkFlatAnd(result, tmp2)]));
353
+ }
354
+
355
+ normalizeSum(p: number) {
356
+ const manager = this.manager;
357
+ const simplified = this.simplify(p);
358
+ if (!isAppOf(manager, simplified, OP_ADD)) return simplified;
359
+ const strip = (expr: number) => {
360
+ if (!isAppOf(manager, expr, OP_MUL) || manager.getNumArgs(expr) !== 2) return expr;
361
+ return this.getNumeral(manager.getArg(expr, 0)) !== undefined
362
+ ? manager.getArg(expr, 1)
363
+ : expr;
364
+ };
365
+ const ids = manager.ids;
366
+ const args = [...manager.getArgs(simplified)].sort(
367
+ (first, second) => ids[strip(first)] - ids[strip(second)],
368
+ );
369
+ return this.mkAddN(args);
370
+ }
371
+
372
+ mkAtom(expr: number, isPositive: boolean) {
373
+ const manager = this.manager;
374
+ if (this.isDivides(expr) !== undefined) return isPositive ? expr : this.mkNotRewrite(expr);
375
+ const [a0, a1] = manager.getArgs(expr);
376
+ if (isAppOf(manager, expr, OP_EQ) && isArith(manager, a0)) {
377
+ if (isPositive) {
378
+ const t1 = this.simplify(this.mkSub(a0, a1));
379
+ const t2 = this.simplify(this.mkSub(a1, a0));
380
+ return this.mkAnd([this.mkLe(t1), this.mkLe(t2)]);
381
+ }
382
+ if (manager.isInt(a0)) {
383
+ const difference = this.mkSub(a0, a1);
384
+ const t1 = this.simplify(this.mkAdd(this.mkOne(SORT_INT), difference));
385
+ const t2 = this.simplify(this.mkSub(this.mkOne(SORT_INT), difference));
386
+ return this.mkOr([this.mkLe(t1), this.mkLe(t2)]);
387
+ }
388
+ const t1 = this.simplify(this.mkSub(a0, a1));
389
+ const t2 = this.simplify(this.mkSub(a1, a0));
390
+ return this.mkOr([this.mkLt(t1), this.mkLt(t2)]);
391
+ }
392
+ const isLe = isAppOf(manager, expr, OP_LE);
393
+ const isGe = isAppOf(manager, expr, OP_GE);
394
+ if (isLe || isGe) {
395
+ if (isPositive) return expr;
396
+ const [low, high] = isLe ? [a0, a1] : [a1, a0];
397
+ return this.mkLt(this.mkSub(high, low));
398
+ }
399
+ const isLt = isAppOf(manager, expr, OP_LT);
400
+ if (isLt || isAppOf(manager, expr, OP_GT)) {
401
+ const [low, high] = isLt ? [a0, a1] : [a1, a0];
402
+ return isPositive ? this.mkLt(this.mkSub(low, high)) : this.mkLe(this.mkSub(high, low));
403
+ }
404
+ return undefined;
405
+ }
406
+
407
+ mkBoundedVar(n: Rational) {
408
+ const manager = this.manager;
409
+ let size = 0;
410
+ let b = n.num;
411
+ do {
412
+ size++;
413
+ b /= 2n;
414
+ } while (b > 0n);
415
+ const zBv = this.pin(manager.mkFreshConst("z", manager.mkBvSort(size)));
416
+ return { zBv, z: this.pin(mkBvApp(manager, OP_UBV2INT, [zBv])) };
417
+ }
418
+
419
+ solve(conjs: readonly number[], formula: number) {
420
+ return this.extractEqualities(conjs).some((eq) => this.reduceEquation(eq, formula));
421
+ }
422
+
423
+ private extractEqualities(conjs: readonly number[]) {
424
+ const manager = this.manager;
425
+ const leqs = new Set<number>();
426
+ const eqs: number[] = [];
427
+ for (const conj of conjs) {
428
+ if (isAppOf(manager, conj, OP_EQ) && isArith(manager, manager.getArg(conj, 0))) {
429
+ eqs.push(
430
+ this.simplify(this.mkSubRewrite(manager.getArg(conj, 0), manager.getArg(conj, 1))),
431
+ );
432
+ continue;
433
+ }
434
+ const isLe = isAppOf(manager, conj, OP_LE);
435
+ if (!isLe && !isAppOf(manager, conj, OP_GE)) continue;
436
+ const [first, second] = manager.getArgs(conj);
437
+ const difference = this.normalizeSum(
438
+ isLe ? this.mkSubRewrite(first, second) : this.mkSubRewrite(second, first),
439
+ );
440
+ const negated = this.normalizeSum(this.mkUminus(difference));
441
+ if (leqs.has(negated)) eqs.push(difference);
442
+ else leqs.add(difference);
443
+ }
444
+ return eqs;
445
+ }
446
+
447
+ addVar(x: number, isTracked = true) {
448
+ this.context.addVar(x);
449
+ if (isTracked) this.varsAdded.push(x);
450
+ }
451
+
452
+ private mkBigOr(up: Rational, x: number, body: number) {
453
+ return Rational.one.compare(up) >= 0
454
+ ? this.mkBigOrBlast(up, x, body)
455
+ : this.mkBigOrSymbolicBlast(up, x, body);
456
+ }
457
+
458
+ private mkBigOrBlast(up: Rational, x: number, body: number) {
459
+ const ors: number[] = [];
460
+ for (let index = 0n; index <= up.num; index++)
461
+ ors.push(this.replace(x, this.mkNumeral(Rational.of(index)), body));
462
+ return this.mkOr(ors);
463
+ }
464
+
465
+ private mkBigOrSymbolicBlast(up: Rational, x: number, body: number) {
466
+ const bound = this.mkLeApp(x, this.mkNumeral(up));
467
+ const bounded = this.mkFlatAnd(bound, body);
468
+ const { zBv, z } = this.mkBoundedVar(up);
469
+ return this.context.blastOr(zBv, this.replace(x, z, bounded));
470
+ }
471
+
472
+ // The coefficient of x, when x occurs in exactly one summand of p.
473
+ private isolateX(p: number, x: number, contains: ContainsApp) {
474
+ const manager = this.manager;
475
+ let current = p;
476
+ while (isAppOf(manager, current, OP_ADD)) {
477
+ const withX = manager.getArgs(current).filter((arg) => contains.has(arg));
478
+ if (withX.length !== 1) return undefined;
479
+ current = withX[0];
480
+ }
481
+ if (current === x) return Rational.one;
482
+ if (!isAppOf(manager, current, OP_MUL) || manager.getNumArgs(current) !== 2) return undefined;
483
+ const [first, second] = manager.getArgs(current);
484
+ const firstValue = this.getNumeral(first);
485
+ if (firstValue !== undefined && second === x) return firstValue;
486
+ const secondValue = this.getNumeral(second);
487
+ return secondValue !== undefined && first === x ? secondValue : undefined;
488
+ }
489
+
490
+ private solveSingular(index: number, p: number, formula: number) {
491
+ const manager = this.manager;
492
+ const context = this.context;
493
+ const x = context.getVar(index);
494
+ const k = this.isolateX(p, x, context.contains(index));
495
+ if (k === undefined) return false;
496
+ if (manager.isInt(x) && !isOne(k.abs())) return false;
497
+ const sort = manager.sorts[x];
498
+ const e = isOne(k.abs())
499
+ ? k.isNegative()
500
+ ? this.mkApp(OP_ADD, [p, x], sort)
501
+ : this.mkApp(OP_SUB, [x, p], sort)
502
+ : (() => {
503
+ // p = p' + k*x = 0, so x = (p - k*x) / -k.
504
+ const ke = this.mkNumeral(k.neg(), false);
505
+ return this.mkApp(
506
+ OP_DIV,
507
+ [this.mkApp(OP_ADD, [p, this.mkMulApp(ke, x)], sort), ke],
508
+ sort,
509
+ );
510
+ })();
511
+ context.elimVar(index, this.simplify(this.replace(x, e, formula)));
512
+ return true;
513
+ }
514
+
515
+ private solveLinear(p: number, formula: number) {
516
+ const manager = this.manager;
517
+ const context = this.context;
518
+ const vars = context.getVars();
519
+ const values = this.getLinear(p, vars);
520
+ if (values === undefined || values.slice(1).every((value) => value.isZero())) return false;
521
+ const solved = solveIntegerEquation(values);
522
+ if (solved === undefined) return false;
523
+ const x = vars[solved.index - 1];
524
+ const sort = manager.sorts[p];
525
+ let p1: number;
526
+ if (solved.isAux) {
527
+ // A fresh variable stands for x, with the coefficient values[index].
528
+ const z = this.pin(manager.mkFreshConst("x", sort));
529
+ this.addVar(z);
530
+ p1 = this.mkMulApp(this.pin(manager.mkNumeralOfSort(values[solved.index], sort)), z);
531
+ } else p1 = this.pin(manager.mkNumeralOfSort(Rational.zero, sort));
532
+ for (let index = 1; index <= vars.length; index++) {
533
+ const k = values[index];
534
+ if (k.isZero() || index === solved.index) continue;
535
+ const term = this.mkMulApp(this.pin(manager.mkNumeralOfSort(k, sort)), vars[index - 1]);
536
+ p1 = this.mkApp(OP_ADD, [p1, term], sort);
537
+ }
538
+ p1 = this.mkApp(OP_ADD, [p1, this.pin(manager.mkNumeralOfSort(values[0], sort))], sort);
539
+ context.elimVar(solved.index - 1, this.simplify(this.replace(x, p1, formula)));
540
+ return true;
541
+ }
542
+
543
+ private reduceEquation(p: number, formula: number) {
544
+ if (this.getNumeral(p)?.isZero() === true) return false;
545
+ for (let index = 0; index < this.context.getNumVars(); index++)
546
+ if (this.solveSingular(index, p, formula)) return true;
547
+ return this.solveLinear(p, formula);
548
+ }
549
+
550
+ // The constant of p, then the coefficient of each variable, when p is linear in them.
551
+ private getLinear(p: number, vars: readonly number[]) {
552
+ const manager = this.manager;
553
+ if (vars.length === 0) return undefined;
554
+ const values = Array.from({ length: vars.length + 1 }, () => Rational.zero);
555
+ const addToVar = (expr: number, k: Rational) => {
556
+ if (manager.getNumArgs(expr) > 0) return false;
557
+ const index = vars.indexOf(expr);
558
+ if (index === -1) return false;
559
+ values[index + 1] = values[index + 1].add(k);
560
+ return true;
561
+ };
562
+ const todo = [p];
563
+ while (todo.length > 0) {
564
+ const expr = todo.pop() as number;
565
+ if (isAppOf(manager, expr, OP_ADD)) {
566
+ todo.push(...manager.getArgs(expr));
567
+ continue;
568
+ }
569
+ if (isAppOf(manager, expr, OP_MUL) && manager.getNumArgs(expr) === 2) {
570
+ const [first, second] = manager.getArgs(expr);
571
+ const firstValue = this.getNumeral(first);
572
+ if (firstValue !== undefined && addToVar(second, firstValue)) continue;
573
+ const secondValue = this.getNumeral(second);
574
+ if (secondValue !== undefined && addToVar(first, secondValue)) continue;
575
+ }
576
+ // Z3 adds a stale coefficient here, zero or that of an earlier product, instead of one.
577
+ if (addToVar(expr, Rational.one)) continue;
578
+ const value = this.getNumeral(expr);
579
+ if (value === undefined) return undefined;
580
+ values[0] = values[0].add(value);
581
+ }
582
+ return values;
583
+ }
584
+ }
585
+
586
+ // One step of the omega test's equality elimination on a1*x1 + ... + an*xn + a0 = 0, where
587
+ // values[0] is a0: it picks the variable of least absolute coefficient, whose coefficient becomes
588
+ // -1, or a fresh one's coefficient when it is not a unit.
589
+ const solveIntegerEquation = (values: Rational[]) => {
590
+ if (!values.every((value) => value.isInt())) return undefined;
591
+ let gcd = 0n;
592
+ for (const value of values) {
593
+ gcd =
594
+ gcd === 0n
595
+ ? value.num < 0n
596
+ ? -value.num
597
+ : value.num
598
+ : getGcd(value.num < 0n ? -value.num : value.num, gcd);
599
+ if (gcd === 1n) break;
600
+ }
601
+ if (gcd !== 0n && gcd !== 1n)
602
+ values.forEach((value, index) => (values[index] = Rational.of(value.num / gcd)));
603
+ let testGcd = 0n;
604
+ for (let index = 1; testGcd !== 1n && index < values.length; index++) {
605
+ const value = values[index].num < 0n ? -values[index].num : values[index].num;
606
+ if (value !== 0n) testGcd = testGcd === 0n ? value : getGcd(value, testGcd);
607
+ }
608
+ if (testGcd === 0n ? !values[0].isZero() : testGcd !== 1n && values[0].num % testGcd !== 0n)
609
+ return undefined;
610
+ let index = 0;
611
+ let least = 0n;
612
+ for (let candidate = 1; candidate < values.length; candidate++) {
613
+ const value = values[candidate].num < 0n ? -values[candidate].num : values[candidate].num;
614
+ if (least === 0n || (value !== 0n && value < least)) {
615
+ index = candidate;
616
+ least = value;
617
+ }
618
+ }
619
+ if (least === 0n) return { index, isAux: false };
620
+ const negate = () => values.forEach((value, position) => (values[position] = value.neg()));
621
+ if (values[index].num === 1n) negate();
622
+ const isAux = least !== 1n;
623
+ if (isAux) {
624
+ const modulus = least + 1n;
625
+ values.forEach((value, position) => {
626
+ const remainder = getEuclideanMod(value.num, modulus);
627
+ values[position] = Rational.of(2n * remainder > modulus ? remainder - modulus : remainder);
628
+ });
629
+ if (values[index].num === 1n) negate();
630
+ values[index] = Rational.of(modulus);
631
+ }
632
+ return { index, isAux };
633
+ };
634
+
635
+ interface Bound {
636
+ term: number;
637
+ coeff: Rational;
638
+ atom: number;
639
+ }
640
+
641
+ interface Div {
642
+ term: number;
643
+ coeff: Rational;
644
+ divisor: Rational;
645
+ atom: number;
646
+ }
647
+
648
+ interface NestedDiv extends Div {
649
+ z: number;
650
+ zBv: number;
651
+ }
652
+
653
+ class BoundsProc {
654
+ private marked = new Set<number>();
655
+ readonly le: Bound[] = [];
656
+ readonly ge: Bound[] = [];
657
+ readonly lt: Bound[] = [];
658
+ readonly gt: Bound[] = [];
659
+ readonly divs: Div[] = [];
660
+ readonly nestedDivs: NestedDiv[] = [];
661
+ private divZ: { d: Rational; z: number; zBv: number } | undefined;
662
+
663
+ constructor(private util: ArithQeUtil) {}
664
+
665
+ getBound(contains: ContainsApp, atom: number) {
666
+ const hasBound =
667
+ this.marked.has(atom) ||
668
+ this.getLeBound(contains, atom) ||
669
+ this.getLtBound(contains, atom) ||
670
+ this.getDivides(contains, atom) ||
671
+ this.getNestedDivs(contains, atom);
672
+ if (hasBound) this.marked.add(atom);
673
+ return hasBound;
674
+ }
675
+
676
+ get(isStrict: boolean, isLower: boolean) {
677
+ return isStrict ? (isLower ? this.lt : this.gt) : isLower ? this.le : this.ge;
678
+ }
679
+
680
+ getDivZ() {
681
+ if (this.divZ !== undefined) return this.divZ;
682
+ if (this.divs.length === 0 && this.nestedDivs.length === 0) return undefined;
683
+ let d = 1n;
684
+ for (const div of [...this.divs, ...this.nestedDivs]) d = getLcm(div.divisor.num, d);
685
+ if (d === 1n || d === -1n) return undefined;
686
+ this.divZ = { d: Rational.of(d), ...this.util.mkBoundedVar(Rational.of(d)) };
687
+ return this.divZ;
688
+ }
689
+
690
+ private getNestedDivs(contains: ContainsApp, atom: number) {
691
+ const util = this.util;
692
+ const manager = util.manager;
693
+ const todo = [atom];
694
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
695
+ if (this.marked.has(expr)) continue;
696
+ this.marked.add(expr);
697
+ if (!contains.has(expr)) continue;
698
+ if (contains.x === expr) return false;
699
+ if (isAppOf(manager, expr, OP_MOD)) {
700
+ const k1 = util.getNumeral(manager.getArg(expr, 1));
701
+ const coeff =
702
+ k1 === undefined ? undefined : util.getCoeff(contains, manager.getArg(expr, 0));
703
+ if (k1 !== undefined && coeff !== undefined) {
704
+ this.nestedDivs.push({
705
+ term: coeff.rest,
706
+ coeff: coeff.k,
707
+ divisor: k1,
708
+ atom: expr,
709
+ ...util.mkBoundedVar(k1),
710
+ });
711
+ continue;
712
+ }
713
+ }
714
+ todo.push(...manager.getArgs(expr));
715
+ }
716
+ return true;
717
+ }
718
+
719
+ private getLeBound(contains: ContainsApp, atom: number) {
720
+ const util = this.util;
721
+ const p = util.isLe(atom);
722
+ const coeff = p === undefined ? undefined : util.getCoeff(contains, p);
723
+ if (coeff === undefined) return false;
724
+ // k*x + rest <= 0
725
+ let k = coeff.k;
726
+ let rest = coeff.rest;
727
+ if (util.isReal(contains.x)) {
728
+ rest = util.mkDiv(rest, k.abs());
729
+ k = k.isPositive() ? Rational.one : Rational.minusOne;
730
+ }
731
+ (k.isNegative() ? this.le : this.ge).push({ term: rest, coeff: k, atom });
732
+ return true;
733
+ }
734
+
735
+ private getLtBound(contains: ContainsApp, atom: number) {
736
+ const util = this.util;
737
+ const manager = util.manager;
738
+ const p = util.isLt(atom);
739
+ let coeff = p === undefined ? undefined : util.getCoeff(contains, p);
740
+ if (coeff === undefined && manager.isNot(atom)) {
741
+ // not (k*x + rest >= 0), that is k*x + rest < 0.
742
+ const negatedP = util.isGe(manager.getArg(atom, 0));
743
+ coeff = negatedP === undefined ? undefined : util.getCoeff(contains, negatedP);
744
+ }
745
+ if (coeff === undefined) return false;
746
+ const rest = util.mkDiv(coeff.rest, coeff.k.abs());
747
+ if (coeff.k.isNegative()) this.lt.push({ term: rest, coeff: Rational.minusOne, atom });
748
+ else this.gt.push({ term: rest, coeff: Rational.one, atom });
749
+ return true;
750
+ }
751
+
752
+ private getDivides(contains: ContainsApp, atom: number) {
753
+ const util = this.util;
754
+ const divides = util.isDivides(atom);
755
+ const coeff = divides === undefined ? undefined : util.getCoeff(contains, divides.p);
756
+ if (divides !== undefined && coeff !== undefined) {
757
+ this.divs.push({ term: coeff.rest, divisor: divides.k, coeff: coeff.k, atom });
758
+ return true;
759
+ }
760
+ const notDivides = util.isNotDivides(atom);
761
+ const notCoeff = notDivides === undefined ? undefined : util.getCoeff(contains, notDivides.p);
762
+ if (notDivides === undefined || notCoeff === undefined) return false;
763
+ this.divs.push({
764
+ term: notCoeff.rest,
765
+ divisor: notDivides.k,
766
+ coeff: notCoeff.k,
767
+ atom: notDivides.atom,
768
+ });
769
+ return true;
770
+ }
771
+ }
772
+
773
+ // x is coeff*x' + term after a substitution.
774
+ class XSubst {
775
+ term = -1;
776
+ coeff = Rational.one;
777
+
778
+ constructor(private util: ArithQeUtil) {}
779
+
780
+ mkTerm(c: Rational, t: number) {
781
+ return this.term === -1 ? t : this.util.mkAdd(this.util.mkMul(c, this.term), t);
782
+ }
783
+
784
+ mkCoeff(k: Rational) {
785
+ return k.mul(this.coeff);
786
+ }
787
+ }
788
+
789
+ interface BranchFormula {
790
+ result: number;
791
+ vars: number[];
792
+ }
793
+
794
+ export class ArithPlugin implements QeSolverPlugin {
795
+ readonly family = FAMILY_ARITH;
796
+ private util: ArithQeUtil;
797
+ private boundsCache = new Map<string, BoundsProc>();
798
+ private substCache = new Map<string, BranchFormula>();
799
+
800
+ constructor(private context: QeSolverContext) {
801
+ this.util = new ArithQeUtil(context);
802
+ }
803
+
804
+ release() {
805
+ this.util.release();
806
+ }
807
+
808
+ assign(contains: ContainsApp, formula: number, value: bigint) {
809
+ const util = this.util;
810
+ const x = contains.x;
811
+ if (this.getCache(x, formula, value) !== undefined) return;
812
+ util.varsAdded = [];
813
+ const bounds = this.getBounds(x, formula);
814
+ const sizes = this.getBoundSizes(bounds, x);
815
+ const isLower = sizes.isLower;
816
+ const xT = new XSubst(util);
817
+ let result = this.assignNestedDivs(bounds, formula);
818
+ result = this.assignDivs(contains, bounds, xT, result);
819
+ if (value === 0n) {
820
+ // The case where x is unbounded.
821
+ result = this.mkNonBounds(bounds, true, isLower, result);
822
+ result = this.mkNonBounds(bounds, false, isLower, result);
823
+ result = this.mkNonResolve(bounds, true, isLower, result);
824
+ result = this.mkNonResolve(bounds, false, isLower, result);
825
+ this.addCache(x, formula, value, util.simplify(result));
826
+ return;
827
+ }
828
+ // Strict bounds come after the others, and a non-strict bound of a real is two cases: x equals
829
+ // it, or x is below it.
830
+ const position = Number(value) - 1;
831
+ const isStrict = sizes.eSize <= position;
832
+ const isEq = !isStrict && util.isReal(x) && position % 2 === 0;
833
+ const index = isStrict
834
+ ? position - sizes.eSize
835
+ : util.isReal(x)
836
+ ? Math.floor(position / 2)
837
+ : position;
838
+ const bound = bounds.get(isStrict, isLower)[index];
839
+ let t = bound.term;
840
+ let a = bound.coeff;
841
+ const context = { bounds, x, isEq, isStrictCtx: isStrict, isLower, index };
842
+ result = this.mkBounds(context, true, a, t, result);
843
+ result = this.mkBounds(context, false, a, t, result);
844
+ t = xT.mkTerm(a, t);
845
+ a = xT.mkCoeff(a);
846
+ result = this.mkResolve(context, xT, true, a, t, result);
847
+ result = this.mkResolve(context, xT, false, a, t, result);
848
+ this.addCache(x, formula, value, util.simplify(result));
849
+ }
850
+
851
+ getNumBranches(contains: ContainsApp, formula: number) {
852
+ if (!this.updateBounds(contains, formula)) return undefined;
853
+ const sizes = this.getBoundSizes(this.getBounds(contains.x, formula), contains.x);
854
+ return BigInt(sizes.tSize + sizes.eSize + 1);
855
+ }
856
+
857
+ subst(contains: ContainsApp, value: bigint, formula: number) {
858
+ const result = this.getCache(contains.x, formula, value);
859
+ if (result === undefined) throw new SmtInvariantError("quantifier elimination lost a branch");
860
+ return result;
861
+ }
862
+
863
+ solve(conjs: readonly number[], formula: number) {
864
+ return this.util.solve(conjs, formula);
865
+ }
866
+
867
+ mkAtom(expr: number, isPositive: boolean) {
868
+ return this.util.mkAtom(expr, isPositive);
869
+ }
870
+
871
+ isUninterpreted(app: number) {
872
+ const manager = this.util.manager;
873
+ const op = manager.getOp(app);
874
+ if ([OP_NUM, OP_LE, OP_LT, OP_GE, OP_GT, OP_ADD, OP_SUB, OP_UMINUS].includes(op)) return false;
875
+ if (op === OP_MOD) return this.util.getNumeral(manager.getArg(app, 1)) === undefined;
876
+ if (op === OP_MUL && manager.getNumArgs(app) === 2)
877
+ return manager.getArgs(app).every((arg) => this.util.getNumeral(arg) === undefined);
878
+ return true;
879
+ }
880
+
881
+ private getBoundSizes(bounds: BoundsProc, x: number) {
882
+ const factor = this.util.isReal(x) ? 2 : 1;
883
+ const leSize = bounds.le.length * factor;
884
+ const geSize = bounds.ge.length * factor;
885
+ return leSize + bounds.lt.length < geSize + bounds.gt.length
886
+ ? { eSize: leSize, tSize: bounds.lt.length, isLower: true }
887
+ : { eSize: geSize, tSize: bounds.gt.length, isLower: false };
888
+ }
889
+
890
+ private addCache(x: number, formula: number, value: bigint, result: number) {
891
+ this.context.pin(x);
892
+ this.context.pin(formula);
893
+ this.substCache.set(`${formula}:${x}:${value}`, {
894
+ result: this.context.pin(result),
895
+ vars: [...this.util.varsAdded],
896
+ });
897
+ }
898
+
899
+ private getCache(x: number, formula: number, value: bigint) {
900
+ const cached = this.substCache.get(`${formula}:${x}:${value}`);
901
+ if (cached === undefined) return undefined;
902
+ for (const variable of cached.vars) this.util.addVar(variable, false);
903
+ return cached.result;
904
+ }
905
+
906
+ private assignDivs(contains: ContainsApp, bounds: BoundsProc, xT: XSubst, formula: number) {
907
+ const util = this.util;
908
+ const x = contains.x;
909
+ const divZ = bounds.getDivZ();
910
+ if (divZ === undefined) return formula;
911
+ util.addVar(divZ.zBv);
912
+ // z < d, d | (x - z) and (c | ax + t <-> c | az + t) for each divisor.
913
+ const d1 = divZ.d.sub(Rational.one);
914
+ this.context.addConstraint(false, util.mkLeApp(divZ.z, util.mkNumeral(d1)));
915
+ const zLeD1 = util.mkLeRewrite(divZ.z, util.mkNumeral(d1));
916
+ let result = util.mkAnd([formula, zLeD1]);
917
+ this.context.addConstraint(false, util.mkDivides(divZ.d, util.mkSub(x, divZ.z)));
918
+ for (const div of bounds.divs) {
919
+ const newAtom = util.mkDivides(
920
+ div.divisor,
921
+ util.mkAdd(util.mkMul(div.coeff, divZ.z), div.term),
922
+ );
923
+ result = util.replace(div.atom, newAtom, result);
924
+ this.context.addConstraint(false, this.mkNot(div.atom), newAtom);
925
+ this.context.addConstraint(false, this.mkNot(newAtom), div.atom);
926
+ }
927
+ xT.term = divZ.z;
928
+ xT.coeff = divZ.d;
929
+ return result;
930
+ }
931
+
932
+ private assignNestedDivs(bounds: BoundsProc, formula: number) {
933
+ const util = this.util;
934
+ const manager = util.manager;
935
+ if (bounds.nestedDivs.length === 0) return formula;
936
+ const divZ = bounds.getDivZ();
937
+ if (divZ === undefined) throw new SmtInvariantError("quantifier elimination found no divisor");
938
+ let result = formula;
939
+ for (const nested of bounds.nestedDivs) {
940
+ // mod_term = arg_0 mod k, with z1 < k and (coeff*x + rest - z1) mod k = 0.
941
+ util.addVar(nested.zBv);
942
+ const k1 = nested.divisor.sub(Rational.one);
943
+ this.context.addConstraint(false, util.mkLeApp(nested.z, util.mkNumeral(k1)));
944
+ const [dividend, divisor] = manager.getArgs(nested.atom);
945
+ const modTerm = util.simplify(
946
+ util.mkApp(OP_MOD, [util.mkSub(dividend, nested.z), divisor], SORT_INT),
947
+ );
948
+ this.context.addConstraint(false, util.pin(manager.mkEq(modTerm, util.mkZero(SORT_INT))));
949
+ result = util.replace(nested.atom, nested.z, result);
950
+ // (coeff*z + rest - z1) mod k = 0
951
+ const scaled = util.mkMulApp(util.mkNumeral(nested.coeff), nested.z);
952
+ const sum = util.mkAdd(scaled, util.mkSub(nested.term, divZ.z));
953
+ const modEq = util.simplify(
954
+ util.pin(manager.mkEq(util.mkApp(OP_MOD, [sum, divisor], SORT_INT), util.mkZero(SORT_INT))),
955
+ );
956
+ result = util.pin(manager.mkAnd([result, modEq]));
957
+ }
958
+ return result;
959
+ }
960
+
961
+ private getBounds(x: number, formula: number) {
962
+ return this.boundsCache.get(`${x}:${formula}`) as BoundsProc;
963
+ }
964
+
965
+ private mkNot(expr: number) {
966
+ const manager = this.util.manager;
967
+ return manager.isNot(expr) ? manager.getArg(expr, 0) : this.util.pin(manager.mkNot(expr));
968
+ }
969
+
970
+ private mkNonBounds(bounds: BoundsProc, isStrict: boolean, isLower: boolean, formula: number) {
971
+ let result = formula;
972
+ for (const bound of bounds.get(isStrict, isLower)) {
973
+ this.context.addConstraint(true, this.mkNot(bound.atom));
974
+ result = this.util.replace(bound.atom, this.util.manager.falseExpr, result);
975
+ }
976
+ return result;
977
+ }
978
+
979
+ private mkNonResolve(bounds: BoundsProc, isStrict: boolean, isLower: boolean, formula: number) {
980
+ let result = formula;
981
+ for (const bound of bounds.get(isStrict, !isLower)) {
982
+ this.context.addConstraint(true, bound.atom);
983
+ result = this.util.replace(bound.atom, this.util.manager.trueExpr, result);
984
+ }
985
+ return result;
986
+ }
987
+
988
+ private mkBound(
989
+ isStrict: boolean,
990
+ isLower: boolean,
991
+ a: Rational,
992
+ t: number,
993
+ b: Rational,
994
+ s: number,
995
+ ) {
996
+ const util = this.util;
997
+ const result = isLower
998
+ ? util.mkBoundAux(isStrict, b, s, a, t)
999
+ : util.mkBoundAux(isStrict, a, t, b, s);
1000
+ return util.simplify(result);
1001
+ }
1002
+
1003
+ // The bounds of the same direction as the chosen one at index, which is a*x <= t.
1004
+ private mkBounds(
1005
+ context: BoundContext,
1006
+ isStrict: boolean,
1007
+ a: Rational,
1008
+ t: number,
1009
+ formula: number,
1010
+ ) {
1011
+ const util = this.util;
1012
+ const manager = util.manager;
1013
+ const bounds = context.bounds.get(isStrict, context.isLower);
1014
+ const isSameStrict = isStrict === context.isStrictCtx;
1015
+ const isNonStrictReal = util.isReal(context.x) && !context.isStrictCtx;
1016
+ const atom = context.bounds.get(context.isStrictCtx, context.isLower)[context.index].atom;
1017
+ let result = formula;
1018
+ for (const [index, bound] of bounds.entries()) {
1019
+ if (isSameStrict && index === context.index) {
1020
+ if (isNonStrictReal) {
1021
+ const eq = util.mkEq(a, context.x, t);
1022
+ if (context.isEq) this.context.addConstraint(true, eq);
1023
+ else {
1024
+ this.context.addConstraint(true, this.mkNot(eq));
1025
+ this.context.addConstraint(true, bound.atom);
1026
+ }
1027
+ } else this.context.addConstraint(true, bound.atom);
1028
+ result = util.replace(atom, manager.trueExpr, result);
1029
+ continue;
1030
+ }
1031
+ // Substitutions keep the exact value of an atom, which may occur in both polarities.
1032
+ const isResultStrict = isNonStrictReal && context.isEq && isStrict;
1033
+ const tmp = this.mkBound(isResultStrict, context.isLower, a, t, bound.coeff, bound.term);
1034
+ result = util.replace(bound.atom, tmp, result);
1035
+ this.context.addConstraint(true, this.mkNot(bound.atom), tmp);
1036
+ }
1037
+ return result;
1038
+ }
1039
+
1040
+ // The bounds of the other direction, resolved against the chosen one.
1041
+ private mkResolve(
1042
+ context: BoundContext,
1043
+ xT: XSubst,
1044
+ isStrict: boolean,
1045
+ a: Rational,
1046
+ t: number,
1047
+ formula: number,
1048
+ ) {
1049
+ const util = this.util;
1050
+ const isStrictReal = !context.isEq && util.isReal(context.x) && !context.isStrictCtx;
1051
+ const isStrictResolve = isStrict || context.isStrictCtx || isStrictReal;
1052
+ let result = formula;
1053
+ for (const bound of context.bounds.get(isStrict, !context.isLower)) {
1054
+ const s = xT.mkTerm(bound.coeff, bound.term);
1055
+ const b = xT.mkCoeff(bound.coeff);
1056
+ const tmp = util.mkResolve(context.x, isStrictResolve, a, t, b, s);
1057
+ result = util.replace(bound.atom, tmp, result);
1058
+ this.context.addConstraint(true, this.mkNot(bound.atom), tmp);
1059
+ }
1060
+ return result;
1061
+ }
1062
+
1063
+ private updateBoundsIn(
1064
+ bounds: BoundsProc,
1065
+ contains: ContainsApp,
1066
+ atoms: Iterable<number>,
1067
+ isPositive: boolean,
1068
+ ) {
1069
+ const manager = this.util.manager;
1070
+ for (const atom of atoms) {
1071
+ if (!contains.has(atom)) continue;
1072
+ const literal = isPositive ? atom : this.util.pin(manager.mkNot(atom));
1073
+ if (!bounds.getBound(contains, literal)) return false;
1074
+ }
1075
+ return true;
1076
+ }
1077
+
1078
+ private updateBounds(contains: ContainsApp, formula: number) {
1079
+ const key = `${contains.x}:${formula}`;
1080
+ if (this.boundsCache.has(key)) return true;
1081
+ const bounds = new BoundsProc(this.util);
1082
+ if (!this.updateBoundsIn(bounds, contains, this.context.posAtoms(), true)) return false;
1083
+ if (!this.updateBoundsIn(bounds, contains, this.context.negAtoms(), false)) return false;
1084
+ this.context.pin(contains.x);
1085
+ this.context.pin(formula);
1086
+ this.boundsCache.set(key, bounds);
1087
+ return true;
1088
+ }
1089
+ }
1090
+
1091
+ interface BoundContext {
1092
+ bounds: BoundsProc;
1093
+ x: number;
1094
+ isEq: boolean;
1095
+ isStrictCtx: boolean;
1096
+ isLower: boolean;
1097
+ index: number;
1098
+ }