tla-ts 0.0.4-dev.a0009b7 → 0.0.4-dev.c4929d7

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 +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/check.ts +1 -0
  26. package/src/codegen.ts +26 -7
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +63 -20
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +265 -55
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
  35. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  36. package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
  37. package/src/{obligations.ts → obligations/index.ts} +29 -13
  38. package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
  39. package/src/{obligation-module.ts → obligations/module.ts} +56 -33
  40. package/src/obligations/pickle.ts +98 -0
  41. package/src/obligations/pragma.ts +189 -0
  42. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  43. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  44. package/src/{obligation-source.ts → obligations/source.ts} +159 -97
  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 +503 -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 +521 -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 +557 -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 +25 -0
  117. package/src/prove/prove.ts +505 -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 +222 -0
  124. package/src/prove/smt/context.ts +108 -0
  125. package/src/prove/smt/data.ts +636 -0
  126. package/src/prove/smt/encode.ts +166 -0
  127. package/src/prove/smt/extensionality.ts +65 -0
  128. package/src/prove/smt/flatten.ts +112 -0
  129. package/src/prove/smt/format.ts +154 -0
  130. package/src/prove/smt/instances.ts +182 -0
  131. package/src/prove/smt/rewrite.ts +773 -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 +96 -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 +437 -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 +334 -75
  305. package/src/standard-modules.ts +5 -2
  306. package/src/successors.ts +24 -5
  307. package/src/tlapm-cache.ts +236 -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,334 @@
1
+ // Ported from Z3 (src/tactic/core/ctx_simplify_tactic.cpp, src/ast/num_occurs.cpp,
2
+ // src/tactic/goal_num_occurs.cpp), MIT license, see z3-license.txt. The ctx-simplify tactic with
3
+ // ctx_propagate_assertions: in the context of a formula or a branch, a shared term that the context
4
+ // asserts becomes true, false or the value it equals.
5
+ import { KIND_APP, OP_AND, OP_EQ, OP_ITE, OP_OR, type AstManager } from "./ast";
6
+ import type { Goal } from "./goal";
7
+ import { RefVector } from "./ref-vector";
8
+ import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
9
+ import { shrink } from "./array";
10
+
11
+ // The max_depth and max_steps that mk_quant_preprocessor gives ctx-simplify.
12
+ const MAX_DEPTH = 30;
13
+ const MAX_STEPS = 5000000;
14
+
15
+ interface CachedResult {
16
+ to: number;
17
+ level: number;
18
+ }
19
+
20
+ class CtxSimplifier {
21
+ // goal_num_occurs: how often each term with more than one reference occurs outside quantifiers.
22
+ // m_pinned holds the formulas it counted.
23
+ private occs = new Map<number, number>();
24
+ private pinned: RefVector;
25
+ // ctx_propagate_assertions: the value of each shared term in the current context, and the terms
26
+ // given one, which the trail holds.
27
+ private assertions = new Map<number, number>();
28
+ private trail: RefVector;
29
+ private scopes: number[] = [];
30
+ // m_cache: the results of a shared term, the innermost level last, and the terms cached at each
31
+ // level. A cached term and its results are held.
32
+ private cache = new Map<number, CachedResult[]>();
33
+ private cacheUndo: number[][] = [];
34
+ private depth = 0;
35
+ private numSteps = 0;
36
+ // m_mk_app: mk_simplified_app, one reduction of the theory rewriters.
37
+ private rewriter: Rewriter;
38
+
39
+ constructor(private manager: AstManager) {
40
+ this.pinned = new RefVector(manager);
41
+ this.trail = new RefVector(manager);
42
+ this.rewriter = new Rewriter(manager, TACTIC_REWRITER_OPTIONS);
43
+ }
44
+
45
+ // operator(): a forward pass over the formulas, then a backward pass that also counts the
46
+ // occurrences of the forward pass's results.
47
+ apply(goal: Goal) {
48
+ const manager = this.manager;
49
+ if (goal.isInconsistent) return;
50
+ this.countOccurrences(goal);
51
+ const size = goal.forms.size;
52
+ for (let index = 0; !goal.isInconsistent && index < size; index++) {
53
+ this.depth = 0;
54
+ const result = this.simplify(goal.forms.items[index]);
55
+ if (index < size - 1 && !manager.isTrue(result) && !manager.isFalse(result))
56
+ this.assertExpr(result, false);
57
+ goal.update(index, result);
58
+ manager.decRef(result);
59
+ }
60
+ this.pop(this.scopes.length);
61
+ this.countOccurrences(goal);
62
+ for (let index = goal.forms.size; !goal.isInconsistent && index > 0;) {
63
+ this.depth = 0;
64
+ index--;
65
+ const result = this.simplify(goal.forms.items[index]);
66
+ if (index > 0 && !manager.isTrue(result) && !manager.isFalse(result))
67
+ this.assertExpr(result, false);
68
+ goal.update(index, result);
69
+ manager.decRef(result);
70
+ }
71
+ this.pop(this.scopes.length);
72
+ }
73
+
74
+ // cleanup: ~imp releases the cache, and then goal_num_occurs its formulas.
75
+ release() {
76
+ this.restoreCache(0);
77
+ this.pinned.reset();
78
+ }
79
+
80
+ // goal_num_occurs::operator() with ignore_ref_count1 and ignore_quantifiers.
81
+ private countOccurrences(goal: Goal) {
82
+ const manager = this.manager;
83
+ const visited = new Set<number>();
84
+ const stack: number[] = [];
85
+ const visit = (expr: number) => {
86
+ if (manager.getRefCount(expr) > 1) this.occs.set(expr, (this.occs.get(expr) ?? 0) + 1);
87
+ if (visited.has(expr)) return;
88
+ visited.add(expr);
89
+ stack.push(expr);
90
+ };
91
+ for (const form of goal.forms.items) {
92
+ this.pinned.push(form);
93
+ visit(form);
94
+ while (stack.length > 0) {
95
+ const expr = stack.pop() as number;
96
+ if (manager.kinds[expr] !== KIND_APP) continue;
97
+ for (let index = manager.getNumArgs(expr) - 1; index >= 0; index--)
98
+ visit(manager.getArg(expr, index));
99
+ }
100
+ }
101
+ }
102
+
103
+ private isShared(expr: number) {
104
+ return this.manager.getRefCount(expr) > 1 && (this.occs.get(expr) ?? 0) > 1;
105
+ }
106
+
107
+ // ctx_propagate_assertions::assert_expr: a shared atom gets its truth value, and a shared term
108
+ // that a positive equality equates with a value gets the value.
109
+ private assertExpr(expr: number, isNegated: boolean) {
110
+ const manager = this.manager;
111
+ let atom = expr;
112
+ let isFalse = isNegated;
113
+ while (manager.isNot(atom)) {
114
+ atom = manager.getArg(atom, 0);
115
+ isFalse = !isFalse;
116
+ }
117
+ let isMakingScope = true;
118
+ if (this.isShared(atom) || this.isShared(expr)) {
119
+ this.scopes.push(this.trail.size);
120
+ isMakingScope = false;
121
+ this.assertEqCore(atom, isFalse ? manager.falseExpr : manager.trueExpr);
122
+ }
123
+ if (isFalse || manager.getOp(atom) !== OP_EQ) return;
124
+ const lhs = manager.getArg(atom, 0);
125
+ const rhs = manager.getArg(atom, 1);
126
+ const isRhsValue = manager.isUniqueValue(rhs);
127
+ if (!isRhsValue && !manager.isUniqueValue(lhs)) return;
128
+ const term = isRhsValue ? lhs : rhs;
129
+ if (!this.isShared(term)) return;
130
+ if (isMakingScope) this.scopes.push(this.trail.size);
131
+ this.assertEqCore(term, isRhsValue ? rhs : lhs);
132
+ }
133
+
134
+ private assertEqCore(term: number, value: number) {
135
+ if (this.assertions.has(term)) return;
136
+ this.assertions.set(term, value);
137
+ this.trail.push(term);
138
+ }
139
+
140
+ // pop: the assertions of the scopes, and then the results cached in them, the innermost first.
141
+ private pop(numScopes: number) {
142
+ if (numScopes === 0) return;
143
+ let level = this.scopes.length;
144
+ const size = this.scopes[level - numScopes];
145
+ while (this.trail.size > size) {
146
+ this.assertions.delete(this.trail.items[this.trail.size - 1]);
147
+ this.trail.pop();
148
+ }
149
+ shrink(this.scopes, this.scopes.length - numScopes);
150
+ for (let index = 0; index < numScopes; index++) this.restoreCache(level--);
151
+ }
152
+
153
+ private restoreCache(level: number) {
154
+ const manager = this.manager;
155
+ const keys = this.cacheUndo[level];
156
+ if (keys === undefined) return;
157
+ for (let index = keys.length - 1; index >= 0; index--) {
158
+ const results = this.cache.get(keys[index]) as CachedResult[];
159
+ manager.decRef((results.pop() as CachedResult).to);
160
+ if (results.length > 0) continue;
161
+ this.cache.delete(keys[index]);
162
+ manager.decRef(keys[index]);
163
+ }
164
+ keys.length = 0;
165
+ }
166
+
167
+ private cacheResult(from: number, to: number) {
168
+ const manager = this.manager;
169
+ if (!this.isShared(from)) return;
170
+ const level = this.scopes.length;
171
+ const results = this.cache.get(from);
172
+ if (results === undefined) {
173
+ this.cache.set(from, [{ to, level }]);
174
+ manager.incRef(from);
175
+ } else results.push({ to, level });
176
+ manager.incRef(to);
177
+ (this.cacheUndo[level] ??= []).push(from);
178
+ }
179
+
180
+ private getCached(expr: number) {
181
+ const top = this.cache.get(expr)?.at(-1);
182
+ return top !== undefined && top.level === this.scopes.length ? top.to : undefined;
183
+ }
184
+
185
+ // m_mk_app, with a reference to the result.
186
+ private mkApp(decl: number, args: number[], sort: number) {
187
+ return this.manager.withTemporaries(() => this.rewriter.mkApp(decl, args, sort));
188
+ }
189
+
190
+ // The result comes with a reference, which the caller releases.
191
+ private simplify(expr: number): number {
192
+ const manager = this.manager;
193
+ if (this.depth >= MAX_DEPTH || this.numSteps >= MAX_STEPS || manager.kinds[expr] !== KIND_APP) {
194
+ manager.incRef(expr);
195
+ return expr;
196
+ }
197
+ // tactic::checkpoint.
198
+ manager.limit.checkpoint();
199
+ const known = this.getCached(expr) ?? this.assertions.get(expr);
200
+ if (known !== undefined) {
201
+ manager.incRef(known);
202
+ return known;
203
+ }
204
+ this.numSteps++;
205
+ this.depth++;
206
+ const op = manager.getOp(expr);
207
+ const result =
208
+ op === OP_OR || op === OP_AND
209
+ ? this.simplifyOrAnd(expr, op === OP_OR)
210
+ : op === OP_ITE
211
+ ? this.simplifyIte(expr)
212
+ : this.simplifyApp(expr);
213
+ this.depth--;
214
+ return result;
215
+ }
216
+
217
+ // simplify_or_and: each argument is simplified in the context of the others before it, then of
218
+ // those after it. A disjunct is asserted false and a conjunct true.
219
+ private simplifyOrAnd(expr: number, isOr: boolean) {
220
+ const manager = this.manager;
221
+ const level = this.scopes.length;
222
+ const isNeutral = (arg: number) => (isOr ? manager.isFalse(arg) : manager.isTrue(arg));
223
+ const isAbsorbing = (arg: number) => (isOr ? manager.isTrue(arg) : manager.isFalse(arg));
224
+ let isModified = false;
225
+ const passes = [new RefVector(manager), new RefVector(manager)];
226
+ const releasePasses = () => {
227
+ passes[1].reset();
228
+ passes[0].reset();
229
+ };
230
+ for (const [pass, newArgs] of passes.entries()) {
231
+ const args = pass === 0 ? manager.getArgs(expr) : [...passes[0].items].reverse();
232
+ for (const [index, arg] of args.entries()) {
233
+ const newArg = this.simplify(arg);
234
+ if (newArg !== arg) isModified = true;
235
+ if (index < args.length - 1 && !manager.isTrue(newArg) && !manager.isFalse(newArg))
236
+ this.assertExpr(newArg, isOr);
237
+ if (isNeutral(newArg)) {
238
+ isModified = true;
239
+ manager.decRef(newArg);
240
+ continue;
241
+ }
242
+ if (isAbsorbing(newArg)) {
243
+ this.pop(this.scopes.length - level);
244
+ this.cacheResult(expr, newArg);
245
+ releasePasses();
246
+ return newArg;
247
+ }
248
+ newArgs.pushOwned(newArg);
249
+ }
250
+ this.pop(this.scopes.length - level);
251
+ }
252
+ const newArgs = passes[1].items;
253
+ const result = !isModified
254
+ ? expr
255
+ : newArgs.length === 0
256
+ ? isOr
257
+ ? manager.falseExpr
258
+ : manager.trueExpr
259
+ : newArgs.length === 1
260
+ ? newArgs[0]
261
+ : -1;
262
+ if (result !== -1) manager.incRef(result);
263
+ const simplified =
264
+ result === -1
265
+ ? this.mkApp(manager.decls[expr], [...newArgs].reverse(), manager.sorts[expr])
266
+ : result;
267
+ this.cacheResult(expr, simplified);
268
+ releasePasses();
269
+ return simplified;
270
+ }
271
+
272
+ // simplify_ite: the branches are simplified in the context of the condition and its negation.
273
+ private simplifyIte(expr: number) {
274
+ const manager = this.manager;
275
+ const condition = manager.getArg(expr, 0);
276
+ const thenBranch = manager.getArg(expr, 1);
277
+ const elseBranch = manager.getArg(expr, 2);
278
+ const level = this.scopes.length;
279
+ const newCondition = this.simplify(condition);
280
+ let result: number;
281
+ if (manager.isTrue(newCondition)) result = this.simplify(thenBranch);
282
+ else if (manager.isFalse(newCondition)) result = this.simplify(elseBranch);
283
+ else {
284
+ this.assertExpr(newCondition, false);
285
+ const newThen = this.simplify(thenBranch);
286
+ this.pop(this.scopes.length - level);
287
+ this.assertExpr(newCondition, true);
288
+ const newElse = this.simplify(elseBranch);
289
+ this.pop(this.scopes.length - level);
290
+ if (condition === newCondition && thenBranch === newThen && elseBranch === newElse) {
291
+ manager.incRef(expr);
292
+ result = expr;
293
+ } else if (newThen === newElse) {
294
+ manager.incRef(newThen);
295
+ result = newThen;
296
+ } else
297
+ result = this.mkApp(
298
+ manager.decls[expr],
299
+ [newCondition, newThen, newElse],
300
+ manager.sorts[expr],
301
+ );
302
+ manager.decRef(newElse);
303
+ manager.decRef(newThen);
304
+ }
305
+ this.cacheResult(expr, result);
306
+ manager.decRef(newCondition);
307
+ return result;
308
+ }
309
+
310
+ private simplifyApp(expr: number) {
311
+ const manager = this.manager;
312
+ const newArgs = new RefVector(manager);
313
+ let isModified = false;
314
+ for (let index = 0; index < manager.getNumArgs(expr); index++) {
315
+ const arg = manager.getArg(expr, index);
316
+ const newArg = this.simplify(arg);
317
+ if (newArg !== arg) isModified = true;
318
+ newArgs.pushOwned(newArg);
319
+ }
320
+ if (!isModified) manager.incRef(expr);
321
+ const result = isModified
322
+ ? this.mkApp(manager.decls[expr], newArgs.items, manager.sorts[expr])
323
+ : expr;
324
+ newArgs.reset();
325
+ return result;
326
+ }
327
+ }
328
+
329
+ // The ctx-simplify tactic, which the clean tactical resets when it is done.
330
+ export const ctxSimplify = (manager: AstManager, goal: Goal) => {
331
+ const simplifier = new CtxSimplifier(manager);
332
+ simplifier.apply(goal);
333
+ simplifier.release();
334
+ };
@@ -0,0 +1,224 @@
1
+ // Ported from Z3 (src/ast/rewriter/der.cpp), MIT license, see z3-license.txt. Destructive equality
2
+ // resolution: a quantified variable that a literal of the body defines is replaced by its
3
+ // definition.
4
+ import { KIND_QUANTIFIER, KIND_VAR, OP_EQ, SORT_BOOL, type AstManager } from "./ast";
5
+ import { flattenAndVector, flattenOrVector } from "./ast-util";
6
+ import { RefVector } from "./ref-vector";
7
+ import { collectUsedVars, elimUnusedVars, VarSubst } from "./var-subst";
8
+
9
+ interface VarDefinition {
10
+ index: number;
11
+ definition: number;
12
+ }
13
+
14
+ // der::is_var_diseq for a universal quantifier and der::is_var_eq for an existential one.
15
+ const getVarDefinition = (
16
+ manager: AstManager,
17
+ literal: number,
18
+ count: number,
19
+ isForall: boolean,
20
+ ): VarDefinition | undefined => {
21
+ const isBoundVar = (term: number) =>
22
+ manager.kinds[term] === KIND_VAR && manager.values[term] < count;
23
+ const isNegatedVar = (term: number) => manager.isNot(term) && isBoundVar(manager.getArg(term, 0));
24
+ const fromEq = (eq: number, isNegated: boolean): VarDefinition | undefined => {
25
+ const isSwapped = !isBoundVar(manager.getArg(eq, 0));
26
+ const lhs = isSwapped ? manager.getArg(eq, 1) : manager.getArg(eq, 0);
27
+ const rhs = isSwapped ? manager.getArg(eq, 0) : manager.getArg(eq, 1);
28
+ if (!isBoundVar(lhs)) return undefined;
29
+ return { index: manager.values[lhs], definition: isNegated ? manager.mkNot(rhs) : rhs };
30
+ };
31
+ if (isForall) {
32
+ if (manager.isNot(literal) && manager.getOp(manager.getArg(literal, 0)) === OP_EQ)
33
+ return fromEq(manager.getArg(literal, 0), false);
34
+ if (
35
+ manager.getOp(literal) === OP_EQ &&
36
+ manager.sorts[manager.getArg(literal, 0)] === SORT_BOOL
37
+ ) {
38
+ const found = fromEq(literal, true);
39
+ if (found !== undefined) return found;
40
+ const isSwapped = !isNegatedVar(manager.getArg(literal, 0));
41
+ const lhs = isSwapped ? manager.getArg(literal, 1) : manager.getArg(literal, 0);
42
+ const rhs = isSwapped ? manager.getArg(literal, 0) : manager.getArg(literal, 1);
43
+ return isNegatedVar(lhs)
44
+ ? { index: manager.values[manager.getArg(lhs, 0)], definition: rhs }
45
+ : undefined;
46
+ }
47
+ if (isBoundVar(literal))
48
+ return { index: manager.values[literal], definition: manager.falseExpr };
49
+ if (isNegatedVar(literal))
50
+ return { index: manager.values[manager.getArg(literal, 0)], definition: manager.trueExpr };
51
+ return undefined;
52
+ }
53
+ if (manager.getOp(literal) === OP_EQ) return fromEq(literal, false);
54
+ if (isBoundVar(literal)) return { index: manager.values[literal], definition: manager.trueExpr };
55
+ if (isNegatedVar(literal))
56
+ return { index: manager.values[manager.getArg(literal, 0)], definition: manager.falseExpr };
57
+ return undefined;
58
+ };
59
+
60
+ export const isOccurring = (manager: AstManager, index: number, expr: number) =>
61
+ collectUsedVars(manager, expr, index + 1)[index];
62
+
63
+ // der_sort_vars: the definitions in an order where each only uses the ones before it, dropping the
64
+ // definitions on a cycle.
65
+ const getEliminationOrder = (manager: AstManager, definitions: (number | undefined)[]) => {
66
+ for (let index = 0; index < definitions.length; index++) {
67
+ const definition = definitions[index];
68
+ if (
69
+ definition !== undefined &&
70
+ (manager.hasQuantifierFlags[definition] || isOccurring(manager, index, definition))
71
+ )
72
+ definitions[index] = undefined;
73
+ }
74
+ const order: number[] = [];
75
+ const visiting = new Set<number>();
76
+ const done = new Set<number>();
77
+ const visit = (expr: number) => {
78
+ if (done.has(expr)) return;
79
+ if (manager.kinds[expr] === KIND_VAR) {
80
+ const index = manager.values[expr];
81
+ const definition = index < definitions.length ? definitions[index] : undefined;
82
+ if (definition !== undefined && visiting.has(expr)) {
83
+ visiting.delete(expr);
84
+ definitions[index] = undefined;
85
+ } else if (definition !== undefined) {
86
+ visiting.add(expr);
87
+ visit(definition);
88
+ if (definitions[index] !== undefined) {
89
+ visiting.delete(expr);
90
+ order.push(index);
91
+ }
92
+ }
93
+ done.add(expr);
94
+ return;
95
+ }
96
+ for (let index = 0; index < manager.getNumArgs(expr); index++) {
97
+ const arg = manager.getArg(expr, index);
98
+ visit(arg);
99
+ }
100
+ done.add(expr);
101
+ };
102
+ definitions.forEach((definition, index) => {
103
+ if (definition !== undefined) visit(manager.mkVar(index, manager.sorts[definition]));
104
+ });
105
+ return order;
106
+ };
107
+
108
+ // der: destructive equality resolution. Its var_subst keeps the cache of its last substitution, and
109
+ // m_map, m_subst_map and m_new_args keep their expressions, until der next fills them.
110
+ export class Der {
111
+ private subst: VarSubst;
112
+ private map: RefVector;
113
+ private substMap: RefVector;
114
+ private newArgs: RefVector;
115
+
116
+ constructor(private manager: AstManager) {
117
+ this.subst = new VarSubst(manager, true);
118
+ this.map = new RefVector(manager);
119
+ this.substMap = new RefVector(manager);
120
+ this.newArgs = new RefVector(manager);
121
+ }
122
+
123
+ // der::operator(): reduces until nothing changes, then drops the eliminated variables. The result
124
+ // is a temporary.
125
+ apply(expr: number) {
126
+ const manager = this.manager;
127
+ let current = expr;
128
+ for (let next = this.reduce(current); next !== current; next = this.reduce(current)) {
129
+ current = next;
130
+ if (manager.kinds[current] !== KIND_QUANTIFIER) return current;
131
+ }
132
+ return current === expr ? expr : elimUnusedVars(manager, current);
133
+ }
134
+
135
+ // ~der.
136
+ release() {
137
+ this.newArgs.reset();
138
+ this.substMap.reset();
139
+ this.map.reset();
140
+ this.subst.release();
141
+ }
142
+
143
+ // der::reduce1.
144
+ private reduce(expr: number) {
145
+ const manager = this.manager;
146
+ const data = manager.getQuantifier(expr);
147
+ const count = data.sorts.length;
148
+ const single = getVarDefinition(manager, data.body, count, data.isForall);
149
+ if (
150
+ single !== undefined &&
151
+ !manager.hasQuantifierFlags[single.definition] &&
152
+ !isOccurring(manager, single.index, single.definition)
153
+ )
154
+ return data.isForall ? manager.falseExpr : manager.trueExpr;
155
+ // The literals vector holds its expressions until reduce1 returns, and releases them in order.
156
+ const vector = new RefVector(manager);
157
+ manager.withoutTemporaries(() => {
158
+ vector.push(data.body);
159
+ if (data.isForall) flattenOrVector(manager, vector);
160
+ else flattenAndVector(manager, vector);
161
+ });
162
+ const result = this.reduceLiterals(expr, vector.items);
163
+ vector.reset();
164
+ return result;
165
+ }
166
+
167
+ // The rest of der::reduce1, on the flattened literals of the body.
168
+ private reduceLiterals(expr: number, literals: number[]) {
169
+ const manager = this.manager;
170
+ const data = manager.getQuantifier(expr);
171
+ const count = data.sorts.length;
172
+ const map = this.map;
173
+ map.reset();
174
+ const positions = literals.map((literal) => {
175
+ const found = getVarDefinition(manager, literal, count, data.isForall);
176
+ if (found === undefined || (map.items[found.index] ?? -1) !== -1) return -1;
177
+ if (map.size <= found.index) map.resize(found.index + 1);
178
+ map.set(found.index, found.definition);
179
+ return found.index;
180
+ });
181
+ if (positions.every((position) => position === -1)) return expr;
182
+ // der_sort_vars drops the definitions on a cycle from m_map.
183
+ const definitions = map.items.map((definition) => (definition === -1 ? undefined : definition));
184
+ const order = getEliminationOrder(manager, definitions);
185
+ definitions.forEach((definition, index) => {
186
+ if (definition === undefined && map.items[index] !== -1) map.set(index, -1);
187
+ });
188
+ if (order.length === 0) return expr;
189
+ // create_substitution: (:var i) becomes the entry at size - i - 1, with the definitions before it
190
+ // in the order substituted.
191
+ const size = map.size;
192
+ const substMap = this.substMap;
193
+ substMap.reset();
194
+ substMap.resize(size);
195
+ for (const index of order)
196
+ substMap.setOwned(size - index - 1, this.subst.apply(map.items[index], substMap.items));
197
+ // apply_substitution: m_new_args holds the kept literals, and the junction of them is held
198
+ // until it returns.
199
+ this.newArgs.reset();
200
+ literals.forEach((literal, position) => {
201
+ const index = positions[position];
202
+ if (index === -1 || map.items[index] === -1) this.newArgs.push(literal);
203
+ });
204
+ const kept = this.newArgs.items;
205
+ const empty = data.isForall ? manager.falseExpr : manager.trueExpr;
206
+ const combined = manager.withoutTemporaries(() =>
207
+ kept.length === 0
208
+ ? empty
209
+ : kept.length === 1
210
+ ? kept[0]
211
+ : data.isForall
212
+ ? manager.mkOr(kept)
213
+ : manager.mkAnd(kept),
214
+ );
215
+ manager.incRef(combined);
216
+ const body = this.subst.apply(combined, substMap.items);
217
+ const patterns = data.patterns.map((pattern) => this.subst.apply(pattern, substMap.items));
218
+ const result = manager.mkQuantifier({ ...data, body, patterns });
219
+ for (const pattern of patterns) manager.releaseLater(pattern);
220
+ manager.releaseLater(body);
221
+ manager.decRef(combined);
222
+ return result;
223
+ }
224
+ }
@@ -0,0 +1,141 @@
1
+ // Ported from Z3 (src/smt/dyn_ack.cpp), MIT license, see z3-license.txt. Dynamic Ackermann
2
+ // reduction with Z3's default DACK_ROOT strategy: a pair of applications whose congruence is the
3
+ // root of conflicts often enough gets the clause f(a) = f(b) or some a_i != b_i, so the search can
4
+ // learn from it without the E-graph. dack.eq is off by default, so equalities are not tracked.
5
+ import { OP_EQ } from "./ast";
6
+ import { CLS_TH_LEMMA } from "./clause";
7
+ import type { Context } from "./context";
8
+ import { Literal, negate } from "./literal";
9
+
10
+ // dyn_ack_params defaults: dack.threshold, dack.factor, dack.gc and dack.gc_inv_decay.
11
+ const DACK_THRESHOLD = 10;
12
+ const DACK_FACTOR = 0.1;
13
+ const DACK_GC = 2000;
14
+ const DACK_GC_INV_DECAY = 0.8;
15
+
16
+ interface AppPair {
17
+ first: number;
18
+ second: number;
19
+ key: string;
20
+ }
21
+
22
+ export class DynAckManager {
23
+ private appPair2NumOccs = new Map<string, number>();
24
+ // The pairs that hold references to their applications. A pair can appear more than once.
25
+ private appPairs: AppPair[] = [];
26
+ private toInstantiate: AppPair[] = [];
27
+ private qhead = 0;
28
+ private numInstances = 0;
29
+ private numPropagationsSinceLastGc = 0;
30
+ private instantiated = new Set<string>();
31
+
32
+ constructor(private readonly context: Context) {}
33
+
34
+ private resetAppPairs() {
35
+ const manager = this.context.manager;
36
+ for (const pair of this.appPairs) {
37
+ manager.decRef(pair.first);
38
+ manager.decRef(pair.second);
39
+ }
40
+ this.appPairs = [];
41
+ }
42
+
43
+ initSearchEh() {
44
+ this.appPair2NumOccs.clear();
45
+ this.resetAppPairs();
46
+ this.toInstantiate = [];
47
+ this.qhead = 0;
48
+ this.numInstances = 0;
49
+ this.numPropagationsSinceLastGc = 0;
50
+ }
51
+
52
+ // cg_conflict_eh, which DACK_ROOT turns into cg_eh: the congruence of the two applications is the
53
+ // root of a conflict.
54
+ cgConflictEh(inputFirst: number, inputSecond: number) {
55
+ const manager = this.context.manager;
56
+ if (manager.decls[inputFirst] === OP_EQ) return;
57
+ const isSwapped = manager.ids[inputFirst] > manager.ids[inputSecond];
58
+ const first = isSwapped ? inputSecond : inputFirst;
59
+ const second = isSwapped ? inputFirst : inputSecond;
60
+ const key = `${first},${second}`;
61
+ if (this.instantiated.has(key)) return;
62
+ const previous = this.appPair2NumOccs.get(key);
63
+ const pair = { first, second, key };
64
+ if (previous === undefined) {
65
+ manager.incRef(first);
66
+ manager.incRef(second);
67
+ this.appPairs.push(pair);
68
+ }
69
+ const numOccs = (previous ?? 0) + 1;
70
+ this.appPair2NumOccs.set(key, numOccs);
71
+ if (numOccs === DACK_THRESHOLD) this.toInstantiate.push(pair);
72
+ }
73
+
74
+ // gc: decays every count, drops the pairs that fall to 1 or below, and queues the frequent ones,
75
+ // most frequent first.
76
+ private gc() {
77
+ const manager = this.context.manager;
78
+ this.toInstantiate = [];
79
+ this.qhead = 0;
80
+ let kept = 0;
81
+ for (const pair of this.appPairs) {
82
+ if (this.instantiated.has(pair.key)) {
83
+ manager.decRef(pair.first);
84
+ manager.decRef(pair.second);
85
+ continue;
86
+ }
87
+ const numOccs = Math.trunc((this.appPair2NumOccs.get(pair.key) ?? 0) * DACK_GC_INV_DECAY);
88
+ if (numOccs <= 1) {
89
+ this.appPair2NumOccs.delete(pair.key);
90
+ manager.decRef(pair.first);
91
+ manager.decRef(pair.second);
92
+ continue;
93
+ }
94
+ this.appPairs[kept++] = pair;
95
+ this.appPair2NumOccs.set(pair.key, numOccs);
96
+ if (numOccs >= DACK_THRESHOLD) this.toInstantiate.push(pair);
97
+ }
98
+ this.appPairs.length = kept;
99
+ const getNumOccs = (pair: AppPair) => this.appPair2NumOccs.get(pair.key) ?? 0;
100
+ this.toInstantiate.sort((left, right) => getNumOccs(right) - getNumOccs(left));
101
+ }
102
+
103
+ propagateEh() {
104
+ this.numPropagationsSinceLastGc++;
105
+ if (this.numPropagationsSinceLastGc > DACK_GC) {
106
+ this.gc();
107
+ this.numPropagationsSinceLastGc = 0;
108
+ }
109
+ const maxInstances = Math.trunc(this.context.getNumConflicts() * DACK_FACTOR);
110
+ while (this.numInstances < maxInstances && this.qhead < this.toInstantiate.length) {
111
+ const pair = this.toInstantiate[this.qhead];
112
+ this.qhead++;
113
+ this.numInstances++;
114
+ this.instantiate(pair);
115
+ }
116
+ }
117
+
118
+ private mkEq(first: number, second: number) {
119
+ const context = this.context;
120
+ const eq = context.manager.mkEq(first, second);
121
+ context.internalize(eq, true);
122
+ return context.getLiteral(eq);
123
+ }
124
+
125
+ private instantiate(pair: AppPair) {
126
+ const context = this.context;
127
+ const manager = context.manager;
128
+ const literals: Literal[] = [];
129
+ for (let index = 0; index < manager.getNumArgs(pair.first); index++)
130
+ if (manager.getArg(pair.first, index) !== manager.getArg(pair.second, index))
131
+ literals.push(
132
+ negate(this.mkEq(manager.getArg(pair.first, index), manager.getArg(pair.second, index))),
133
+ );
134
+ this.appPair2NumOccs.delete(pair.key);
135
+ // The pair stays in appPairs, which still holds its references.
136
+ this.instantiated.add(pair.key);
137
+ literals.push(this.mkEq(pair.first, pair.second));
138
+ for (const literal of literals) context.markLiteralAsRelevant(literal);
139
+ context.mkClause(literals, null, CLS_TH_LEMMA, () => this.instantiated.delete(pair.key));
140
+ }
141
+ }