tla-ts 0.0.4-dev.0be9567 → 0.0.4-dev.2a873ee

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 (320) hide show
  1. package/README.md +37 -126
  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 +33 -1
  6. package/dist/index.d.ts +33 -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 +37 -47
  17. package/dist/run-cli.js +37 -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/ast.ts +2 -2
  26. package/src/check.ts +1 -0
  27. package/src/cli-options.ts +1 -1
  28. package/src/errors.ts +88 -29
  29. package/src/evaluate.ts +56 -21
  30. package/src/index.ts +10 -0
  31. package/src/live-check.ts +1 -1
  32. package/src/{obligation-action.ts → obligations/action.ts} +247 -69
  33. package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
  34. package/src/obligations/ctx.ts +64 -0
  35. package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
  36. package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
  37. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  38. package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
  39. package/src/{obligations.ts → obligations/index.ts} +32 -16
  40. package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
  41. package/src/{obligation-module.ts → obligations/module.ts} +113 -121
  42. package/src/obligations/pickle.ts +98 -0
  43. package/src/obligations/pragma.ts +189 -0
  44. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  45. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  46. package/src/{obligation-source.ts → obligations/source.ts} +154 -99
  47. package/src/obligations/temporal.ts +321 -0
  48. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  49. package/src/ocaml-marshal.ts +166 -0
  50. package/src/parallel-worker.ts +2 -18
  51. package/src/parallel.ts +10 -43
  52. package/src/prove/decide-pool.ts +95 -0
  53. package/src/prove/deciders.ts +33 -0
  54. package/src/prove/first-order.ts +78 -0
  55. package/src/prove/isabelle/LICENSE +36 -0
  56. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  57. package/src/prove/isabelle/decide.ts +47 -0
  58. package/src/prove/isabelle/encode.ts +446 -0
  59. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  60. package/src/prove/isabelle/isar/method.ts +367 -0
  61. package/src/prove/isabelle/isar/proof.ts +28 -0
  62. package/src/prove/isabelle/isar/statement.ts +57 -0
  63. package/src/prove/isabelle/isar/theory.ts +192 -0
  64. package/src/prove/isabelle/isar/type-check.ts +278 -0
  65. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  66. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  67. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  68. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  69. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  70. package/src/prove/isabelle/provers/blast/term.ts +546 -0
  71. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  72. package/src/prove/isabelle/provers/classical.ts +389 -0
  73. package/src/prove/isabelle/provers/hypsubst.ts +433 -0
  74. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  75. package/src/prove/isabelle/pure/consts.ts +32 -0
  76. package/src/prove/isabelle/pure/conv.ts +79 -0
  77. package/src/prove/isabelle/pure/drule.ts +264 -0
  78. package/src/prove/isabelle/pure/envir.ts +331 -0
  79. package/src/prove/isabelle/pure/goal.ts +53 -0
  80. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  81. package/src/prove/isabelle/pure/list.ts +12 -0
  82. package/src/prove/isabelle/pure/logic.ts +330 -0
  83. package/src/prove/isabelle/pure/name.ts +98 -0
  84. package/src/prove/isabelle/pure/net.ts +215 -0
  85. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  86. package/src/prove/isabelle/pure/pattern.ts +631 -0
  87. package/src/prove/isabelle/pure/raw-simplifier.ts +338 -0
  88. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  89. package/src/prove/isabelle/pure/search.ts +68 -0
  90. package/src/prove/isabelle/pure/seq.ts +133 -0
  91. package/src/prove/isabelle/pure/simplifier.ts +106 -0
  92. package/src/prove/isabelle/pure/table.ts +201 -0
  93. package/src/prove/isabelle/pure/tactic.ts +168 -0
  94. package/src/prove/isabelle/pure/tactical.ts +264 -0
  95. package/src/prove/isabelle/pure/term-ord.ts +105 -0
  96. package/src/prove/isabelle/pure/term.ts +688 -0
  97. package/src/prove/isabelle/pure/thm.ts +783 -0
  98. package/src/prove/isabelle/pure/type.ts +121 -0
  99. package/src/prove/isabelle/pure/unify.ts +753 -0
  100. package/src/prove/isabelle/pure/variable.ts +25 -0
  101. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  102. package/src/prove/isabelle/tla/context.ts +74 -0
  103. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  104. package/src/prove/isabelle/tla/logic.ts +215 -0
  105. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  106. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  107. package/src/prove/ocaml.ts +22 -0
  108. package/src/prove/prep/action.ts +508 -0
  109. package/src/prove/prep/defs.ts +33 -0
  110. package/src/prove/prep/elab.ts +156 -0
  111. package/src/prove/prep/enabled-axioms.ts +189 -0
  112. package/src/prove/prep/enabled.ts +43 -0
  113. package/src/prove/prep/fingerprint.ts +388 -0
  114. package/src/prove/prep/flatten.ts +70 -0
  115. package/src/prove/prep/level-comparison.ts +529 -0
  116. package/src/prove/prep/md5.ts +67 -0
  117. package/src/prove/prep/pragma.ts +221 -0
  118. package/src/prove/prep/trivial.ts +22 -0
  119. package/src/prove/prove-worker.ts +22 -0
  120. package/src/prove/prove.ts +498 -0
  121. package/src/prove/ptl/decide.ts +68 -0
  122. package/src/prove/ptl/encode.ts +255 -0
  123. package/src/prove/ptl/sat.ts +151 -0
  124. package/src/prove/ptl/tableau.ts +276 -0
  125. package/src/prove/smt/axiomatize.ts +69 -0
  126. package/src/prove/smt/axioms.ts +209 -0
  127. package/src/prove/smt/context.ts +108 -0
  128. package/src/prove/smt/data.ts +636 -0
  129. package/src/prove/smt/encode.ts +164 -0
  130. package/src/prove/smt/extensionality.ts +65 -0
  131. package/src/prove/smt/flatten.ts +112 -0
  132. package/src/prove/smt/format.ts +154 -0
  133. package/src/prove/smt/instances.ts +181 -0
  134. package/src/prove/smt/rewrite.ts +772 -0
  135. package/src/prove/smt/simplify.ts +57 -0
  136. package/src/prove/smt/solver/act-cache.ts +265 -0
  137. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  138. package/src/prove/smt/solver/array.ts +22 -0
  139. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  140. package/src/prove/smt/solver/ast-lt.ts +157 -0
  141. package/src/prove/smt/solver/ast-util.ts +91 -0
  142. package/src/prove/smt/solver/ast.ts +1315 -0
  143. package/src/prove/smt/solver/auf-solver.ts +572 -0
  144. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  145. package/src/prove/smt/solver/cg-table.ts +175 -0
  146. package/src/prove/smt/solver/clause.ts +276 -0
  147. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  148. package/src/prove/smt/solver/context.ts +1292 -0
  149. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  150. package/src/prove/smt/solver/der.ts +224 -0
  151. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  152. package/src/prove/smt/solver/e-matching.ts +659 -0
  153. package/src/prove/smt/solver/enode.ts +259 -0
  154. package/src/prove/smt/solver/expr-ref.ts +21 -0
  155. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  156. package/src/prove/smt/solver/fingerprints.ts +92 -0
  157. package/src/prove/smt/solver/flat-literals.ts +51 -0
  158. package/src/prove/smt/solver/goal.ts +138 -0
  159. package/src/prove/smt/solver/hash.ts +173 -0
  160. package/src/prove/smt/solver/hashtable.ts +166 -0
  161. package/src/prove/smt/solver/internalizer.ts +1381 -0
  162. package/src/prove/smt/solver/lbool.ts +5 -0
  163. package/src/prove/smt/solver/literal.ts +24 -0
  164. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  165. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  166. package/src/prove/smt/solver/lp/containers.ts +296 -0
  167. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  168. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  169. package/src/prove/smt/solver/lp/dep-intervals.ts +642 -0
  170. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  171. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  172. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  173. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  174. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  175. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  176. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  177. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  178. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  179. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  180. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  181. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  182. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  183. package/src/prove/smt/solver/lp/nex.ts +120 -0
  184. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  185. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  186. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  187. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  188. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  189. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  190. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  191. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  192. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  193. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  194. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  195. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  196. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  197. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  198. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  199. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  200. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  201. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  202. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  203. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  204. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  205. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  206. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  207. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  208. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  209. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  210. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  211. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  212. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  213. package/src/prove/smt/solver/model-checker.ts +347 -0
  214. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  215. package/src/prove/smt/solver/model-finder.ts +155 -0
  216. package/src/prove/smt/solver/model-generator.ts +97 -0
  217. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  218. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  219. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  220. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  221. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  222. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  223. package/src/prove/smt/solver/nlsat/levelwise.ts +737 -0
  224. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  225. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  226. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  227. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  228. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  229. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  230. package/src/prove/smt/solver/nnf.ts +469 -0
  231. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  232. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  233. package/src/prove/smt/solver/propagate-values.ts +83 -0
  234. package/src/prove/smt/solver/proto-model.ts +551 -0
  235. package/src/prove/smt/solver/pull-quant.ts +139 -0
  236. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  237. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  238. package/src/prove/smt/solver/qe-lite.ts +381 -0
  239. package/src/prove/smt/solver/qi-queue.ts +362 -0
  240. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  241. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  242. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  243. package/src/prove/smt/solver/random-gen.ts +10 -0
  244. package/src/prove/smt/solver/rational.ts +165 -0
  245. package/src/prove/smt/solver/ref-vector.ts +62 -0
  246. package/src/prove/smt/solver/relevancy.ts +247 -0
  247. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  248. package/src/prove/smt/solver/rewriter.ts +843 -0
  249. package/src/prove/smt/solver/rlimit.ts +79 -0
  250. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  251. package/src/prove/smt/solver/solver.ts +71 -0
  252. package/src/prove/smt/solver/sort.ts +35 -0
  253. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  254. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  255. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  256. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  257. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  258. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  259. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  260. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  261. package/src/prove/smt/solver/theory-lra.ts +56 -0
  262. package/src/prove/smt/solver/var-subst.ts +258 -0
  263. package/src/prove/smt/solver/z3-license.txt +10 -0
  264. package/src/prove/smt/table.ts +170 -0
  265. package/src/prove/tlapm/tlapm.ts +96 -0
  266. package/src/prove/tlaps-module.ts +510 -0
  267. package/src/prove/verdict.ts +18 -0
  268. package/src/prove/zenon/LICENSE +32 -0
  269. package/src/prove/zenon/check/check.ts +105 -0
  270. package/src/prove/zenon/check/definitions.ts +144 -0
  271. package/src/prove/zenon/check/equality.ts +182 -0
  272. package/src/prove/zenon/check/functions.ts +62 -0
  273. package/src/prove/zenon/check/keys.ts +125 -0
  274. package/src/prove/zenon/check/propositional.ts +104 -0
  275. package/src/prove/zenon/check/records.ts +188 -0
  276. package/src/prove/zenon/check/relations.ts +121 -0
  277. package/src/prove/zenon/check/rewrites.ts +224 -0
  278. package/src/prove/zenon/check/sets.ts +302 -0
  279. package/src/prove/zenon/check/terms.ts +127 -0
  280. package/src/prove/zenon/check/tla.ts +126 -0
  281. package/src/prove/zenon/decide.ts +113 -0
  282. package/src/prove/zenon/encode.ts +379 -0
  283. package/src/prove/zenon/eqrel.ts +300 -0
  284. package/src/prove/zenon/equality-rules.ts +435 -0
  285. package/src/prove/zenon/expr.ts +551 -0
  286. package/src/prove/zenon/index-table.ts +350 -0
  287. package/src/prove/zenon/isar-case.ts +513 -0
  288. package/src/prove/zenon/isar.ts +1249 -0
  289. package/src/prove/zenon/limits.ts +15 -0
  290. package/src/prove/zenon/llproof.ts +173 -0
  291. package/src/prove/zenon/mltoll.ts +1566 -0
  292. package/src/prove/zenon/node.ts +297 -0
  293. package/src/prove/zenon/ocaml.ts +169 -0
  294. package/src/prove/zenon/parse.ts +247 -0
  295. package/src/prove/zenon/phrase.ts +191 -0
  296. package/src/prove/zenon/proof.ts +198 -0
  297. package/src/prove/zenon/propositional-rules.ts +387 -0
  298. package/src/prove/zenon/rules.ts +94 -0
  299. package/src/prove/zenon/search.ts +288 -0
  300. package/src/prove/zenon/tla/functions.ts +151 -0
  301. package/src/prove/zenon/tla/llproof.ts +480 -0
  302. package/src/prove/zenon/tla/records.ts +225 -0
  303. package/src/prove/zenon/tla/rewrites.ts +447 -0
  304. package/src/prove/zenon/tla/sets.ts +304 -0
  305. package/src/prove/zenon/tla/terms.ts +162 -0
  306. package/src/prove/zenon/tla/tla.ts +506 -0
  307. package/src/resolve.ts +1 -1
  308. package/src/run-cli.ts +283 -81
  309. package/src/sany-generator.ts +1 -1
  310. package/src/sany-report.ts +1 -1
  311. package/src/successors.ts +24 -5
  312. package/src/tlapm-cache.ts +236 -0
  313. package/src/tlc-random.ts +55 -32
  314. package/src/tlc-replay.ts +1 -1
  315. package/src/tlc-version.ts +8 -7
  316. package/src/values.ts +47 -4
  317. package/src/worker.ts +65 -0
  318. package/dist/parallel.cjs +0 -12
  319. package/dist/parallel.js +0 -12
  320. package/src/value-sources.ts +0 -29
@@ -0,0 +1,400 @@
1
+ // Ported from Z3 (src/smt/mam.cpp), MIT license, see z3-license.txt. The interpreter of Z3's
2
+ // matching abstract machine: it runs a code tree against a term, backtracking through the choices
3
+ // of BIND, CONTINUE and CHOOSE, and reports each match.
4
+ import type { Context } from "./context";
5
+ import type { Enode } from "./enode";
6
+ import {
7
+ type CodeTree,
8
+ type Instruction,
9
+ type Joint,
10
+ JOINT_GROUND,
11
+ JOINT_NESTED,
12
+ JOINT_VAR,
13
+ OP_BIND,
14
+ OP_CFILTER,
15
+ OP_CHECK,
16
+ OP_CHOOSE,
17
+ OP_COMPARE,
18
+ OP_CONTINUE,
19
+ OP_FILTER,
20
+ OP_GET_CGR,
21
+ OP_GET_ENODE,
22
+ OP_INIT,
23
+ OP_IS_CGR,
24
+ OP_NOOP,
25
+ OP_PFILTER,
26
+ OP_YIELD,
27
+ } from "./mam-compiler";
28
+ import { OP_ITE } from "./ast";
29
+ import { shrink } from "./array";
30
+
31
+ export type OnMatch = (quantifier: number, bindings: Enode[], maxGeneration: number) => void;
32
+
33
+ // backtrack_point: the instruction to resume, the generation to restore, the term a BIND is at,
34
+ // and the terms a CONTINUE goes through.
35
+ interface BacktrackPoint {
36
+ instr: Instruction;
37
+ oldMaxGeneration: number;
38
+ curr: Enode | null;
39
+ candidates: Enode[];
40
+ index: number;
41
+ end: number;
42
+ }
43
+
44
+ // GET_CGR1 to GET_CGR6 filter their arguments by the parent labels, GET_CGRN does not.
45
+ const MAX_FILTERED_GET_CGR_ARGS = 6;
46
+
47
+ export class Interpreter {
48
+ private registers: (Enode | null)[] = [];
49
+ // m_bindings: the terms a YIELD reports, which the match callback does not keep.
50
+ private bindings: Enode[] = [];
51
+ private backtrackStack: BacktrackPoint[] = [];
52
+ private top = 0;
53
+ // m_max_generation: the largest generation of a term the match went through.
54
+ private maxGeneration = 0;
55
+
56
+ constructor(
57
+ private context: Context,
58
+ private onMatch: OnMatch,
59
+ ) {}
60
+
61
+ private updateMaxGeneration(node: Enode) {
62
+ this.maxGeneration = Math.max(this.maxGeneration, this.context.getGeneration(node));
63
+ }
64
+
65
+ private pushPoint(instr: Instruction, oldMaxGeneration: number) {
66
+ let point = this.backtrackStack[this.top];
67
+ if (point === undefined) {
68
+ point = { instr, oldMaxGeneration, curr: null, candidates: [], index: 0, end: 0 };
69
+ this.backtrackStack.push(point);
70
+ }
71
+ point.instr = instr;
72
+ point.oldMaxGeneration = oldMaxGeneration;
73
+ this.top++;
74
+ return point;
75
+ }
76
+
77
+ // get_first_f_app and get_next_f_app: the next congruence root with the label in the class.
78
+ private getNextFApp(label: number, numArgs: number, first: Enode, start: Enode | null) {
79
+ let curr = start === null ? first : start.next;
80
+ if (start !== null && curr === first) return null;
81
+ do {
82
+ if (curr.decl === label && curr.isCgr() && curr.numArgs === numArgs) {
83
+ this.updateMaxGeneration(curr);
84
+ return curr;
85
+ }
86
+ curr = curr.next;
87
+ } while (curr !== first);
88
+ return null;
89
+ }
90
+
91
+ // exec_is_cgr: whether the class has a term with the label and the arguments of the registers.
92
+ private isCgr(instr: Instruction) {
93
+ const registers = this.registers;
94
+ const args: Enode[] = [];
95
+ for (const reg of instr.regs) {
96
+ const node = registers[reg];
97
+ if (node === null || node === undefined) return false;
98
+ args.push(node.root);
99
+ }
100
+ const first = registers[instr.reg];
101
+ if (first === null || first === undefined) return false;
102
+ let node = first;
103
+ do {
104
+ if (
105
+ node.decl === instr.label &&
106
+ node.numArgs === instr.numArgs &&
107
+ args.every((arg, index) => node.getArg(index).root === arg)
108
+ ) {
109
+ this.updateMaxGeneration(node);
110
+ return true;
111
+ }
112
+ node = node.next;
113
+ } while (node !== first);
114
+ return false;
115
+ }
116
+
117
+ private isRelevantParent(parent: Enode, decl: number, argIndex: number, child: Enode) {
118
+ return (
119
+ parent.decl === decl &&
120
+ argIndex < parent.numArgs &&
121
+ this.context.isRelevant(parent.owner) &&
122
+ parent.isCgr() &&
123
+ parent.getArg(argIndex).root === child
124
+ );
125
+ }
126
+
127
+ // mk_depth1_vector: the relevant decl-parents of the class of node where it is argument argIndex.
128
+ // init_continue drops a vector of limit terms or more, so this stops at limit and returns null.
129
+ private getDepth1Vector(node: Enode, decl: number, argIndex: number, limit: number) {
130
+ const root = node.root;
131
+ const result: Enode[] = [];
132
+ for (const parent of root.parents) {
133
+ if (!this.isRelevantParent(parent, decl, argIndex, root)) continue;
134
+ if (result.length + 1 >= limit) return null;
135
+ result.push(parent);
136
+ }
137
+ return result;
138
+ }
139
+
140
+ // mk_depth2_vector, which stops at limit like getDepth1Vector.
141
+ private getDepth2Vector(joint: Joint, decl: number, argIndex: number, limit: number) {
142
+ const node = this.registers[joint.reg];
143
+ if (node === null || node === undefined) return null;
144
+ const root = node.root;
145
+ if (root.parents.length === 0) return null;
146
+ const result: Enode[] = [];
147
+ for (const parent of root.parents) {
148
+ if (!this.isRelevantParent(parent, joint.decl, joint.argPos, root)) continue;
149
+ const parentRoot = parent.root;
150
+ for (const grandparent of parentRoot.parents) {
151
+ if (!this.isRelevantParent(grandparent, decl, argIndex, parentRoot)) continue;
152
+ if (result.length + 1 >= limit) return null;
153
+ result.push(grandparent);
154
+ }
155
+ }
156
+ return result;
157
+ }
158
+
159
+ // SET_VAR's filter: whether the class of each input register has a parent with the label.
160
+ private hasParentLabels(instr: Instruction) {
161
+ for (const reg of instr.regs) {
162
+ const root = (this.registers[reg] as Enode).root;
163
+ if ((root.plbls & instr.lblLow) === 0 && (root.plblsHigh & instr.lblHigh) === 0) return false;
164
+ }
165
+ return true;
166
+ }
167
+
168
+ private getJointNode(joint: Joint) {
169
+ if (joint.kind === JOINT_GROUND) return joint.enode;
170
+ if (joint.kind === JOINT_VAR) return this.registers[joint.reg] ?? null;
171
+ return null;
172
+ }
173
+
174
+ // init_continue: the smallest candidate vector among the joints, or all terms with the label.
175
+ private initContinue(instr: Instruction) {
176
+ const context = this.context;
177
+ const label = instr.label;
178
+ const all = context.enodesOf(label);
179
+ for (const joint of instr.joints) {
180
+ const node = this.getJointNode(joint);
181
+ if (node === null) continue;
182
+ const root = node.root;
183
+ if ((root.plbls & instr.lblLow) === 0 && (root.plblsHigh & instr.lblHigh) === 0) return null;
184
+ if (root.parents.length === 0) return null;
185
+ }
186
+ let best: Enode[] | null = null;
187
+ for (let argIndex = 0; argIndex < instr.joints.length; argIndex++) {
188
+ const joint = instr.joints[argIndex];
189
+ const node = this.getJointNode(joint);
190
+ const limit: number = best === null ? all.length : Math.min(all.length, best.length);
191
+ const current =
192
+ node !== null
193
+ ? this.getDepth1Vector(node, label, argIndex, limit)
194
+ : joint.kind === JOINT_NESTED
195
+ ? this.getDepth2Vector(joint, label, argIndex, limit)
196
+ : null;
197
+ if (
198
+ current === null ||
199
+ current.length >= all.length ||
200
+ (best !== null && current.length >= best.length)
201
+ )
202
+ continue;
203
+ if (current.length === 0) return null;
204
+ best = current;
205
+ }
206
+ const candidates = best ?? all;
207
+ const end = candidates.length;
208
+ let index = 0;
209
+ while (index < end) {
210
+ const node = candidates[index];
211
+ if (node.numArgs === instr.numArgs && context.isRelevant(node.owner)) break;
212
+ index++;
213
+ }
214
+ if (index === end) return null;
215
+ const point = this.pushPoint(instr, this.maxGeneration);
216
+ point.candidates = candidates;
217
+ point.index = index;
218
+ point.end = end;
219
+ this.updateMaxGeneration(candidates[index]);
220
+ return candidates[index];
221
+ }
222
+
223
+ private setArgs(oreg: number, node: Enode, numArgs: number) {
224
+ for (let index = 0; index < numArgs; index++) this.registers[oreg + index] = node.getArg(index);
225
+ }
226
+
227
+ // The backtracking step of execute_core: the instruction to resume at, or null when the top choice
228
+ // is exhausted and was popped.
229
+ private resume(point: BacktrackPoint): Instruction | null {
230
+ const instr = point.instr;
231
+ if (instr.op === OP_CHOOSE) {
232
+ this.top--;
233
+ return instr.alt;
234
+ }
235
+ if (instr.op === OP_BIND) {
236
+ const node = this.getNextFApp(
237
+ instr.label,
238
+ instr.numArgs,
239
+ this.registers[instr.reg] as Enode,
240
+ point.curr,
241
+ );
242
+ if (node === null) {
243
+ this.top--;
244
+ return null;
245
+ }
246
+ point.curr = node;
247
+ this.setArgs(instr.oreg, node, instr.numArgs);
248
+ return instr.next;
249
+ }
250
+ const context = this.context;
251
+ for (point.index++; point.index < point.end; point.index++) {
252
+ const node = point.candidates[point.index];
253
+ if (node.numArgs === instr.numArgs && context.isRelevant(node.owner)) {
254
+ this.updateMaxGeneration(node);
255
+ this.setArgs(instr.oreg, node, instr.numArgs);
256
+ return instr.next;
257
+ }
258
+ }
259
+ this.top--;
260
+ return null;
261
+ }
262
+
263
+ // execute_core: runs the tree against a term, one instruction at a time, and backtracks when an
264
+ // instruction fails. It returns false when the search is canceled.
265
+ executeCore(tree: CodeTree, node: Enode) {
266
+ const context = this.context;
267
+ const registers = this.registers;
268
+ this.maxGeneration = context.getGeneration(node);
269
+ registers[0] = node;
270
+ this.top = 0;
271
+ let sinceLastCheck = 0;
272
+ let pc: Instruction | null = tree.root;
273
+ for (;;) {
274
+ if (pc === null) {
275
+ if (this.top === 0) return true;
276
+ const point = this.backtrackStack[this.top - 1];
277
+ this.maxGeneration = point.oldMaxGeneration;
278
+ if (sinceLastCheck++ > 100) {
279
+ sinceLastCheck = 0;
280
+ if (context.checkCanceled()) {
281
+ this.top = 0;
282
+ return false;
283
+ }
284
+ }
285
+ pc = this.resume(point);
286
+ continue;
287
+ }
288
+ const instr: Instruction = pc;
289
+ pc = null;
290
+ switch (instr.op) {
291
+ case OP_INIT: {
292
+ const first = registers[0] as Enode;
293
+ if (first.numArgs !== instr.numArgs) break;
294
+ this.setArgs(1, first, instr.numArgs);
295
+ pc = instr.next;
296
+ break;
297
+ }
298
+ case OP_COMPARE: {
299
+ const first = registers[instr.reg];
300
+ const second = registers[instr.reg2];
301
+ if (first === null || first === undefined || second === null || second === undefined)
302
+ break;
303
+ if (first.root === second.root) pc = instr.next;
304
+ break;
305
+ }
306
+ case OP_CHECK: {
307
+ const first = registers[instr.reg];
308
+ const second = instr.enode;
309
+ if (first === null || first === undefined || second === null) break;
310
+ // Z3's hack for dynamically generated patterns: a ground if-then-else is not checked.
311
+ if (first.root === second.root || context.manager.getOp(second.owner) === OP_ITE)
312
+ pc = instr.next;
313
+ break;
314
+ }
315
+ case OP_CFILTER:
316
+ case OP_FILTER:
317
+ case OP_PFILTER: {
318
+ const root = (registers[instr.reg] as Enode).root;
319
+ const isParent = instr.op === OP_PFILTER;
320
+ const low = isParent ? root.plbls : root.lbls;
321
+ const high = isParent ? root.plblsHigh : root.lblsHigh;
322
+ if ((low & instr.lblLow) !== 0 || (high & instr.lblHigh) !== 0) pc = instr.next;
323
+ break;
324
+ }
325
+ case OP_CHOOSE:
326
+ this.pushPoint(instr, this.maxGeneration);
327
+ pc = instr.next;
328
+ break;
329
+ case OP_NOOP:
330
+ pc = instr.next;
331
+ break;
332
+ case OP_BIND: {
333
+ const oldMaxGeneration = this.maxGeneration;
334
+ const found = this.getNextFApp(
335
+ instr.label,
336
+ instr.numArgs,
337
+ registers[instr.reg] as Enode,
338
+ null,
339
+ );
340
+ if (found === null) break;
341
+ this.pushPoint(instr, oldMaxGeneration).curr = found;
342
+ this.setArgs(instr.oreg, found, instr.numArgs);
343
+ pc = instr.next;
344
+ break;
345
+ }
346
+ case OP_YIELD: {
347
+ const numBindings = instr.regs.length;
348
+ const bindings = this.bindings;
349
+ shrink(bindings, 0);
350
+ for (let index = 0; index < numBindings; index++) {
351
+ const binding = registers[instr.regs[numBindings - index - 1]] as Enode;
352
+ bindings.push(binding);
353
+ this.updateMaxGeneration(binding);
354
+ }
355
+ this.onMatch(instr.quantifier, bindings, this.maxGeneration);
356
+ break;
357
+ }
358
+ case OP_GET_ENODE:
359
+ registers[instr.oreg] = instr.enode;
360
+ pc = instr.next;
361
+ break;
362
+ case OP_GET_CGR: {
363
+ if (instr.numArgs <= MAX_FILTERED_GET_CGR_ARGS && !this.hasParentLabels(instr)) break;
364
+ const found = context.findCongruent(
365
+ instr.label,
366
+ instr.regs.map((reg) => registers[reg] as Enode),
367
+ );
368
+ if (found === undefined || !context.isRelevant(found.owner)) break;
369
+ this.updateMaxGeneration(found);
370
+ registers[instr.oreg] = found;
371
+ pc = instr.next;
372
+ break;
373
+ }
374
+ case OP_IS_CGR:
375
+ if (this.isCgr(instr)) pc = instr.next;
376
+ break;
377
+ case OP_CONTINUE: {
378
+ const found = this.initContinue(instr);
379
+ if (found === null) break;
380
+ this.setArgs(instr.oreg, found, instr.numArgs);
381
+ pc = instr.next;
382
+ break;
383
+ }
384
+ }
385
+ }
386
+ }
387
+
388
+ // execute: runs the tree against its candidates. A tree that filters its candidates runs each
389
+ // term once.
390
+ execute(tree: CodeTree) {
391
+ const context = this.context;
392
+ const seen = tree.isFilteringCandidates ? new Set<Enode>() : null;
393
+ for (const node of tree.candidates) {
394
+ if (seen?.has(node) || !node.isCgr()) continue;
395
+ if (context.checkCanceled() || !this.executeCore(tree, node)) return false;
396
+ seen?.add(node);
397
+ }
398
+ return true;
399
+ }
400
+ }
@@ -0,0 +1,118 @@
1
+ // Ported from Z3 (src/ast/rewriter/maximize_ac_sharing.cpp), MIT license, see z3-license.txt.
2
+ // maximize_bv_sharing_rw: an associative application of more than two arguments becomes a tree of
3
+ // binary applications that reuses the pairs it made before.
4
+ import { OP_ADD, OP_OR, type AstManager } from "./ast";
5
+ import { RewriterTpl } from "./rewriter-tpl";
6
+ import { shrink } from "./array";
7
+
8
+ interface SharingEntry {
9
+ decl: number;
10
+ first: number;
11
+ second: number;
12
+ }
13
+
14
+ // MAX_NUM_ARGS_FOR_OPT: pairs are reused only for fewer arguments.
15
+ const MAX_NUM_ARGS_FOR_OPT = 128;
16
+
17
+ export class MaxBvSharing extends RewriterTpl {
18
+ // Z3 registers the kinds of bvadd, bvmul, bvor and bvand when the first scope is pushed, and
19
+ // compares the kind without the family. bvmul has the kind of or and of +, so those are shared.
20
+ private isInit = false;
21
+ // m_entries and m_cache: the pairs made, which hold their arguments. The cache maps a declaration
22
+ // and the lower of two arguments to the higher ones, so a pair matches in either order.
23
+ private entries: SharingEntry[] = [];
24
+ private pairCache = new Map<number, Map<number, Set<number>>>();
25
+ private pairScopes: number[] = [];
26
+
27
+ constructor(manager: AstManager) {
28
+ super(manager);
29
+ }
30
+
31
+ reduceApp(decl: number, args: number[], sort: number) {
32
+ const manager = this.manager;
33
+ const op = manager.funcDecls[decl].op;
34
+ if (!this.isInit || (op !== OP_OR && op !== OP_ADD) || args.length <= 2) return -1;
35
+ return manager.withTemporaries(() => {
36
+ const pending = [...args];
37
+ // Reuses the pairs made before, the first pair found first. Z3 scans every pair again after
38
+ // each reuse, but no pair is made meanwhile, so before the reused pair only the pairs with
39
+ // the argument it became can match.
40
+ for (let merged = 0; pending.length > 1 && pending.length < MAX_NUM_ARGS_FOR_OPT;) {
41
+ let pairFirst = -1;
42
+ let pairSecond = -1;
43
+ for (let first = 0; first < merged && pairFirst === -1; first++)
44
+ if (this.hasPair(decl, pending[first], pending[merged])) {
45
+ pairFirst = first;
46
+ pairSecond = merged;
47
+ }
48
+ for (let first = merged; first + 1 < pending.length && pairFirst === -1; first++)
49
+ for (let second = first + 1; second < pending.length && pairFirst === -1; second++)
50
+ if (this.hasPair(decl, pending[first], pending[second])) {
51
+ pairFirst = first;
52
+ pairSecond = second;
53
+ }
54
+ if (pairFirst === -1) break;
55
+ pending[pairFirst] = manager.mkApp(decl, [pending[pairFirst], pending[pairSecond]], sort);
56
+ pending.splice(pairSecond, 1);
57
+ merged = pairFirst;
58
+ }
59
+ while (pending.length > 1) {
60
+ const next: number[] = [];
61
+ for (let index = 0; index < pending.length; index += 2) {
62
+ if (index === pending.length - 1) {
63
+ next.push(pending[index]);
64
+ continue;
65
+ }
66
+ this.insert(decl, pending[index], pending[index + 1]);
67
+ next.push(manager.mkApp(decl, [pending[index], pending[index + 1]], sort));
68
+ }
69
+ pending.splice(0, pending.length, ...next);
70
+ }
71
+ return pending[0];
72
+ });
73
+ }
74
+
75
+ // entry orders its arguments by id, and pop_scope releases them in that order.
76
+ private insert(decl: number, first: number, second: number) {
77
+ const isOrdered = this.manager.ids[first] <= this.manager.ids[second];
78
+ this.entries.push({
79
+ decl,
80
+ first: isOrdered ? first : second,
81
+ second: isOrdered ? second : first,
82
+ });
83
+ const byDecl = this.pairCache.get(decl) ?? new Map<number, Set<number>>();
84
+ this.pairCache.set(decl, byDecl);
85
+ const low = Math.min(first, second);
86
+ const highs = byDecl.get(low) ?? new Set<number>();
87
+ byDecl.set(low, highs);
88
+ highs.add(Math.max(first, second));
89
+ this.manager.incRef(first);
90
+ this.manager.incRef(second);
91
+ }
92
+
93
+ private hasPair(decl: number, first: number, second: number) {
94
+ return (
95
+ this.pairCache.get(decl)?.get(Math.min(first, second))?.has(Math.max(first, second)) === true
96
+ );
97
+ }
98
+
99
+ pushScope() {
100
+ this.isInit = true;
101
+ this.pairScopes.push(this.entries.length);
102
+ }
103
+
104
+ // pop_scope: releases the pairs made since the matching push, the last first.
105
+ popScope() {
106
+ const size = this.pairScopes.pop() as number;
107
+ for (let index = this.entries.length - 1; index >= size; index--) {
108
+ const entry = this.entries[index];
109
+ this.pairCache
110
+ .get(entry.decl)
111
+ ?.get(Math.min(entry.first, entry.second))
112
+ ?.delete(Math.max(entry.first, entry.second));
113
+ this.manager.decRef(entry.first);
114
+ this.manager.decRef(entry.second);
115
+ }
116
+ shrink(this.entries, size);
117
+ }
118
+ }