tla-ts 0.0.4-dev.e4c2d0e → 0.0.4-dev.e92649a

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 (311) hide show
  1. package/README.md +26 -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 +35 -1
  6. package/dist/index.d.ts +35 -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 +515 -0
  15. package/dist/prove.js +515 -0
  16. package/dist/run-cli.cjs +30 -47
  17. package/dist/run-cli.js +30 -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} +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-generate.ts → obligations/generate.ts} +134 -61
  36. package/src/{obligations.ts → obligations/index.ts} +26 -12
  37. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  38. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  39. package/src/obligations/pickle.ts +100 -0
  40. package/src/obligations/pragma.ts +189 -0
  41. package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
  42. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  43. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  44. package/src/obligations/temporal.ts +319 -0
  45. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  46. package/src/parallel-worker.ts +2 -18
  47. package/src/parallel.ts +10 -43
  48. package/src/prove/decide-pool.ts +100 -0
  49. package/src/prove/deciders.ts +27 -0
  50. package/src/prove/isabelle/LICENSE +36 -0
  51. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  52. package/src/prove/isabelle/decide.ts +47 -0
  53. package/src/prove/isabelle/encode.ts +477 -0
  54. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  55. package/src/prove/isabelle/isar/method.ts +367 -0
  56. package/src/prove/isabelle/isar/proof.ts +28 -0
  57. package/src/prove/isabelle/isar/statement.ts +57 -0
  58. package/src/prove/isabelle/isar/theory.ts +192 -0
  59. package/src/prove/isabelle/isar/type-check.ts +278 -0
  60. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  61. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  62. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  63. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  64. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  65. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  66. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  67. package/src/prove/isabelle/provers/classical.ts +389 -0
  68. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  69. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  70. package/src/prove/isabelle/pure/consts.ts +32 -0
  71. package/src/prove/isabelle/pure/conv.ts +79 -0
  72. package/src/prove/isabelle/pure/drule.ts +264 -0
  73. package/src/prove/isabelle/pure/envir.ts +363 -0
  74. package/src/prove/isabelle/pure/goal.ts +53 -0
  75. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  76. package/src/prove/isabelle/pure/list.ts +12 -0
  77. package/src/prove/isabelle/pure/logic.ts +402 -0
  78. package/src/prove/isabelle/pure/name.ts +110 -0
  79. package/src/prove/isabelle/pure/net.ts +262 -0
  80. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  81. package/src/prove/isabelle/pure/pattern.ts +650 -0
  82. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  83. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  84. package/src/prove/isabelle/pure/search.ts +68 -0
  85. package/src/prove/isabelle/pure/seq.ts +156 -0
  86. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  87. package/src/prove/isabelle/pure/table.ts +208 -0
  88. package/src/prove/isabelle/pure/tactic.ts +276 -0
  89. package/src/prove/isabelle/pure/tactical.ts +347 -0
  90. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  91. package/src/prove/isabelle/pure/term.ts +808 -0
  92. package/src/prove/isabelle/pure/thm.ts +806 -0
  93. package/src/prove/isabelle/pure/type.ts +133 -0
  94. package/src/prove/isabelle/pure/unify.ts +753 -0
  95. package/src/prove/isabelle/pure/variable.ts +25 -0
  96. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  97. package/src/prove/isabelle/tla/context.ts +74 -0
  98. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  99. package/src/prove/isabelle/tla/logic.ts +215 -0
  100. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  101. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  102. package/src/prove/ocaml.ts +22 -0
  103. package/src/prove/prep/action.ts +520 -0
  104. package/src/prove/prep/defs.ts +27 -0
  105. package/src/prove/prep/elab.ts +156 -0
  106. package/src/prove/prep/enabled-axioms.ts +189 -0
  107. package/src/prove/prep/enabled.ts +43 -0
  108. package/src/prove/prep/fingerprint.ts +388 -0
  109. package/src/prove/prep/flatten.ts +70 -0
  110. package/src/prove/prep/level-comparison.ts +552 -0
  111. package/src/prove/prep/md5.ts +67 -0
  112. package/src/prove/prep/pragma.ts +221 -0
  113. package/src/prove/prep/trivial.ts +22 -0
  114. package/src/prove/prove-worker.ts +29 -0
  115. package/src/prove/prove.ts +417 -0
  116. package/src/prove/ptl/decide.ts +68 -0
  117. package/src/prove/ptl/encode.ts +256 -0
  118. package/src/prove/ptl/sat.ts +151 -0
  119. package/src/prove/ptl/tableau.ts +276 -0
  120. package/src/prove/smt/axiomatize.ts +69 -0
  121. package/src/prove/smt/axioms.ts +210 -0
  122. package/src/prove/smt/context.ts +108 -0
  123. package/src/prove/smt/data.ts +665 -0
  124. package/src/prove/smt/encode.ts +169 -0
  125. package/src/prove/smt/extensionality.ts +63 -0
  126. package/src/prove/smt/flatten.ts +127 -0
  127. package/src/prove/smt/format.ts +143 -0
  128. package/src/prove/smt/instances.ts +182 -0
  129. package/src/prove/smt/rewrite.ts +784 -0
  130. package/src/prove/smt/simplify.ts +57 -0
  131. package/src/prove/smt/solver/act-cache.ts +265 -0
  132. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  133. package/src/prove/smt/solver/array.ts +22 -0
  134. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  135. package/src/prove/smt/solver/ast-lt.ts +157 -0
  136. package/src/prove/smt/solver/ast-util.ts +147 -0
  137. package/src/prove/smt/solver/ast.ts +1315 -0
  138. package/src/prove/smt/solver/auf-solver.ts +572 -0
  139. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  140. package/src/prove/smt/solver/cg-table.ts +175 -0
  141. package/src/prove/smt/solver/clause.ts +276 -0
  142. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  143. package/src/prove/smt/solver/context.ts +1292 -0
  144. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  145. package/src/prove/smt/solver/der.ts +224 -0
  146. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  147. package/src/prove/smt/solver/e-matching.ts +659 -0
  148. package/src/prove/smt/solver/enode.ts +259 -0
  149. package/src/prove/smt/solver/expr-ref.ts +21 -0
  150. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  151. package/src/prove/smt/solver/fingerprints.ts +92 -0
  152. package/src/prove/smt/solver/flat-literals.ts +51 -0
  153. package/src/prove/smt/solver/goal.ts +138 -0
  154. package/src/prove/smt/solver/hash.ts +173 -0
  155. package/src/prove/smt/solver/hashtable.ts +166 -0
  156. package/src/prove/smt/solver/internalizer.ts +1381 -0
  157. package/src/prove/smt/solver/lbool.ts +5 -0
  158. package/src/prove/smt/solver/literal.ts +24 -0
  159. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  160. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  161. package/src/prove/smt/solver/lp/containers.ts +296 -0
  162. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  163. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  164. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  165. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  166. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  167. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  168. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  169. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  170. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  171. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  172. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  173. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  174. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  175. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  176. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  177. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  178. package/src/prove/smt/solver/lp/nex.ts +120 -0
  179. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  180. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  181. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  182. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  183. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  184. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  185. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  186. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  187. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  188. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  189. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  190. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  191. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  192. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  193. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  194. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  195. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  196. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  197. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  198. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  199. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  200. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  201. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  202. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  203. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  204. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  205. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  206. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  207. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  208. package/src/prove/smt/solver/model-checker.ts +347 -0
  209. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  210. package/src/prove/smt/solver/model-finder.ts +155 -0
  211. package/src/prove/smt/solver/model-generator.ts +97 -0
  212. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  213. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  214. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  215. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  216. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  217. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  218. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  219. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  220. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  221. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  222. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  223. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  224. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  225. package/src/prove/smt/solver/nnf.ts +469 -0
  226. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  227. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  228. package/src/prove/smt/solver/propagate-values.ts +83 -0
  229. package/src/prove/smt/solver/proto-model.ts +551 -0
  230. package/src/prove/smt/solver/pull-quant.ts +139 -0
  231. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  232. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  233. package/src/prove/smt/solver/qe-lite.ts +381 -0
  234. package/src/prove/smt/solver/qi-queue.ts +362 -0
  235. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  236. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  237. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  238. package/src/prove/smt/solver/random-gen.ts +10 -0
  239. package/src/prove/smt/solver/rational.ts +165 -0
  240. package/src/prove/smt/solver/ref-vector.ts +62 -0
  241. package/src/prove/smt/solver/relevancy.ts +247 -0
  242. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  243. package/src/prove/smt/solver/rewriter.ts +843 -0
  244. package/src/prove/smt/solver/rlimit.ts +79 -0
  245. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  246. package/src/prove/smt/solver/solver.ts +71 -0
  247. package/src/prove/smt/solver/sort.ts +35 -0
  248. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  249. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  250. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  251. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  252. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  253. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  254. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  255. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  256. package/src/prove/smt/solver/theory-lra.ts +56 -0
  257. package/src/prove/smt/solver/var-subst.ts +258 -0
  258. package/src/prove/smt/solver/z3-license.txt +10 -0
  259. package/src/prove/smt/table.ts +170 -0
  260. package/src/prove/tlapm/tlapm.ts +96 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +13 -0
  263. package/src/prove/zenon/LICENSE +32 -0
  264. package/src/prove/zenon/check/check.ts +105 -0
  265. package/src/prove/zenon/check/definitions.ts +144 -0
  266. package/src/prove/zenon/check/equality.ts +182 -0
  267. package/src/prove/zenon/check/functions.ts +62 -0
  268. package/src/prove/zenon/check/keys.ts +125 -0
  269. package/src/prove/zenon/check/propositional.ts +104 -0
  270. package/src/prove/zenon/check/records.ts +188 -0
  271. package/src/prove/zenon/check/relations.ts +121 -0
  272. package/src/prove/zenon/check/rewrites.ts +224 -0
  273. package/src/prove/zenon/check/sets.ts +302 -0
  274. package/src/prove/zenon/check/terms.ts +127 -0
  275. package/src/prove/zenon/check/tla.ts +126 -0
  276. package/src/prove/zenon/decide.ts +113 -0
  277. package/src/prove/zenon/encode.ts +444 -0
  278. package/src/prove/zenon/eqrel.ts +300 -0
  279. package/src/prove/zenon/equality-rules.ts +435 -0
  280. package/src/prove/zenon/expr.ts +551 -0
  281. package/src/prove/zenon/index-table.ts +350 -0
  282. package/src/prove/zenon/isar-case.ts +513 -0
  283. package/src/prove/zenon/isar.ts +1249 -0
  284. package/src/prove/zenon/limits.ts +15 -0
  285. package/src/prove/zenon/llproof.ts +173 -0
  286. package/src/prove/zenon/mltoll.ts +1566 -0
  287. package/src/prove/zenon/node.ts +297 -0
  288. package/src/prove/zenon/ocaml.ts +169 -0
  289. package/src/prove/zenon/parse.ts +247 -0
  290. package/src/prove/zenon/phrase.ts +191 -0
  291. package/src/prove/zenon/proof.ts +198 -0
  292. package/src/prove/zenon/propositional-rules.ts +387 -0
  293. package/src/prove/zenon/rules.ts +94 -0
  294. package/src/prove/zenon/search.ts +288 -0
  295. package/src/prove/zenon/tla/functions.ts +151 -0
  296. package/src/prove/zenon/tla/llproof.ts +480 -0
  297. package/src/prove/zenon/tla/records.ts +225 -0
  298. package/src/prove/zenon/tla/rewrites.ts +447 -0
  299. package/src/prove/zenon/tla/sets.ts +304 -0
  300. package/src/prove/zenon/tla/terms.ts +181 -0
  301. package/src/prove/zenon/tla/tla.ts +506 -0
  302. package/src/run-cli.ts +73 -20
  303. package/src/standard-modules.ts +5 -2
  304. package/src/successors.ts +24 -5
  305. package/src/tlc-random.ts +55 -32
  306. package/src/tlc-version.ts +8 -7
  307. package/src/values.ts +85 -41
  308. package/src/worker.ts +65 -0
  309. package/dist/parallel.cjs +0 -12
  310. package/dist/parallel.js +0 -12
  311. /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
@@ -0,0 +1,968 @@
1
+ // Ported from Z3 (src/math/lp/nla_core.h, src/math/lp/nla_core.cpp, src/math/lp/nla_common.cpp,
2
+ // src/math/lp/nla_explanations.cpp, src/math/lp/factorization.cpp,
3
+ // src/math/lp/factorization_factory_imp.cpp, src/math/lp/nla_solver.cpp), MIT license, see
4
+ // z3-license.txt. The nonlinear core over lar_solver: the monomials whose values disagree with the
5
+ // products of their factors' values are refined by lemmas, which the passes below generate, and
6
+ // by literals to split on, and by nlsat's search on what they leave open, see nra-solver.ts.
7
+ import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
8
+ import type { ResourceLimit } from "../rlimit";
9
+ import { Rational } from "../rational";
10
+ import { IndexedUintSet } from "./containers";
11
+ import {
12
+ COLUMN_BOXED,
13
+ COLUMN_FIXED,
14
+ COLUMN_FREE,
15
+ COLUMN_LOWER,
16
+ COLUMN_UPPER,
17
+ LP_FEASIBLE,
18
+ LP_OPTIMAL,
19
+ } from "./core-solver";
20
+ import { KIND_EQ, KIND_GE, KIND_GT, KIND_LE, KIND_LT, KIND_NE } from "./constraints";
21
+ import type { Dependency } from "./dependency";
22
+ import { Explanation } from "./explanation";
23
+ import type { LarSolver } from "./lar-solver";
24
+ import { LarTerm } from "./lar-term";
25
+ import { Impq } from "./numeric-pair";
26
+ import { Backoff, SqueezeSchedule } from "./nla-backoff";
27
+ import { Basics } from "./nla-basics";
28
+ import { Divisions } from "./nla-divisions";
29
+ import { Emonics, Monic } from "./nla-emonics";
30
+ import { type Factor, type Factorization, mkFactor, mkMonFactorization } from "./nla-factorization";
31
+ import { Grobner } from "./nla-grobner";
32
+ import { Horner } from "./nla-horner";
33
+ import { Intervals } from "./nla-intervals";
34
+ import { MonomialBounds } from "./nla-monomial-bounds";
35
+ import { Monotone } from "./nla-monotone";
36
+ import { Order } from "./nla-order";
37
+ import { Patcher } from "./nla-patcher";
38
+ import { Tangents } from "./nla-tangents";
39
+ import { NlaThrottle } from "./nla-throttle";
40
+ import {
41
+ type Ineq,
42
+ isConflictLemma,
43
+ type Lemma,
44
+ LemmaBuilder,
45
+ mkIneq,
46
+ negateKind,
47
+ } from "./nla-types";
48
+ import { NraSolver } from "./nra-solver";
49
+ import { getSignedVarVar, isSignedVarNegated, mkSignedVar, VarEqs } from "./nla-var-eqs";
50
+
51
+ const SMALL_RANGE = new Impq(Rational.of(4n));
52
+
53
+ interface NlaParams {
54
+ horner: boolean;
55
+ hornerSubsFixed: number;
56
+ hornerFrequency: number;
57
+ hornerRowLengthLimit: number;
58
+ grobner: boolean;
59
+ grobnerRowLengthLimit: number;
60
+ grobnerFrequency: number;
61
+ grobnerEqsGrowth: number;
62
+ grobnerExprSizeGrowth: number;
63
+ grobnerExprDegreeGrowth: number;
64
+ grobnerMaxSimplified: number;
65
+ grobnerCnflToReport: number;
66
+ grobnerPropagateQuotients: boolean;
67
+ grobnerGcdTest: boolean;
68
+ grobnerExpDelay: boolean;
69
+ grobnerAdaptive: boolean;
70
+ grQ: number;
71
+ grobnerSubsFixed: number;
72
+ grobnerExpandTerms: boolean;
73
+ grobnerPerfectSquares: boolean;
74
+ branching: boolean;
75
+ nra: boolean;
76
+ nraCheckAssignment: boolean;
77
+ nraCheckAssignmentMaxFail: number;
78
+ order: boolean;
79
+ orderBinomialSign: boolean;
80
+ tangents: boolean;
81
+ tangentsBoxCorners: boolean;
82
+ expensivePatching: boolean;
83
+ expp: boolean;
84
+ monomialSandwich: boolean;
85
+ monomialSandwichMaxFanout: number;
86
+ monomialBinomialSign: boolean;
87
+ reducePseudoLinear: boolean;
88
+ delay: number;
89
+ propagateLinearMonomials: boolean;
90
+ linearizeViolatedMonomials: boolean;
91
+ optimizeBounds: boolean;
92
+ optimizeBoundsLpMaxVars: number;
93
+ crossNested: boolean;
94
+ }
95
+
96
+ // The arith.nl parameters of Z3's defaults that nla reads.
97
+ export const NLA_PARAMS: Readonly<NlaParams> = {
98
+ horner: true,
99
+ hornerSubsFixed: 2,
100
+ hornerFrequency: 4,
101
+ hornerRowLengthLimit: 10,
102
+ grobner: true,
103
+ grobnerRowLengthLimit: 10,
104
+ grobnerFrequency: 4,
105
+ grobnerEqsGrowth: 10,
106
+ grobnerExprSizeGrowth: 2,
107
+ grobnerExprDegreeGrowth: 2,
108
+ grobnerMaxSimplified: 10000,
109
+ grobnerCnflToReport: 1,
110
+ grobnerPropagateQuotients: true,
111
+ grobnerGcdTest: true,
112
+ grobnerExpDelay: true,
113
+ grobnerAdaptive: false,
114
+ grQ: 10,
115
+ grobnerSubsFixed: 1,
116
+ grobnerExpandTerms: true,
117
+ grobnerPerfectSquares: true,
118
+ branching: true,
119
+ nra: true,
120
+ nraCheckAssignment: true,
121
+ nraCheckAssignmentMaxFail: 7,
122
+ order: true,
123
+ orderBinomialSign: true,
124
+ tangents: true,
125
+ tangentsBoxCorners: false,
126
+ expensivePatching: false,
127
+ expp: false,
128
+ monomialSandwich: false,
129
+ monomialSandwichMaxFanout: 0,
130
+ monomialBinomialSign: false,
131
+ reducePseudoLinear: true,
132
+ delay: 10,
133
+ propagateLinearMonomials: true,
134
+ linearizeViolatedMonomials: true,
135
+ optimizeBounds: true,
136
+ optimizeBoundsLpMaxVars: 120,
137
+ crossNested: true,
138
+ };
139
+
140
+ interface NlaEquality {
141
+ readonly first: number;
142
+ readonly second: number;
143
+ readonly explanation: Explanation;
144
+ }
145
+
146
+ interface NlaFixedEquality {
147
+ readonly lpVar: number;
148
+ readonly value: Rational;
149
+ readonly explanation: Explanation;
150
+ }
151
+
152
+ type WeightedCheck = [weight: number, check: () => void];
153
+
154
+ export class NlaCore {
155
+ readonly varEqs = new VarEqs();
156
+ readonly emons = new Emonics(this.varEqs);
157
+ lemmas: Lemma[] = [];
158
+ literals: Ineq[] = [];
159
+ equalities: NlaEquality[] = [];
160
+ fixedEqualities: NlaFixedEquality[] = [];
161
+ readonly toRefine = new IndexedUintSet();
162
+ readonly monicsWithChangedBounds = new IndexedUintSet();
163
+ readonly activeVarSet = new IndexedUintSet();
164
+ isCheckFeasible = false;
165
+ isNlaSatisfied = false;
166
+ readonly throttle: NlaThrottle;
167
+ readonly tangents: Tangents;
168
+ readonly basics: Basics;
169
+ readonly order: Order;
170
+ readonly monotone: Monotone;
171
+ readonly divisions: Divisions;
172
+ readonly intervals: Intervals;
173
+ readonly monomialBounds: MonomialBounds;
174
+ readonly patcher: Patcher;
175
+ readonly horner: Horner;
176
+ readonly grobner: Grobner;
177
+ readonly nra = new NraSolver(this);
178
+ // m_use_nra_model: whether the values of the last nra check stand for lar_solver's.
179
+ isUsingNraModel = false;
180
+ private nlsatBackoff: Backoff;
181
+ private checkAssignmentFailCount = 0;
182
+ private squeezeSchedule = new SqueezeSchedule();
183
+ isRelevant: (lpVar: number) => boolean = () => true;
184
+
185
+ constructor(
186
+ readonly lra: LarSolver,
187
+ readonly limit: ResourceLimit,
188
+ ) {
189
+ this.nlsatBackoff = new Backoff(NLA_PARAMS.delay);
190
+ this.throttle = new NlaThrottle(lra, lra.settings.stats);
191
+ this.tangents = new Tangents(this);
192
+ this.basics = new Basics(this);
193
+ this.order = new Order(this);
194
+ this.monotone = new Monotone(this);
195
+ this.divisions = new Divisions(this);
196
+ this.intervals = new Intervals(this);
197
+ this.monomialBounds = new MonomialBounds(this);
198
+ this.patcher = new Patcher(this);
199
+ this.horner = new Horner(this);
200
+ this.grobner = new Grobner(this);
201
+ lra.onChangedBounds = (columns) => {
202
+ for (const column of columns.elems) {
203
+ if (this.isMonicVar(column)) this.monicsWithChangedBounds.add(column);
204
+ for (const monic of this.emons.getUseList(column))
205
+ this.monicsWithChangedBounds.add(monic.variable);
206
+ }
207
+ };
208
+ }
209
+
210
+ get settings() {
211
+ return this.lra.settings;
212
+ }
213
+
214
+ get stats() {
215
+ return this.lra.settings.stats;
216
+ }
217
+
218
+ // Values and bounds.
219
+
220
+ val(lpVar: number) {
221
+ return this.lra.getValue(lpVar).x;
222
+ }
223
+
224
+ varVal(monic: Monic) {
225
+ return this.val(monic.variable);
226
+ }
227
+
228
+ mulVal(monic: Monic) {
229
+ let product = Rational.one;
230
+ for (const lpVar of monic.vars) product = product.mul(this.val(lpVar));
231
+ return product;
232
+ }
233
+
234
+ valFactor(factor: Factor) {
235
+ const value = this.val(factor.variable);
236
+ return factor.isNegated ? value.neg() : value;
237
+ }
238
+
239
+ compareHolds(left: Rational, cmp: number, right: Rational) {
240
+ const comparison = left.compare(right);
241
+ switch (cmp) {
242
+ case KIND_LE:
243
+ return comparison <= 0;
244
+ case KIND_LT:
245
+ return comparison < 0;
246
+ case KIND_GE:
247
+ return comparison >= 0;
248
+ case KIND_GT:
249
+ return comparison > 0;
250
+ case KIND_EQ:
251
+ return comparison === 0;
252
+ default:
253
+ return comparison !== 0;
254
+ }
255
+ }
256
+
257
+ value(term: LarTerm) {
258
+ let result = Rational.zero;
259
+ for (const entry of term.coeffs) result = result.add(entry[1].mul(this.val(entry[0])));
260
+ return result;
261
+ }
262
+
263
+ ineqHolds(ineq: Ineq) {
264
+ return this.compareHolds(this.value(ineq.term), ineq.cmp, ineq.rs);
265
+ }
266
+
267
+ hasUpperBound(lpVar: number) {
268
+ return this.lra.core.hasUpperBound(lpVar);
269
+ }
270
+
271
+ hasLowerBound(lpVar: number) {
272
+ return this.lra.core.hasLowerBound(lpVar);
273
+ }
274
+
275
+ getUpperBound(lpVar: number) {
276
+ return this.lra.getUpperBound(lpVar).x;
277
+ }
278
+
279
+ getLowerBound(lpVar: number) {
280
+ return this.lra.getLowerBound(lpVar).x;
281
+ }
282
+
283
+ noBounds(lpVar: number) {
284
+ return !this.hasUpperBound(lpVar) && !this.hasLowerBound(lpVar);
285
+ }
286
+
287
+ zeroIsAnInnerPointOfBounds(lpVar: number) {
288
+ if (this.hasUpperBound(lpVar) && !this.getUpperBound(lpVar).isPositive()) return false;
289
+ return !(this.hasLowerBound(lpVar) && !this.getLowerBound(lpVar).isNegative());
290
+ }
291
+
292
+ varIsInt(lpVar: number) {
293
+ return this.lra.isInt(lpVar);
294
+ }
295
+
296
+ varIsFixedToZero(lpVar: number) {
297
+ return this.lra.isFixed(lpVar) && this.lra.getLowerBound(lpVar).isZero();
298
+ }
299
+
300
+ varIsFixed(lpVar: number) {
301
+ return this.lra.isFixed(lpVar);
302
+ }
303
+
304
+ varIsFree(lpVar: number) {
305
+ return this.lra.isFree(lpVar);
306
+ }
307
+
308
+ varHasPositiveLowerBound(lpVar: number) {
309
+ const lower = this.lra.getLowerBound(lpVar);
310
+ return (
311
+ this.hasLowerBound(lpVar) &&
312
+ (lower.x.isPositive() || (lower.x.isZero() && lower.y.isPositive()))
313
+ );
314
+ }
315
+
316
+ varHasNegativeUpperBound(lpVar: number) {
317
+ const upper = this.lra.getUpperBound(lpVar);
318
+ return (
319
+ this.hasUpperBound(lpVar) &&
320
+ (upper.x.isNegative() || (upper.x.isZero() && upper.y.isNegative()))
321
+ );
322
+ }
323
+
324
+ varIsBig(lpVar: number) {
325
+ return !this.varIsInt(lpVar) && this.val(lpVar).isBig();
326
+ }
327
+
328
+ hasBigNum(monic: Monic) {
329
+ return this.varIsBig(monic.variable) || monic.vars.some((lpVar) => this.varIsBig(lpVar));
330
+ }
331
+
332
+ hasReal(monic: Monic) {
333
+ return monic.vars.some((lpVar) => !this.varIsInt(lpVar));
334
+ }
335
+
336
+ hasRealFactorization(factorization: Factorization) {
337
+ return factorization.factors.some((factor) => !this.varIsInt(factor.variable));
338
+ }
339
+
340
+ monHasZero(vars: number[]) {
341
+ return vars.some((lpVar) => this.val(lpVar).isZero());
342
+ }
343
+
344
+ // Monomials and their canonization.
345
+
346
+ isMonicVar(lpVar: number) {
347
+ return this.emons.isMonicVar(lpVar);
348
+ }
349
+
350
+ emon(lpVar: number) {
351
+ return this.emons.get(lpVar);
352
+ }
353
+
354
+ mapToRoot(lpVar: number) {
355
+ return getSignedVarVar(this.varEqs.findVar(lpVar));
356
+ }
357
+
358
+ sortedRvars(factor: Factor) {
359
+ return factor.isMon ? this.emons.get(factor.variable).rvars : [this.mapToRoot(factor.variable)];
360
+ }
361
+
362
+ canonizeSignVar(lpVar: number) {
363
+ return isSignedVarNegated(this.varEqs.findVar(lpVar));
364
+ }
365
+
366
+ canonizeSignFactor(factor: Factor) {
367
+ return (
368
+ factor.isNegated !==
369
+ (factor.isMon ? this.emons.get(factor.variable).rsign : this.canonizeSignVar(factor.variable))
370
+ );
371
+ }
372
+
373
+ canonizeSignFactorization(factorization: Factorization) {
374
+ let sign = false;
375
+ for (const factor of factorization.factors) sign = sign !== this.canonizeSignFactor(factor);
376
+ return sign;
377
+ }
378
+
379
+ getMonicSign(monic: Monic) {
380
+ let sign = 1;
381
+ for (const lpVar of monic.vars) {
382
+ const value = this.val(lpVar);
383
+ if (value.isNegative()) sign = -sign;
384
+ else if (!value.isPositive()) return 0;
385
+ }
386
+ return sign;
387
+ }
388
+
389
+ findCanonicalMonicOfVars(vars: number[]) {
390
+ return this.emons.findCanonical(vars)?.variable;
391
+ }
392
+
393
+ isCanonicalMonic(lpVar: number) {
394
+ return this.emons.isCanonicalMonic(lpVar);
395
+ }
396
+
397
+ addMonic(lpVar: number, vars: number[]) {
398
+ this.emons.add(lpVar, vars);
399
+ this.monicsWithChangedBounds.add(lpVar);
400
+ }
401
+
402
+ productValue(monic: Monic) {
403
+ return this.mulVal(monic);
404
+ }
405
+
406
+ // check_monic: whether the value of the monic is the product of its factors' values.
407
+ checkMonic(monic: Monic) {
408
+ const value = this.lra.getValue(monic.variable);
409
+ if (this.lra.isInt(monic.variable) && !value.x.isInt()) return true;
410
+ return this.productValue(monic).equals(value.x);
411
+ }
412
+
413
+ hasRelevantMonomial() {
414
+ return this.emons.monics.some((monic) => this.isRelevant(monic.variable));
415
+ }
416
+
417
+ getVarWeight(lpVar: number) {
418
+ const type = this.lra.core.getColumnType(lpVar);
419
+ let weight =
420
+ type === COLUMN_FIXED
421
+ ? 0
422
+ : type === COLUMN_BOXED
423
+ ? 3
424
+ : type === COLUMN_LOWER || type === COLUMN_UPPER
425
+ ? 6
426
+ : type === COLUMN_FREE
427
+ ? 9
428
+ : 0;
429
+ if (this.isMonicVar(lpVar)) {
430
+ weight++;
431
+ if (this.toRefine.has(lpVar)) weight++;
432
+ }
433
+ return weight;
434
+ }
435
+
436
+ // divide: the factor b with bc = b * c, up to sign.
437
+ divide(product: Monic, divisor: Factor): Factor | undefined {
438
+ const divisorVars = this.sortedRvars(divisor);
439
+ const quotientVars = getVectorDiv(product.rvars, divisorVars);
440
+ if (quotientVars === undefined) return undefined;
441
+ let quotient: Factor;
442
+ if (quotientVars.length === 1) quotient = mkFactor(quotientVars[0], false);
443
+ else {
444
+ const monic = this.emons.findCanonical(quotientVars);
445
+ if (monic === undefined) return undefined;
446
+ quotient = mkFactor(monic.variable, true);
447
+ }
448
+ quotient.isNegated =
449
+ (this.canonizeSignFactor(quotient) !== this.canonizeSignFactor(divisor)) !== product.rsign;
450
+ return quotient;
451
+ }
452
+
453
+ // The factorizations of a monic: into its variables first, then into two canonical factors.
454
+ *getFactorizations(rooted: Monic): Generator<Factorization> {
455
+ const vars = rooted.rvars;
456
+ const monic = this.emons.get(rooted.variable);
457
+ const mask: boolean[] =
458
+ vars.length !== 2 ? Array.from({ length: vars.length - 1 }, () => false) : [true];
459
+ let isFullReturned = false;
460
+ let numFailures = 0;
461
+ const getFactor = (factorVars: number[]): Factor | undefined => {
462
+ if (factorVars.length === 1) return mkFactor(factorVars[0], false);
463
+ const variable = this.findCanonicalMonicOfVars(factorVars);
464
+ if (variable === undefined) {
465
+ numFailures++;
466
+ return undefined;
467
+ }
468
+ return mkFactor(variable, true);
469
+ };
470
+ const getBinary = (): Factorization => {
471
+ const kVars = [vars[vars.length - 1]];
472
+ const jVars: number[] = [];
473
+ mask.forEach((isSet, index) => (isSet ? kVars : jVars).push(vars[index]));
474
+ kVars.sort((first, second) => first - second);
475
+ jVars.sort((first, second) => first - second);
476
+ if (numFailures > 1000) {
477
+ mask.fill(true);
478
+ mask[0] = false;
479
+ isFullReturned = true;
480
+ return { factors: [], mon: null };
481
+ }
482
+ const first = getFactor(kVars);
483
+ if (first === undefined) return { factors: [], mon: null };
484
+ numFailures = 0;
485
+ const second = getFactor(jVars);
486
+ if (second === undefined) return { factors: [], mon: null };
487
+ const factorization: Factorization = { factors: [first, second], mon: null };
488
+ first.isNegated =
489
+ first.isNegated !== (this.canonizeSignFactorization(factorization) !== monic.rsign);
490
+ return factorization;
491
+ };
492
+ for (;;) {
493
+ if (isFullReturned && mask.every(Boolean)) return;
494
+ yield isFullReturned ? getBinary() : mkMonFactorization(monic);
495
+ if (!isFullReturned) {
496
+ isFullReturned = true;
497
+ continue;
498
+ }
499
+ const index = mask.indexOf(false);
500
+ mask.fill(false, 0, index === -1 ? mask.length : index);
501
+ if (index !== -1) mask[index] = true;
502
+ }
503
+ }
504
+
505
+ // Lemma helpers.
506
+
507
+ negateRelation(lemma: LemmaBuilder, lpVar: number, value: Rational) {
508
+ lemma.addIneq(mkIneq(lpVar, this.val(lpVar).compare(value) < 0 ? KIND_GE : KIND_LE, value));
509
+ }
510
+
511
+ // Explanations of inequalities by bounds.
512
+
513
+ private explainCoeffBound(
514
+ column: number,
515
+ coeff: Rational,
516
+ isUpper: boolean,
517
+ explanation: Explanation,
518
+ ) {
519
+ const useUpper = isUpper ? !coeff.isNegative() : coeff.isNegative();
520
+ const dep = useUpper ? this.lra.getUpperWitness(column) : this.lra.getLowerWitness(column);
521
+ if (dep === null) return undefined;
522
+ const bound = useUpper ? this.lra.getUpperBound(column) : this.lra.getLowerBound(column);
523
+ explanation.pushDependency(dep);
524
+ return coeff.mul(bound.x);
525
+ }
526
+
527
+ private explainBound(term: LarTerm, rs: Rational, isUpper: boolean, explanation: Explanation) {
528
+ let bound = Rational.zero;
529
+ for (const entry of term.coeffs) {
530
+ const coeffBound = this.explainCoeffBound(entry[0], entry[1], isUpper, explanation);
531
+ if (coeffBound === undefined) {
532
+ explanation.clear();
533
+ return false;
534
+ }
535
+ bound = bound.add(coeffBound);
536
+ }
537
+ if (isUpper ? bound.compare(rs) > 0 : bound.compare(rs) < 0) {
538
+ explanation.clear();
539
+ return false;
540
+ }
541
+ return true;
542
+ }
543
+
544
+ // explain_ineq: whether the bounds imply the negation of term cmp rs, added to the lemma.
545
+ explainIneq(lemma: LemmaBuilder, term: LarTerm, cmp: number, rs: Rational) {
546
+ if (term.size === 0 && rs.isZero() && (cmp === KIND_LT || cmp === KIND_GT || cmp === KIND_NE))
547
+ return true;
548
+ const explanation = new Explanation();
549
+ const one = Rational.one;
550
+ const isExplained = (() => {
551
+ switch (negateKind(cmp)) {
552
+ case KIND_LE:
553
+ return this.explainBound(term, rs, true, explanation);
554
+ case KIND_LT:
555
+ return this.explainBound(term, rs.sub(one), true, explanation);
556
+ case KIND_GE:
557
+ return this.explainBound(term, rs, false, explanation);
558
+ case KIND_GT:
559
+ return this.explainBound(term, rs.add(one), false, explanation);
560
+ case KIND_EQ:
561
+ return (
562
+ (this.explainBound(term, rs, false, explanation) &&
563
+ this.explainBound(term, rs, true, explanation)) ||
564
+ (rs.isZero() && this.explainByEquiv(term, explanation))
565
+ );
566
+ default:
567
+ return (
568
+ this.explainBound(term, rs.add(one), false, explanation) ||
569
+ this.explainBound(term, rs.sub(one), true, explanation)
570
+ );
571
+ }
572
+ })();
573
+ if (!isExplained) return false;
574
+ lemma.addExplanation(explanation);
575
+ return true;
576
+ }
577
+
578
+ // is_octagon_term: whether the term is +-x +-y, and whether its signs agree.
579
+ private getOctagonTerm(term: LarTerm) {
580
+ if (term.size !== 2) return undefined;
581
+ let isMinusSeen = false;
582
+ let isPlusSeen = false;
583
+ const vars: number[] = [];
584
+ for (const entry of term.coeffs) {
585
+ if (entry[1].equals(Rational.one)) isPlusSeen = true;
586
+ else if (entry[1].equals(Rational.minusOne)) isMinusSeen = true;
587
+ else return undefined;
588
+ vars.push(entry[0]);
589
+ }
590
+ return { first: vars[0], second: vars[1], isNegated: !(isMinusSeen && isPlusSeen) };
591
+ }
592
+
593
+ explainByEquiv(term: LarTerm, explanation: Explanation) {
594
+ const octagon = this.getOctagonTerm(term);
595
+ if (octagon === undefined) return false;
596
+ const first = mkSignedVar(octagon.first, false);
597
+ const second = mkSignedVar(octagon.second, octagon.isNegated);
598
+ if (this.varEqs.find(first) !== this.varEqs.find(second)) return false;
599
+ this.varEqs.explain(first, second, explanation);
600
+ return true;
601
+ }
602
+
603
+ // collect_equivs: the term columns fixed to zero that equate or negate two variables.
604
+ private collectEquivs() {
605
+ const lra = this.lra;
606
+ for (const term of lra.terms) {
607
+ const column = term.column;
608
+ if (!lra.hasTerm(column) || !this.varIsFixedToZero(column)) continue;
609
+ const octagon = this.getOctagonTerm(term);
610
+ if (octagon === undefined) continue;
611
+ const justification: Dependency[] = [
612
+ lra.getUpperWitness(column),
613
+ lra.getLowerWitness(column),
614
+ ];
615
+ if (octagon.isNegated) this.varEqs.mergeMinus(octagon.first, octagon.second, justification);
616
+ else this.varEqs.mergePlus(octagon.first, octagon.second, justification);
617
+ }
618
+ this.emons.ensureCanonized();
619
+ }
620
+
621
+ // The search.
622
+
623
+ random() {
624
+ return this.settings.getRandomNext();
625
+ }
626
+
627
+ isCanceled() {
628
+ return this.settings.isCanceled();
629
+ }
630
+
631
+ // check_bounded_divisions: the lemmas of the divisions of bounded terms by numerals.
632
+ checkBoundedDivisions() {
633
+ this.clear();
634
+ this.divisions.checkBoundedDivisions();
635
+ }
636
+
637
+ clear() {
638
+ this.lemmas = [];
639
+ this.literals = [];
640
+ this.fixedEqualities = [];
641
+ this.equalities = [];
642
+ this.isCheckFeasible = false;
643
+ }
644
+
645
+ private initSearch() {
646
+ this.clear();
647
+ this.collectEquivs();
648
+ }
649
+
650
+ insertToRefine(lpVar: number) {
651
+ this.toRefine.add(lpVar);
652
+ }
653
+
654
+ eraseFromToRefine(lpVar: number) {
655
+ if (this.toRefine.has(lpVar)) this.toRefine.delete(lpVar);
656
+ }
657
+
658
+ initToRefine() {
659
+ if (this.lra.isFeasible()) this.lra.getRidOfInfEps();
660
+ this.toRefine.clear();
661
+ const offset = this.random();
662
+ const size = this.emons.numMonics;
663
+ for (let index = 0; index < size; index++) {
664
+ const monic = this.emons.monics[(index + offset) % size];
665
+ if (!this.checkMonic(monic)) this.insertToRefine(monic.variable);
666
+ }
667
+ }
668
+
669
+ conflictFound() {
670
+ return this.lemmas.some(isConflictLemma);
671
+ }
672
+
673
+ done() {
674
+ return this.lemmas.length >= 10 || this.conflictFound() || this.isCanceled();
675
+ }
676
+
677
+ findBfcToRefineOnMonic(monic: Monic) {
678
+ for (const factorization of this.getFactorizations(monic)) {
679
+ if (factorization.factors.length !== 2) continue;
680
+ const product = this.valFactor(factorization.factors[0]).mul(
681
+ this.valFactor(factorization.factors[1]),
682
+ );
683
+ if (!this.varVal(monic).equals(product)) return factorization;
684
+ }
685
+ return undefined;
686
+ }
687
+
688
+ // find_bfc_to_refine: a monic to refine, with a binary factorization of it.
689
+ findBfcToRefine() {
690
+ const offset = this.random();
691
+ const size = this.toRefine.size;
692
+ for (let index = 0; index < size; index++) {
693
+ const monic = this.emons.get(this.toRefine.elems[(index + offset) % size]);
694
+ if (this.hasReal(monic)) continue;
695
+ if (monic.size === 2) {
696
+ const factorization: Factorization = {
697
+ factors: [mkFactor(monic.vars[0], false), mkFactor(monic.vars[1], false)],
698
+ mon: monic,
699
+ };
700
+ return { monic, factorization };
701
+ }
702
+ const factorization = this.findBfcToRefineOnMonic(monic);
703
+ if (factorization !== undefined) return { monic, factorization };
704
+ }
705
+ return undefined;
706
+ }
707
+
708
+ // check_weighted: runs the checks in a random order weighted by their weights, until one yields.
709
+ private checkWeighted(checks: WeightedCheck[]) {
710
+ let bound = 0;
711
+ for (const check of checks) bound += check[0];
712
+ const seen = new Set<number>();
713
+ while (bound > 0 && !this.done() && this.lemmas.length === 0) {
714
+ let draw = this.random() % bound;
715
+ for (let index = 0; index < checks.length; index++) {
716
+ if (seen.has(index)) continue;
717
+ if (draw < checks[index][0]) {
718
+ seen.add(index);
719
+ checks[index][1]();
720
+ bound -= checks[index][0];
721
+ break;
722
+ }
723
+ draw -= checks[index][0];
724
+ }
725
+ }
726
+ }
727
+
728
+ // add_bounds: a split on a free variable of a monic to refine.
729
+ private addBounds() {
730
+ const offset = this.random();
731
+ const size = this.toRefine.size;
732
+ for (let index = 0; index < size; index++) {
733
+ const monic = this.emons.get(this.toRefine.elems[(index + offset) % size]);
734
+ for (const lpVar of monic.vars) {
735
+ if (!this.varIsFree(lpVar) || monic.isBoundPropagated) continue;
736
+ this.emons.setBoundPropagated(monic);
737
+ this.literals.push(mkIneq(lpVar, KIND_EQ, 0));
738
+ this.stats.nlaAddBounds++;
739
+ return;
740
+ }
741
+ }
742
+ }
743
+
744
+ private onToRefineEmpty() {
745
+ this.squeezeSchedule.onNothingToRefine();
746
+ return L_TRUE;
747
+ }
748
+
749
+ check(level: number) {
750
+ const stats = this.stats;
751
+ stats.nlaCalls++;
752
+ this.lra.getRidOfInfEps();
753
+ if (this.lra.status !== LP_OPTIMAL && this.lra.status !== LP_FEASIBLE) return L_UNDEF;
754
+ this.initToRefine();
755
+ this.patcher.patchMonomials();
756
+ this.setUseNraModel(false);
757
+ if (this.toRefine.size === 0) return this.onToRefineEmpty();
758
+ this.initSearch();
759
+ this.isNlaSatisfied = false;
760
+ let result = L_UNDEF;
761
+ const isRunningGrobner = NLA_PARAMS.grobner;
762
+ const isRunningHorner = NLA_PARAMS.horner && stats.nlaCalls % NLA_PARAMS.hornerFrequency === 0;
763
+ const isRunningBounds = NLA_PARAMS.branching;
764
+ // Model-based basic lemmas are effective on small systems, and branching on larger ones.
765
+ const isDelayingBounds = isRunningBounds && this.emons.numMonics <= 8;
766
+ const hasNoEffect = () =>
767
+ result === L_UNDEF &&
768
+ !this.done() &&
769
+ !this.isNlaSatisfied &&
770
+ this.lemmas.length === 0 &&
771
+ this.literals.length === 0 &&
772
+ !this.isCheckFeasible;
773
+ if (hasNoEffect()) this.monomialBounds.generateLemmas();
774
+ if (hasNoEffect() && this.refinePseudoLinear()) return L_FALSE;
775
+ const isSqueezeCadence = stats.nlaCalls % NLA_PARAMS.hornerFrequency === 0;
776
+ if (
777
+ hasNoEffect() &&
778
+ this.squeezeSchedule.isEnabled &&
779
+ (isRunningHorner || isRunningGrobner) &&
780
+ (this.squeezeSchedule.isEager || isSqueezeCadence)
781
+ ) {
782
+ this.squeezeSchedule.onSqueeze(this.monomialBounds.optimizeNlBounds());
783
+ if (this.toRefine.size === 0) return this.onToRefineEmpty();
784
+ }
785
+ const runHorner = () => {
786
+ if (hasNoEffect() && isRunningHorner) this.horner.hornerLemmas();
787
+ };
788
+ const runGrobner = () => {
789
+ if (hasNoEffect() && isRunningGrobner) this.grobner.run();
790
+ };
791
+ const runBounds = () => {
792
+ if (hasNoEffect() && isRunningBounds) this.addBounds();
793
+ };
794
+ this.checkWeighted(
795
+ isDelayingBounds
796
+ ? [
797
+ [1, runHorner],
798
+ [1, runGrobner],
799
+ ]
800
+ : [
801
+ [1, runHorner],
802
+ [1, runGrobner],
803
+ [1, runBounds],
804
+ ],
805
+ );
806
+ if (this.isCanceled()) return L_UNDEF;
807
+ if (this.lemmas.length > 0 || this.literals.length > 0 || this.isCheckFeasible) return L_FALSE;
808
+ if (this.isNlaSatisfied) return L_TRUE;
809
+ if (
810
+ hasNoEffect() &&
811
+ NLA_PARAMS.nraCheckAssignment &&
812
+ this.checkAssignmentFailCount < NLA_PARAMS.nraCheckAssignmentMaxFail
813
+ ) {
814
+ result = this.nra.checkAssignment();
815
+ if (result !== L_TRUE) this.checkAssignmentFailCount++;
816
+ }
817
+ if (hasNoEffect() && this.shouldRunBoundedNlsat()) result = this.boundedNlsat();
818
+ if (hasNoEffect()) this.basics.basicLemma(true);
819
+ if (hasNoEffect() && isDelayingBounds) this.basics.basicLemma(false);
820
+ if (hasNoEffect() && isDelayingBounds) this.addBounds();
821
+ if (hasNoEffect() && !isDelayingBounds) this.basics.basicLemma(false);
822
+ if (hasNoEffect()) this.divisions.check();
823
+ if (hasNoEffect()) {
824
+ this.checkWeighted([
825
+ [6, () => this.order.orderLemma()],
826
+ [2, () => this.monotone.monotonicityLemma()],
827
+ [1, () => this.tangents.tangentLemma()],
828
+ ]);
829
+ const numCalls = stats.nlaCalls;
830
+ if (!this.conflictFound() && NLA_PARAMS.nra && numCalls % 50 === 0 && numCalls > 500)
831
+ result = this.boundedNlsat();
832
+ }
833
+ if (hasNoEffect() && NLA_PARAMS.nra && level >= 2) {
834
+ result = this.nra.check(Infinity, Infinity);
835
+ stats.nraCalls++;
836
+ }
837
+ if (result === L_UNDEF && !hasNoEffect()) result = L_FALSE;
838
+ stats.nlaLemmas += this.lemmas.length;
839
+ return result;
840
+ }
841
+
842
+ private shouldRunBoundedNlsat() {
843
+ return NLA_PARAMS.nra && this.nlsatBackoff.shouldRun();
844
+ }
845
+
846
+ // bounded_nlsat: a run of nlsat capped at 100 conflicts and 100000 steps. A refutation, or a run
847
+ // that took less than a tenth of the steps, makes the backoff run it again sooner.
848
+ private boundedNlsat() {
849
+ const budget = 100000;
850
+ const result = this.nra.check(100, budget);
851
+ this.stats.nraCalls++;
852
+ this.nlsatBackoff.update(result === L_FALSE || this.nra.steps < budget / 10);
853
+ if (result === L_TRUE) this.clear();
854
+ return result;
855
+ }
856
+
857
+ // set_use_nra_model, undone on pop.
858
+ setUseNraModel(isUsing: boolean) {
859
+ if (isUsing === this.isUsingNraModel) return;
860
+ this.emons.trail.push(() => {
861
+ this.isUsingNraModel = !isUsing;
862
+ });
863
+ this.isUsingNraModel = isUsing;
864
+ }
865
+
866
+ // Propagation.
867
+
868
+ propagate() {
869
+ this.clear();
870
+ let isPropagated = false;
871
+ if (this.monomialBounds.tightenLpBounds()) isPropagated = true;
872
+ if (this.monomialBounds.propagateChangedBounds()) isPropagated = true;
873
+ if (this.monomialBounds.propagateViolatedLinearMonomials()) isPropagated = true;
874
+ this.monicsWithChangedBounds.clear();
875
+ if (isPropagated) this.isCheckFeasible = true;
876
+ return isPropagated;
877
+ }
878
+
879
+ incrementalPropagate() {
880
+ this.clear();
881
+ const isPropagated = this.monomialBounds.propagateChangedBounds();
882
+ this.monicsWithChangedBounds.clear();
883
+ if (isPropagated) this.isCheckFeasible = true;
884
+ return isPropagated;
885
+ }
886
+
887
+ // Pseudo-linear monomials: all but one factor are integers in a range of at most 4.
888
+
889
+ private isPseudoLinear(monic: Monic) {
890
+ let hasUnbounded = false;
891
+ for (const lpVar of monic.vars) {
892
+ if (this.isSmallIntRange(lpVar)) continue;
893
+ if (hasUnbounded) return false;
894
+ hasUnbounded = true;
895
+ }
896
+ return true;
897
+ }
898
+
899
+ private isSmallIntRange(lpVar: number) {
900
+ const lra = this.lra;
901
+ const type = lra.core.getColumnType(lpVar);
902
+ if ((type !== COLUMN_BOXED && type !== COLUMN_FIXED) || !lra.isInt(lpVar)) return false;
903
+ return lra.getUpperBound(lpVar).sub(lra.getLowerBound(lpVar)).compare(SMALL_RANGE) <= 0;
904
+ }
905
+
906
+ private refinePseudoLinear() {
907
+ if (!NLA_PARAMS.reducePseudoLinear) return false;
908
+ for (const lpVar of this.toRefine.elems) {
909
+ const monic = this.emons.get(lpVar);
910
+ if (!this.isPseudoLinear(monic)) continue;
911
+ this.refinePseudoLinearMonic(monic);
912
+ return true;
913
+ }
914
+ return false;
915
+ }
916
+
917
+ private refinePseudoLinearMonic(monic: Monic) {
918
+ const lemma = new LemmaBuilder(this);
919
+ let nlVar = -1;
920
+ let product = Rational.one;
921
+ for (let index = 0; index < monic.vars.length; index++) {
922
+ const lpVar = monic.vars[index];
923
+ if (index === monic.vars.length - 1 && nlVar === -1) {
924
+ nlVar = lpVar;
925
+ break;
926
+ }
927
+ if (this.isSmallIntRange(lpVar)) {
928
+ lemma.addIneq(mkIneq(lpVar, KIND_NE, this.val(lpVar)));
929
+ product = product.mul(this.val(lpVar));
930
+ continue;
931
+ }
932
+ nlVar = lpVar;
933
+ }
934
+ lemma.addIneq(
935
+ mkIneq(
936
+ new LarTerm([
937
+ [monic.variable, Rational.one],
938
+ [nlVar, product.neg()],
939
+ ]),
940
+ KIND_EQ,
941
+ 0,
942
+ ),
943
+ );
944
+ }
945
+
946
+ // Scopes.
947
+
948
+ push() {
949
+ this.emons.push();
950
+ }
951
+
952
+ pop(count: number) {
953
+ this.emons.pop(count);
954
+ }
955
+ }
956
+
957
+ // vector_div: the multiset difference of sorted vectors, when the divisor is a proper factor.
958
+ const getVectorDiv = (product: number[], divisor: number[]) => {
959
+ if (divisor.length >= product.length) return undefined;
960
+ const quotient: number[] = [];
961
+ let divisorIndex = 0;
962
+ for (const lpVar of product) {
963
+ if (divisorIndex < divisor.length && divisor[divisorIndex] === lpVar) divisorIndex++;
964
+ else if (divisorIndex < divisor.length && divisor[divisorIndex] < lpVar) return undefined;
965
+ else quotient.push(lpVar);
966
+ }
967
+ return divisorIndex === divisor.length ? quotient : undefined;
968
+ };