tla-ts 0.0.4-dev.6dec595 → 0.0.4-dev.7714e32

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 (378) hide show
  1. package/README.md +37 -126
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +44 -12
  8. package/dist/index.d.ts +44 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1154
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +112 -718
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +17 -15
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +109 -108
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +169 -142
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +79 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +16 -20
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +16 -19
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -213
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/transfer.ts +32 -32
  365. package/src/values.ts +80 -70
  366. package/src/worker.ts +62 -0
  367. package/dist/parallel.cjs +0 -12
  368. package/dist/parallel.js +0 -12
  369. package/dist/run-cli.cjs +0 -55
  370. package/dist/run-cli.js +0 -55
  371. package/src/canonical.ts +0 -40
  372. package/src/obligation-expression.ts +0 -1060
  373. package/src/obligation-module.ts +0 -1042
  374. package/src/standard-ranges.ts +0 -116
  375. package/src/value-sources.ts +0 -29
  376. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  377. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
  378. /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
@@ -0,0 +1,1181 @@
1
+ // Ported from Z3 (src/math/lp/dioph_eq.cpp, src/math/lp/var_register.h), MIT license, see
2
+ // z3-license.txt. The Diophantine solver of Griggio's "A Practical Approach to Satisfiability
3
+ // Modulo Linear Integer Arithmetic": every integer term t with column j gives the equation
4
+ // t - j = 0 over the columns that are not fixed. The equations are normalized by the gcd of their
5
+ // coefficients, which finds a conflict when the gcd does not divide the constant, and solved for a
6
+ // column with a unit coefficient, or rewritten with a fresh column until one appears. The bounds of
7
+ // the term columns are then tightened modulo the gcd of their terms after the substitutions.
8
+ import { SmtInvariantError } from "../../../../errors";
9
+ import { getGcd, getLcm, Rational } from "../rational";
10
+ import { IndexedUintSet, UnorderedUintMap } from "./containers";
11
+ import { KIND_GE, KIND_LE } from "./constraints";
12
+ import { LP_CANCELLED, LP_FEASIBLE, LP_OPTIMAL } from "./core-solver";
13
+ import { type Dependency, mkJoin } from "./dependency";
14
+ import { Explanation } from "./explanation";
15
+ import type { IntSolver } from "./int-solver";
16
+ import type { LarSolver } from "./lar-solver";
17
+ import { LarTerm } from "./lar-term";
18
+ import { Impq } from "./numeric-pair";
19
+ import { StaticMatrix } from "./static-matrix";
20
+ import { shrink } from "../array";
21
+
22
+ type DioMove = "undef" | "conflict" | "continue";
23
+
24
+ interface Monomial {
25
+ readonly coeff: Rational;
26
+ readonly column: number;
27
+ }
28
+
29
+ interface FreshDefinition {
30
+ readonly term: LarTerm;
31
+ readonly row: number;
32
+ }
33
+
34
+ const NO_VAR = -1;
35
+ // m_tighten_size_max: a longer term likely has gcd one.
36
+ const TIGHTEN_SIZE_MAX = 10;
37
+
38
+ // join of lia_move, for the moves the Diophantine solver makes.
39
+ const joinMoves = (first: DioMove, second: DioMove): DioMove => {
40
+ if (first === second || second === "undef") return first;
41
+ if (first === "undef") return second;
42
+ return first === "conflict" || second === "conflict" ? "conflict" : "continue";
43
+ };
44
+
45
+ const getTermMonomials = (term: LarTerm): Monomial[] =>
46
+ [...term.coeffs].map((entry) => ({ coeff: entry[1], column: entry[0] }));
47
+
48
+ // ext_coeffs: the monomials of the term and then the term column with coefficient -1.
49
+ const getExtendedMonomials = (term: LarTerm) => [
50
+ ...getTermMonomials(term),
51
+ { coeff: Rational.minusOne, column: term.column },
52
+ ];
53
+
54
+ const isUnit = (value: Rational) => value.equals(Rational.one) || value.equals(Rational.minusOne);
55
+
56
+ // rem and machine_div_rem of integers: truncating, so the remainder has the sign of the dividend.
57
+ const getRemainder = (left: Rational, right: Rational) => Rational.of(left.num % right.num);
58
+
59
+ const getTruncatedQuotient = (left: Rational, right: Rational) => Rational.of(left.num / right.num);
60
+
61
+ // bitsize of an mpq: the bits of the numerator, and of the denominator when it is not one.
62
+ const getBitsize = (value: Rational) => {
63
+ const getIntBitsize = (part: bigint) =>
64
+ part === 0n ? 1 : (part < 0n ? -part : part).toString(2).length;
65
+ return value.isInt()
66
+ ? getIntBitsize(value.num)
67
+ : getIntBitsize(value.num) + getIntBitsize(value.den);
68
+ };
69
+
70
+ // gcd_of_coeffs: one as soon as a unit coefficient shows up when asked to look for one.
71
+ const getGcdOfCoeffs = (monomials: Iterable<{ coeff: Rational }>, isCheckingForOne: boolean) => {
72
+ if (isCheckingForOne)
73
+ for (const monomial of monomials) if (isUnit(monomial.coeff)) return Rational.one;
74
+ let gcd = Rational.zero;
75
+ for (const monomial of monomials) {
76
+ gcd = gcd.isZero() ? monomial.coeff.abs() : Rational.of(getGcd(gcd.num, monomial.coeff.num));
77
+ if (gcd.equals(Rational.one)) break;
78
+ }
79
+ return gcd;
80
+ };
81
+
82
+ // term_with_index: the monomials in a vector with the position of every column, and a removal
83
+ // that moves the last monomial into the gap.
84
+ class TermWithIndex {
85
+ readonly data: Monomial[] = [];
86
+ private positions: number[] = [];
87
+
88
+ get size() {
89
+ return this.data.length;
90
+ }
91
+
92
+ has(column: number) {
93
+ return (this.positions[column] ?? -1) >= 0;
94
+ }
95
+
96
+ get(column: number) {
97
+ return this.data[this.positions[column]].coeff;
98
+ }
99
+
100
+ erase(column: number) {
101
+ const position = this.positions[column] ?? -1;
102
+ if (position === -1) return;
103
+ const last = this.data.length - 1;
104
+ if (position !== last) {
105
+ this.data[position] = this.data[last];
106
+ this.positions[this.data[position].column] = position;
107
+ }
108
+ this.data.pop();
109
+ this.positions[column] = -1;
110
+ }
111
+
112
+ add(coeff: Rational, column: number) {
113
+ const position = this.positions[column] ?? -1;
114
+ if (position === -1) {
115
+ this.data.push({ coeff, column });
116
+ this.positions[column] = this.data.length - 1;
117
+ return;
118
+ }
119
+ const sum = this.data[position].coeff.add(coeff);
120
+ if (sum.isZero()) this.erase(column);
121
+ else this.data[position] = { coeff: sum, column };
122
+ }
123
+
124
+ clear() {
125
+ for (const monomial of this.data) this.positions[monomial.column] = -1;
126
+ this.data.length = 0;
127
+ }
128
+ }
129
+
130
+ // protected_queue: a queue of distinct columns that can also lose a column in the middle.
131
+ class ProtectedQueue {
132
+ readonly items: number[] = [];
133
+ private members = new Set<number>();
134
+
135
+ get isEmpty() {
136
+ return this.items.length === 0;
137
+ }
138
+
139
+ push(column: number) {
140
+ if (this.members.has(column)) return;
141
+ this.items.push(column);
142
+ this.members.add(column);
143
+ }
144
+
145
+ popFront() {
146
+ const column = this.items.shift() ?? NO_VAR;
147
+ this.members.delete(column);
148
+ return column;
149
+ }
150
+
151
+ remove(column: number) {
152
+ if (!this.members.delete(column)) return;
153
+ this.items.splice(this.items.indexOf(column), 1);
154
+ }
155
+
156
+ reset() {
157
+ this.items.length = 0;
158
+ this.members.clear();
159
+ }
160
+ }
161
+
162
+ // var_register: the local columns of the equations, and the lar_solver column of each, or none
163
+ // for a fresh column.
164
+ class VarRegister {
165
+ private localToExternal: number[] = [];
166
+ private externalToLocal = new Map<number, number>();
167
+
168
+ addVar(external: number) {
169
+ const existing = external === NO_VAR ? undefined : this.externalToLocal.get(external);
170
+ if (existing !== undefined) return existing;
171
+ const local = this.localToExternal.length;
172
+ this.localToExternal.push(external);
173
+ if (external !== NO_VAR) this.externalToLocal.set(external, local);
174
+ return local;
175
+ }
176
+
177
+ getExternal(local: number) {
178
+ return local < this.localToExternal.length ? this.localToExternal[local] : NO_VAR;
179
+ }
180
+
181
+ isUsed(external: number) {
182
+ return this.externalToLocal.has(external);
183
+ }
184
+
185
+ // external_to_local, which Z3 asserts finds the column.
186
+ getLocal(external: number) {
187
+ const local = this.externalToLocal.get(external);
188
+ if (local === undefined)
189
+ throw new SmtInvariantError(`the Diophantine solver has no column for ${external}`);
190
+ return local;
191
+ }
192
+
193
+ shrink(size: number) {
194
+ for (let local = this.localToExternal.length; local-- > size;)
195
+ this.externalToLocal.delete(this.localToExternal[local]);
196
+ shrink(this.localToExternal, size);
197
+ }
198
+
199
+ clear() {
200
+ this.localToExternal = [];
201
+ this.externalToLocal.clear();
202
+ }
203
+ }
204
+
205
+ // m_fresh_k2xt_terms: the definition of a substituted column k by a fresh column xt, reachable
206
+ // from both. The map from k to xt is an unordered_map whose order Z3 iterates.
207
+ class FreshDefinitions {
208
+ readonly keyToFresh = new UnorderedUintMap<number>();
209
+ private freshToKey = new Map<number, number>();
210
+ private definitions = new Map<number, FreshDefinition>();
211
+
212
+ add(key: number, fresh: number, definition: FreshDefinition) {
213
+ this.keyToFresh.insert(key, fresh);
214
+ this.freshToKey.set(fresh, key);
215
+ this.definitions.set(fresh, definition);
216
+ }
217
+
218
+ hasKey(key: number) {
219
+ return this.keyToFresh.has(key);
220
+ }
221
+
222
+ hasFresh(fresh: number) {
223
+ return this.definitions.has(fresh);
224
+ }
225
+
226
+ getByKey(key: number) {
227
+ return this.getByFresh(this.keyToFresh.get(key) ?? NO_VAR);
228
+ }
229
+
230
+ getByFresh(fresh: number) {
231
+ const definition = this.definitions.get(fresh);
232
+ if (definition === undefined)
233
+ throw new SmtInvariantError(`the Diophantine solver has no definition for ${fresh}`);
234
+ return definition;
235
+ }
236
+
237
+ eraseByFresh(fresh: number) {
238
+ this.keyToFresh.delete(this.freshToKey.get(fresh) ?? NO_VAR);
239
+ this.freshToKey.delete(fresh);
240
+ this.definitions.delete(fresh);
241
+ }
242
+
243
+ clear() {
244
+ this.keyToFresh.clear();
245
+ this.freshToKey.clear();
246
+ this.definitions.clear();
247
+ }
248
+ }
249
+
250
+ export class DiophantineSolver {
251
+ // m_some_terms_are_ignored: a term was not integral or had a big number, so the GCD test and
252
+ // Gomory cuts run.
253
+ hasIgnoredTerms = false;
254
+ private readonly solver: LarSolver;
255
+ private sumOfFixed: Rational[] = [];
256
+ private varRegister = new VarRegister();
257
+ // m_e_matrix: the equations over local columns. m_l_matrix: each as a combination of the term
258
+ // definitions, which explains it.
259
+ private eMatrix = new StaticMatrix();
260
+ private lMatrix = new StaticMatrix();
261
+ private infeasExplanation = new Explanation();
262
+ // m_c, the constant of m_espace.
263
+ private constant = Rational.zero;
264
+ private lspace = new TermWithIndex();
265
+ private espace = new TermWithIndex();
266
+ // m_k2s: the column each equation of S is solved for, and back.
267
+ private keyToRow = new Map<number, number>();
268
+ private rowToKey = new Map<number, number>();
269
+ private freshDefinitions = new FreshDefinitions();
270
+ private rowToFreshDefs = new Map<number, number[]>();
271
+ private changedRows = new IndexedUintSet();
272
+ private changedFixedColumns = new IndexedUintSet();
273
+ private changedTerms = new IndexedUintSet();
274
+ private termsToTighten = new IndexedUintSet();
275
+ private columnsToTerms = new Map<number, Set<number>>();
276
+ private conflictRow = NO_VAR;
277
+ private conflictGcd = Rational.zero;
278
+ private undoWork = 0;
279
+ private addedTerms: LarTerm[] = [];
280
+ private activeTerms = new Set<LarTerm>();
281
+ private queue = new ProtectedQueue();
282
+
283
+ constructor(private readonly lia: IntSolver) {
284
+ this.solver = lia.solver;
285
+ this.solver.onAddTerm = (term) => this.addTermCallback(term);
286
+ this.solver.onColumnBoundUpdate = (column) => this.updateColumnBoundCallback(column);
287
+ }
288
+
289
+ check() {
290
+ const settings = this.solver.settings;
291
+ settings.stats.dioCalls++;
292
+ const fVector: number[] = [];
293
+ let move: DioMove;
294
+ do {
295
+ this.init(fVector);
296
+ move = this.processFAndTightenTerms(fVector);
297
+ } while (move === "continue");
298
+ return move;
299
+ }
300
+
301
+ explain(explanation: Explanation) {
302
+ explanation.clear();
303
+ if (this.conflictRow === NO_VAR) {
304
+ for (const constraint of this.infeasExplanation) explanation.push(constraint);
305
+ return;
306
+ }
307
+ const dep = this.explainFixedInMetaTerm(
308
+ this.getRowMonomials(this.lMatrix, this.conflictRow),
309
+ this.conflictGcd,
310
+ );
311
+ explanation.pushDependency(dep);
312
+ }
313
+
314
+ // Callbacks of lar_solver.
315
+
316
+ private addTermCallback(term: LarTerm) {
317
+ if (!this.solver.isInt(term.column)) {
318
+ this.hasIgnoredTerms = true;
319
+ return;
320
+ }
321
+ this.addedTerms.push(term);
322
+ this.changedTerms.add(term.column);
323
+ this.solver.pushTrail(() => this.undoAddTerm(term));
324
+ }
325
+
326
+ private updateColumnBoundCallback(column: number) {
327
+ const solver = this.solver;
328
+ if (!solver.isInt(column)) return;
329
+ if (solver.hasTerm(column)) this.termsToTighten.add(column);
330
+ if (!solver.isFixed(column)) return;
331
+ this.changedFixedColumns.add(column);
332
+ solver.pushTrail(() => this.changedFixedColumns.add(column));
333
+ }
334
+
335
+ private undoAddTerm(term: LarTerm) {
336
+ if (!this.activeTerms.has(term)) {
337
+ const index = this.addedTerms.lastIndexOf(term);
338
+ if (index !== -1) {
339
+ this.addedTerms[index] = this.addedTerms[this.addedTerms.length - 1];
340
+ this.addedTerms.pop();
341
+ }
342
+ return;
343
+ }
344
+ this.deregisterColumnsOfTerm(term);
345
+ this.activeTerms.delete(term);
346
+ const settings = this.solver.settings;
347
+ this.undoWork += 1 + this.getEliminationWorkEstimate();
348
+ if (this.undoWork > settings.dioUndoMaxWork || settings.isCanceled()) {
349
+ this.resetState();
350
+ return;
351
+ }
352
+ this.shrinkMatrices();
353
+ }
354
+
355
+ private deregisterColumnsOfTerm(term: LarTerm) {
356
+ for (const monomial of getExtendedMonomials(term)) {
357
+ const terms = this.columnsToTerms.get(monomial.column);
358
+ if (terms === undefined) continue;
359
+ terms.delete(term.column);
360
+ if (terms.size === 0) this.columnsToTerms.delete(monomial.column);
361
+ }
362
+ }
363
+
364
+ // elimination_work_estimate: the words that eliminating the column of the retired term from
365
+ // m_l_matrix touches.
366
+ private getEliminationWorkEstimate() {
367
+ const lMatrix = this.lMatrix;
368
+ if (lMatrix.getColumnCount() === 0 || lMatrix.getRowCount() === 0) return 0;
369
+ const columnSize = lMatrix.columns[lMatrix.getColumnCount() - 1].length;
370
+ if (columnSize <= 1) return 0;
371
+ let words = 0;
372
+ for (const cell of lMatrix.rows[lMatrix.getRowCount() - 1])
373
+ words += 1 + Math.floor(getBitsize(cell.coeff) / 32);
374
+ return (columnSize - 1) * words;
375
+ }
376
+
377
+ // reset_state: drops what was derived, and puts the active terms back to be added again in the
378
+ // order of their columns.
379
+ private resetState() {
380
+ for (const term of this.activeTerms) {
381
+ this.deregisterColumnsOfTerm(term);
382
+ this.addedTerms.push(term);
383
+ }
384
+ this.activeTerms.clear();
385
+ this.addedTerms.sort((first, second) => first.column - second.column);
386
+ this.eMatrix.clear();
387
+ this.lMatrix.clear();
388
+ this.sumOfFixed = [];
389
+ this.varRegister.clear();
390
+ this.keyToRow.clear();
391
+ this.rowToKey.clear();
392
+ this.freshDefinitions.clear();
393
+ this.rowToFreshDefs.clear();
394
+ this.changedRows.clear();
395
+ this.changedFixedColumns.clear();
396
+ this.changedTerms.clear();
397
+ this.termsToTighten.clear();
398
+ this.espace.clear();
399
+ this.lspace.clear();
400
+ this.queue.reset();
401
+ this.infeasExplanation.clear();
402
+ this.conflictRow = NO_VAR;
403
+ this.undoWork = 0;
404
+ this.solver.settings.stats.dioStateResets++;
405
+ }
406
+
407
+ // shrink_matrices: removes the equation of the retired term, the last one.
408
+ private shrinkMatrices() {
409
+ const lastRow = this.lMatrix.getRowCount() - 1;
410
+ this.eliminateLastTermColumn();
411
+ removeLastRow(this.lMatrix);
412
+ removeLastRow(this.eMatrix);
413
+ for (const fresh of this.rowToFreshDefs.get(lastRow) ?? [])
414
+ if (fresh < this.eMatrix.getColumnCount())
415
+ for (const cell of this.eMatrix.columns[fresh]) this.changedRows.add(cell.row);
416
+ popEmptyColumns(this.lMatrix);
417
+ popEmptyColumns(this.eMatrix);
418
+ this.varRegister.shrink(this.eMatrix.getColumnCount());
419
+ this.removeOutOfBoundsFreshDefs();
420
+ this.removeIrrelevantFreshDefsForRow(lastRow);
421
+ if (this.rowToKey.has(lastRow)) this.removeFromS(lastRow);
422
+ this.sumOfFixed.pop();
423
+ }
424
+
425
+ // eliminate_last_term_column: pivots the last column of m_l_matrix into its last row, and marks
426
+ // the rows that change, whose equations are recalculated later.
427
+ private eliminateLastTermColumn() {
428
+ const lMatrix = this.lMatrix;
429
+ const termColumn = lMatrix.getColumnCount() - 1;
430
+ const lastRowIndex = lMatrix.getRowCount() - 1;
431
+ if (!lMatrix.rows[lastRowIndex].some((cell) => cell.column === termColumn))
432
+ lMatrix.addRows(Rational.one, lMatrix.columns[termColumn][0].row, lastRowIndex);
433
+ const alpha = lMatrix.rows[lastRowIndex].find((cell) => cell.column === termColumn)?.coeff;
434
+ if (alpha === undefined) return;
435
+ lMatrix.divideRow(lastRowIndex, alpha);
436
+ const column = lMatrix.columns[termColumn];
437
+ const pivotIndex = column.findIndex((cell) => cell.row === lastRowIndex);
438
+ if (pivotIndex > 0) moveCellToFront(lMatrix, column, pivotIndex);
439
+ while (column.length > 1) {
440
+ const cell = column[column.length - 1];
441
+ this.changedRows.add(cell.row);
442
+ lMatrix.pivotRowToRowGivenCell(lastRowIndex, cell, termColumn);
443
+ }
444
+ }
445
+
446
+ // Filling the equations.
447
+
448
+ private init(fVector: number[]) {
449
+ this.infeasExplanation.clear();
450
+ this.lia.term.clear();
451
+ this.conflictRow = NO_VAR;
452
+ this.undoWork = 0;
453
+ this.processChangedFixedColumns(fVector);
454
+ for (const term of this.addedTerms) {
455
+ this.activeTerms.add(term);
456
+ fVector.push(this.eMatrix.getRowCount());
457
+ this.fillEntry(term);
458
+ this.registerColumnsToTerm(term);
459
+ }
460
+ this.addedTerms = [];
461
+ }
462
+
463
+ private registerColumnsToTerm(term: LarTerm) {
464
+ for (const monomial of getExtendedMonomials(term)) {
465
+ const terms = this.columnsToTerms.get(monomial.column);
466
+ if (terms === undefined) this.columnsToTerms.set(monomial.column, new Set([term.column]));
467
+ else terms.add(term.column);
468
+ }
469
+ }
470
+
471
+ // fill_entry: the equation t - j = 0 with the fixed columns in the constant, explained by j.
472
+ private fillEntry(term: LarTerm) {
473
+ const solver = this.solver;
474
+ const row = this.eMatrix.getRowCount();
475
+ this.lMatrix.addRow();
476
+ this.lMatrix.addColumnsUpTo(term.column);
477
+ this.lMatrix.addNewElement(row, term.column, Rational.one);
478
+ this.eMatrix.addRow();
479
+ let fixedSum = Rational.zero;
480
+ for (const monomial of getExtendedMonomials(term)) {
481
+ if (solver.isFixed(monomial.column)) {
482
+ fixedSum = fixedSum.add(monomial.coeff.mul(solver.getLowerBound(monomial.column).x));
483
+ continue;
484
+ }
485
+ const local = this.varRegister.addVar(monomial.column);
486
+ this.eMatrix.addColumnsUpTo(local);
487
+ this.eMatrix.addNewElement(row, local, monomial.coeff);
488
+ }
489
+ this.sumOfFixed.push(fixedSum);
490
+ this.subsEntry(row);
491
+ }
492
+
493
+ // subs_entry: substitutes the solved and the freshly defined columns in the equation.
494
+ private subsEntry(row: number) {
495
+ if (row >= this.eMatrix.getRowCount()) return;
496
+ const queue = this.queue;
497
+ queue.reset();
498
+ for (const cell of this.eMatrix.rows[row])
499
+ if (this.canSubstitute(cell.column)) queue.push(cell.column);
500
+ while (!queue.isEmpty) {
501
+ const column = queue.popFront();
502
+ const alpha = this.getCoeffInERow(row, column);
503
+ if (alpha.isZero()) continue;
504
+ const solvedRow = this.keyToRow.get(column);
505
+ if (solvedRow === undefined)
506
+ this.eMatrix.addTermToRow(alpha.neg(), this.freshDefinitions.getByKey(column).term, row);
507
+ else
508
+ this.addTwoEntries(
509
+ alpha.neg().mul(Rational.fromNumber(this.getSignInERow(solvedRow, column))),
510
+ solvedRow,
511
+ row,
512
+ );
513
+ for (const cell of this.eMatrix.rows[row])
514
+ if (this.canSubstitute(cell.column)) queue.push(cell.column);
515
+ }
516
+ }
517
+
518
+ // add_two_entries: adds an equation times coeff to another.
519
+ private addTwoEntries(coeff: Rational, from: number, to: number) {
520
+ this.eMatrix.addRows(coeff, from, to);
521
+ this.lMatrix.addRows(coeff, from, to);
522
+ this.sumOfFixed[to] = this.sumOfFixed[to].add(coeff.mul(this.sumOfFixed[from]));
523
+ }
524
+
525
+ // recalculate_entry: the equation again from its explanation, scaled to integers.
526
+ private recalculateEntry(row: number) {
527
+ let fixedSum = this.openLTermToEspace(row);
528
+ const eRow = this.eMatrix.rows[row];
529
+ while (eRow.length > 0) this.eMatrix.removeElement(eRow, eRow[eRow.length - 1]);
530
+ let denominator = 1n;
531
+ for (const monomial of this.espace.data) {
532
+ const local = this.varRegister.addVar(monomial.column);
533
+ this.eMatrix.addColumnsUpTo(local);
534
+ this.eMatrix.addNewElement(row, local, monomial.coeff);
535
+ if (monomial.coeff.den !== 1n) denominator = getLcm(denominator, monomial.coeff.den);
536
+ }
537
+ if (denominator !== 1n) {
538
+ const scale = Rational.of(denominator);
539
+ fixedSum = fixedSum.mul(scale);
540
+ this.lMatrix.multiplyRow(row, scale);
541
+ this.eMatrix.multiplyRow(row, scale);
542
+ }
543
+ this.sumOfFixed[row] = fixedSum;
544
+ if (this.rowToKey.has(row)) this.removeFromS(row);
545
+ }
546
+
547
+ // open_l_term_to_espace: the combination of term definitions of the row, over lar_solver
548
+ // columns, with the fixed ones in the returned constant.
549
+ private openLTermToEspace(row: number) {
550
+ const solver = this.solver;
551
+ this.espace.clear();
552
+ let constant = Rational.zero;
553
+ for (const cell of this.lMatrix.rows[row])
554
+ for (const monomial of getExtendedMonomials(solver.getTerm(cell.column))) {
555
+ const coeff = cell.coeff.mul(monomial.coeff);
556
+ if (solver.isFixed(monomial.column))
557
+ constant = constant.add(coeff.mul(solver.getLowerBound(monomial.column).x));
558
+ else this.espace.add(coeff, monomial.column);
559
+ }
560
+ return constant;
561
+ }
562
+
563
+ // process_m_changed_f_columns: recalculates the equations that the columns that became fixed or
564
+ // stopped being fixed, and the changed terms, touch.
565
+ private processChangedFixedColumns(fVector: number[]) {
566
+ for (const column of this.changedFixedColumns.elems.slice()) {
567
+ const terms = this.columnsToTerms.get(column);
568
+ if (terms !== undefined)
569
+ for (const termColumn of [...terms].sort((first, second) => first - second))
570
+ this.changedTerms.add(termColumn);
571
+ if (!this.varRegister.isUsed(column)) continue;
572
+ for (const cell of this.eMatrix.columns[this.varRegister.getLocal(column)])
573
+ this.changedRows.add(cell.row);
574
+ }
575
+ for (const column of this.changedTerms.elems.slice()) {
576
+ if (!this.isBigTermOrNoTerm(column)) this.termsToTighten.add(column);
577
+ if (column < this.lMatrix.getColumnCount())
578
+ for (const cell of this.lMatrix.columns[column]) this.changedRows.add(cell.row);
579
+ }
580
+ const moreChangedRows: number[] = [];
581
+ for (const row of this.changedRows.elems)
582
+ for (const fresh of this.rowToFreshDefs.get(row) ?? [])
583
+ for (const cell of this.eMatrix.columns[fresh]) moreChangedRows.push(cell.row);
584
+ for (const row of moreChangedRows) this.changedRows.add(row);
585
+ this.removeOutOfBoundsFreshDefs();
586
+ for (const row of this.changedRows.elems.slice()) this.removeIrrelevantFreshDefsForRow(row);
587
+ for (const row of this.changedRows.elems.slice()) {
588
+ if (row >= this.eMatrix.getRowCount()) continue;
589
+ if (this.rowToKey.has(row)) fVector.push(row);
590
+ this.recalculateEntry(row);
591
+ const eMatrix = this.eMatrix;
592
+ if (
593
+ eMatrix.getColumnCount() > 0 &&
594
+ eMatrix.columns[eMatrix.getColumnCount() - 1].length === 0
595
+ ) {
596
+ eMatrix.popColumn();
597
+ this.varRegister.shrink(eMatrix.getColumnCount());
598
+ this.removeOutOfBoundsFreshDefs();
599
+ }
600
+ const lMatrix = this.lMatrix;
601
+ if (
602
+ lMatrix.getColumnCount() > 0 &&
603
+ lMatrix.columns[lMatrix.getColumnCount() - 1].length === 0
604
+ )
605
+ lMatrix.popColumn();
606
+ }
607
+ for (const row of this.changedRows.elems.slice()) this.subsEntry(row);
608
+ this.changedFixedColumns.clear();
609
+ this.changedRows.clear();
610
+ this.changedTerms.clear();
611
+ }
612
+
613
+ // is_big_term_or_no_term: also marks the terms ignored for their big numbers.
614
+ private isBigTermOrNoTerm(column: number) {
615
+ const solver = this.solver;
616
+ if (column >= solver.getColumnCount() || !solver.hasTerm(column)) return true;
617
+ if (!solver.settings.isDioIgnoringBigNums) return false;
618
+ for (const entry of solver.getTerm(column).coeffs) {
619
+ const isBigFixed = solver.isFixed(entry[0]) && solver.getLowerBound(entry[0]).x.isBig();
620
+ if (!entry[1].isBig() && !isBigFixed) continue;
621
+ this.hasIgnoredTerms = true;
622
+ return true;
623
+ }
624
+ return false;
625
+ }
626
+
627
+ // Fresh definitions.
628
+
629
+ // collect_dependent_fresh_vars: the fresh columns whose definitions use a removed one.
630
+ private collectDependentFreshVars(removed: number, toRemove: number[]) {
631
+ const newlyFound: number[] = [];
632
+ for (const entry of this.freshDefinitions.keyToFresh) {
633
+ const fresh = entry[1];
634
+ if (fresh === removed || toRemove.includes(fresh)) continue;
635
+ const coeffs = this.freshDefinitions.getByFresh(fresh).term.coeffs;
636
+ if (coeffs.has(removed) || toRemove.some((marked) => coeffs.has(marked)))
637
+ newlyFound.push(fresh);
638
+ }
639
+ toRemove.push(...newlyFound);
640
+ for (const fresh of newlyFound) this.collectDependentFreshVars(fresh, toRemove);
641
+ }
642
+
643
+ // deep_remove_fresh_var: removes the fresh column and those that depend on it, and marks the
644
+ // rows that use them.
645
+ private deepRemoveFreshVar(removed: number) {
646
+ if (!this.freshDefinitions.hasFresh(removed)) return;
647
+ const toRemove = [removed];
648
+ this.collectDependentFreshVars(removed, toRemove);
649
+ for (const fresh of toRemove) {
650
+ if (!this.freshDefinitions.hasFresh(fresh)) continue;
651
+ const row = this.freshDefinitions.getByFresh(fresh).row;
652
+ this.freshDefinitions.eraseByFresh(fresh);
653
+ const defs = this.rowToFreshDefs.get(row);
654
+ if (defs !== undefined) {
655
+ const kept = defs.filter((def) => def !== fresh);
656
+ if (kept.length === 0) this.rowToFreshDefs.delete(row);
657
+ else this.rowToFreshDefs.set(row, kept);
658
+ }
659
+ if (fresh < this.eMatrix.getColumnCount())
660
+ for (const cell of this.eMatrix.columns[fresh]) this.changedRows.add(cell.row);
661
+ }
662
+ }
663
+
664
+ private removeIrrelevantFreshDefsForRow(row: number) {
665
+ const defs = this.rowToFreshDefs.get(row);
666
+ if (defs === undefined) return;
667
+ for (const fresh of defs.slice()) this.deepRemoveFreshVar(fresh);
668
+ this.rowToFreshDefs.delete(row);
669
+ }
670
+
671
+ private removeOutOfBoundsFreshDefs() {
672
+ const freshToRemove: number[] = [];
673
+ const rows: number[] = [];
674
+ for (const entry of this.freshDefinitions.keyToFresh) {
675
+ if (entry[1] < this.eMatrix.getColumnCount()) continue;
676
+ freshToRemove.push(entry[1]);
677
+ rows.push(this.freshDefinitions.getByFresh(entry[1]).row);
678
+ }
679
+ for (const fresh of freshToRemove) this.deepRemoveFreshVar(fresh);
680
+ for (const row of rows) this.removeIrrelevantFreshDefsForRow(row);
681
+ }
682
+
683
+ // fresh_var_step: step 7 of the paper. With the smallest coefficient a of k in row h, the fresh
684
+ // column xt = k + sum (a_i div a) x_i replaces k in the equations of F.
685
+ private freshVarStep(row: number, key: number, ahk: Rational) {
686
+ const fresh = this.varRegister.addVar(NO_VAR);
687
+ while (fresh >= this.eMatrix.getColumnCount()) this.eMatrix.addColumn();
688
+ const freshTerm = new LarTerm();
689
+ freshTerm.addMonomial(Rational.minusOne, fresh);
690
+ freshTerm.addMonomial(Rational.one, key);
691
+ for (const cell of this.eMatrix.rows[row]) {
692
+ if (cell.column === key) continue;
693
+ const quotient = getTruncatedQuotient(cell.coeff, ahk);
694
+ if (!quotient.isZero()) freshTerm.addMonomial(quotient, cell.column);
695
+ }
696
+ // std::make_pair copies the term with lar_term's copy constructor, and the bij_map assigns
697
+ // it, so the stored term is reinserted twice in iteration order.
698
+ const stored = new LarTerm(new LarTerm(freshTerm.coeffs).coeffs);
699
+ this.freshDefinitions.add(key, fresh, { term: stored, row });
700
+ const defs = this.rowToFreshDefs.get(row);
701
+ if (defs === undefined) this.rowToFreshDefs.set(row, [fresh]);
702
+ else defs.push(fresh);
703
+ const column = this.eMatrix.columns[key];
704
+ for (let index = column.length; index-- > 0;) {
705
+ const cell = column[index];
706
+ if (this.rowToKey.has(cell.row)) continue;
707
+ this.eMatrix.pivotTermToRowGivenCell(freshTerm, cell, key, 1);
708
+ }
709
+ }
710
+
711
+ // Solving F.
712
+
713
+ private processFAndTightenTerms(fVector: number[]): DioMove {
714
+ const move = this.processF(fVector);
715
+ if (move !== "undef") return move;
716
+ const tightened = this.tightenTermsWithS();
717
+ if (tightened === "conflict") this.solver.settings.stats.dioTightenConflicts++;
718
+ return tightened;
719
+ }
720
+
721
+ private processF(fVector: number[]): DioMove {
722
+ if (this.conflictRow !== NO_VAR) return "conflict";
723
+ let move: DioMove;
724
+ do {
725
+ move = this.rewriteEqs(fVector);
726
+ if (this.solver.settings.isCanceled()) return "undef";
727
+ if (move !== "continue") break;
728
+ } while (fVector.length > 0);
729
+ return move === "conflict" ? "conflict" : "undef";
730
+ }
731
+
732
+ private setRewriteConflict(row: number, gcd: Rational) {
733
+ this.conflictRow = row;
734
+ this.conflictGcd = gcd;
735
+ this.solver.settings.stats.dioRewriteConflicts++;
736
+ }
737
+
738
+ // rewrite_eqs: steps 6 and 7 of the paper on the equation of F with the smallest coefficient,
739
+ // and of those the one whose substitution fills the fewest cells.
740
+ private rewriteEqs(fVector: number[]): DioMove {
741
+ if (fVector.length === 0) return "undef";
742
+ let chosenRow = NO_VAR;
743
+ let chosenKey = 0;
744
+ let chosenIndex = NO_VAR;
745
+ let chosenSign = 0;
746
+ let chosenMarkovich = 0;
747
+ let minAhk = Rational.zero;
748
+ let numChoices = 0;
749
+ for (let index = 0; index < fVector.length; index++) {
750
+ const row = fVector[index];
751
+ const eRow = this.eMatrix.rows[row];
752
+ if (eRow.length === 0) {
753
+ if (this.sumOfFixed[row].isZero()) continue;
754
+ this.setRewriteConflict(row, Rational.zero);
755
+ return "conflict";
756
+ }
757
+ if (!this.sumOfFixed[row].isInt()) {
758
+ this.setRewriteConflict(row, Rational.zero);
759
+ return "conflict";
760
+ }
761
+ const minimal = this.findMinimalAbsCoeff(row);
762
+ const gcd = this.normalizeEByGcd(row);
763
+ if (gcd === undefined) return "conflict";
764
+ const ahk = gcd.equals(Rational.one) ? minimal.ahk : minimal.ahk.div(gcd);
765
+ if (numChoices === 0 || minAhk.compare(ahk) > 0) {
766
+ chosenIndex = index;
767
+ numChoices = 1;
768
+ minAhk = ahk;
769
+ chosenRow = row;
770
+ chosenKey = minimal.column;
771
+ chosenSign = minimal.sign;
772
+ chosenMarkovich = minimal.markovich;
773
+ continue;
774
+ }
775
+ if (minAhk.equals(ahk) && chosenMarkovich > minimal.markovich) {
776
+ chosenIndex = index;
777
+ chosenRow = row;
778
+ chosenKey = minimal.column;
779
+ chosenSign = minimal.sign;
780
+ chosenMarkovich = minimal.markovich;
781
+ }
782
+ if (minAhk.equals(Rational.one) && chosenMarkovich === 0) break;
783
+ }
784
+ if (chosenRow === NO_VAR) return "undef";
785
+ if (minAhk.equals(Rational.one)) {
786
+ this.keyToRow.set(chosenKey, chosenRow);
787
+ this.rowToKey.set(chosenRow, chosenKey);
788
+ this.eliminateVarInF(chosenRow, chosenKey, chosenSign);
789
+ fVector[chosenIndex] = fVector[fVector.length - 1];
790
+ fVector.pop();
791
+ } else this.freshVarStep(chosenRow, chosenKey, minAhk.mul(Rational.fromNumber(chosenSign)));
792
+ return "continue";
793
+ }
794
+
795
+ // find_minimal_abs_coeff: the first column with the smallest coefficient, its sign, and the
796
+ // Markowitz number of the pivot.
797
+ private findMinimalAbsCoeff(row: number) {
798
+ let ahk = Rational.zero;
799
+ let column = NO_VAR;
800
+ let sign = 0;
801
+ for (const cell of this.eMatrix.rows[row]) {
802
+ const magnitude = cell.coeff.abs();
803
+ if (column !== NO_VAR && magnitude.compare(ahk) >= 0) continue;
804
+ ahk = magnitude;
805
+ sign = cell.coeff.isPositive() ? 1 : -1;
806
+ column = cell.column;
807
+ if (ahk.equals(Rational.one)) break;
808
+ }
809
+ const markovich =
810
+ (this.eMatrix.columns[column].length - 1) * (this.eMatrix.rows[row].length - 1);
811
+ return { ahk, column, sign, markovich };
812
+ }
813
+
814
+ // normalize_e_by_gcd: the gcd of the coefficients after dividing the equation by it, or
815
+ // undefined on the conflict of a gcd that does not divide the constant.
816
+ private normalizeEByGcd(row: number) {
817
+ const gcd = getGcdOfCoeffs(this.eMatrix.rows[row], true);
818
+ if (gcd.isZero() || gcd.equals(Rational.one)) return gcd;
819
+ const quotient = this.sumOfFixed[row].div(gcd);
820
+ if (!quotient.isInt()) {
821
+ this.setRewriteConflict(row, gcd);
822
+ return undefined;
823
+ }
824
+ this.eMatrix.divideRow(row, gcd);
825
+ this.sumOfFixed[row] = quotient;
826
+ this.lMatrix.divideRow(row, gcd);
827
+ return gcd;
828
+ }
829
+
830
+ // eliminate_var_in_f: substitutes the column solved by the row in the other equations of F.
831
+ private eliminateVarInF(row: number, key: number, sign: number) {
832
+ const constant = this.sumOfFixed[row];
833
+ const column = this.eMatrix.columns[key];
834
+ const pivotIndex = column.findIndex((cell) => cell.row === row);
835
+ if (pivotIndex > 0) moveCellToFront(this.eMatrix, column, pivotIndex);
836
+ const signValue = Rational.fromNumber(sign);
837
+ for (let index = column.length; index-- > 0;) {
838
+ const cell = column[index];
839
+ if (this.rowToKey.has(cell.row)) continue;
840
+ const coeff = this.eMatrix.getVal(cell);
841
+ const target = cell.row;
842
+ this.sumOfFixed[target] = this.sumOfFixed[target].sub(signValue.mul(coeff).mul(constant));
843
+ this.eMatrix.pivotRowToRowGivenCellWithSign(row, cell, key, sign);
844
+ this.lMatrix.addRows(signValue.neg().mul(coeff), row, target);
845
+ }
846
+ }
847
+
848
+ private removeFromS(row: number) {
849
+ const key = this.rowToKey.get(row);
850
+ if (key === undefined) return;
851
+ this.rowToKey.delete(row);
852
+ this.keyToRow.delete(key);
853
+ }
854
+
855
+ private canSubstitute(column: number) {
856
+ return this.keyToRow.has(column) || this.freshDefinitions.hasKey(column);
857
+ }
858
+
859
+ private isFresh(column: number) {
860
+ return this.freshDefinitions.hasFresh(column);
861
+ }
862
+
863
+ private getCoeffInERow(row: number, column: number) {
864
+ return this.eMatrix.rows[row].find((cell) => cell.column === column)?.coeff ?? Rational.zero;
865
+ }
866
+
867
+ private getSignInERow(row: number, column: number) {
868
+ return this.getCoeffInERow(row, column).isPositive() ? 1 : -1;
869
+ }
870
+
871
+ private getRowMonomials(matrix: StaticMatrix, row: number): Monomial[] {
872
+ return matrix.rows[row].map((cell) => ({ coeff: cell.coeff, column: cell.column }));
873
+ }
874
+
875
+ // Tightening the bounds of term columns.
876
+
877
+ // tighten_terms_with_S: the terms whose bounds changed, the most shared first.
878
+ private tightenTermsWithS(): DioMove {
879
+ const solver = this.solver;
880
+ const sortedTerms: number[] = [];
881
+ const processedTerms: number[] = [];
882
+ for (const column of this.termsToTighten.elems) {
883
+ if (
884
+ column >= solver.getColumnCount() ||
885
+ !solver.hasTerm(column) ||
886
+ solver.isFree(column) ||
887
+ !solver.isInt(column)
888
+ )
889
+ processedTerms.push(column);
890
+ else sortedTerms.push(column);
891
+ }
892
+ const weights = new Map(
893
+ sortedTerms.map((column) => [column, this.getTermWeight(solver.getTerm(column))]),
894
+ );
895
+ sortedTerms.sort(
896
+ (first, second) => (weights.get(second) ?? 0) - (weights.get(first) ?? 0) || first - second,
897
+ );
898
+ let move: DioMove = "undef";
899
+ for (const column of sortedTerms) {
900
+ if (this.isBigTermOrNoTerm(column)) {
901
+ this.termsToTighten.delete(column);
902
+ continue;
903
+ }
904
+ const tightened = this.tightenBoundsForTermColumn(column);
905
+ this.termsToTighten.delete(column);
906
+ move = joinMoves(tightened, move);
907
+ if (move === "conflict") break;
908
+ }
909
+ for (const column of processedTerms) this.termsToTighten.delete(column);
910
+ return move;
911
+ }
912
+
913
+ private getTermWeight(term: LarTerm) {
914
+ let weight = 0;
915
+ for (const entry of term.coeffs)
916
+ weight = Math.max(weight, this.columnsToTerms.get(entry[0])?.size ?? 0);
917
+ return weight;
918
+ }
919
+
920
+ private tightenBoundsForTermColumn(column: number): DioMove {
921
+ const queue = new ProtectedQueue();
922
+ if (!this.initSubstitutions(this.solver.getTerm(column), queue)) return "undef";
923
+ if (this.subsWithSAndFresh(queue, column) === "conflict") return "conflict";
924
+ this.processFixedInEspace();
925
+ return this.tightenOnEspace(column);
926
+ }
927
+
928
+ // init_substitutions: m_espace is the term over local columns with its fixed part in m_c, and
929
+ // m_lspace explains it. False on a big number.
930
+ private initSubstitutions(term: LarTerm, queue: ProtectedQueue) {
931
+ const solver = this.solver;
932
+ const isIgnoringBigNums = solver.settings.isDioIgnoringBigNums;
933
+ this.espace.clear();
934
+ this.constant = Rational.zero;
935
+ this.lspace.clear();
936
+ this.lspace.add(Rational.one, term.column);
937
+ for (const entry of term.coeffs) {
938
+ const column = entry[0];
939
+ const coeff = entry[1];
940
+ if (solver.isFixed(column)) {
941
+ const bound = solver.getLowerBound(column).x;
942
+ if (isIgnoringBigNums && bound.isBig()) return false;
943
+ this.constant = this.constant.add(coeff.mul(bound));
944
+ continue;
945
+ }
946
+ const local = this.varRegister.getLocal(column);
947
+ if (isIgnoringBigNums && coeff.isBig()) return false;
948
+ this.espace.add(coeff, local);
949
+ if (this.canSubstitute(local)) queue.push(local);
950
+ }
951
+ return true;
952
+ }
953
+
954
+ private subsWithSAndFresh(queue: ProtectedQueue, column: number) {
955
+ let move: DioMove = "undef";
956
+ while (!queue.isEmpty && move !== "conflict" && this.espace.size <= TIGHTEN_SIZE_MAX)
957
+ move = joinMoves(this.subsFrontWithSAndFresh(queue, column), move);
958
+ return move;
959
+ }
960
+
961
+ private subsFrontWithSAndFresh(queue: ProtectedQueue, column: number): DioMove {
962
+ this.processFixedInEspace();
963
+ const tightened = this.tightenOnEspace(column);
964
+ if (tightened === "conflict") return "conflict";
965
+ const key = this.findVarToSubstituteOnEspace(queue);
966
+ if (key === NO_VAR) return "undef";
967
+ const move = this.freshDefinitions.hasKey(key)
968
+ ? this.subsByFresh(key, queue, column)
969
+ : this.subsByS(key, queue, column);
970
+ return joinMoves(move, tightened);
971
+ }
972
+
973
+ // find_var_to_substitute_on_espace: the queued column whose substitution adds the fewest new
974
+ // columns, drawn at random among ties, and the queued columns no longer in m_espace dropped.
975
+ private findVarToSubstituteOnEspace(queue: ProtectedQueue) {
976
+ const espace = this.espace;
977
+ let best = NO_VAR;
978
+ let minNewVars = Number.MAX_SAFE_INTEGER;
979
+ let numCandidates = 0;
980
+ const toRemove: number[] = [];
981
+ for (const column of queue.items) {
982
+ if (!espace.has(column)) {
983
+ toRemove.push(column);
984
+ continue;
985
+ }
986
+ let newVars = 0;
987
+ const solvedRow = this.keyToRow.get(column);
988
+ if (solvedRow !== undefined) {
989
+ for (const cell of this.eMatrix.rows[solvedRow])
990
+ if (cell.column !== column && !espace.has(cell.column)) newVars++;
991
+ } else if (this.freshDefinitions.hasKey(column))
992
+ for (const entry of this.freshDefinitions.getByKey(column).term.coeffs)
993
+ if (entry[0] !== column && !espace.has(entry[0])) newVars++;
994
+ if (newVars < minNewVars) {
995
+ minNewVars = newVars;
996
+ best = column;
997
+ numCandidates = 1;
998
+ } else if (
999
+ newVars === minNewVars &&
1000
+ this.solver.settings.getRandomNext() % ++numCandidates === 0
1001
+ )
1002
+ best = column;
1003
+ }
1004
+ if (best !== NO_VAR) queue.remove(best);
1005
+ for (const column of toRemove) queue.remove(column);
1006
+ return best;
1007
+ }
1008
+
1009
+ // subs_qfront_by_fresh: replaces k by its fresh definition, which leaves m_lspace as it is.
1010
+ private subsByFresh(key: number, queue: ProtectedQueue, column: number) {
1011
+ const term = this.freshDefinitions.getByKey(key).term;
1012
+ const coeff = this.espace.get(key).neg();
1013
+ this.espace.erase(key);
1014
+ for (const entry of term.coeffs) {
1015
+ if (entry[0] === key) continue;
1016
+ this.espace.add(entry[1].mul(coeff), entry[0]);
1017
+ if (this.espace.has(entry[0]) && this.canSubstitute(entry[0])) queue.push(entry[0]);
1018
+ }
1019
+ return this.tightenOnEspace(column);
1020
+ }
1021
+
1022
+ // subs_qfront_by_S: replaces k by the equation solved for it, and adds that equation's
1023
+ // explanation to m_lspace.
1024
+ private subsByS(key: number, queue: ProtectedQueue, column: number) {
1025
+ const row = this.keyToRow.get(key) ?? NO_VAR;
1026
+ const constant = this.sumOfFixed[row];
1027
+ let coeff = this.espace.get(key);
1028
+ this.espace.erase(key);
1029
+ const eRow = this.eMatrix.rows[row];
1030
+ if (this.getCoeffInERow(row, key).equals(Rational.one)) coeff = coeff.neg();
1031
+ for (const cell of eRow) {
1032
+ if (cell.column === key) continue;
1033
+ this.espace.add(cell.coeff.mul(coeff), cell.column);
1034
+ if (this.espace.has(cell.column) && this.canSubstitute(cell.column)) queue.push(cell.column);
1035
+ }
1036
+ this.constant = this.constant.add(coeff.mul(constant));
1037
+ for (const cell of this.lMatrix.rows[row]) this.lspace.add(coeff.mul(cell.coeff), cell.column);
1038
+ return this.tightenOnEspace(column);
1039
+ }
1040
+
1041
+ private processFixedInEspace() {
1042
+ const solver = this.solver;
1043
+ const fixed: number[] = [];
1044
+ for (const monomial of this.espace.data)
1045
+ if (
1046
+ !this.isFresh(monomial.column) &&
1047
+ solver.isFixed(this.varRegister.getExternal(monomial.column))
1048
+ )
1049
+ fixed.push(monomial.column);
1050
+ for (const local of fixed) {
1051
+ const bound = solver.getLowerBound(this.varRegister.getExternal(local)).x;
1052
+ this.constant = this.constant.add(this.espace.get(local).mul(bound));
1053
+ this.espace.erase(local);
1054
+ }
1055
+ }
1056
+
1057
+ // tighten_on_espace: with g the gcd of m_espace, the bounds of the term column move to the
1058
+ // nearest values congruent to m_c modulo g, and a constant m_espace is checked against them.
1059
+ private tightenOnEspace(column: number): DioMove {
1060
+ const gcd = getGcdOfCoeffs(this.espace.data, true);
1061
+ if (gcd.equals(Rational.one)) return "undef";
1062
+ if (gcd.isZero()) {
1063
+ this.handleConstantTerm(column);
1064
+ return this.infeasExplanation.isEmpty ? "undef" : "conflict";
1065
+ }
1066
+ if (this.tightenBoundsForNonTrivialGcd(gcd, column, true)) return "conflict";
1067
+ if (this.tightenBoundsForNonTrivialGcd(gcd, column, false)) return "conflict";
1068
+ return this.changedFixedColumns.has(column) ? "continue" : "undef";
1069
+ }
1070
+
1071
+ private handleConstantTerm(column: number) {
1072
+ const solver = this.solver;
1073
+ const constant = this.constant;
1074
+ if (constant.isZero()) return;
1075
+ const upper = solver.getBound(column, true);
1076
+ const isAboveUpper =
1077
+ upper !== undefined &&
1078
+ (constant.compare(upper.value) > 0 || (upper.isStrict && constant.equals(upper.value)));
1079
+ const lower = isAboveUpper ? undefined : solver.getBound(column, false);
1080
+ const isBelowLower =
1081
+ lower !== undefined &&
1082
+ (constant.compare(lower.value) < 0 || (lower.isStrict && constant.equals(lower.value)));
1083
+ if (!isAboveUpper && !isBelowLower) return;
1084
+ const dep = mkJoin(
1085
+ mkJoin(
1086
+ this.explainFixed(getTermMonomials(solver.getTerm(column)), Rational.zero),
1087
+ this.explainFixedInMetaTerm(this.lspace.data, Rational.zero),
1088
+ ),
1089
+ this.solver.getBoundWitnesses(column),
1090
+ );
1091
+ this.infeasExplanation.pushDependency(dep);
1092
+ }
1093
+
1094
+ // tighten_bounds_for_non_trivial_gcd: whether tightening the bound found a conflict.
1095
+ private tightenBoundsForNonTrivialGcd(gcd: Rational, column: number, isUpper: boolean) {
1096
+ const bound = this.solver.getBound(column, isUpper);
1097
+ if (bound === undefined) return false;
1098
+ let remainder = getRemainder(bound.value.sub(this.constant), gcd);
1099
+ if (remainder.isNegative()) remainder = remainder.add(gcd);
1100
+ return (
1101
+ !remainder.isZero() && this.tightenBoundKind(gcd, column, bound.value, remainder, isUpper)
1102
+ );
1103
+ }
1104
+
1105
+ // tighten_bound_kind: t = g*t' + m_c <= rs gives t <= rs - (rs - m_c) mod g, and a lower bound
1106
+ // likewise. The fixed columns whose coefficients g divides do not explain the new bound.
1107
+ private tightenBoundKind(
1108
+ gcd: Rational,
1109
+ column: number,
1110
+ rs: Rational,
1111
+ remainder: Rational,
1112
+ isUpper: boolean,
1113
+ ) {
1114
+ const solver = this.solver;
1115
+ const bound = isUpper ? rs.sub(remainder) : rs.add(gcd).sub(remainder);
1116
+ let dep = isUpper ? solver.getUpperWitness(column) : solver.getLowerWitness(column);
1117
+ const fixedPart = this.openFixedFromMl(this.lspace.data);
1118
+ if (solver.isFixed(column)) fixedPart.add(Rational.one, column);
1119
+ for (const monomial of fixedPart.data) {
1120
+ if (monomial.coeff.isInt() && getRemainder(monomial.coeff, gcd).isZero()) continue;
1121
+ dep = mkJoin(dep, this.solver.getBoundWitnesses(monomial.column));
1122
+ }
1123
+ if (solver.settings.isCanceled()) return false;
1124
+ solver.updateColumnTypeAndBound(column, isUpper ? KIND_LE : KIND_GE, new Impq(bound), dep);
1125
+ const status = solver.findFeasibleSolution();
1126
+ if (status === LP_FEASIBLE || status === LP_OPTIMAL || status === LP_CANCELLED) return false;
1127
+ solver.getInfeasibilityExplanation(this.infeasExplanation);
1128
+ return true;
1129
+ }
1130
+
1131
+ // open_fixed_from_ml: the fixed columns of a combination of term definitions.
1132
+ private openFixedFromMl(monomials: Iterable<Monomial>) {
1133
+ const solver = this.solver;
1134
+ const result = new TermWithIndex();
1135
+ for (const outer of monomials)
1136
+ for (const monomial of getExtendedMonomials(solver.getTerm(outer.column)))
1137
+ if (solver.isFixed(monomial.column))
1138
+ result.add(outer.coeff.mul(monomial.coeff), monomial.column);
1139
+ return result;
1140
+ }
1141
+
1142
+ private explainFixedInMetaTerm(monomials: Iterable<Monomial>, gcd: Rational) {
1143
+ return this.explainFixed(this.openFixedFromMl(monomials).data, gcd);
1144
+ }
1145
+
1146
+ // explain_fixed: the bounds of the fixed columns, but those whose coefficients a nonzero gcd
1147
+ // divides.
1148
+ private explainFixed(monomials: Iterable<Monomial>, gcd: Rational) {
1149
+ let dep: Dependency = null;
1150
+ for (const monomial of monomials) {
1151
+ if (!this.solver.isFixed(monomial.column)) continue;
1152
+ if (!gcd.isZero() && monomial.coeff.div(gcd).isInt()) continue;
1153
+ dep = mkJoin(dep, this.solver.getBoundWitnesses(monomial.column));
1154
+ }
1155
+ return dep;
1156
+ }
1157
+ }
1158
+
1159
+ const removeLastRow = (matrix: StaticMatrix) => {
1160
+ const lastRow = matrix.rows[matrix.getRowCount() - 1];
1161
+ for (let index = lastRow.length; index-- > 0;) matrix.removeElement(lastRow, lastRow[index]);
1162
+ matrix.rows.pop();
1163
+ };
1164
+
1165
+ const popEmptyColumns = (matrix: StaticMatrix) => {
1166
+ while (matrix.getColumnCount() > 0 && matrix.columns[matrix.getColumnCount() - 1].length === 0)
1167
+ matrix.popColumn();
1168
+ };
1169
+
1170
+ // Swaps the cell of the pivot row to the head of the column, as the pivots of Z3 do.
1171
+ const moveCellToFront = (
1172
+ matrix: StaticMatrix,
1173
+ column: { row: number; offset: number }[],
1174
+ index: number,
1175
+ ) => {
1176
+ const first = column[0];
1177
+ column[0] = column[index];
1178
+ column[index] = first;
1179
+ matrix.rows[column[0].row][column[0].offset].offset = 0;
1180
+ matrix.rows[first.row][first.offset].offset = index;
1181
+ };