tla-ts 0.0.4-dev.2be6058 → 0.0.4-dev.43f28be

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 (313) hide show
  1. package/README.md +27 -141
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +37 -1
  6. package/dist/index.d.ts +37 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +996 -0
  15. package/dist/prove.js +996 -0
  16. package/dist/run-cli.cjs +517 -47
  17. package/dist/run-cli.js +517 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +26 -7
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +255 -56
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  35. package/src/{obligation-format.ts → obligations/format.ts} +6 -5
  36. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  37. package/src/{obligations.ts → obligations/index.ts} +28 -12
  38. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  39. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  40. package/src/obligations/pickle.ts +100 -0
  41. package/src/obligations/pragma.ts +189 -0
  42. package/src/{obligation-printer.ts → obligations/printer.ts} +9 -63
  43. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  44. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  45. package/src/obligations/temporal.ts +319 -0
  46. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  47. package/src/ocaml-marshal.ts +166 -0
  48. package/src/parallel-worker.ts +2 -18
  49. package/src/parallel.ts +10 -43
  50. package/src/prove/decide-pool.ts +100 -0
  51. package/src/prove/deciders.ts +33 -0
  52. package/src/prove/isabelle/LICENSE +36 -0
  53. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  54. package/src/prove/isabelle/decide.ts +47 -0
  55. package/src/prove/isabelle/encode.ts +508 -0
  56. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  57. package/src/prove/isabelle/isar/method.ts +367 -0
  58. package/src/prove/isabelle/isar/proof.ts +28 -0
  59. package/src/prove/isabelle/isar/statement.ts +57 -0
  60. package/src/prove/isabelle/isar/theory.ts +192 -0
  61. package/src/prove/isabelle/isar/type-check.ts +278 -0
  62. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  63. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  64. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  65. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  66. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  67. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  68. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  69. package/src/prove/isabelle/provers/classical.ts +389 -0
  70. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  71. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  72. package/src/prove/isabelle/pure/consts.ts +32 -0
  73. package/src/prove/isabelle/pure/conv.ts +79 -0
  74. package/src/prove/isabelle/pure/drule.ts +264 -0
  75. package/src/prove/isabelle/pure/envir.ts +363 -0
  76. package/src/prove/isabelle/pure/goal.ts +53 -0
  77. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  78. package/src/prove/isabelle/pure/list.ts +12 -0
  79. package/src/prove/isabelle/pure/logic.ts +402 -0
  80. package/src/prove/isabelle/pure/name.ts +110 -0
  81. package/src/prove/isabelle/pure/net.ts +262 -0
  82. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  83. package/src/prove/isabelle/pure/pattern.ts +650 -0
  84. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  85. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  86. package/src/prove/isabelle/pure/search.ts +68 -0
  87. package/src/prove/isabelle/pure/seq.ts +156 -0
  88. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  89. package/src/prove/isabelle/pure/table.ts +208 -0
  90. package/src/prove/isabelle/pure/tactic.ts +276 -0
  91. package/src/prove/isabelle/pure/tactical.ts +347 -0
  92. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  93. package/src/prove/isabelle/pure/term.ts +808 -0
  94. package/src/prove/isabelle/pure/thm.ts +806 -0
  95. package/src/prove/isabelle/pure/type.ts +133 -0
  96. package/src/prove/isabelle/pure/unify.ts +753 -0
  97. package/src/prove/isabelle/pure/variable.ts +25 -0
  98. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  99. package/src/prove/isabelle/tla/context.ts +74 -0
  100. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  101. package/src/prove/isabelle/tla/logic.ts +215 -0
  102. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  103. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  104. package/src/prove/ocaml.ts +22 -0
  105. package/src/prove/prep/action.ts +520 -0
  106. package/src/prove/prep/defs.ts +33 -0
  107. package/src/prove/prep/elab.ts +156 -0
  108. package/src/prove/prep/enabled-axioms.ts +189 -0
  109. package/src/prove/prep/enabled.ts +43 -0
  110. package/src/prove/prep/fingerprint.ts +388 -0
  111. package/src/prove/prep/flatten.ts +70 -0
  112. package/src/prove/prep/level-comparison.ts +552 -0
  113. package/src/prove/prep/md5.ts +67 -0
  114. package/src/prove/prep/pragma.ts +221 -0
  115. package/src/prove/prep/trivial.ts +22 -0
  116. package/src/prove/prove-worker.ts +27 -0
  117. package/src/prove/prove.ts +518 -0
  118. package/src/prove/ptl/decide.ts +68 -0
  119. package/src/prove/ptl/encode.ts +256 -0
  120. package/src/prove/ptl/sat.ts +151 -0
  121. package/src/prove/ptl/tableau.ts +276 -0
  122. package/src/prove/smt/axiomatize.ts +69 -0
  123. package/src/prove/smt/axioms.ts +210 -0
  124. package/src/prove/smt/context.ts +108 -0
  125. package/src/prove/smt/data.ts +665 -0
  126. package/src/prove/smt/encode.ts +169 -0
  127. package/src/prove/smt/extensionality.ts +63 -0
  128. package/src/prove/smt/flatten.ts +127 -0
  129. package/src/prove/smt/format.ts +143 -0
  130. package/src/prove/smt/instances.ts +182 -0
  131. package/src/prove/smt/rewrite.ts +784 -0
  132. package/src/prove/smt/simplify.ts +57 -0
  133. package/src/prove/smt/solver/act-cache.ts +265 -0
  134. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  135. package/src/prove/smt/solver/array.ts +22 -0
  136. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  137. package/src/prove/smt/solver/ast-lt.ts +157 -0
  138. package/src/prove/smt/solver/ast-util.ts +147 -0
  139. package/src/prove/smt/solver/ast.ts +1315 -0
  140. package/src/prove/smt/solver/auf-solver.ts +572 -0
  141. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  142. package/src/prove/smt/solver/cg-table.ts +175 -0
  143. package/src/prove/smt/solver/clause.ts +276 -0
  144. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  145. package/src/prove/smt/solver/context.ts +1292 -0
  146. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  147. package/src/prove/smt/solver/der.ts +224 -0
  148. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  149. package/src/prove/smt/solver/e-matching.ts +659 -0
  150. package/src/prove/smt/solver/enode.ts +259 -0
  151. package/src/prove/smt/solver/expr-ref.ts +21 -0
  152. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  153. package/src/prove/smt/solver/fingerprints.ts +92 -0
  154. package/src/prove/smt/solver/flat-literals.ts +51 -0
  155. package/src/prove/smt/solver/goal.ts +138 -0
  156. package/src/prove/smt/solver/hash.ts +173 -0
  157. package/src/prove/smt/solver/hashtable.ts +166 -0
  158. package/src/prove/smt/solver/internalizer.ts +1381 -0
  159. package/src/prove/smt/solver/lbool.ts +5 -0
  160. package/src/prove/smt/solver/literal.ts +24 -0
  161. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  162. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  163. package/src/prove/smt/solver/lp/containers.ts +296 -0
  164. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  165. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  166. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  167. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  168. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  169. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  170. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  171. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  172. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  173. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  174. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  175. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  176. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  177. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  178. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  179. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  180. package/src/prove/smt/solver/lp/nex.ts +120 -0
  181. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  182. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  183. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  184. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  185. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  186. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  187. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  188. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  189. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  190. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  191. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  192. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  193. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  194. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  195. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  196. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  197. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  198. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  199. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  200. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  201. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  202. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  203. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  204. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  205. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  206. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  207. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  208. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  209. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  210. package/src/prove/smt/solver/model-checker.ts +347 -0
  211. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  212. package/src/prove/smt/solver/model-finder.ts +155 -0
  213. package/src/prove/smt/solver/model-generator.ts +97 -0
  214. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  215. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  216. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  217. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  218. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  219. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  220. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  221. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  222. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  223. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  224. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  225. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  226. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  227. package/src/prove/smt/solver/nnf.ts +469 -0
  228. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  229. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  230. package/src/prove/smt/solver/propagate-values.ts +83 -0
  231. package/src/prove/smt/solver/proto-model.ts +551 -0
  232. package/src/prove/smt/solver/pull-quant.ts +139 -0
  233. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  234. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  235. package/src/prove/smt/solver/qe-lite.ts +381 -0
  236. package/src/prove/smt/solver/qi-queue.ts +362 -0
  237. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  238. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  239. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  240. package/src/prove/smt/solver/random-gen.ts +10 -0
  241. package/src/prove/smt/solver/rational.ts +165 -0
  242. package/src/prove/smt/solver/ref-vector.ts +62 -0
  243. package/src/prove/smt/solver/relevancy.ts +247 -0
  244. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  245. package/src/prove/smt/solver/rewriter.ts +843 -0
  246. package/src/prove/smt/solver/rlimit.ts +79 -0
  247. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  248. package/src/prove/smt/solver/solver.ts +71 -0
  249. package/src/prove/smt/solver/sort.ts +35 -0
  250. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  251. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  252. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  253. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  254. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  255. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  256. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  257. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  258. package/src/prove/smt/solver/theory-lra.ts +56 -0
  259. package/src/prove/smt/solver/var-subst.ts +258 -0
  260. package/src/prove/smt/solver/z3-license.txt +10 -0
  261. package/src/prove/smt/table.ts +170 -0
  262. package/src/prove/tlapm/tlapm.ts +97 -0
  263. package/src/prove/tlaps-module.ts +510 -0
  264. package/src/prove/verdict.ts +18 -0
  265. package/src/prove/zenon/LICENSE +32 -0
  266. package/src/prove/zenon/check/check.ts +105 -0
  267. package/src/prove/zenon/check/definitions.ts +144 -0
  268. package/src/prove/zenon/check/equality.ts +182 -0
  269. package/src/prove/zenon/check/functions.ts +62 -0
  270. package/src/prove/zenon/check/keys.ts +125 -0
  271. package/src/prove/zenon/check/propositional.ts +104 -0
  272. package/src/prove/zenon/check/records.ts +188 -0
  273. package/src/prove/zenon/check/relations.ts +121 -0
  274. package/src/prove/zenon/check/rewrites.ts +224 -0
  275. package/src/prove/zenon/check/sets.ts +302 -0
  276. package/src/prove/zenon/check/terms.ts +127 -0
  277. package/src/prove/zenon/check/tla.ts +126 -0
  278. package/src/prove/zenon/decide.ts +113 -0
  279. package/src/prove/zenon/encode.ts +444 -0
  280. package/src/prove/zenon/eqrel.ts +300 -0
  281. package/src/prove/zenon/equality-rules.ts +435 -0
  282. package/src/prove/zenon/expr.ts +551 -0
  283. package/src/prove/zenon/index-table.ts +350 -0
  284. package/src/prove/zenon/isar-case.ts +513 -0
  285. package/src/prove/zenon/isar.ts +1249 -0
  286. package/src/prove/zenon/limits.ts +15 -0
  287. package/src/prove/zenon/llproof.ts +173 -0
  288. package/src/prove/zenon/mltoll.ts +1566 -0
  289. package/src/prove/zenon/node.ts +297 -0
  290. package/src/prove/zenon/ocaml.ts +169 -0
  291. package/src/prove/zenon/parse.ts +247 -0
  292. package/src/prove/zenon/phrase.ts +191 -0
  293. package/src/prove/zenon/proof.ts +198 -0
  294. package/src/prove/zenon/propositional-rules.ts +387 -0
  295. package/src/prove/zenon/rules.ts +94 -0
  296. package/src/prove/zenon/search.ts +288 -0
  297. package/src/prove/zenon/tla/functions.ts +151 -0
  298. package/src/prove/zenon/tla/llproof.ts +480 -0
  299. package/src/prove/zenon/tla/records.ts +225 -0
  300. package/src/prove/zenon/tla/rewrites.ts +447 -0
  301. package/src/prove/zenon/tla/sets.ts +304 -0
  302. package/src/prove/zenon/tla/terms.ts +181 -0
  303. package/src/prove/zenon/tla/tla.ts +506 -0
  304. package/src/run-cli.ts +338 -62
  305. package/src/standard-modules.ts +5 -2
  306. package/src/successors.ts +25 -6
  307. package/src/tlapm-cache.ts +244 -0
  308. package/src/tlc-random.ts +55 -32
  309. package/src/tlc-version.ts +8 -7
  310. package/src/values.ts +97 -47
  311. package/src/worker.ts +65 -0
  312. package/dist/parallel.cjs +0 -12
  313. package/dist/parallel.js +0 -12
@@ -0,0 +1,477 @@
1
+ // Ported from Z3 (src/ast/rewriter/poly_rewriter.h, poly_rewriter_def.h), MIT license, see
2
+ // z3-license.txt. The rewrites of sums and products of monomials, which arith_rewriter extends.
3
+ // Powers are not ported, as tlapm's encoding does not produce them.
4
+ import {
5
+ AstManager,
6
+ KIND_APP,
7
+ OP_ABS,
8
+ OP_ADD,
9
+ OP_DIV,
10
+ OP_GE,
11
+ OP_GT,
12
+ OP_IDIV,
13
+ OP_IS_INT,
14
+ OP_LE,
15
+ OP_LT,
16
+ OP_MOD,
17
+ OP_MUL,
18
+ OP_NUM,
19
+ OP_SUB,
20
+ OP_TO_INT,
21
+ OP_TO_REAL,
22
+ OP_UMINUS,
23
+ SORT_INT,
24
+ } from "./ast";
25
+ import { Rational } from "./rational";
26
+ import type { Rewrite } from "./rewriter-tpl";
27
+
28
+ export interface ArithRewriterOptions {
29
+ // poly_rewriter's som: distributes products over sums.
30
+ readonly isSom: boolean;
31
+ // arith_rewriter's sort_sums: orders the monomials of a sum.
32
+ readonly isSortSums: boolean;
33
+ // arith_rewriter's arith_ineq_lhs: moves the monomials of an inequality to the left-hand side.
34
+ readonly isArithIneqLhs: boolean;
35
+ // arith_rewriter's gcd_rounding: divides integer atoms by the gcd of their coefficients.
36
+ readonly isGcdRounding: boolean;
37
+ }
38
+
39
+ const ARITH_OPS: ReadonlySet<number> = new Set([
40
+ OP_NUM,
41
+ OP_ADD,
42
+ OP_SUB,
43
+ OP_UMINUS,
44
+ OP_MUL,
45
+ OP_IDIV,
46
+ OP_MOD,
47
+ OP_ABS,
48
+ OP_LE,
49
+ OP_GE,
50
+ OP_LT,
51
+ OP_GT,
52
+ OP_DIV,
53
+ OP_TO_REAL,
54
+ OP_TO_INT,
55
+ OP_IS_INT,
56
+ ]);
57
+
58
+ export class PolyRewriter {
59
+ // m_curr_sort: the sort of the numerals and terms that the current rewrite makes.
60
+ protected currSort = SORT_INT;
61
+ // The expr_fast_mark1 and expr_fast_mark2 of mk_nflat_add_core: Z3 marks the power products in
62
+ // their nodes, and a stamp per expression marks them here for one call.
63
+ private visitedStamps = new Int32Array(0);
64
+ private multipleStamps = new Int32Array(0);
65
+ private stamp = 0;
66
+
67
+ constructor(
68
+ protected manager: AstManager,
69
+ protected options: ArithRewriterOptions,
70
+ ) {}
71
+
72
+ protected reduce(expr: number, depth: number): Rewrite {
73
+ return { expr, depth };
74
+ }
75
+
76
+ protected isZero(expr: number) {
77
+ return this.manager.isNumeral(expr) && this.getValue(expr).isZero();
78
+ }
79
+
80
+ // The value of a numeral of either sort.
81
+ protected getValue(expr: number) {
82
+ return this.manager.getRationalValue(expr);
83
+ }
84
+
85
+ protected mkNumeral(value: Rational) {
86
+ return this.manager.mkNumeralOfSort(value, this.currSort);
87
+ }
88
+
89
+ protected isAdd(expr: number) {
90
+ return this.manager.getOp(expr) === OP_ADD;
91
+ }
92
+
93
+ protected isMul(expr: number) {
94
+ return this.manager.getOp(expr) === OP_MUL;
95
+ }
96
+
97
+ protected isArithTerm(expr: number) {
98
+ return this.manager.kinds[expr] === KIND_APP && ARITH_OPS.has(this.manager.getOp(expr));
99
+ }
100
+
101
+ // get_monomials: the summands of a sum, and otherwise the term itself.
102
+ protected getNumMonomials(expr: number) {
103
+ return this.isAdd(expr) ? this.manager.getNumArgs(expr) : 1;
104
+ }
105
+
106
+ protected getMonomial(expr: number, index: number) {
107
+ return this.isAdd(expr) ? this.manager.getArg(expr, index) : expr;
108
+ }
109
+
110
+ // get_power_product: the monomial without its coefficient.
111
+ protected getPowerProduct(expr: number) {
112
+ return this.isMul(expr) &&
113
+ this.manager.getNumArgs(expr) === 2 &&
114
+ this.manager.isNumeral(this.manager.getArg(expr, 0))
115
+ ? this.manager.getArg(expr, 1)
116
+ : expr;
117
+ }
118
+
119
+ protected getCoefficient(expr: number) {
120
+ return this.isMul(expr) &&
121
+ this.manager.getNumArgs(expr) === 2 &&
122
+ this.manager.isNumeral(this.manager.getArg(expr, 0))
123
+ ? this.getValue(this.manager.getArg(expr, 0))
124
+ : Rational.one;
125
+ }
126
+
127
+ // mon_lt::ordinal, without powers.
128
+ protected getOrdinal(expr: number) {
129
+ const manager = this.manager;
130
+ if (manager.kinds[expr] !== KIND_APP || !ARITH_OPS.has(manager.getOp(expr)))
131
+ return manager.ids[expr];
132
+ if (this.isMul(expr)) {
133
+ return manager.ids[
134
+ manager.isNumeral(manager.getArg(expr, 0)) ? manager.getArg(expr, 1) : expr
135
+ ];
136
+ }
137
+ return manager.isNumeral(expr) ? -1 : manager.ids[expr];
138
+ }
139
+
140
+ // std::sort with mon_lt, of the monomials from start, in place. Insertion sort is stable, as
141
+ // Array.prototype.sort is, and allocates nothing for the short sums that are the common case.
142
+ protected sortMonomials(monomials: number[], start: number) {
143
+ for (let index = start + 1; index < monomials.length; index++) {
144
+ const monomial = monomials[index];
145
+ const ordinal = this.getOrdinal(monomial);
146
+ let position = index;
147
+ for (; position > start && this.getOrdinal(monomials[position - 1]) > ordinal; position--)
148
+ monomials[position] = monomials[position - 1];
149
+ monomials[position] = monomial;
150
+ }
151
+ return monomials;
152
+ }
153
+
154
+ mkAddApp(args: number[]) {
155
+ if (args.length === 0) return this.mkNumeral(Rational.zero);
156
+ if (args.length === 1) return args[0];
157
+ return this.manager.mkApp(OP_ADD, args, this.currSort);
158
+ }
159
+
160
+ mkMulApp(args: number[]): number {
161
+ if (args.length === 0) return this.mkNumeral(Rational.one);
162
+ if (args.length === 1) return args[0];
163
+ if (args.length > 2 && this.manager.isNumeral(args[0]))
164
+ return this.mkMulAppWith(this.getValue(args[0]), this.mkMulApp(args.slice(1)));
165
+ return this.manager.mkApp(OP_MUL, args, this.currSort);
166
+ }
167
+
168
+ protected mkMulAppWith(coefficient: Rational, arg: number) {
169
+ if (coefficient.equals(Rational.one) || this.isZero(arg)) return arg;
170
+ return this.mkMulApp([this.mkNumeral(coefficient), arg]);
171
+ }
172
+
173
+ // The rewrites return undefined when they do not apply, like BR_FAILED.
174
+ mkAdd(args: number[]): number | undefined {
175
+ if (args.length < 2) return undefined;
176
+ this.currSort = this.manager.sorts[args[0]];
177
+ if (!args.some((arg) => this.isAdd(arg))) return this.mkNflatAdd(args);
178
+ const flat: number[] = [];
179
+ for (const arg of args) {
180
+ if (this.isAdd(arg)) this.manager.pushArgs(arg, flat);
181
+ else flat.push(arg);
182
+ }
183
+ return this.mkNflatAdd(flat) ?? this.mkAddApp(flat);
184
+ }
185
+
186
+ private mkNflatAdd(args: number[]) {
187
+ const manager = this.manager;
188
+ const isSortSums = this.options.isSortSums;
189
+ let constant = Rational.zero;
190
+ let numCoeffs = 0;
191
+ let isOrdered = true;
192
+ let previous = -1;
193
+ let isMultiple = false;
194
+ const stamp = ++this.stamp;
195
+ for (let index = 0; index < args.length; index++) {
196
+ const arg = args[index];
197
+ if (manager.isNumeral(arg)) {
198
+ numCoeffs++;
199
+ constant = constant.add(this.getValue(arg));
200
+ isOrdered = !isSortSums || index === 0;
201
+ } else if (isSortSums && isOrdered) {
202
+ if (previous !== -1 && this.getOrdinal(arg) < this.getOrdinal(previous)) isOrdered = false;
203
+ previous = arg;
204
+ }
205
+ const product = this.getPowerProduct(arg);
206
+ if (product >= this.visitedStamps.length) this.growStamps(product);
207
+ if (this.visitedStamps[product] === stamp) {
208
+ this.multipleStamps[product] = stamp;
209
+ isMultiple = true;
210
+ } else this.visitedStamps[product] = stamp;
211
+ }
212
+ if (isMultiple) {
213
+ const coeffs = new Map<number, Rational>();
214
+ for (const arg of args) {
215
+ if (manager.isNumeral(arg)) continue;
216
+ const product = this.getPowerProduct(arg);
217
+ if (this.multipleStamps[product] === stamp)
218
+ coeffs.set(product, (coeffs.get(product) ?? Rational.zero).add(this.getCoefficient(arg)));
219
+ }
220
+ const newArgs: number[] = constant.isZero() ? [] : [this.mkNumeral(constant)];
221
+ // visited.reset(): a new stamp marks the power products already copied.
222
+ const copiedStamp = ++this.stamp;
223
+ for (const arg of args) {
224
+ if (manager.isNumeral(arg)) continue;
225
+ const product = this.getPowerProduct(arg);
226
+ if (this.multipleStamps[product] !== stamp) newArgs.push(arg);
227
+ else if (this.visitedStamps[product] !== copiedStamp) {
228
+ this.visitedStamps[product] = copiedStamp;
229
+ const coefficient = coeffs.get(product) ?? Rational.zero;
230
+ if (!coefficient.isZero()) newArgs.push(this.mkMulAppWith(coefficient, product));
231
+ }
232
+ }
233
+ return this.mkAddApp(
234
+ isSortSums ? this.sortMonomials(newArgs, constant.isZero() ? 0 : 1) : newArgs,
235
+ );
236
+ }
237
+ if (isOrdered) {
238
+ if (numCoeffs === 0) return undefined;
239
+ if (numCoeffs === 1 && manager.isNumeral(args[0]) && !this.getValue(args[0]).isZero())
240
+ return undefined;
241
+ }
242
+ const newArgs: number[] = constant.isZero() ? [] : [this.mkNumeral(constant)];
243
+ for (const arg of args) if (!manager.isNumeral(arg)) newArgs.push(arg);
244
+ return this.mkAddApp(
245
+ isOrdered ? newArgs : this.sortMonomials(newArgs, constant.isZero() ? 0 : 1),
246
+ );
247
+ }
248
+
249
+ private growStamps(expr: number) {
250
+ const size = Math.max(2 * this.visitedStamps.length, expr + 1, 1024);
251
+ const visitedStamps = new Int32Array(size);
252
+ visitedStamps.set(this.visitedStamps);
253
+ this.visitedStamps = visitedStamps;
254
+ const multipleStamps = new Int32Array(size);
255
+ multipleStamps.set(this.multipleStamps);
256
+ this.multipleStamps = multipleStamps;
257
+ }
258
+
259
+ mkMul(args: number[]): number | Rewrite | undefined {
260
+ if (args.length < 2) return undefined;
261
+ this.currSort = this.manager.sorts[args[0]];
262
+ const isFlatMonomial =
263
+ args.length === 2 &&
264
+ this.manager.isNumeral(args[0]) &&
265
+ !(this.isMul(args[1]) && this.manager.isNumeral(this.manager.getArg(args[1], 0)));
266
+ if (isFlatMonomial || !args.some((arg) => this.isMul(arg))) return this.mkNflatMul(args);
267
+ const flat: number[] = [];
268
+ const collect = (arg: number) => {
269
+ if (this.isMul(arg))
270
+ for (let index = 0; index < this.manager.getNumArgs(arg); index++)
271
+ collect(this.manager.getArg(arg, index));
272
+ else flat.push(arg);
273
+ };
274
+ for (const arg of args) collect(arg);
275
+ return this.mkNflatMul(flat) ?? this.mkMulApp(flat);
276
+ }
277
+
278
+ private mkNflatMul(args: number[]): number | Rewrite | undefined {
279
+ const manager = this.manager;
280
+ if (
281
+ args.length === 2 &&
282
+ this.manager.isNumeral(args[0]) &&
283
+ !this.getValue(args[0]).equals(Rational.one) &&
284
+ !this.getValue(args[0]).isZero() &&
285
+ !this.isArithTerm(args[1])
286
+ )
287
+ return undefined;
288
+ let coefficient = Rational.one;
289
+ let numCoeffs = 0;
290
+ let numAdd = 0;
291
+ let factor = -1;
292
+ for (const arg of args) {
293
+ if (this.manager.isNumeral(arg)) {
294
+ numCoeffs++;
295
+ coefficient = coefficient.mul(this.getValue(arg));
296
+ } else {
297
+ factor = arg;
298
+ if (this.isAdd(arg)) numAdd++;
299
+ }
300
+ }
301
+ if (numCoeffs === args.length || coefficient.isZero()) return this.mkNumeral(coefficient);
302
+ if (numCoeffs === args.length - 1) {
303
+ if (coefficient.equals(Rational.one)) return factor;
304
+ if (this.isMul(factor)) {
305
+ if (manager.getNumArgs(factor) !== 2 || !this.manager.isNumeral(manager.getArg(factor, 0)))
306
+ return undefined;
307
+ return this.reduce(
308
+ this.mkMulAppWith(
309
+ coefficient.mul(this.getValue(manager.getArg(factor, 0))),
310
+ manager.getArg(factor, 1),
311
+ ),
312
+ 1,
313
+ );
314
+ }
315
+ if (numAdd === 0) {
316
+ if (args.length === 2 && args[1] === factor) return undefined;
317
+ return this.mkMulAppWith(coefficient, factor);
318
+ }
319
+ return this.reduce(
320
+ this.mkAddApp(
321
+ manager.mapArgs(factor, (innerArg) => this.mkMulAppWith(coefficient, innerArg)),
322
+ ),
323
+ 2,
324
+ );
325
+ }
326
+ if (numCoeffs > 1 || (numCoeffs === 1 && !this.manager.isNumeral(args[0])))
327
+ return this.reduce(
328
+ this.mkMulAppWith(
329
+ coefficient,
330
+ this.mkMulApp(args.filter((arg) => !this.manager.isNumeral(arg))),
331
+ ),
332
+ 2,
333
+ );
334
+ if (!this.options.isSom || numAdd === 0) {
335
+ const factors = args.filter((arg) => !this.manager.isNumeral(arg));
336
+ const isOrdered = factors.every(
337
+ (arg, index) => index === 0 || this.getOrdinal(arg) >= this.getOrdinal(factors[index - 1]),
338
+ );
339
+ if (isOrdered && numCoeffs === 0) return undefined;
340
+ const ordered = isOrdered ? factors : this.sortMonomials(factors, 0);
341
+ return this.mkMulAppWith(coefficient, this.mkMulApp(ordered));
342
+ }
343
+ const sums = args.map((arg) => (this.isAdd(arg) ? manager.getArgs(arg) : [arg]));
344
+ const positions = sums.map(() => 0);
345
+ // Like som's expr_ref_buffer, the products are released in order when it returns.
346
+ const products: number[] = [];
347
+ const isBlownUp = manager.withTemporaries(
348
+ () => {
349
+ for (;;) {
350
+ if (products.length > 10 * sums.length) return true;
351
+ products.push(this.mkMulApp(sums.map((sum, index) => sum[positions[index]])));
352
+ let index = 0;
353
+ for (; index < sums.length; index++) {
354
+ positions[index]++;
355
+ if (positions[index] < sums[index].length) break;
356
+ positions[index] = 0;
357
+ }
358
+ if (index === sums.length) return false;
359
+ }
360
+ },
361
+ () => products,
362
+ );
363
+ const result = isBlownUp ? undefined : this.reduce(this.mkAddApp(products), 2);
364
+ for (const product of products) manager.decRef(product);
365
+ return result;
366
+ }
367
+
368
+ mkSub(args: number[]) {
369
+ if (args.length === 1) return args[0];
370
+ this.currSort = this.manager.sorts[args[0]];
371
+ const minusOne = this.mkNumeral(Rational.minusOne);
372
+ const newArgs = [args[0]];
373
+ for (const arg of args.slice(1))
374
+ if (!this.isZero(arg)) newArgs.push(this.mkMulApp([minusOne, arg]));
375
+ return this.reduce(this.mkAddApp(newArgs), 2);
376
+ }
377
+
378
+ mkUminus(arg: number) {
379
+ this.currSort = this.manager.sorts[arg];
380
+ if (this.manager.isNumeral(arg)) return this.mkNumeral(this.getValue(arg).neg());
381
+ return this.reduce(this.mkMulAppWith(Rational.minusOne, arg), 1);
382
+ }
383
+
384
+ // poly_rewriter::cancel_monomials. The stamps stand for its visited, multiple and copied marks.
385
+ protected cancelMonomials(lhs: number, rhs: number, isMoving: boolean) {
386
+ const manager = this.manager;
387
+ this.currSort = manager.sorts[lhs];
388
+ const stamp = ++this.stamp;
389
+ let constant = Rational.zero;
390
+ let numCoeffs = 0;
391
+ for (let index = 0; index < this.getNumMonomials(lhs); index++) {
392
+ const arg = this.getMonomial(lhs, index);
393
+ if (manager.isNumeral(arg)) {
394
+ constant = constant.add(this.getValue(arg));
395
+ numCoeffs++;
396
+ continue;
397
+ }
398
+ const product = this.getPowerProduct(arg);
399
+ if (product >= this.visitedStamps.length) this.growStamps(product);
400
+ this.visitedStamps[product] = stamp;
401
+ }
402
+ if (isMoving && numCoeffs === 0 && manager.isNumeral(rhs)) return undefined;
403
+ let isMultiple = false;
404
+ for (let index = 0; index < this.getNumMonomials(rhs); index++) {
405
+ const arg = this.getMonomial(rhs, index);
406
+ if (manager.isNumeral(arg)) {
407
+ constant = constant.sub(this.getValue(arg));
408
+ numCoeffs++;
409
+ continue;
410
+ }
411
+ const product = this.getPowerProduct(arg);
412
+ if (product < this.visitedStamps.length && this.visitedStamps[product] === stamp) {
413
+ this.multipleStamps[product] = stamp;
414
+ isMultiple = true;
415
+ }
416
+ }
417
+ if (!isMultiple && numCoeffs <= 1) {
418
+ if (isMoving ? manager.isNumeral(rhs) : numCoeffs === 0 || manager.isNumeral(rhs))
419
+ return undefined;
420
+ }
421
+ const isMultipleProduct = (product: number) =>
422
+ product < this.multipleStamps.length && this.multipleStamps[product] === stamp;
423
+ const coeffs = new Map<number, Rational>();
424
+ if (isMultiple) {
425
+ for (let index = 0; index < this.getNumMonomials(lhs); index++) {
426
+ const arg = this.getMonomial(lhs, index);
427
+ if (manager.isNumeral(arg)) continue;
428
+ const product = this.getPowerProduct(arg);
429
+ if (isMultipleProduct(product))
430
+ coeffs.set(product, (coeffs.get(product) ?? Rational.zero).add(this.getCoefficient(arg)));
431
+ }
432
+ for (let index = 0; index < this.getNumMonomials(rhs); index++) {
433
+ const arg = this.getMonomial(rhs, index);
434
+ if (manager.isNumeral(arg)) continue;
435
+ const product = this.getPowerProduct(arg);
436
+ if (isMultipleProduct(product))
437
+ coeffs.set(product, (coeffs.get(product) ?? Rational.zero).sub(this.getCoefficient(arg)));
438
+ }
439
+ }
440
+ const newLhs: number[] = [];
441
+ const copiedStamp = ++this.stamp;
442
+ for (let index = 0; index < this.getNumMonomials(lhs); index++) {
443
+ const arg = this.getMonomial(lhs, index);
444
+ if (manager.isNumeral(arg)) continue;
445
+ const product = this.getPowerProduct(arg);
446
+ if (!isMultipleProduct(product)) newLhs.push(arg);
447
+ else if (this.visitedStamps[product] !== copiedStamp) {
448
+ this.visitedStamps[product] = copiedStamp;
449
+ const coefficient = coeffs.get(product) ?? Rational.zero;
450
+ if (!coefficient.isZero()) newLhs.push(this.mkMulAppWith(coefficient, product));
451
+ }
452
+ }
453
+ const newRhs: number[] = [];
454
+ for (let index = 0; index < this.getNumMonomials(rhs); index++) {
455
+ const arg = this.getMonomial(rhs, index);
456
+ if (manager.isNumeral(arg)) continue;
457
+ const product = this.getPowerProduct(arg);
458
+ if (isMultipleProduct(product)) continue;
459
+ if (!isMoving) newRhs.push(arg);
460
+ else {
461
+ const coefficient = this.getCoefficient(arg);
462
+ if (coefficient.equals(Rational.minusOne)) newLhs.push(product);
463
+ else if (!coefficient.isZero())
464
+ newLhs.push(this.mkMulApp([this.mkNumeral(coefficient.neg()), product]));
465
+ }
466
+ }
467
+ const sortedLhs = isMoving && this.options.isSortSums ? this.sortMonomials(newLhs, 0) : newLhs;
468
+ const isConstantAtRhs = isMoving || newRhs.length === 0 || newLhs.length > 0;
469
+ const value = isConstantAtRhs ? constant.neg() : constant;
470
+ const isLhsConstant = !isConstantAtRhs && (sortedLhs.length === 0 || !value.isZero());
471
+ const isRhsConstant = isConstantAtRhs && (newRhs.length === 0 || !value.isZero());
472
+ if (isLhsConstant) sortedLhs.unshift(this.mkNumeral(value));
473
+ if (isRhsConstant) newRhs.unshift(this.mkNumeral(value));
474
+ const lhsResult = this.mkAddApp(sortedLhs);
475
+ return { lhs: lhsResult, rhs: this.mkAddApp(newRhs) };
476
+ }
477
+ }
@@ -0,0 +1,83 @@
1
+ // Ported from Z3 (src/tactic/core/propagate_values_tactic.cpp, src/ast/shared_occs.cpp), MIT license,
2
+ // see z3-license.txt. The propagate-values tactic: a formula that is an atom, a negated atom or an
3
+ // equality with a value rewrites the other formulas, when its atom or term occurs more than once in
4
+ // the goal.
5
+ import { KIND_APP, KIND_QUANTIFIER, OP_EQ, type AstManager } from "./ast";
6
+ import type { Goal } from "./goal";
7
+ import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
8
+
9
+ // The max_rounds parameter's default.
10
+ const MAX_ROUNDS = 4;
11
+
12
+ // goal_shared_occs with atoms tracked: the terms that the goal's formulas reach more than once,
13
+ // quantifier bodies included and patterns excluded.
14
+ const getSharedOccs = (manager: AstManager, forms: number[]) => {
15
+ const visited = new Set<number>();
16
+ const shared = new Set<number>();
17
+ const todo = [...forms];
18
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
19
+ if (visited.has(expr)) {
20
+ shared.add(expr);
21
+ continue;
22
+ }
23
+ visited.add(expr);
24
+ if (manager.kinds[expr] === KIND_APP) manager.pushArgs(expr, todo);
25
+ else if (manager.kinds[expr] === KIND_QUANTIFIER) todo.push(manager.getQuantifier(expr).body);
26
+ }
27
+ return shared;
28
+ };
29
+
30
+ export const propagateValues = (manager: AstManager, goal: Goal) => {
31
+ if (goal.isInconsistent) return;
32
+ const rewriter = new Rewriter(manager, TACTIC_REWRITER_OPTIONS);
33
+ const substitution = new Map<number, number>();
34
+ rewriter.setSubstitution(substitution);
35
+ let occs = getSharedOccs(manager, goal.forms.items);
36
+ let isModified = false;
37
+ // process_current and push_result.
38
+ const process = (index: number) => {
39
+ const current = goal.forms.items[index];
40
+ const isRewriting = substitution.size !== 0;
41
+ const rewritten = isRewriting ? rewriter.rewrite(current) : current;
42
+ if (rewritten !== current) isModified = true;
43
+ goal.update(index, rewritten);
44
+ if (isRewriting) manager.decRef(rewritten);
45
+ if (occs.has(rewritten)) substitution.set(rewritten, manager.trueExpr);
46
+ if (manager.isNot(rewritten) && occs.has(manager.getArg(rewritten, 0)))
47
+ substitution.set(manager.getArg(rewritten, 0), manager.falseExpr);
48
+ if (manager.getOp(rewritten) !== OP_EQ) return;
49
+ if (
50
+ manager.isUniqueValue(manager.getArg(rewritten, 0)) &&
51
+ occs.has(manager.getArg(rewritten, 1))
52
+ )
53
+ substitution.set(manager.getArg(rewritten, 1), manager.getArg(rewritten, 0));
54
+ else if (
55
+ manager.isUniqueValue(manager.getArg(rewritten, 1)) &&
56
+ occs.has(manager.getArg(rewritten, 0))
57
+ )
58
+ substitution.set(manager.getArg(rewritten, 0), manager.getArg(rewritten, 1));
59
+ };
60
+ // Each pass is a round: a forward pass, which stops when it found nothing, then a backward pass,
61
+ // which stops when it changed nothing.
62
+ for (let round = 0; round < MAX_ROUNDS; round += 2) {
63
+ const size = goal.forms.size;
64
+ for (let index = 0; index < size; index++) {
65
+ process(index);
66
+ if (goal.isInconsistent) return;
67
+ }
68
+ if (substitution.size === 0 && !isModified) break;
69
+ occs = getSharedOccs(manager, goal.forms.items);
70
+ substitution.clear();
71
+ rewriter.setSubstitution(substitution);
72
+ for (let index = goal.forms.size - 1; index >= 0; index--) {
73
+ process(index);
74
+ if (goal.isInconsistent) return;
75
+ }
76
+ if (!isModified) break;
77
+ substitution.clear();
78
+ rewriter.setSubstitution(substitution);
79
+ isModified = false;
80
+ occs = getSharedOccs(manager, goal.forms.items);
81
+ }
82
+ goal.elimRedundancies();
83
+ };