tla-ts 0.0.4 → 0.0.5-dev.cc59f31

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 (378) hide show
  1. package/README.md +37 -126
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +46 -12
  8. package/dist/index.d.ts +46 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1153
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +115 -721
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +43 -22
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +361 -181
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +207 -141
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +79 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +21 -22
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +39 -23
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -190
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +166 -111
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -0,0 +1,962 @@
1
+ // Ported from Z3 (src/ast/rewriter/arith_rewriter.cpp), MIT license, see z3-license.txt. Only
2
+ // linear arithmetic and nonlinear factoring are ported, without powers, algebraic numbers or
3
+ // hoisting, which tlapm's encoding does not produce.
4
+ import {
5
+ OP_ADD,
6
+ OP_GE,
7
+ OP_IDIV,
8
+ OP_ITE,
9
+ OP_LE,
10
+ OP_LT,
11
+ OP_MOD,
12
+ OP_MUL,
13
+ OP_SUB,
14
+ OP_TO_INT,
15
+ OP_TO_REAL,
16
+ OP_UMINUS,
17
+ SORT_BOOL,
18
+ SORT_INT,
19
+ SORT_REAL,
20
+ } from "./ast";
21
+ import { getEuclideanDiv, getEuclideanMod, getGcd, Rational } from "./rational";
22
+ import { type ArithRewriterOptions, PolyRewriter } from "./poly-rewriter";
23
+ import type { Rewrite } from "./rewriter-tpl";
24
+ import { shrink } from "./array";
25
+
26
+ // The parameters that asserted_formulas gives the kernel's rewriter, which also simplifies instances.
27
+ export const KERNEL_ARITH_OPTIONS: ArithRewriterOptions = {
28
+ isSom: true,
29
+ isSortSums: true,
30
+ isArithIneqLhs: true,
31
+ isGcdRounding: true,
32
+ };
33
+
34
+ // The defaults, which the simplify tactic uses.
35
+ export const TACTIC_ARITH_OPTIONS: ArithRewriterOptions = {
36
+ isSom: false,
37
+ isSortSums: false,
38
+ isArithIneqLhs: false,
39
+ isGcdRounding: false,
40
+ };
41
+
42
+ // The ceiling of the quotient by a positive divisor.
43
+ const getCeilDiv = (dividend: bigint, divisor: bigint) => -getEuclideanDiv(-dividend, divisor);
44
+
45
+ // symmod: the remainder closest to zero, for a positive modulus.
46
+ const getSymmetricMod = (value: bigint, modulus: bigint) => {
47
+ const remainder = getEuclideanMod(value, modulus);
48
+ return 2n * remainder > modulus ? remainder - modulus : remainder;
49
+ };
50
+
51
+ // The running gcd of the coefficients of an atom's sides, and the number of their constants.
52
+ interface GcdState {
53
+ gcd: bigint;
54
+ isFirst: boolean;
55
+ numConsts: number;
56
+ }
57
+
58
+ const KIND_LE = 0;
59
+ const KIND_GE = 1;
60
+ const KIND_EQ = 2;
61
+
62
+ const getInverse = (kind: number) =>
63
+ kind === KIND_LE ? KIND_GE : kind === KIND_GE ? KIND_LE : KIND_EQ;
64
+
65
+ export class ArithRewriter extends PolyRewriter {
66
+ // The buffer of isNonNegative's factors.
67
+ private factors: number[] = [];
68
+
69
+ mkLe(left: number, right: number) {
70
+ return this.mkLeGeEq(left, right, KIND_LE);
71
+ }
72
+
73
+ mkGe(left: number, right: number) {
74
+ return this.mkLeGeEq(left, right, KIND_GE);
75
+ }
76
+
77
+ mkLt(left: number, right: number) {
78
+ return this.reduce(this.manager.mkNot(this.mkAtom(right, left, KIND_LE)), 2);
79
+ }
80
+
81
+ mkGt(left: number, right: number) {
82
+ return this.reduce(this.manager.mkNot(this.mkAtom(left, right, KIND_LE)), 2);
83
+ }
84
+
85
+ mkEq(left: number, right: number) {
86
+ if (!this.isArithTerm(left) && !this.isArithTerm(right)) return undefined;
87
+ return this.mkLeGeEq(left, right, KIND_EQ);
88
+ }
89
+
90
+ // mk_idiv_core and mk_mod_core: SMT-LIB integer division, whose remainder is non-negative.
91
+ private mkIdivApp(left: number, right: number) {
92
+ return this.manager.mkApp(OP_IDIV, [left, right], SORT_INT);
93
+ }
94
+
95
+ private mkModApp(left: number, right: number) {
96
+ return this.manager.mkApp(OP_MOD, [left, right], SORT_INT);
97
+ }
98
+
99
+ // arith_util's mk_mul, which makes no product of one factor.
100
+ private mkFlatMulApp(args: number[]) {
101
+ return args.length === 1 ? args[0] : this.manager.mkApp(OP_MUL, args, SORT_INT);
102
+ }
103
+
104
+ private mkIntIte(condition: number, thenExpr: number, elseExpr: number) {
105
+ return this.manager.mkApp(OP_ITE, [condition, thenExpr, elseExpr], SORT_INT);
106
+ }
107
+
108
+ // flat_mul: the factors of nested products, in Z3's order.
109
+ private getFlatMul(expr: number) {
110
+ const args = [expr];
111
+ for (let index = 0; index < args.length; index++) {
112
+ if (!this.isMul(args[index])) continue;
113
+ this.manager.pushArgs(args[index], args);
114
+ args[index] = args[args.length - 1];
115
+ args.pop();
116
+ index--;
117
+ }
118
+ return args;
119
+ }
120
+
121
+ private removeFactor(factor: number, args: number[]) {
122
+ const index = args.indexOf(factor);
123
+ args[index] = args[args.length - 1];
124
+ args.pop();
125
+ }
126
+
127
+ // remove_divisor: div ab ac is div b c when a is positive, and div -b -c when it is negative.
128
+ private removeDivisor(factor: number, dividend: number, divisor: number) {
129
+ const manager = this.manager;
130
+ const dividendArgs = this.getFlatMul(dividend);
131
+ const divisorArgs = this.getFlatMul(divisor);
132
+ this.removeFactor(factor, dividendArgs);
133
+ this.removeFactor(factor, divisorArgs);
134
+ const zero = manager.mkNumeral(0n);
135
+ const newDividend =
136
+ dividendArgs.length === 0 ? manager.mkNumeral(1n) : this.mkFlatMulApp(dividendArgs);
137
+ const newDivisor =
138
+ divisorArgs.length === 0 ? manager.mkNumeral(1n) : this.mkFlatMulApp(divisorArgs);
139
+ return this.mkIntIte(
140
+ manager.mkEq(zero, factor),
141
+ this.mkIdivApp(zero, zero),
142
+ this.mkIntIte(
143
+ manager.mkApp(OP_GE, [factor, zero], SORT_BOOL),
144
+ this.mkIdivApp(newDividend, newDivisor),
145
+ this.mkIdivApp(
146
+ manager.mkApp(OP_UMINUS, [newDividend], SORT_INT),
147
+ manager.mkApp(OP_UMINUS, [newDivisor], SORT_INT),
148
+ ),
149
+ ),
150
+ );
151
+ }
152
+
153
+ // get_divides: div ab ac is div b c, and common numeral factors cancel.
154
+ private getDivides(dividend: number, divisor: number) {
155
+ const manager = this.manager;
156
+ const dividendArgs = this.getFlatMul(dividend);
157
+ const divisorArgs = this.getFlatMul(divisor);
158
+ let dividendValue = 1n;
159
+ let divisorValue = 1n;
160
+ let dividendNumeral: number | undefined;
161
+ let divisorNumeral: number | undefined;
162
+ const marked = new Set(dividendArgs);
163
+ for (const arg of dividendArgs) {
164
+ const value = manager.getNumeral(arg);
165
+ if (value === undefined) continue;
166
+ dividendValue = value;
167
+ dividendNumeral = arg;
168
+ }
169
+ for (const arg of divisorArgs) {
170
+ const value = manager.getNumeral(arg);
171
+ // A common factor of -1 stays, or the rewriting of (div (* -1 x) (* -1 y)) diverges. Z3's
172
+ // check stores the -1 as the dividend's value.
173
+ if (marked.has(arg) && value !== -1n) return this.removeDivisor(arg, dividend, divisor);
174
+ if (marked.has(arg)) dividendValue = -1n;
175
+ if (value === undefined) continue;
176
+ divisorValue = value;
177
+ divisorNumeral = arg;
178
+ }
179
+ const gcd = getGcd(dividendValue, divisorValue);
180
+ if (gcd === 1n) return undefined;
181
+ const reduced = (args: number[], numeral: number | undefined, value: bigint) => {
182
+ const index = args.indexOf(numeral ?? -1);
183
+ if (index !== -1) args[index] = manager.mkNumeral(value / gcd);
184
+ return this.mkFlatMulApp(args);
185
+ };
186
+ return this.mkIdivApp(
187
+ reduced(dividendArgs, dividendNumeral, dividendValue),
188
+ reduced(divisorArgs, divisorNumeral, divisorValue),
189
+ );
190
+ }
191
+
192
+ // mk_idiv_core.
193
+ mkIdiv(left: number, right: number) {
194
+ const manager = this.manager;
195
+ this.currSort = SORT_INT;
196
+ const dividend = manager.getNumeral(left);
197
+ const divisor = manager.getNumeral(right);
198
+ if (dividend !== undefined && divisor !== undefined && divisor !== 0n)
199
+ return manager.mkNumeral(getEuclideanDiv(dividend, divisor));
200
+ if (divisor === 1n) return left;
201
+ if (divisor === -1n) return this.reduce(this.mkFlatMulApp([manager.mkNumeral(-1n), left]), 1);
202
+ if (divisor === 0n) return undefined;
203
+ const zero = manager.mkNumeral(0n);
204
+ if (left === right)
205
+ return this.reduce(
206
+ this.mkIntIte(manager.mkEq(left, zero), this.mkIdivApp(zero, zero), manager.mkNumeral(1n)),
207
+ 3,
208
+ );
209
+ if (divisor !== undefined && divisor > 0n && this.isAdd(left)) {
210
+ let isChanged = false;
211
+ let added = 0n;
212
+ const args = manager.mapArgs(left, (arg) => {
213
+ const value = manager.getNumeral(arg);
214
+ if (value === undefined || value <= 0n || getEuclideanMod(value, divisor) === value)
215
+ return arg;
216
+ isChanged = true;
217
+ added += getEuclideanDiv(value, divisor);
218
+ return manager.mkNumeral(getEuclideanMod(value, divisor));
219
+ });
220
+ if (isChanged)
221
+ return this.reduce(
222
+ this.mkAddApp([
223
+ manager.mkNumeral(added),
224
+ this.mkIdivApp(manager.mkApp(OP_ADD, args, SORT_INT), right),
225
+ ]),
226
+ 3,
227
+ );
228
+ }
229
+ const divided = this.getDivides(left, right);
230
+ if (divided === undefined) return undefined;
231
+ return this.reduce(
232
+ this.mkIntIte(manager.mkEq(zero, right), this.mkIdivApp(left, zero), divided),
233
+ Infinity,
234
+ );
235
+ }
236
+
237
+ // mk_mod_core.
238
+ mkMod(left: number, right: number) {
239
+ const manager = this.manager;
240
+ this.currSort = SORT_INT;
241
+ const dividend = manager.getNumeral(left);
242
+ const divisor = manager.getNumeral(right);
243
+ if (dividend !== undefined && divisor !== undefined && divisor !== 0n)
244
+ return manager.mkNumeral(getEuclideanMod(dividend, divisor));
245
+ if (divisor === 1n || divisor === -1n) return manager.mkNumeral(0n);
246
+ const zero = manager.mkNumeral(0n);
247
+ if (left === right && divisor === undefined)
248
+ return this.mkIntIte(manager.mkEq(right, zero), this.mkModApp(zero, zero), zero);
249
+ // mod is idempotent on a nonzero modulus.
250
+ if (manager.getOp(left) === OP_MOD && manager.getArg(left, 1) === right) {
251
+ if (divisor !== undefined && divisor !== 0n) return left;
252
+ if (divisor === undefined)
253
+ return this.reduce(
254
+ this.mkIntIte(
255
+ manager.mkEq(right, zero),
256
+ this.mkModApp(this.mkModApp(manager.getArg(left, 0), zero), zero),
257
+ left,
258
+ ),
259
+ 2,
260
+ );
261
+ }
262
+ // Propagates mod inside a sum or product only if there is something to reduce.
263
+ if (divisor !== undefined && divisor > 0n && (this.isAdd(left) || this.isMul(left))) {
264
+ let isChanged = false;
265
+ const args = manager.mapArgs(left, (arg) => {
266
+ const value = manager.getNumeral(arg);
267
+ if (value !== undefined && getEuclideanMod(value, divisor) !== value) {
268
+ isChanged = true;
269
+ return manager.mkNumeral(getEuclideanMod(value, divisor));
270
+ }
271
+ if (manager.getOp(arg) === OP_MOD && manager.getArg(arg, 1) === right) {
272
+ isChanged = true;
273
+ return manager.getArg(arg, 0);
274
+ }
275
+ const coefficient =
276
+ this.isMul(arg) && manager.getNumArgs(arg) === 2
277
+ ? manager.getNumeral(manager.getArg(arg, 0))
278
+ : undefined;
279
+ if (coefficient !== undefined && getSymmetricMod(coefficient, divisor) !== coefficient) {
280
+ isChanged = true;
281
+ return manager.mkApp(
282
+ OP_MUL,
283
+ [manager.mkNumeral(getSymmetricMod(coefficient, divisor)), manager.getArg(arg, 1)],
284
+ SORT_INT,
285
+ );
286
+ }
287
+ return arg;
288
+ });
289
+ if (isChanged)
290
+ return this.reduce(
291
+ this.mkModApp(manager.mkApp(manager.decls[left], args, SORT_INT), right),
292
+ 3,
293
+ );
294
+ }
295
+ // For a symbolic modulus, the summands that are multiples of it go: mod (a + k*y) y = mod a y.
296
+ if (divisor === undefined && this.isAdd(left)) {
297
+ const args: number[] = [];
298
+ for (let index = 0; index < manager.getNumArgs(left); index++) {
299
+ const arg = manager.getArg(left, index);
300
+ if (
301
+ arg !== right &&
302
+ !(
303
+ this.isMul(arg) &&
304
+ manager.getNumArgs(arg) === 2 &&
305
+ ((manager.isNumeral(manager.getArg(arg, 0)) && manager.getArg(arg, 1) === right) ||
306
+ (manager.isNumeral(manager.getArg(arg, 1)) && manager.getArg(arg, 0) === right))
307
+ )
308
+ )
309
+ args.push(arg);
310
+ }
311
+ if (args.length < manager.getNumArgs(left))
312
+ return this.reduce(this.mkModApp(args.length === 0 ? zero : this.mkAddApp(args), right), 3);
313
+ }
314
+ const factor =
315
+ this.isMul(left) && manager.getNumArgs(left) === 2
316
+ ? manager.getNumeral(manager.getArg(left, 0))
317
+ : undefined;
318
+ if (
319
+ divisor !== undefined &&
320
+ divisor > 0n &&
321
+ factor !== undefined &&
322
+ factor > 0n &&
323
+ divisor % factor === 0n
324
+ )
325
+ return this.reduce(
326
+ manager.mkApp(
327
+ OP_MUL,
328
+ [
329
+ manager.mkNumeral(factor),
330
+ this.mkModApp(manager.getArg(left, 1), manager.mkNumeral(divisor / factor)),
331
+ ],
332
+ SORT_INT,
333
+ ),
334
+ 1,
335
+ );
336
+ // mod x -y = mod x y.
337
+ if (
338
+ this.isMul(right) &&
339
+ manager.getNumArgs(right) === 2 &&
340
+ manager.getNumeral(manager.getArg(right, 0)) === -1n
341
+ )
342
+ return this.reduce(this.mkModApp(left, manager.getArg(right, 1)), 1);
343
+ if (manager.getOp(right) === OP_ITE)
344
+ return this.reduce(
345
+ this.mkIntIte(
346
+ manager.getArg(right, 0),
347
+ this.mkModApp(left, manager.getArg(right, 1)),
348
+ this.mkModApp(left, manager.getArg(right, 2)),
349
+ ),
350
+ 3,
351
+ );
352
+ return undefined;
353
+ }
354
+
355
+ mkAbs(arg: number) {
356
+ const manager = this.manager;
357
+ const sort = manager.sorts[arg];
358
+ return this.reduce(
359
+ manager.mkApp(
360
+ OP_ITE,
361
+ [
362
+ this.mkAtom(arg, manager.mkNumeralOfSort(Rational.zero, sort), KIND_GE),
363
+ arg,
364
+ manager.mkApp(OP_UMINUS, [arg], sort),
365
+ ],
366
+ sort,
367
+ ),
368
+ 2,
369
+ );
370
+ }
371
+
372
+ // mk_div_core: division by a numeral other than 0 is a product.
373
+ mkDiv(left: number, right: number) {
374
+ const manager = this.manager;
375
+ this.currSort = manager.sorts[left];
376
+ if (!manager.isNumeral(right) || this.getValue(right).isZero()) return undefined;
377
+ const divisor = this.getValue(right);
378
+ if (manager.isNumeral(left)) return manager.mkRealNumeral(this.getValue(left).div(divisor));
379
+ return this.reduce(
380
+ manager.mkApp(OP_MUL, [manager.mkRealNumeral(Rational.one.div(divisor)), left], SORT_REAL),
381
+ 1,
382
+ );
383
+ }
384
+
385
+ // mk_to_int_core: (to_int (+ 1.0 (to_real x) y)) is (+ 1 x (to_int y)).
386
+ mkToInt(arg: number) {
387
+ const manager = this.manager;
388
+ if (manager.isInt(arg)) return arg;
389
+ if (manager.isNumeral(arg)) return manager.mkNumeral(this.getValue(arg).floor().num);
390
+ const op = manager.getOp(arg);
391
+ if (op === OP_TO_REAL && manager.isInt(manager.getArg(arg, 0))) return manager.getArg(arg, 0);
392
+ if (op !== OP_ADD && op !== OP_MUL) return undefined;
393
+ const intArgs: number[] = [];
394
+ const realArgs: number[] = [];
395
+ for (let index = 0; index < manager.getNumArgs(arg); index++) {
396
+ const child = manager.getArg(arg, index);
397
+ if (manager.isNumeral(child) && this.getValue(child).isInt())
398
+ intArgs.push(manager.mkNumeral(this.getValue(child).num));
399
+ else if (manager.getOp(child) === OP_TO_REAL) intArgs.push(manager.getArg(child, 0));
400
+ else realArgs.push(child);
401
+ }
402
+ // Z3 makes a sum of one argument, which the manager leaves out.
403
+ const mkSum = (args: number[], sort: number) =>
404
+ args.length === 1 ? args[0] : manager.mkApp(op, args, sort);
405
+ if (realArgs.length === 0) return this.reduce(mkSum(intArgs, SORT_INT), 1);
406
+ if (intArgs.length === 0 || op !== OP_ADD) return undefined;
407
+ const intSum = mkSum(intArgs, SORT_INT);
408
+ const realSum = mkSum(realArgs, SORT_REAL);
409
+ return this.reduce(
410
+ manager.mkApp(OP_ADD, [intSum, manager.mkApp(OP_TO_INT, [realSum], SORT_INT)], SORT_INT),
411
+ 3,
412
+ );
413
+ }
414
+
415
+ // mk_to_real_core, with push_to_real: to_real distributes over sums and products.
416
+ mkToReal(arg: number) {
417
+ const manager = this.manager;
418
+ if (manager.isNumeral(arg)) return manager.mkRealNumeral(this.getValue(arg));
419
+ if (manager.isReal(arg)) return arg;
420
+ const op = manager.getOp(arg);
421
+ if (op !== OP_ADD && op !== OP_MUL) return undefined;
422
+ return this.reduce(
423
+ manager.mkApp(
424
+ op,
425
+ manager.mapArgs(arg, (child) => manager.mkApp(OP_TO_REAL, [child], SORT_REAL)),
426
+ SORT_REAL,
427
+ ),
428
+ 2,
429
+ );
430
+ }
431
+
432
+ // mk_is_int: a numeral is decided, and a term built from integers by sums and products is an
433
+ // integer. Any other term x is an integer when (to_real (to_int x)) is x.
434
+ mkIsInt(arg: number) {
435
+ const manager = this.manager;
436
+ if (manager.isNumeral(arg))
437
+ return this.getValue(arg).isInt() ? manager.trueExpr : manager.falseExpr;
438
+ const todo = [arg];
439
+ const visited = new Set<number>();
440
+ let isIntegral = true;
441
+ while (isIntegral) {
442
+ const current = todo.pop();
443
+ if (current === undefined) break;
444
+ if (visited.has(current)) continue;
445
+ visited.add(current);
446
+ const op = manager.getOp(current);
447
+ if (op === OP_TO_REAL) continue;
448
+ if (manager.isNumeral(current)) isIntegral = this.getValue(current).isInt();
449
+ else if (op === OP_MUL || op === OP_ADD || op === OP_SUB || op === OP_UMINUS)
450
+ manager.pushArgs(current, todo);
451
+ else isIntegral = false;
452
+ }
453
+ if (isIntegral) return manager.trueExpr;
454
+ return this.reduce(
455
+ manager.mkEq(
456
+ manager.mkApp(OP_TO_REAL, [manager.mkApp(OP_TO_INT, [arg], SORT_INT)], SORT_REAL),
457
+ arg,
458
+ ),
459
+ 3,
460
+ );
461
+ }
462
+
463
+ private mkAtom(left: number, right: number, kind: number) {
464
+ const manager = this.manager;
465
+ if (kind === KIND_EQ) return manager.mkEq(left, right);
466
+ return manager.mkApp(kind === KIND_LE ? OP_LE : OP_GE, [left, right], SORT_BOOL);
467
+ }
468
+
469
+ private flattenMul(expr: number, result: number[]) {
470
+ if (this.isMul(expr))
471
+ for (let index = 0; index < this.manager.getNumArgs(expr); index++)
472
+ this.flattenMul(this.manager.getArg(expr, index), result);
473
+ else result.push(expr);
474
+ }
475
+
476
+ // is_non_negative, without powers and sequences. It counts each factor's occurrences by scanning
477
+ // the factors, which are few, rather than by sorting them.
478
+ private isNonNegative(expr: number) {
479
+ if (!this.isMul(expr)) return false;
480
+ const factors = this.factors;
481
+ shrink(factors, 0);
482
+ this.flattenMul(expr, factors);
483
+ let isNegative = false;
484
+ let numFactors = 0;
485
+ for (const arg of factors) {
486
+ if (!this.manager.isNumeral(arg)) factors[numFactors++] = arg;
487
+ else if (this.getValue(arg).isNegative()) isNegative = !isNegative;
488
+ }
489
+ if (isNegative) return false;
490
+ let numOdd = 0;
491
+ let firstOdd = -1;
492
+ let secondOdd = -1;
493
+ for (let index = 0; index < numFactors; index++) {
494
+ const factor = factors[index];
495
+ if (factors.indexOf(factor) < index) continue;
496
+ let count = 0;
497
+ for (let other = index; other < numFactors; other++) if (factors[other] === factor) count++;
498
+ if (count % 2 === 0) continue;
499
+ numOdd++;
500
+ if (numOdd === 1) firstOdd = factor;
501
+ else if (numOdd === 2) secondOdd = factor;
502
+ else return false;
503
+ }
504
+ if (numOdd === 0) return true;
505
+ // x * (x + 1) >= 0 holds for an integer x, as no integer lies strictly between -1 and 0, but
506
+ // not for a real one.
507
+ if (numOdd !== 2 || !this.manager.isInt(expr)) return false;
508
+ return this.isSuccessor(firstOdd, secondOdd) || this.isSuccessor(secondOdd, firstOdd);
509
+ }
510
+
511
+ // Whether sum is base plus or minus one.
512
+ private isSuccessor(base: number, sum: number) {
513
+ if (!this.isAdd(sum)) return false;
514
+ let offset = Rational.zero;
515
+ let numBase = 0;
516
+ for (let index = 0; index < this.manager.getNumArgs(sum); index++) {
517
+ const arg = this.manager.getArg(sum, index);
518
+ if (this.manager.isNumeral(arg)) offset = offset.add(this.getValue(arg));
519
+ else if (arg === base) numBase++;
520
+ else return false;
521
+ }
522
+ return numBase === 1 && (offset.equals(Rational.one) || offset.equals(Rational.minusOne));
523
+ }
524
+
525
+ private negateMonomial(expr: number) {
526
+ const manager = this.manager;
527
+ if (this.manager.isNumeral(expr)) return this.mkNumeral(this.getValue(expr).neg());
528
+ if (this.isMul(expr)) {
529
+ const coefficient = manager.getArg(expr, 0);
530
+ if (!this.manager.isNumeral(coefficient))
531
+ return this.mkMulApp([this.mkNumeral(Rational.minusOne), expr]);
532
+ const value = this.getValue(coefficient);
533
+ const factors = value.equals(Rational.minusOne) ? [] : [this.mkNumeral(value.neg())];
534
+ for (let index = 1; index < manager.getNumArgs(expr); index++)
535
+ factors.push(manager.getArg(expr, index));
536
+ return factors.length === 1 ? factors[0] : manager.mkApp(OP_MUL, factors, this.currSort);
537
+ }
538
+ return manager.mkApp(OP_MUL, [this.mkNumeral(Rational.minusOne), expr], this.currSort);
539
+ }
540
+
541
+ private getNegatedPolynomial(expr: number) {
542
+ const manager = this.manager;
543
+ const isNegativeMonomial = (term: number) =>
544
+ this.isMul(term) &&
545
+ this.manager.isNumeral(manager.getArg(term, 0)) &&
546
+ this.getValue(manager.getArg(term, 0)).isNegative();
547
+ if (isNegativeMonomial(expr)) return this.negateMonomial(expr);
548
+ if (!this.isAdd(expr) || !isNegativeMonomial(manager.getArg(expr, 0))) return undefined;
549
+ return manager.mkApp(
550
+ OP_ADD,
551
+ manager.mapArgs(expr, (arg) => this.negateMonomial(arg)),
552
+ this.currSort,
553
+ );
554
+ }
555
+
556
+ // is_separated. Like narg, the last negated polynomial lives until is_separated returns.
557
+ private getSeparated(left: number, right: number, kind: number) {
558
+ const manager = this.manager;
559
+ if (kind === KIND_EQ || !this.manager.isNumeral(right)) return undefined;
560
+ const rightValue = this.getValue(right);
561
+ if (kind === KIND_GE && rightValue.isZero() && this.isMul(left) && this.isNonNegative(left))
562
+ return manager.trueExpr;
563
+ let bound = Rational.zero;
564
+ let hasBound = true;
565
+ let lastNegated: number | undefined;
566
+ for (let index = 0; index < this.getNumMonomials(left); index++) {
567
+ const arg = this.getMonomial(left, index);
568
+ if (this.manager.isNumeral(arg)) bound = bound.add(this.getValue(arg));
569
+ else if (kind === KIND_LE && this.isNonNegative(arg)) continue;
570
+ else if (kind === KIND_GE) {
571
+ const negated = manager.withTemporaries(
572
+ () => this.getNegatedPolynomial(arg),
573
+ (result) => (result === undefined ? [] : [result]),
574
+ );
575
+ if (negated !== undefined) {
576
+ if (lastNegated !== undefined) manager.decRef(lastNegated);
577
+ lastNegated = negated;
578
+ }
579
+ if (negated === undefined || !this.isNonNegative(negated)) hasBound = false;
580
+ } else hasBound = false;
581
+ }
582
+ const result = hasBound ? this.mkSeparated(left, kind, bound, rightValue) : undefined;
583
+ if (lastNegated !== undefined) manager.decRef(lastNegated);
584
+ return result;
585
+ }
586
+
587
+ private mkSeparated(left: number, kind: number, bound: Rational, rightValue: Rational) {
588
+ const manager = this.manager;
589
+ const comparison = bound.compare(rightValue);
590
+ if (kind === KIND_LE && comparison < 0) return undefined;
591
+ if (kind === KIND_GE && comparison > 0) return undefined;
592
+ if (kind === KIND_LE && comparison > 0) return manager.falseExpr;
593
+ if (kind === KIND_GE && comparison < 0) return manager.falseExpr;
594
+ const zero = this.mkNumeral(Rational.zero);
595
+ if (bound.isZero() && this.isMul(left)) {
596
+ const factors: number[] = [];
597
+ this.flattenMul(left, factors);
598
+ return this.reduce(
599
+ manager.mkOr(
600
+ factors
601
+ .filter((arg) => !this.manager.isNumeral(arg))
602
+ .map((arg) => manager.mkEq(arg, zero)),
603
+ ),
604
+ 2,
605
+ );
606
+ }
607
+ if (!this.isAdd(left)) return undefined;
608
+ const atoms: number[] = [];
609
+ for (let index = 0; index < manager.getNumArgs(left); index++) {
610
+ const arg = manager.getArg(left, index);
611
+ if (!manager.isNumeral(arg)) atoms.push(this.mkAtom(arg, zero, kind));
612
+ }
613
+ return this.reduce(manager.mkAnd(atoms), 2);
614
+ }
615
+
616
+ // is_bound.
617
+ private getBound(inputLeft: number, inputRight: number, inputKind: number) {
618
+ const manager = this.manager;
619
+ if (
620
+ !this.isAdd(inputLeft) &&
621
+ manager.getOp(inputLeft) !== OP_MOD &&
622
+ this.manager.isNumeral(inputRight)
623
+ ) {
624
+ const product = this.getPowerProduct(inputLeft);
625
+ const coefficient = this.getCoefficient(inputLeft);
626
+ const isNegative = coefficient.isNegative();
627
+ const scale = coefficient.abs();
628
+ const kind = isNegative ? getInverse(inputKind) : inputKind;
629
+ if (coefficient.isZero() || (!isNegative && scale.equals(Rational.one))) return undefined;
630
+ const value = this.getValue(inputRight);
631
+ const bound = (isNegative ? value.neg() : value).div(scale);
632
+ const isInt = manager.isInt(inputLeft);
633
+ if (!isInt || bound.isInt())
634
+ return this.mkAtom(product, manager.mkNumeralOfSort(bound, manager.sorts[inputLeft]), kind);
635
+ if (kind === KIND_EQ) return manager.falseExpr;
636
+ return this.mkAtom(
637
+ product,
638
+ manager.mkNumeral(kind === KIND_LE ? bound.floor().num : bound.ceil().num),
639
+ kind,
640
+ );
641
+ }
642
+ const isSwapped = manager.getOp(inputRight) === OP_MOD;
643
+ const left = isSwapped ? inputRight : inputLeft;
644
+ const right = isSwapped ? inputLeft : inputRight;
645
+ const kind = isSwapped ? getInverse(inputKind) : inputKind;
646
+ if (manager.getNumeral(right) === undefined || manager.getOp(left) !== OP_MOD) return undefined;
647
+ const divisor = manager.getArg(left, 1);
648
+ if (!this.manager.isNumeral(divisor) || this.manager.getNumeralValue(divisor) === 0n)
649
+ return undefined;
650
+ const value = this.manager.getNumeralValue(right);
651
+ const divisorValue = this.manager.getNumeralValue(divisor);
652
+ const modulus = divisorValue < 0n ? -divisorValue : divisorValue;
653
+ if (value < 0n) return kind === KIND_GE ? manager.trueExpr : manager.falseExpr;
654
+ if (value === 0n && kind === KIND_GE) return manager.trueExpr;
655
+ if (value > 0n && value >= modulus)
656
+ return kind === KIND_LE ? manager.trueExpr : manager.falseExpr;
657
+ if (value + 1n === modulus && kind === KIND_LE) return manager.trueExpr;
658
+ return undefined;
659
+ }
660
+
661
+ // div_polynomial: the quotient, with a reference the caller owns, or undefined when a constant is
662
+ // not divisible and the atom is an equality. new_args is an expr_ref_buffer, which Z3 releases
663
+ // first to last as it returns.
664
+ private dividePolynomial(expr: number, divisor: bigint, rounding: "floor" | "ceil" | "none") {
665
+ const manager = this.manager;
666
+ const newArgs: number[] = [];
667
+ const pushArg = (arg: number) => {
668
+ manager.incRef(arg);
669
+ newArgs.push(arg);
670
+ };
671
+ const quotient = manager.withoutTemporaries(() => {
672
+ for (let index = 0; index < this.getNumMonomials(expr); index++) {
673
+ const arg = this.getMonomial(expr, index);
674
+ if (manager.isNumeral(arg)) {
675
+ const value = manager.getNumeralValue(arg);
676
+ const isDivisible = value % divisor === 0n;
677
+ if (!isDivisible && rounding === "none") return undefined;
678
+ const rounded =
679
+ isDivisible || rounding === "floor"
680
+ ? getEuclideanDiv(value, divisor)
681
+ : getCeilDiv(value, divisor);
682
+ if (rounded !== 0n) pushArg(manager.mkNumeral(rounded));
683
+ continue;
684
+ }
685
+ const coefficient = this.getCoefficient(arg).num / divisor;
686
+ const product = this.getPowerProduct(arg);
687
+ if (coefficient === 1n) pushArg(product);
688
+ else if (coefficient !== 0n)
689
+ pushArg(manager.mkApp(OP_MUL, [manager.mkNumeral(coefficient), product], SORT_INT));
690
+ }
691
+ return this.mkAddApp(newArgs);
692
+ });
693
+ if (quotient !== undefined) manager.incRef(quotient);
694
+ for (const arg of newArgs) manager.decRef(arg);
695
+ return quotient;
696
+ }
697
+
698
+ // get_coeffs_gcd: the gcd of the coefficients, or 0 when there is no monomial, and the number of
699
+ // non-zero constants.
700
+ private getCoeffsGcd(expr: number, state: GcdState) {
701
+ for (let index = 0; index < this.getNumMonomials(expr); index++) {
702
+ const arg = this.getMonomial(expr, index);
703
+ if (this.manager.isNumeral(arg)) {
704
+ if (this.manager.getNumeralValue(arg) !== 0n) state.numConsts++;
705
+ continue;
706
+ }
707
+ state.gcd = state.isFirst
708
+ ? this.getCoefficient(arg).num
709
+ : getGcd(this.getCoefficient(arg).num, state.gcd);
710
+ state.isFirst = false;
711
+ if (state.gcd === 1n) return;
712
+ }
713
+ }
714
+
715
+ private isHolding(left: Rational, right: Rational, kind: number) {
716
+ const comparison = left.compare(right);
717
+ return kind === KIND_LE
718
+ ? comparison <= 0
719
+ : kind === KIND_GE
720
+ ? comparison >= 0
721
+ : comparison === 0;
722
+ }
723
+
724
+ // mk_le_ge_eq_core. Z3 holds the rewritten sides, new_arg1 and new_arg2, until it returns.
725
+ private mkLeGeEq(originalLeft: number, originalRight: number, kind: number) {
726
+ const manager = this.manager;
727
+ const sides: number[] = [];
728
+ const result = this.mkLeGeEqCore(originalLeft, originalRight, kind, sides);
729
+ for (let index = sides.length - 1; index >= 0; index--) manager.decRef(sides[index]);
730
+ return result;
731
+ }
732
+
733
+ private mkLeGeEqCore(
734
+ originalLeft: number,
735
+ originalRight: number,
736
+ kind: number,
737
+ sides: number[],
738
+ ): number | Rewrite | undefined {
739
+ const manager = this.manager;
740
+ this.currSort = manager.sorts[originalLeft];
741
+ const setSide = (index: number, expr: number) => {
742
+ manager.incRef(expr);
743
+ if (index < sides.length) manager.decRef(sides[index]);
744
+ sides[index] = expr;
745
+ };
746
+ const cancelled = manager.withTemporaries(
747
+ () => this.cancelMonomials(originalLeft, originalRight, this.options.isArithIneqLhs),
748
+ (result) => (result === undefined ? [] : [result.lhs, result.rhs]),
749
+ );
750
+ if (cancelled !== undefined) sides.push(cancelled.lhs, cancelled.rhs);
751
+ let isChanged = cancelled !== undefined;
752
+ let left = cancelled === undefined ? originalLeft : cancelled.lhs;
753
+ let right = cancelled === undefined ? originalRight : cancelled.rhs;
754
+ if (this.manager.isNumeral(left) && this.manager.isNumeral(right))
755
+ return this.isHolding(this.getValue(left), this.getValue(right), kind)
756
+ ? manager.trueExpr
757
+ : manager.falseExpr;
758
+ const separated = this.getSeparated(left, right, kind);
759
+ if (separated !== undefined) return separated;
760
+ const bound = this.getBound(left, right, kind) ?? this.getBound(right, left, getInverse(kind));
761
+ if (bound !== undefined) return bound;
762
+ if (manager.isInt(left) && this.options.isGcdRounding) {
763
+ const state = { gcd: 0n, isFirst: true, numConsts: 0 };
764
+ this.getCoeffsGcd(left, state);
765
+ if ((state.isFirst || state.gcd !== 1n) && state.numConsts <= 1)
766
+ this.getCoeffsGcd(right, state);
767
+ const divisor = state.gcd < 0n ? -state.gcd : state.gcd;
768
+ if (!state.isFirst && divisor !== 1n && state.numConsts <= 1) {
769
+ const newLeft = this.dividePolynomial(
770
+ left,
771
+ divisor,
772
+ kind === KIND_LE ? "ceil" : kind === KIND_GE ? "floor" : "none",
773
+ );
774
+ if (newLeft === undefined) return manager.falseExpr;
775
+ setSide(0, newLeft);
776
+ manager.decRef(newLeft);
777
+ const newRight = this.dividePolynomial(
778
+ right,
779
+ divisor,
780
+ kind === KIND_LE ? "floor" : kind === KIND_GE ? "ceil" : "none",
781
+ );
782
+ if (newRight === undefined) return manager.falseExpr;
783
+ setSide(1, newRight);
784
+ manager.decRef(newRight);
785
+ left = newLeft;
786
+ right = newRight;
787
+ isChanged = true;
788
+ }
789
+ }
790
+ if (manager.getOp(left) === OP_ITE && this.manager.isNumeral(right)) {
791
+ const condition = manager.getArg(left, 0);
792
+ const rightValue = this.getValue(right);
793
+ const holds = (value: Rational) => this.isHolding(value, rightValue, kind);
794
+ // Z3 makes the negated condition before it knows whether the result uses it, and its
795
+ // conjunctions build an equality with arith_util::mk_eq but its disjunctions with m.mk_eq.
796
+ const mkConjunct = (other: number) =>
797
+ kind === KIND_EQ ? this.mkArithEq(other, right) : this.mkAtom(other, right, kind);
798
+ if (this.manager.isNumeral(manager.getArg(left, 1))) {
799
+ const negated = manager.mkNot(condition);
800
+ return this.reduce(
801
+ holds(this.getValue(manager.getArg(left, 1)))
802
+ ? manager.mkOr([condition, this.mkAtom(manager.getArg(left, 2), right, kind)])
803
+ : manager.mkAnd([negated, mkConjunct(manager.getArg(left, 2))]),
804
+ 2,
805
+ );
806
+ }
807
+ if (this.manager.isNumeral(manager.getArg(left, 2))) {
808
+ const negated = manager.mkNot(condition);
809
+ return this.reduce(
810
+ holds(this.getValue(manager.getArg(left, 2)))
811
+ ? manager.mkOr([negated, this.mkAtom(manager.getArg(left, 1), right, kind)])
812
+ : manager.mkAnd([condition, mkConjunct(manager.getArg(left, 1))]),
813
+ 2,
814
+ );
815
+ }
816
+ }
817
+ const isToIntRight = manager.getOp(right) === OP_TO_INT && manager.isNumeral(left);
818
+ const toIntArg =
819
+ manager.getOp(isToIntRight ? right : left) === OP_TO_INT
820
+ ? manager.getArg(isToIntRight ? right : left, 0)
821
+ : undefined;
822
+ const toIntBound = isToIntRight ? left : right;
823
+ if (toIntArg !== undefined && manager.isNumeral(toIntBound)) {
824
+ const toIntKind = isToIntRight ? getInverse(kind) : kind;
825
+ const value = this.getValue(toIntBound);
826
+ const mkLower = () =>
827
+ manager.mkApp(OP_GE, [toIntArg, manager.mkRealNumeral(value)], SORT_BOOL);
828
+ const mkUpper = () =>
829
+ manager.mkApp(OP_LT, [toIntArg, manager.mkRealNumeral(value.add(Rational.one))], SORT_BOOL);
830
+ if (toIntKind === KIND_LE) return this.reduce(mkUpper(), 1);
831
+ if (toIntKind === KIND_GE) return this.reduce(mkLower(), 1);
832
+ const lower = mkLower();
833
+ return this.reduce(manager.mkAnd([mkUpper(), lower]), 3);
834
+ }
835
+ const negated =
836
+ this.options.isArithIneqLhs && this.manager.isNumeral(right)
837
+ ? this.getNegatedPolynomial(left)
838
+ : undefined;
839
+ if (negated !== undefined) {
840
+ setSide(0, negated);
841
+ const negatedRight = this.mkNumeral(this.getValue(right).neg());
842
+ setSide(1, negatedRight);
843
+ return this.mkAtom(negated, negatedRight, getInverse(kind));
844
+ }
845
+ if (isChanged && left === originalLeft && right === originalRight) return undefined;
846
+ if (isChanged) return this.mkAtom(left, right, kind);
847
+ return this.factorLeGeEq(left, right, kind);
848
+ }
849
+
850
+ // factor_le_ge_eq: a sum with a nonlinear factor f, fg >= 0, splits on the signs of f and g.
851
+ private factorLeGeEq(left: number, right: number, kind: number) {
852
+ if (!this.isZero(right)) return undefined;
853
+ const factor = this.findNlFactor(left);
854
+ if (factor === undefined) return undefined;
855
+ const manager = this.manager;
856
+ const rest = this.removeNlFactor(factor, left);
857
+ const zero = manager.mkNumeralOfSort(Rational.zero, manager.sorts[left]);
858
+ const factorEq = this.mkArithEq(factor, zero);
859
+ const restEq = this.mkArithEq(rest, zero);
860
+ const isZeroProduct = manager.mkOr([factorEq, restEq]);
861
+ if (kind === KIND_EQ) return this.reduce(isZeroProduct, 3);
862
+ const factorGe = manager.mkApp(OP_GE, [factor, zero], SORT_BOOL);
863
+ const restGe = manager.mkApp(OP_GE, [rest, zero], SORT_BOOL);
864
+ const isSameSign = manager.mkEq(factorGe, restGe);
865
+ return this.reduce(
866
+ manager.mkOr([kind === KIND_GE ? isSameSign : manager.mkNot(isSameSign), isZeroProduct]),
867
+ 3,
868
+ );
869
+ }
870
+
871
+ // arith_util::mk_eq: a numeral goes right, and otherwise the side with the smaller id goes left.
872
+ private mkArithEq(left: number, right: number) {
873
+ const manager = this.manager;
874
+ const isSwapped =
875
+ manager.isNumeral(left) ||
876
+ (!manager.isNumeral(right) && manager.ids[left] > manager.ids[right]);
877
+ const lhs = isSwapped ? right : left;
878
+ const rhs = isSwapped ? left : right;
879
+ if (lhs === rhs) return manager.trueExpr;
880
+ if (manager.isNumeral(lhs) && manager.isNumeral(rhs)) return manager.falseExpr;
881
+ return manager.mkEq(lhs, rhs);
882
+ }
883
+
884
+ // find_nl_factor: a factor of the first nonlinear product of a sum that divides every monomial.
885
+ private findNlFactor(expr: number) {
886
+ const sum = [expr];
887
+ for (let index = 0; index < sum.length; index++) {
888
+ const arg = sum[index];
889
+ if (this.isAdd(arg)) {
890
+ this.manager.pushArgs(arg, sum);
891
+ continue;
892
+ }
893
+ if (!this.isMul(arg)) continue;
894
+ const muls: number[] = [];
895
+ this.getNlMuls(arg, muls);
896
+ if (muls.length <= 1) continue;
897
+ return muls.find((mul) => this.isAddFactor(mul, expr));
898
+ }
899
+ return undefined;
900
+ }
901
+
902
+ // get_nl_muls: the factors of a product that are not numerals.
903
+ private getNlMuls(expr: number, muls: number[]) {
904
+ if (this.isMul(expr))
905
+ for (let index = 0; index < this.manager.getNumArgs(expr); index++)
906
+ this.getNlMuls(this.manager.getArg(expr, index), muls);
907
+ else if (!this.manager.isNumeral(expr)) muls.push(expr);
908
+ }
909
+
910
+ private isMulFactor(factor: number, expr: number): boolean {
911
+ if (this.isMul(expr)) return this.manager.someArg(expr, (arg) => this.isMulFactor(factor, arg));
912
+ return factor === expr;
913
+ }
914
+
915
+ private isAddFactor(factor: number, expr: number): boolean {
916
+ if (this.isAdd(expr))
917
+ return this.manager.everyArg(expr, (arg) => this.isAddFactor(factor, arg));
918
+ return this.isMulFactor(factor, expr);
919
+ }
920
+
921
+ // remove_factor: the sum or product without one occurrence of the factor in each monomial.
922
+ private removeNlFactor(factor: number, expr: number): number {
923
+ const manager = this.manager;
924
+ const sort = manager.sorts[expr];
925
+ if (this.isMul(expr)) {
926
+ const rest = [expr];
927
+ for (let index = 0; index < rest.length; index++) {
928
+ const arg = rest[index];
929
+ if (this.isMul(arg)) {
930
+ manager.pushArgs(arg, rest);
931
+ rest[index] = rest[rest.length - 1];
932
+ rest.pop();
933
+ index--;
934
+ continue;
935
+ }
936
+ if (arg === factor) {
937
+ rest[index] = rest[rest.length - 1];
938
+ rest.pop();
939
+ break;
940
+ }
941
+ }
942
+ if (rest.length === 0) return manager.mkNumeralOfSort(Rational.one, sort);
943
+ return rest.length === 1 ? rest[0] : manager.mkApp(OP_MUL, rest, sort);
944
+ }
945
+ if (this.isAdd(expr)) {
946
+ const sum = [expr];
947
+ for (let index = 0; index < sum.length; index++) {
948
+ const arg = sum[index];
949
+ if (this.isAdd(arg)) {
950
+ manager.pushArgs(arg, sum);
951
+ sum[index] = sum[sum.length - 1];
952
+ sum.pop();
953
+ index--;
954
+ continue;
955
+ }
956
+ sum[index] = this.removeNlFactor(factor, arg);
957
+ }
958
+ return sum.length === 1 ? sum[0] : manager.mkApp(OP_ADD, sum, sort);
959
+ }
960
+ return manager.mkNumeralOfSort(Rational.one, sort);
961
+ }
962
+ }