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

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 +33 -143
  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,607 @@
1
+ // Ported from Z3 (src/nlsat/nlsat_explain.cpp), MIT license, see z3-license.txt. Explains a set of
2
+ // literals that is infeasible at the sample: the literals of a lemma that exclude a cell around
3
+ // the sample in which the set stays infeasible. Only Z3's default nlsat parameters are ported:
4
+ // simplify_conflicts and factor on, minimize_conflicts, add_all_coeffs and zero_disc off, and lws
5
+ // on. So the cell always comes from the levelwise construction, and Z3's fallback projection
6
+ // (project with cac_add_cell_lits, add_lcs and the psc_* helpers) is not ported.
7
+ import type { AlgebraicManager, Anum } from "./algebraic";
8
+ import {
9
+ type AtomTable,
10
+ FALSE_LITERAL,
11
+ flipKind,
12
+ ScopedLiteral,
13
+ ScopedLiterals,
14
+ TRUE_BOOL_VAR,
15
+ TRUE_LITERAL,
16
+ } from "./atoms";
17
+ import { getSingleCell, TodoSet } from "./levelwise";
18
+ import {
19
+ NULL_VAR,
20
+ type Polynomial,
21
+ type PolynomialCache,
22
+ type PolynomialManager,
23
+ } from "./polynomial";
24
+ import { type IneqAtom, type IneqKind, type RootKind, isIneqAtom } from "./types";
25
+
26
+ // The solver state an explanation reads.
27
+ export interface ExplainContext {
28
+ atoms: AtomTable;
29
+ // sample(): the solver's assignment, refined in place.
30
+ sample: (Anum | undefined)[];
31
+ // value(l): l_true, l_false or l_undef, as 1, -1 and 0.
32
+ getValue: (literal: number) => number;
33
+ // m_var2eq: the equation of least degree assigned for each variable.
34
+ var2eq: (IneqAtom | null)[];
35
+ }
36
+
37
+ // add_all_coeffs_restart: every coefficient of a polynomial vanished, so the explanation starts
38
+ // over adding all coefficients.
39
+ class AddAllCoeffsRestart {}
40
+
41
+ // eq_info: an equation used to rewrite the core, and what its leading coefficient must satisfy.
42
+ interface EqInfo {
43
+ eq: Polynomial;
44
+ variable: number;
45
+ degree: number;
46
+ lc: Polynomial;
47
+ lcSign: number;
48
+ isLcConst: boolean;
49
+ isLcAdded: boolean;
50
+ isLcIneqAdded: boolean;
51
+ }
52
+
53
+ const ROOT_TO_INEQ: Record<RootKind, { kind: IneqKind; isNeg: boolean }> = {
54
+ ROOT_EQ: { kind: "EQ", isNeg: false },
55
+ ROOT_LT: { kind: "LT", isNeg: false },
56
+ ROOT_GT: { kind: "GT", isNeg: false },
57
+ ROOT_LE: { kind: "GT", isNeg: true },
58
+ ROOT_GE: { kind: "LT", isNeg: true },
59
+ };
60
+
61
+ const addLcIneq = (info: EqInfo) => {
62
+ info.isLcAdded = true;
63
+ info.isLcIneqAdded = true;
64
+ };
65
+
66
+ const addLcDiseq = (info: EqInfo) => {
67
+ if (info.isLcAdded) return;
68
+ info.isLcAdded = true;
69
+ info.isLcIneqAdded = false;
70
+ };
71
+
72
+ const getKindForSign = (sign: number): IneqKind => (sign === 0 ? "EQ" : sign < 0 ? "LT" : "GT");
73
+
74
+ export class Explain {
75
+ private result: ScopedLiterals | null = null;
76
+ private added = new Set<number>();
77
+ private todo: TodoSet;
78
+ private lowerStagePolys: Polynomial[] = [];
79
+ private core: ScopedLiterals;
80
+ private isAddAllCoeffs = false;
81
+
82
+ // m_full_dimensional: the solver sets it when every clause is full dimensional, and the cell
83
+ // bounds are then closed.
84
+ isFullDimensional = false;
85
+
86
+ constructor(
87
+ private pm: PolynomialManager,
88
+ private am: AlgebraicManager,
89
+ private cache: PolynomialCache,
90
+ private context: ExplainContext,
91
+ ) {
92
+ this.todo = new TodoSet(pm, cache);
93
+ this.core = new ScopedLiterals(context.atoms);
94
+ }
95
+
96
+ private getSign(polynomial: Polynomial) {
97
+ return this.am.evalSignAt(this.pm, polynomial, this.context.sample);
98
+ }
99
+
100
+ private getAtom(literal: number) {
101
+ return this.context.atoms.getAtom(literal)!;
102
+ }
103
+
104
+ private addLiteral(literal: number) {
105
+ if (literal === FALSE_LITERAL || this.added.has(literal)) return;
106
+ this.added.add(literal);
107
+ this.result!.push(literal);
108
+ }
109
+
110
+ private resetResult() {
111
+ this.added.clear();
112
+ this.result = null;
113
+ }
114
+
115
+ private collectPolys(literals: readonly number[]) {
116
+ return literals.flatMap((literal) => {
117
+ const atom = this.getAtom(literal);
118
+ return isIneqAtom(atom) ? atom.polynomials : [atom.polynomial];
119
+ });
120
+ }
121
+
122
+ private getMaxVarOfPolys(polynomials: readonly Polynomial[]) {
123
+ let result = NULL_VAR;
124
+ for (const polynomial of polynomials) {
125
+ const variable = this.pm.maxVar(polynomial);
126
+ if (result === NULL_VAR || variable > result) result = variable;
127
+ }
128
+ return result;
129
+ }
130
+
131
+ private getMaxVarOfLiterals(literals: readonly number[]) {
132
+ let result = NULL_VAR;
133
+ for (const literal of literals) {
134
+ const atom = this.context.atoms.getAtom(literal);
135
+ if (atom !== null && (result === NULL_VAR || atom.maxVar > result)) result = atom.maxVar;
136
+ }
137
+ return result;
138
+ }
139
+
140
+ // add_assumption: the negation of p kind 0, or of p != 0 when isNeg, into the lemma.
141
+ private addAssumption(kind: IneqKind, polynomial: Polynomial, isNeg = false) {
142
+ const boolVar = this.context.atoms.mkIneqAtom(kind, [polynomial], [false]);
143
+ this.addLiteral(2 * boolVar + (isNeg ? 0 : 1));
144
+ }
145
+
146
+ // find_cell_roots for one polynomial: the root equal to the sample of its maximal variable.
147
+ private findSectionRoot(polynomial: Polynomial, variable: number) {
148
+ const value = this.context.sample[variable]!;
149
+ const values = this.context.sample.map((current, index) =>
150
+ index === variable ? undefined : current,
151
+ );
152
+ const roots = this.am.isolateRoots(this.pm, polynomial, values);
153
+ for (const [index, root] of roots.entries()) {
154
+ const sign = this.am.compare(value, root);
155
+ if (sign === 0) return index + 1;
156
+ if (sign < 0) return null;
157
+ }
158
+ return null;
159
+ }
160
+
161
+ // add_zero_assumption: p vanishes at the sample, so the sample lies on a root of its square-free
162
+ // part, which becomes a section literal.
163
+ private addZeroAssumption(polynomial: Polynomial) {
164
+ const squareFree = this.pm.squareFree(polynomial);
165
+ if (this.pm.isConst(squareFree)) return;
166
+ const variable = this.pm.maxVar(squareFree);
167
+ const index = this.findSectionRoot(squareFree, variable);
168
+ if (index !== null) this.addRootLiteral("ROOT_EQ", variable, index, squareFree);
169
+ }
170
+
171
+ // elim_vanishing: p without its leading coefficients that vanish at the sample, each of which
172
+ // becomes an assumption. Zero when all do.
173
+ private elimVanishing(polynomial: Polynomial) {
174
+ let p = polynomial;
175
+ let variable = this.pm.maxVar(p);
176
+ let degree = this.pm.degree(p, variable);
177
+ while (true) {
178
+ if (this.pm.isConst(p)) return p;
179
+ if (degree === 0) {
180
+ variable = this.pm.maxVar(p);
181
+ degree = this.pm.degree(p, variable);
182
+ }
183
+ if (this.pm.isNonzeroConstCoeff(p, variable, degree)) return p;
184
+ // Z3 passes lc to insert_fresh_factors_in_todo by reference, so from here on lc is without
185
+ // its own vanishing coefficients, which equals it given the assumptions that removed them.
186
+ const lc = this.insertFreshFactorsInTodo(this.pm.coeff(p, variable, degree));
187
+ const reduct = this.pm.reduct(p, variable, degree);
188
+ if (!this.pm.isZero(lc) && this.getSign(lc) !== 0) return p;
189
+ if (degree === 0) {
190
+ if (this.isAddAllCoeffs) {
191
+ this.addZeroAssumption(lc);
192
+ return this.pm.zero;
193
+ }
194
+ this.isAddAllCoeffs = true;
195
+ throw new AddAllCoeffsRestart();
196
+ }
197
+ this.addZeroAssumption(lc);
198
+ degree--;
199
+ p = reduct;
200
+ }
201
+ }
202
+
203
+ private elimVanishingAll(polynomials: readonly Polynomial[]) {
204
+ return polynomials
205
+ .map((polynomial) => this.elimVanishing(polynomial))
206
+ .filter((polynomial) => !this.pm.isConst(polynomial));
207
+ }
208
+
209
+ // insert_fresh_factors_in_todo: the factors of p, without their vanishing coefficients. Returns
210
+ // p without its vanishing coefficients, which Z3 writes back to its argument.
211
+ private insertFreshFactorsInTodo(polynomial: Polynomial) {
212
+ if (this.pm.isConst(polynomial)) return polynomial;
213
+ const p = this.elimVanishing(polynomial);
214
+ if (this.pm.isConst(p)) return p;
215
+ for (const factor of this.cache.factor(p)) {
216
+ const reduced = this.elimVanishing(factor);
217
+ if (!this.pm.isConst(reduced)) this.todo.insert(reduced);
218
+ }
219
+ return p;
220
+ }
221
+
222
+ // normalize: the literal without the vanishing coefficients of max and the factors of lower
223
+ // stages, which become assumptions. True or false when nothing is left.
224
+ private normalizeLiteral(literal: number, max: number) {
225
+ if (literal >> 1 === TRUE_BOOL_VAR) return literal;
226
+ const atom = this.getAtom(literal);
227
+ if (!isIneqAtom(atom)) return literal;
228
+ const isNeg = (literal & 1) === 1;
229
+ const polynomials: Polynomial[] = [];
230
+ const isEven: boolean[] = [];
231
+ let atomSign = 1;
232
+ let isNormalized = false;
233
+ for (const [index, factor] of atom.polynomials.entries()) {
234
+ const p = this.pm.maxVar(factor) === max ? this.elimVanishing(factor) : factor;
235
+ if (this.pm.isConst(p) || this.pm.maxVar(p) < max) {
236
+ const sign = this.getSign(p);
237
+ if (!this.pm.isConst(p)) {
238
+ this.lowerStagePolys.push(p);
239
+ if (sign === 0) this.addAssumption("EQ", p);
240
+ else if (atom.isEven[index]) this.addAssumption("EQ", p, true);
241
+ else this.addAssumption(getKindForSign(sign), p);
242
+ }
243
+ if (sign === 0) return (atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
244
+ if (sign < 0 && !atom.isEven[index]) atomSign = -atomSign;
245
+ isNormalized = true;
246
+ continue;
247
+ }
248
+ if (p !== factor) isNormalized = true;
249
+ isEven.push(atom.isEven[index]);
250
+ polynomials.push(p);
251
+ }
252
+ if (polynomials.length === 0) {
253
+ const isTrue = atom.kind === "EQ" ? false : atom.kind === "LT" ? atomSign < 0 : atomSign > 0;
254
+ return isTrue !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
255
+ }
256
+ if (!isNormalized) return literal;
257
+ const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
258
+ return this.context.atoms.mkIneqLiteral(kind, polynomials, isEven) ^ (isNeg ? 1 : 0);
259
+ }
260
+
261
+ private normalizeCore(core: ScopedLiterals, max: number) {
262
+ let kept = 0;
263
+ for (const literal of core.literals) {
264
+ const normalized = this.normalizeLiteral(literal, max);
265
+ if (normalized === TRUE_LITERAL) continue;
266
+ if (normalized === FALSE_LITERAL) {
267
+ core.reset();
268
+ return;
269
+ }
270
+ core.set(kept++, normalized);
271
+ }
272
+ core.shrink(kept);
273
+ }
274
+
275
+ // simplify(l, info, max, new_lit): rewrites the factors of degree at least the equation's by
276
+ // their pseudo-remainders, recording the condition on the equation's leading coefficient.
277
+ private simplifyLiteral(literal: number, info: EqInfo, max: number, newLiteral: ScopedLiteral) {
278
+ const atom = this.getAtom(literal);
279
+ if (!isIneqAtom(atom) || (atom.polynomials.length === 1 && atom.polynomials[0] === info.eq)) {
280
+ newLiteral.set(literal);
281
+ return;
282
+ }
283
+ const isNeg = (literal & 1) === 1;
284
+ const factors: Polynomial[] = [];
285
+ const isEven: boolean[] = [];
286
+ let atomSign = 1;
287
+ let isModified = false;
288
+ const addLcCondition = (steps: number, isFactorEven: boolean) => {
289
+ if (info.isLcConst) return;
290
+ if (steps % 2 === 0 || isFactorEven || atom.kind === "EQ") addLcDiseq(info);
291
+ else addLcIneq(info);
292
+ };
293
+ for (const [index, factor] of atom.polynomials.entries()) {
294
+ const isFactorEven = atom.isEven[index];
295
+ if (this.pm.degree(factor, info.variable) < info.degree) {
296
+ factors.push(factor);
297
+ isEven.push(isFactorEven);
298
+ continue;
299
+ }
300
+ isModified = true;
301
+ const division = this.pm.pseudoRemainder(factor, info.eq, info.variable);
302
+ if (division.steps % 2 === 1 && !isFactorEven && info.lcSign < 0) atomSign = -atomSign;
303
+ const remainder = division.remainder;
304
+ if (!this.pm.isConst(remainder)) {
305
+ factors.push(remainder);
306
+ isEven.push(isFactorEven);
307
+ addLcCondition(division.steps, isFactorEven);
308
+ continue;
309
+ }
310
+ const sign = this.getSign(remainder);
311
+ if (sign === 0) {
312
+ newLiteral.set((atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL);
313
+ if (!info.isLcConst) addLcDiseq(info);
314
+ return;
315
+ }
316
+ addLcCondition(division.steps, isFactorEven);
317
+ if (sign < 0 && !isFactorEven) atomSign = -atomSign;
318
+ }
319
+ if (!isModified) {
320
+ newLiteral.set(literal);
321
+ return;
322
+ }
323
+ const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
324
+ newLiteral.set(this.context.atoms.mkIneqLiteral(kind, factors, isEven) ^ (isNeg ? 1 : 0));
325
+ // Z3's null_var is the largest unsigned, so true and false never count as lower stage.
326
+ const maxVar = this.context.atoms.getMaxVar(newLiteral.literal);
327
+ if (maxVar === NULL_VAR || maxVar >= max) {
328
+ newLiteral.set(this.normalizeLiteral(newLiteral.literal, max));
329
+ return;
330
+ }
331
+ if (this.context.getValue(newLiteral.literal) === 1) {
332
+ newLiteral.set(literal);
333
+ return;
334
+ }
335
+ this.addLiteral(newLiteral.literal);
336
+ newLiteral.set(TRUE_LITERAL);
337
+ }
338
+
339
+ // simplify(C, eq, max): the core rewritten by eq. Like Z3's scoped_literal, newLiteral keeps a
340
+ // reference until the next literal or the end, also when an elimination restarts.
341
+ private simplifyWithEq(core: ScopedLiterals, eq: Polynomial, max: number) {
342
+ const variable = this.pm.maxVar(eq);
343
+ const degree = this.pm.degree(eq, variable);
344
+ const lc = this.pm.coeff(eq, variable, degree);
345
+ const info: EqInfo = {
346
+ eq,
347
+ variable,
348
+ degree,
349
+ lc,
350
+ lcSign: this.getSign(lc),
351
+ isLcConst: this.pm.isConst(lc),
352
+ isLcAdded: false,
353
+ isLcIneqAdded: false,
354
+ };
355
+ const newLiteral = new ScopedLiteral(this.context.atoms);
356
+ try {
357
+ let isModified = false;
358
+ let kept = 0;
359
+ for (const literal of core.literals) {
360
+ newLiteral.set(TRUE_LITERAL);
361
+ this.simplifyLiteral(literal, info, max, newLiteral);
362
+ if (newLiteral.literal === literal) {
363
+ core.set(kept++, literal);
364
+ continue;
365
+ }
366
+ isModified = true;
367
+ if (newLiteral.literal === TRUE_LITERAL) continue;
368
+ if (newLiteral.literal === FALSE_LITERAL) {
369
+ kept = 0;
370
+ break;
371
+ }
372
+ core.set(kept++, newLiteral.literal);
373
+ }
374
+ core.shrink(kept);
375
+ if (info.isLcAdded) {
376
+ if (info.isLcIneqAdded) this.addAssumption(info.lcSign < 0 ? "LT" : "GT", info.lc);
377
+ else this.addAssumption("EQ", info.lc, true);
378
+ }
379
+ return isModified;
380
+ } finally {
381
+ newLiteral.set(TRUE_LITERAL);
382
+ }
383
+ }
384
+
385
+ // select_eq: the positive single-factor odd equation of least degree in max.
386
+ private selectEq(core: ScopedLiterals, max: number) {
387
+ let result: Polynomial | null = null;
388
+ let minDegree = Infinity;
389
+ for (const literal of core.literals) {
390
+ if ((literal & 1) === 1) continue;
391
+ const atom = this.getAtom(literal);
392
+ if (!isIneqAtom(atom) || atom.kind !== "EQ" || atom.polynomials.length > 1 || atom.isEven[0])
393
+ continue;
394
+ const degree = this.pm.degree(atom.polynomials[0], max);
395
+ if (degree < minDegree) {
396
+ result = atom.polynomials[0];
397
+ minDegree = degree;
398
+ if (minDegree === 1) break;
399
+ }
400
+ }
401
+ return result;
402
+ }
403
+
404
+ // select_lower_stage_eq: an assigned equation of a lower variable with a constant leading
405
+ // coefficient that can rewrite a literal of the core.
406
+ private selectLowerStageEq(core: ScopedLiterals, max: number) {
407
+ for (const literal of core.literals) {
408
+ const atom = this.getAtom(literal);
409
+ if (!isIneqAtom(atom)) continue;
410
+ for (const factor of atom.polynomials) {
411
+ const variables = new Set(factor.ms.flatMap((monomial) => [...monomial.vars]));
412
+ for (const variable of variables) {
413
+ if (variable >= max) continue;
414
+ const eq = this.context.var2eq[variable] ?? null;
415
+ if (eq === null) continue;
416
+ const eqPolynomial = eq.polynomials[0];
417
+ const eqDegree = this.pm.degree(eqPolynomial, variable);
418
+ if (!this.pm.isNonzeroConstCoeff(eqPolynomial, variable, eqDegree)) continue;
419
+ if (this.pm.degree(factor, variable) >= eqDegree) return eq;
420
+ }
421
+ }
422
+ }
423
+ return null;
424
+ }
425
+
426
+ private simplifyCore(core: ScopedLiterals, max: number) {
427
+ while (core.size > 0) {
428
+ const eq = this.selectEq(core, max);
429
+ if (eq === null || !this.simplifyWithEq(core, eq, max)) break;
430
+ }
431
+ while (core.size > 0) {
432
+ const eq = this.selectLowerStageEq(core, max);
433
+ if (eq === null) break;
434
+ this.simplifyWithEq(core, eq.polynomials[0], max);
435
+ this.addLiteral(2 * eq.boolVar + 1);
436
+ }
437
+ }
438
+
439
+ // add_root_literal: the negation of y kind root[i](p), as an inequality when p is linear or
440
+ // quadratic in y, else as a root atom.
441
+ private addRootLiteral(kind: RootKind, variable: number, index: number, polynomial: Polynomial) {
442
+ if (this.mkLinearRoot(kind, variable, polynomial)) return;
443
+ if (this.mkQuadraticRoot(kind, variable, index, polynomial)) return;
444
+ const boolVar = this.context.atoms.mkRootAtom(kind, variable, index, polynomial);
445
+ this.addLiteral(2 * boolVar + 1);
446
+ }
447
+
448
+ private mkLinearRoot(kind: RootKind, variable: number, polynomial: Polynomial) {
449
+ const coeff = this.pm.getConstCoeff(polynomial, variable, 1);
450
+ if (this.pm.degree(polynomial, variable) !== 1 || coeff === null) return false;
451
+ this.addLinearRoot(kind, polynomial, coeff < 0n);
452
+ return true;
453
+ }
454
+
455
+ private addLinearRoot(kind: RootKind, polynomial: Polynomial, isNegated: boolean) {
456
+ const ineq = ROOT_TO_INEQ[kind];
457
+ this.addAssumption(ineq.kind, isNegated ? this.pm.neg(polynomial) : polynomial, ineq.isNeg);
458
+ }
459
+
460
+ // mk_plinear_root: a root of p linear in y whose coefficient keeps its sign.
461
+ private mkPlinearRoot(kind: RootKind, variable: number, polynomial: Polynomial) {
462
+ if (this.pm.degree(polynomial, variable) !== 1) return false;
463
+ const coeff = this.pm.coeff(polynomial, variable, 1);
464
+ const sign = this.getSign(coeff);
465
+ if (sign === 0) return false;
466
+ this.ensureSign(coeff);
467
+ this.addLinearRoot(kind, polynomial, sign < 0);
468
+ return true;
469
+ }
470
+
471
+ // mk_quadratic_root: by Thom's lemma, the signs of the discriminant, the leading coefficient, the
472
+ // derivative and p characterize the sample's position among the roots of a quadratic.
473
+ private mkQuadraticRoot(kind: RootKind, variable: number, index: number, polynomial: Polynomial) {
474
+ if (this.pm.degree(polynomial, variable) !== 2 || (index !== 1 && index !== 2)) return false;
475
+ const a = this.pm.coeff(polynomial, variable, 2);
476
+ const b = this.pm.coeff(polynomial, variable, 1);
477
+ const c = this.pm.coeff(polynomial, variable, 0);
478
+ const discriminant = this.pm.sub(this.pm.mul(b, b), this.pm.mul(this.pm.mulConst(4n, a), c));
479
+ const y = this.pm.mkVar(variable);
480
+ const derivative = this.pm.normalize(this.pm.add(this.pm.mul(this.pm.mulConst(2n, a), y), b));
481
+ if (this.ensureSignQuad(discriminant) < 0) return false;
482
+ if (this.ensureSignQuad(a) === 0)
483
+ return this.mkPlinearRoot(kind, variable, this.pm.add(this.pm.mul(b, y), c));
484
+ this.ensureSign(derivative);
485
+ if (this.getSign(discriminant) > 0) this.ensureSign(polynomial);
486
+ return true;
487
+ }
488
+
489
+ private ensureSign(polynomial: Polynomial) {
490
+ if (this.pm.isConst(polynomial)) return;
491
+ this.addAssumption(getKindForSign(this.getSign(polynomial)), polynomial);
492
+ this.insertFreshFactorsInTodo(polynomial);
493
+ }
494
+
495
+ private ensureSignQuad(polynomial: Polynomial) {
496
+ const sign = this.getSign(polynomial);
497
+ if (!this.pm.isConst(polynomial)) {
498
+ this.addAssumption(getKindForSign(sign), polynomial);
499
+ this.insertFreshFactorsInTodo(polynomial);
500
+ }
501
+ return sign;
502
+ }
503
+
504
+ // levelwise_single_cell: the literals that bound the cell.
505
+ private addCellLiterals(polynomials: readonly Polynomial[], maxVar: number, isLinear: boolean) {
506
+ const cell = getSingleCell(
507
+ this.pm,
508
+ this.am,
509
+ this.cache,
510
+ polynomials,
511
+ maxVar,
512
+ this.context.sample,
513
+ isLinear,
514
+ );
515
+ const isFull = this.isFullDimensional;
516
+ for (const interval of cell) {
517
+ if (interval.isSection) {
518
+ const lower = interval.lower!;
519
+ this.addRootLiteral("ROOT_EQ", this.pm.maxVar(lower), interval.lowerIndex, lower);
520
+ continue;
521
+ }
522
+ if (interval.lower !== null)
523
+ this.addRootLiteral(
524
+ isFull ? "ROOT_GE" : "ROOT_GT",
525
+ this.pm.maxVar(interval.lower),
526
+ interval.lowerIndex,
527
+ interval.lower,
528
+ );
529
+ if (interval.upper !== null)
530
+ this.addRootLiteral(
531
+ isFull ? "ROOT_LE" : "ROOT_LT",
532
+ this.pm.maxVar(interval.upper),
533
+ interval.upperIndex,
534
+ interval.upper,
535
+ );
536
+ }
537
+ }
538
+
539
+ // project: the factors of the polynomials, then the cell around the sample.
540
+ private project(polynomials: readonly Polynomial[], maxVar: number) {
541
+ if (polynomials.length === 0) return;
542
+ this.todo.reset();
543
+ for (const polynomial of polynomials) this.insertFreshFactorsInTodo(polynomial);
544
+ this.addCellLiterals([...this.todo.polynomials], maxVar, false);
545
+ }
546
+
547
+ private explainCore(literals: readonly number[]) {
548
+ if (literals.length === 0) return;
549
+ const polynomials = [...this.collectPolys(literals), ...this.lowerStagePolys];
550
+ const maxVar = this.getMaxVarOfPolys(polynomials);
551
+ this.project(this.elimVanishingAll(polynomials), maxVar);
552
+ }
553
+
554
+ // process2: with simplify_conflicts, the core normalized and rewritten by its equations first.
555
+ // As in Z3, a restart leaves the core holding its literals until the next attempt.
556
+ private process(literals: readonly number[]) {
557
+ this.lowerStagePolys = [];
558
+ const core = this.core;
559
+ core.reset();
560
+ for (const literal of literals) core.push(literal);
561
+ const max = this.getMaxVarOfLiterals(literals);
562
+ this.normalizeCore(core, max);
563
+ this.simplifyCore(core, max);
564
+ this.explainCore(core.literals);
565
+ core.reset();
566
+ }
567
+
568
+ // compute_conflict_explanation: the literals, appended to result, that with the negations of
569
+ // literals make a valid lemma.
570
+ computeConflictExplanation(literals: readonly number[], result: ScopedLiterals) {
571
+ if (this.getMaxVarOfLiterals(literals) === 0 && this.context.sample[0] === undefined) {
572
+ result.reset();
573
+ return;
574
+ }
575
+ const savedAddAllCoeffs = this.isAddAllCoeffs;
576
+ const base = result.size;
577
+ try {
578
+ while (true) {
579
+ this.result = result;
580
+ try {
581
+ this.process(literals);
582
+ return;
583
+ } catch (error) {
584
+ if (!(error instanceof AddAllCoeffsRestart)) throw error;
585
+ result.shrink(base);
586
+ } finally {
587
+ this.resetResult();
588
+ }
589
+ }
590
+ } finally {
591
+ this.isAddAllCoeffs = savedAddAllCoeffs;
592
+ }
593
+ }
594
+
595
+ // compute_linear_explanation: the literals of a linear cell around a sample of every variable.
596
+ computeLinearExplanation(literals: readonly number[], result: ScopedLiterals) {
597
+ this.result = result;
598
+ this.lowerStagePolys = [];
599
+ const polynomials = this.collectPolys(literals);
600
+ try {
601
+ if (polynomials.length > 0)
602
+ this.addCellLiterals(polynomials, this.getMaxVarOfPolys(polynomials) + 1, true);
603
+ } finally {
604
+ this.resetResult();
605
+ }
606
+ }
607
+ }