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,728 @@
1
+ // Ported from Z3 (src/model/model_macro_solver.cpp, src/ast/macros/macro_util.cpp,
2
+ // src/ast/func_decl_dependencies.cpp), MIT license, see z3-license.txt. Collects the conditional
3
+ // macros of a quantifier, f(x) = def when cond, and satisfies quantifiers by taking such a def as the
4
+ // else case of the interpretation of f.
5
+ import {
6
+ FAMILY_BASIC,
7
+ FAMILY_USER,
8
+ KIND_APP,
9
+ KIND_QUANTIFIER,
10
+ KIND_VAR,
11
+ OP_ADD,
12
+ OP_AND,
13
+ OP_EQ,
14
+ OP_GE,
15
+ OP_ITE,
16
+ OP_LE,
17
+ OP_NOT,
18
+ OP_OR,
19
+ SORT_BOOL,
20
+ type AstManager,
21
+ } from "./ast";
22
+ import { FuncInterp, type ProtoModel } from "./proto-model";
23
+ import { Rational } from "./rational";
24
+ import type { Rewriter } from "./rewriter";
25
+ import { replaceFreeVars } from "./var-subst";
26
+
27
+ // cond_macro: f(x_0, ..., x_n) = def whenever cond holds. A hint has no condition.
28
+ export interface CondMacro {
29
+ decl: number;
30
+ def: number;
31
+ cond: number | null;
32
+ isIneq: boolean;
33
+ isSatisfyAtom: boolean;
34
+ isHint: boolean;
35
+ weight: number;
36
+ }
37
+
38
+ export interface QuantifierMacroInfo {
39
+ readonly condMacros: CondMacro[];
40
+ readonly ngDecls: Set<number>;
41
+ readonly isAuf: boolean;
42
+ theOne: number | null;
43
+ }
44
+
45
+ type GetInfo = (quantifier: number) => QuantifierMacroInfo;
46
+
47
+ const isUserApp = (manager: AstManager, expr: number) =>
48
+ manager.kinds[expr] === KIND_APP && manager.funcDecls[manager.decls[expr]].family === FAMILY_USER;
49
+
50
+ const isAtom = (manager: AstManager, expr: number) => {
51
+ if (manager.kinds[expr] === KIND_QUANTIFIER || manager.sorts[expr] !== SORT_BOOL) return false;
52
+ if (
53
+ manager.kinds[expr] === KIND_VAR ||
54
+ manager.funcDecls[manager.decls[expr]].family !== FAMILY_BASIC
55
+ )
56
+ return true;
57
+ return (
58
+ (manager.getOp(expr) === OP_EQ && !manager.isBool(manager.getArg(expr, 0))) ||
59
+ manager.isTrue(expr) ||
60
+ manager.isFalse(expr)
61
+ );
62
+ };
63
+
64
+ const isLiteral = (manager: AstManager, expr: number) =>
65
+ isAtom(manager, expr) || (manager.isNot(expr) && isAtom(manager, manager.getArg(expr, 0)));
66
+
67
+ const getPolyArgs = (manager: AstManager, expr: number) =>
68
+ manager.getOp(expr) === OP_ADD ? manager.getArgs(expr) : [expr];
69
+
70
+ const isMacroHead = (manager: AstManager, expr: number, numDecls: number) => {
71
+ if (!isUserApp(manager, expr) || manager.getNumArgs(expr) !== numDecls) return false;
72
+ const seen = new Set<number>();
73
+ for (let argIndex = 0; argIndex < manager.getNumArgs(expr); argIndex++) {
74
+ const arg = manager.getArg(expr, argIndex);
75
+ if (manager.kinds[arg] !== KIND_VAR) return false;
76
+ const index = manager.values[arg];
77
+ if (index >= numDecls || seen.has(index)) return false;
78
+ seen.add(index);
79
+ }
80
+ return true;
81
+ };
82
+
83
+ const isQuasiMacroHead = (manager: AstManager, expr: number, numDecls: number) => {
84
+ if (!isUserApp(manager, expr) || manager.getNumArgs(expr) < numDecls) return false;
85
+ const found = new Set<number>();
86
+ for (let argIndex = 0; argIndex < manager.getNumArgs(expr); argIndex++) {
87
+ const arg = manager.getArg(expr, argIndex);
88
+ if (manager.kinds[arg] === KIND_VAR) {
89
+ const index = manager.values[arg];
90
+ if (index >= numDecls) return false;
91
+ found.add(index);
92
+ } else if (manager.isOccurring(manager.decls[expr], arg)) return false;
93
+ }
94
+ return found.size === numDecls;
95
+ };
96
+
97
+ const getHintHeadVars = (manager: AstManager, expr: number) => {
98
+ const vars: number[] = [];
99
+ if (!isUserApp(manager, expr)) return vars;
100
+ for (let index = 0; index < manager.getNumArgs(expr); index++) {
101
+ const arg = manager.getArg(expr, index);
102
+ if (manager.kinds[arg] === KIND_VAR) vars.push(arg);
103
+ }
104
+ return vars;
105
+ };
106
+
107
+ const isVarsOfSubset = (manager: AstManager, expr: number, vars: number[]) => {
108
+ const visited = new Set<number>();
109
+ const visit = (current: number): boolean => {
110
+ if (manager.isGround(current) || visited.has(current)) return true;
111
+ visited.add(current);
112
+ const kind = manager.kinds[current];
113
+ if (kind === KIND_VAR) return vars.includes(current);
114
+ if (kind === KIND_QUANTIFIER) return false;
115
+ return manager.everyArg(current, (arg) => visit(arg));
116
+ };
117
+ return visit(expr);
118
+ };
119
+
120
+ const isHintAtom = (manager: AstManager, lhs: number, rhs: number) => {
121
+ const vars = getHintHeadVars(manager, lhs);
122
+ return (
123
+ vars.length > 0 &&
124
+ !manager.isOccurring(manager.decls[lhs], rhs) &&
125
+ isVarsOfSubset(manager, rhs, vars)
126
+ );
127
+ };
128
+
129
+ const isPolyHint = (manager: AstManager, poly: number, head: number, exception: number | null) => {
130
+ const vars = getHintHeadVars(manager, head);
131
+ if (vars.length === 0) return false;
132
+ const decl = manager.decls[head];
133
+ return getPolyArgs(manager, poly).every(
134
+ (arg) =>
135
+ arg === exception || (!manager.isOccurring(decl, arg) && isVarsOfSubset(manager, arg, vars)),
136
+ );
137
+ };
138
+
139
+ // quantifier_macro_info::collect_macro_candidates, with an empty forbidden set. Each candidate holds
140
+ // a reference to its definition and condition, which releaseCondMacros releases. Like macro_util,
141
+ // the expressions of each step live until the step returns. The rewriter does macro_util's Boolean
142
+ // and arithmetic rewriting, which keeps nothing between calls.
143
+ export const collectMacroCandidates = (
144
+ manager: AstManager,
145
+ rewriter: Rewriter,
146
+ quantifier: number,
147
+ ) => {
148
+ const data = manager.getQuantifier(quantifier);
149
+ // qa: an existential quantifier becomes a universal one of the negated body until the candidates
150
+ // are collected.
151
+ const qa = data.isForall
152
+ ? quantifier
153
+ : manager.withTemporaries(() =>
154
+ manager.mkQuantifier({ ...data, isForall: true, body: manager.mkNot(data.body) }),
155
+ );
156
+ const candidates = manager.hasQuantifierFlags[manager.getQuantifier(qa).body]
157
+ ? []
158
+ : collectCandidates(manager, rewriter, qa);
159
+ if (qa !== quantifier) manager.decRef(qa);
160
+ return candidates;
161
+ };
162
+
163
+ // ~cond_macro, for each candidate in order.
164
+ export const releaseCondMacros = (manager: AstManager, candidates: CondMacro[]) => {
165
+ for (const candidate of candidates) {
166
+ if (candidate.cond !== null) manager.decRef(candidate.cond);
167
+ manager.decRef(candidate.def);
168
+ }
169
+ };
170
+
171
+ // macro_util::collect_macro_candidates.
172
+ const collectCandidates = (manager: AstManager, rewriter: Rewriter, quantifier: number) => {
173
+ const data = manager.getQuantifier(quantifier);
174
+ const body = data.body;
175
+ const candidates: CondMacro[] = [];
176
+ // The expressions of a step without a reference live until the step returns.
177
+ const scope = (step: () => void) => manager.withTemporaries(step, () => []);
178
+ const mkNot = (expr: number) => rewriter.mkAppCore(OP_NOT, [expr], SORT_BOOL);
179
+ const mkAnd = (args: number[]) =>
180
+ args.length === 0
181
+ ? manager.trueExpr
182
+ : args.length === 1
183
+ ? args[0]
184
+ : rewriter.mkAppCore(OP_AND, args, SORT_BOOL);
185
+ const mkSub = (first: number, second: number) => rewriter.mkSub(first, second);
186
+ const mkAdd = (args: number[], sort: number) =>
187
+ args.length === 0
188
+ ? manager.mkNumeralOfSort(Rational.zero, sort)
189
+ : args.length === 1
190
+ ? args[0]
191
+ : manager.mkApp(OP_ADD, args, sort);
192
+ const isClause =
193
+ isLiteral(manager, body) ||
194
+ (manager.getOp(body) === OP_OR && manager.everyArg(body, (arg) => isLiteral(manager, arg)));
195
+ const clause = isClause ? (manager.getOp(body) === OP_OR ? manager.getArgs(body) : [body]) : null;
196
+
197
+ const isRestContainingDecl = (decl: number, exceptLiteral: number) =>
198
+ clause !== null &&
199
+ clause.some((literal) => literal !== exceptLiteral && manager.isOccurring(decl, literal));
200
+
201
+ // get_rest_clause_as_cond: the condition comes with a reference, which the caller releases.
202
+ const getRestClauseAsCond = (exceptLiteral: number) =>
203
+ clause === null
204
+ ? null
205
+ : manager.withTemporaries(
206
+ () => {
207
+ const negated = clause
208
+ .filter((literal) => literal !== exceptLiteral)
209
+ .map((literal) => mkNot(literal));
210
+ return negated.length === 0 ? null : mkAnd(negated);
211
+ },
212
+ (cond) => (cond === null ? [] : [cond]),
213
+ );
214
+
215
+ // A step with the rest of the clause as its condition, which it holds until it returns.
216
+ const withRestClauseAsCond = (exceptLiteral: number, step: (cond: number | null) => void) => {
217
+ const cond = getRestClauseAsCond(exceptLiteral);
218
+ step(cond);
219
+ if (cond !== null) manager.decRef(cond);
220
+ };
221
+
222
+ // normalize_expr: the variables of the head become (:var 0) ... (:var n-1) in order.
223
+ const normalize = (head: number, expr: number) => {
224
+ const mapping = new Map<number, number>();
225
+ for (let index = 0; index < manager.getNumArgs(head); index++)
226
+ mapping.set(manager.values[manager.getArg(head, index)], index);
227
+ return [...mapping].every((entry) => entry[0] === entry[1])
228
+ ? expr
229
+ : replaceFreeVars(manager, expr, (variable, index, shift) => {
230
+ const target = mapping.get(index);
231
+ return target === undefined
232
+ ? variable
233
+ : manager.mkVar(target + shift, manager.sorts[variable]);
234
+ });
235
+ };
236
+
237
+ // insert_macro: the candidate holds references to the normalized definition and condition.
238
+ const insertMacro = (
239
+ head: number,
240
+ def: number,
241
+ cond: number | null,
242
+ isIneq: boolean,
243
+ isHint: boolean,
244
+ ) =>
245
+ scope(() => {
246
+ const normDef = normalize(head, def);
247
+ const normCond = cond !== null ? normalize(head, cond) : isHint ? null : manager.trueExpr;
248
+ manager.incRef(normDef);
249
+ if (normCond !== null) manager.incRef(normCond);
250
+ candidates.push({
251
+ decl: manager.decls[head],
252
+ def: normDef,
253
+ cond: normCond,
254
+ isIneq,
255
+ isSatisfyAtom: true,
256
+ isHint,
257
+ weight: data.weight,
258
+ });
259
+ });
260
+
261
+ // insert_quasi_macro: a head whose arguments are not distinct variables gets fresh variables,
262
+ // and for a macro the equalities between them and the arguments join the condition. new_head,
263
+ // extra_cond and new_cond hold references until it returns, and are released in the reverse
264
+ // order of their declarations.
265
+ const insertQuasiMacro = (
266
+ head: number,
267
+ numDecls: number,
268
+ def: number,
269
+ cond: number | null,
270
+ isIneq: boolean,
271
+ isHint: boolean,
272
+ ) => {
273
+ if (isMacroHead(manager, head, manager.getNumArgs(head))) {
274
+ insertMacro(head, def, cond, isIneq, isHint);
275
+ return;
276
+ }
277
+ // quasi_macro_head_to_macro_head and hint_to_macro_head: the condition comes before the head.
278
+ const converted = manager.withTemporaries(
279
+ () => {
280
+ const seen = new Set<number>();
281
+ const newArgs: number[] = [];
282
+ const newConds: number[] = [];
283
+ let nextVarIndex = numDecls;
284
+ for (let index = 0; index < manager.getNumArgs(head); index++) {
285
+ const arg = manager.getArg(head, index);
286
+ if (manager.kinds[arg] === KIND_VAR && !seen.has(manager.values[arg])) {
287
+ seen.add(manager.values[arg]);
288
+ newArgs.push(arg);
289
+ continue;
290
+ }
291
+ const newVar = manager.mkVar(nextVarIndex, manager.sorts[arg]);
292
+ nextVarIndex++;
293
+ newArgs.push(newVar);
294
+ if (!isHint) newConds.push(manager.mkEq(newVar, arg));
295
+ }
296
+ const extraCond = isHint ? null : mkAnd(newConds);
297
+ return {
298
+ extraCond,
299
+ newHead: manager.mkApp(manager.decls[head], newArgs, manager.sorts[head]),
300
+ };
301
+ },
302
+ (result) =>
303
+ result.extraCond === null ? [result.newHead] : [result.extraCond, result.newHead],
304
+ );
305
+ const extraCond = converted.extraCond;
306
+ const newCond =
307
+ extraCond === null
308
+ ? null
309
+ : cond === null
310
+ ? extraCond
311
+ : manager.withTemporaries(() => mkAnd([cond, extraCond]));
312
+ if (newCond === extraCond && extraCond !== null) manager.incRef(extraCond);
313
+ insertMacro(converted.newHead, def, newCond, isIneq, isHint);
314
+ if (newCond !== null) manager.decRef(newCond);
315
+ if (extraCond !== null) manager.decRef(extraCond);
316
+ manager.decRef(converted.newHead);
317
+ };
318
+
319
+ const collectArith = (
320
+ lhs: number,
321
+ rhs: number,
322
+ atom: number,
323
+ numDecls: number,
324
+ isIneq: boolean,
325
+ ) => {
326
+ if (manager.getOp(lhs) !== OP_ADD && manager.getOp(atom) === OP_EQ) return;
327
+ const lhsArgs = getPolyArgs(manager, lhs);
328
+ const tryHead = (head: number, monomial: number, isNegated: boolean) => {
329
+ const decl = manager.decls[head];
330
+ const isArithMacro =
331
+ isQuasiMacroHead(manager, head, numDecls) &&
332
+ !lhsArgs.some((arg) => arg !== monomial && manager.isOccurring(decl, arg)) &&
333
+ !manager.isOccurring(decl, rhs) &&
334
+ !isRestContainingDecl(decl, atom);
335
+ const isHint = !isArithMacro && isPolyHint(manager, lhs, head, monomial);
336
+ if (!isArithMacro && !isHint) return false;
337
+ scope(() => {
338
+ const rest = mkAdd(
339
+ lhsArgs.filter((arg) => arg !== monomial),
340
+ manager.sorts[lhs],
341
+ );
342
+ const def = isNegated ? mkSub(rest, rhs) : mkSub(rhs, rest);
343
+ // A hint's right-hand side may contain variables that are not arguments of the head.
344
+ if (isHint && !isPolyHint(manager, def, head, null)) return;
345
+ // add_arith_macro_candidate.
346
+ if (isHint) insertQuasiMacro(head, numDecls, def, null, isIneq, true);
347
+ else
348
+ withRestClauseAsCond(atom, (cond) =>
349
+ insertQuasiMacro(head, numDecls, def, cond, isIneq, false),
350
+ );
351
+ });
352
+ return true;
353
+ };
354
+ for (const arg of lhsArgs) {
355
+ if (manager.kinds[arg] !== KIND_APP) continue;
356
+ if (tryHead(arg, arg, false)) continue;
357
+ const negated = manager.getTimesMinusOneArg(arg);
358
+ if (negated !== undefined && manager.kinds[negated] === KIND_APP) tryHead(negated, arg, true);
359
+ }
360
+ };
361
+
362
+ const collectCore = (atom: number, numDecls: number) => {
363
+ const insertQuasi = (lhs: number, rhs: number) => {
364
+ if (
365
+ !isQuasiMacroHead(manager, lhs, numDecls) ||
366
+ manager.isOccurring(manager.decls[lhs], rhs) ||
367
+ isRestContainingDecl(manager.decls[lhs], atom)
368
+ )
369
+ return false;
370
+ withRestClauseAsCond(atom, (cond) =>
371
+ insertQuasiMacro(lhs, numDecls, rhs, cond, false, false),
372
+ );
373
+ return true;
374
+ };
375
+ const insertHint = (lhs: number, rhs: number) => {
376
+ if (isHintAtom(manager, lhs, rhs)) insertQuasiMacro(lhs, numDecls, rhs, null, false, true);
377
+ };
378
+ const op = manager.getOp(atom);
379
+ if (op === OP_EQ) {
380
+ const lhs = manager.getArg(atom, 0);
381
+ const rhs = manager.getArg(atom, 1);
382
+ if (!insertQuasi(lhs, rhs)) insertHint(lhs, rhs);
383
+ if (!insertQuasi(rhs, lhs)) insertHint(rhs, lhs);
384
+ }
385
+ if (op === OP_NOT) {
386
+ const inner = manager.getArg(atom, 0);
387
+ if (manager.getOp(inner) === OP_EQ && manager.isBool(manager.getArg(inner, 0)))
388
+ scope(() => {
389
+ const lhs = manager.getArg(inner, 0);
390
+ const rhs = manager.getArg(inner, 1);
391
+ const negatedLhs = manager.mkNot(lhs);
392
+ const negatedRhs = manager.mkNot(rhs);
393
+ if (!insertQuasi(lhs, negatedRhs)) insertHint(lhs, negatedRhs);
394
+ if (!insertQuasi(rhs, negatedLhs)) insertHint(rhs, negatedLhs);
395
+ });
396
+ }
397
+ if (op === OP_EQ || op === OP_LE || op === OP_GE) {
398
+ const lhs = manager.getArg(atom, 0);
399
+ const rhs = manager.getArg(atom, 1);
400
+ collectArith(lhs, rhs, atom, numDecls, op !== OP_EQ);
401
+ collectArith(rhs, lhs, atom, numDecls, op !== OP_EQ);
402
+ }
403
+ };
404
+
405
+ for (const literal of clause ?? [body]) scope(() => collectCore(literal, data.sorts.length));
406
+ return candidates;
407
+ };
408
+
409
+ const setElseInterp = (manager: AstManager, model: ProtoModel, decl: number, elseExpr: number) => {
410
+ let interp = model.funcInterps.get(decl);
411
+ if (interp === undefined) {
412
+ interp = new FuncInterp(manager, manager.funcDecls[decl].domain.length);
413
+ model.registerFunc(decl, interp);
414
+ }
415
+ interp.setElse(elseExpr);
416
+ };
417
+
418
+ type Process = (qs: number[], newQs: number[], residue: number[]) => boolean;
419
+
420
+ // base_macro_solver::operator(): runs the solver until it removes no more quantifiers, and leaves
421
+ // in qs the quantifiers of its last round.
422
+ const runMacroSolver = (qs: number[], residue: number[], process: Process) => {
423
+ let current = qs;
424
+ let next: number[] = [];
425
+ while (process(current, next, residue)) {
426
+ current = next;
427
+ next = [];
428
+ }
429
+ return next;
430
+ };
431
+
432
+ // simple_macro_solver: a macro for f satisfies its quantifier when no other quantifier uses f.
433
+ const simpleMacroSolver =
434
+ (manager: AstManager, model: ProtoModel, getInfo: GetInfo): Process =>
435
+ (qs, newQs) => {
436
+ let isRemoved = false;
437
+ for (const quantifier of qs) {
438
+ const info = getInfo(quantifier);
439
+ const macro = info.condMacros.find(
440
+ (candidate) =>
441
+ candidate.isSatisfyAtom &&
442
+ !qs.some((other) => other !== quantifier && getInfo(other).ngDecls.has(candidate.decl)),
443
+ );
444
+ if (macro === undefined) {
445
+ newQs.push(quantifier);
446
+ continue;
447
+ }
448
+ // The conditions of the macro can be ignored: the partial interpretation of f satisfies the
449
+ // ground part, and MBQI adds instances when it does not satisfy the quantifier.
450
+ info.theOne = macro.decl;
451
+ setElseInterp(manager, model, macro.decl, macro.def);
452
+ isRemoved = true;
453
+ }
454
+ return isRemoved;
455
+ };
456
+
457
+ const GREEDY_MAX_DEPTH = 10;
458
+
459
+ // hint_macro_solver: searches greedily for a set of hints and macros, one per function symbol,
460
+ // that satisfies a set of quantifiers without cyclic definitions.
461
+ const hintMacroSolver =
462
+ (manager: AstManager, model: ProtoModel, getInfo: GetInfo): Process =>
463
+ (qs, newQs) => {
464
+ const forbidden = new Set<number>();
465
+ const isCandidate = (quantifier: number) =>
466
+ getInfo(quantifier).condMacros.some(
467
+ (macro) => macro.isSatisfyAtom && !forbidden.has(macro.decl),
468
+ );
469
+ let current = qs;
470
+ let qcandidates: number[] = [];
471
+ for (;;) {
472
+ for (const quantifier of current) {
473
+ if (isCandidate(quantifier)) qcandidates.push(quantifier);
474
+ else {
475
+ for (const decl of getInfo(quantifier).ngDecls) forbidden.add(decl);
476
+ newQs.push(quantifier);
477
+ }
478
+ }
479
+ if (current.length === qcandidates.length) break;
480
+ current = qcandidates;
481
+ qcandidates = [];
482
+ }
483
+ if (qcandidates.length === 0) return false;
484
+ const qF = new Map<number, Set<number>>();
485
+ const qFDef = new Map<number, Map<number, Set<number>>>();
486
+ const candidateDecls = new Set<number>();
487
+ for (const quantifier of qcandidates) {
488
+ const info = getInfo(quantifier);
489
+ for (const decl of info.ngDecls) {
490
+ if (forbidden.has(decl)) continue;
491
+ const set = qF.get(decl) ?? new Set<number>();
492
+ qF.set(decl, set);
493
+ set.add(quantifier);
494
+ }
495
+ for (const macro of info.condMacros) {
496
+ if (!macro.isSatisfyAtom || forbidden.has(macro.decl)) continue;
497
+ const defs = qFDef.get(macro.decl) ?? new Map<number, Set<number>>();
498
+ qFDef.set(macro.decl, defs);
499
+ const set = defs.get(macro.def) ?? new Set<number>();
500
+ defs.set(macro.def, set);
501
+ set.add(quantifier);
502
+ candidateDecls.add(macro.decl);
503
+ }
504
+ }
505
+ const satisfied = new Set<number>();
506
+ const residue = new Set<number>();
507
+ const fs = new Map<number, number>();
508
+
509
+ const isCyclic = () => {
510
+ const acyclic = new Set<number>();
511
+ const isAcyclic = (def: number) => {
512
+ const visited = new Set<number>();
513
+ const visit = (current: number): boolean => {
514
+ if (visited.has(current)) return true;
515
+ visited.add(current);
516
+ const kind = manager.kinds[current];
517
+ if (kind === KIND_VAR) return true;
518
+ if (kind === KIND_QUANTIFIER) return visit(manager.getQuantifier(current).body);
519
+ const decl = manager.decls[current];
520
+ if (fs.has(decl) && !acyclic.has(decl)) return false;
521
+ return manager.everyArg(current, (arg) => visit(arg));
522
+ };
523
+ return visit(def);
524
+ };
525
+ for (;;) {
526
+ const size = acyclic.size;
527
+ if (size === fs.size) return false;
528
+ for (const entry of fs)
529
+ if (!acyclic.has(entry[0]) && isAcyclic(entry[1])) acyclic.add(entry[0]);
530
+ if (size === acyclic.size) return true;
531
+ }
532
+ };
533
+
534
+ const greedy = (depth: number): boolean => {
535
+ if (residue.size === 0) return !isCyclic();
536
+ const candidates = new Set<number>();
537
+ for (const quantifier of residue)
538
+ for (const macro of getInfo(quantifier).condMacros)
539
+ if (macro.isSatisfyAtom && !forbidden.has(macro.decl) && !fs.has(macro.decl))
540
+ candidates.add(macro.decl);
541
+ for (const decl of candidates) if (greedyOn(decl, depth)) return true;
542
+ return false;
543
+ };
544
+
545
+ const greedyOn = (decl: number, depth: number): boolean => {
546
+ if (depth >= GREEDY_MAX_DEPTH) return false;
547
+ for (const entry of qFDef.get(decl) ?? []) {
548
+ const savedSatisfied = [...satisfied];
549
+ const savedResidue = [...residue];
550
+ fs.set(decl, entry[0]);
551
+ // update_satisfied_residue.
552
+ let isUseful = false;
553
+ for (const quantifier of entry[1]) {
554
+ if (satisfied.has(quantifier)) continue;
555
+ isUseful = true;
556
+ residue.delete(quantifier);
557
+ satisfied.add(quantifier);
558
+ getInfo(quantifier).theOne = decl;
559
+ }
560
+ if (isUseful) {
561
+ for (const quantifier of qF.get(decl) ?? [])
562
+ if (!satisfied.has(quantifier)) residue.add(quantifier);
563
+ if (greedy(depth + 1)) return true;
564
+ }
565
+ for (const quantifier of satisfied)
566
+ if (!savedSatisfied.includes(quantifier)) getInfo(quantifier).theOne = null;
567
+ satisfied.clear();
568
+ for (const quantifier of savedSatisfied) satisfied.add(quantifier);
569
+ residue.clear();
570
+ for (const quantifier of savedResidue) residue.add(quantifier);
571
+ fs.delete(decl);
572
+ }
573
+ return false;
574
+ };
575
+
576
+ for (const decl of candidateDecls) {
577
+ if (!greedyOn(decl, 0)) continue;
578
+ for (const entry of fs) setElseInterp(manager, model, entry[0], entry[1]);
579
+ for (const quantifier of qcandidates) if (!satisfied.has(quantifier)) newQs.push(quantifier);
580
+ return true;
581
+ }
582
+ newQs.push(...qcandidates);
583
+ return false;
584
+ };
585
+
586
+ // collect_func_decls with ng_only: the uninterpreted functions applied in non-ground terms.
587
+ const collectNgFuncDecls = (manager: AstManager, expr: number) => {
588
+ const decls = new Set<number>();
589
+ const visited = new Set<number>();
590
+ const visit = (current: number) => {
591
+ if (visited.has(current)) return;
592
+ visited.add(current);
593
+ const kind = manager.kinds[current];
594
+ if (kind === KIND_VAR) return;
595
+ if (kind === KIND_QUANTIFIER) return;
596
+ for (let index = 0; index < manager.getNumArgs(current); index++) {
597
+ const arg = manager.getArg(current, index);
598
+ visit(arg);
599
+ }
600
+ if (
601
+ manager.getNumArgs(current) > 0 &&
602
+ !manager.isGround(current) &&
603
+ isUserApp(manager, current)
604
+ )
605
+ decls.add(manager.decls[current]);
606
+ };
607
+ visit(expr);
608
+ return decls;
609
+ };
610
+
611
+ // non_auf_macro_solver: satisfies quantifiers outside the AUF fragment with their macros, even when
612
+ // other quantifiers use the defined symbol.
613
+ const nonAufMacroSolver =
614
+ (
615
+ manager: AstManager,
616
+ model: ProtoModel,
617
+ getInfo: GetInfo,
618
+ dependencies: Map<number, Set<number>>,
619
+ forceTemplate: number,
620
+ ): Process =>
621
+ (qs, newQs, residue) => {
622
+ // func_decl_dependencies::insert: fails when f has a definition or the new one is cyclic.
623
+ const addMacro = (decl: number, elseExpr: number) => {
624
+ if (dependencies.has(decl)) return false;
625
+ dependencies.set(decl, collectNgFuncDecls(manager, elseExpr));
626
+ const colors = new Map<number, "progress" | "closed">();
627
+ const isCycle = (current: number): boolean => {
628
+ const color = colors.get(current);
629
+ if (color === "closed") return false;
630
+ if (color === "progress") return true;
631
+ colors.set(current, "progress");
632
+ for (const child of dependencies.get(current) ?? []) if (isCycle(child)) return true;
633
+ colors.set(current, "closed");
634
+ return false;
635
+ };
636
+ if (isCycle(decl)) {
637
+ dependencies.delete(decl);
638
+ return false;
639
+ }
640
+ setElseInterp(manager, model, decl, elseExpr);
641
+ return true;
642
+ };
643
+ const isBetterMacro = (first: CondMacro, second: CondMacro | null) => {
644
+ if (second === null || !first.isHint) return true;
645
+ if (!second.isHint) return false;
646
+ return manager.isGround(first.def) && !manager.isGround(second.def);
647
+ };
648
+ const getMacroFor = (decl: number, quantifier: number) => {
649
+ let result: CondMacro | null = null;
650
+ for (const macro of getInfo(quantifier).condMacros)
651
+ if (macro.decl === decl && !macro.isHint && isBetterMacro(macro, result)) result = macro;
652
+ return result;
653
+ };
654
+ const isUnconditional = (macro: CondMacro) => macro.cond === null || manager.isTrue(macro.cond);
655
+
656
+ const fullMacros = new Map<number, { macro: CondMacro; quantifier: number }>();
657
+ const condMacros = new Set<number>();
658
+ for (const quantifier of qs) {
659
+ const info = getInfo(quantifier);
660
+ for (const macro of info.condMacros) {
661
+ if (macro.isHint) continue;
662
+ if (isUnconditional(macro) && (!info.isAuf || macro.weight >= forceTemplate)) {
663
+ fullMacros.set(macro.decl, { macro, quantifier });
664
+ condMacros.delete(macro.decl);
665
+ } else if (!fullMacros.has(macro.decl) && !info.isAuf) condMacros.add(macro.decl);
666
+ }
667
+ }
668
+ const removed = new Set<number>();
669
+ for (const entry of fullMacros)
670
+ if (addMacro(entry[0], entry[1].macro.def)) {
671
+ getInfo(entry[1].quantifier).theOne = entry[0];
672
+ removed.add(entry[1].quantifier);
673
+ }
674
+ for (const decl of condMacros) {
675
+ let elseExpr: number | null = null;
676
+ const toRemove: number[] = [];
677
+ let isFullMacro = false;
678
+ for (const quantifier of qs) {
679
+ if (removed.has(quantifier)) continue;
680
+ const macro = getMacroFor(decl, quantifier);
681
+ if (macro === null) continue;
682
+ if (isUnconditional(macro)) {
683
+ isFullMacro = true;
684
+ break;
685
+ }
686
+ toRemove.push(quantifier);
687
+ elseExpr =
688
+ elseExpr === null
689
+ ? macro.def
690
+ : manager.mkApp(
691
+ OP_ITE,
692
+ [macro.cond ?? manager.trueExpr, macro.def, elseExpr],
693
+ manager.sorts[elseExpr],
694
+ );
695
+ }
696
+ if (isFullMacro || elseExpr === null || !addMacro(decl, elseExpr)) continue;
697
+ for (const quantifier of toRemove) {
698
+ getInfo(quantifier).theOne = decl;
699
+ removed.add(quantifier);
700
+ }
701
+ }
702
+ for (const quantifier of qs) {
703
+ if (removed.has(quantifier)) continue;
704
+ newQs.push(quantifier);
705
+ residue.push(quantifier);
706
+ }
707
+ return removed.size > 0;
708
+ };
709
+
710
+ // The macro part of model_finder::fix_model: returns the quantifiers left for the AUF solver.
711
+ export const solveMacros = (
712
+ manager: AstManager,
713
+ model: ProtoModel,
714
+ qs: number[],
715
+ getInfo: GetInfo,
716
+ forceTemplate: number,
717
+ ) => {
718
+ const residue: number[] = [];
719
+ const afterSimple = runMacroSolver(qs, residue, simpleMacroSolver(manager, model, getInfo));
720
+ const afterHint = runMacroSolver(afterSimple, residue, hintMacroSolver(manager, model, getInfo));
721
+ const dependencies = new Map<number, Set<number>>();
722
+ const afterNonAuf = runMacroSolver(
723
+ afterHint,
724
+ residue,
725
+ nonAufMacroSolver(manager, model, getInfo, dependencies, forceTemplate),
726
+ );
727
+ return [...afterNonAuf, ...residue];
728
+ };