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

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 (314) hide show
  1. package/README.md +32 -143
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +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 +996 -0
  15. package/dist/prove.js +996 -0
  16. package/dist/run-cli.cjs +37 -47
  17. package/dist/run-cli.js +37 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +26 -7
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +63 -20
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +247 -69
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
  35. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  36. package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
  37. package/src/{obligations.ts → obligations/index.ts} +32 -16
  38. package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
  39. package/src/{obligation-module.ts → obligations/module.ts} +113 -121
  40. package/src/obligations/pickle.ts +98 -0
  41. package/src/obligations/pragma.ts +189 -0
  42. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  43. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  44. package/src/{obligation-source.ts → obligations/source.ts} +154 -99
  45. package/src/obligations/temporal.ts +321 -0
  46. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  47. package/src/ocaml-marshal.ts +166 -0
  48. package/src/parallel-worker.ts +2 -18
  49. package/src/parallel.ts +10 -43
  50. package/src/prove/decide-pool.ts +95 -0
  51. package/src/prove/deciders.ts +33 -0
  52. package/src/prove/first-order.ts +78 -0
  53. package/src/prove/isabelle/LICENSE +36 -0
  54. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  55. package/src/prove/isabelle/decide.ts +47 -0
  56. package/src/prove/isabelle/encode.ts +446 -0
  57. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  58. package/src/prove/isabelle/isar/method.ts +367 -0
  59. package/src/prove/isabelle/isar/proof.ts +28 -0
  60. package/src/prove/isabelle/isar/statement.ts +57 -0
  61. package/src/prove/isabelle/isar/theory.ts +192 -0
  62. package/src/prove/isabelle/isar/type-check.ts +278 -0
  63. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  64. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  65. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  66. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  67. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  68. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  69. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  70. package/src/prove/isabelle/provers/classical.ts +389 -0
  71. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  72. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  73. package/src/prove/isabelle/pure/consts.ts +32 -0
  74. package/src/prove/isabelle/pure/conv.ts +79 -0
  75. package/src/prove/isabelle/pure/drule.ts +264 -0
  76. package/src/prove/isabelle/pure/envir.ts +363 -0
  77. package/src/prove/isabelle/pure/goal.ts +53 -0
  78. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  79. package/src/prove/isabelle/pure/list.ts +12 -0
  80. package/src/prove/isabelle/pure/logic.ts +402 -0
  81. package/src/prove/isabelle/pure/name.ts +110 -0
  82. package/src/prove/isabelle/pure/net.ts +262 -0
  83. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  84. package/src/prove/isabelle/pure/pattern.ts +650 -0
  85. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  86. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  87. package/src/prove/isabelle/pure/search.ts +68 -0
  88. package/src/prove/isabelle/pure/seq.ts +156 -0
  89. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  90. package/src/prove/isabelle/pure/table.ts +208 -0
  91. package/src/prove/isabelle/pure/tactic.ts +276 -0
  92. package/src/prove/isabelle/pure/tactical.ts +347 -0
  93. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  94. package/src/prove/isabelle/pure/term.ts +808 -0
  95. package/src/prove/isabelle/pure/thm.ts +806 -0
  96. package/src/prove/isabelle/pure/type.ts +133 -0
  97. package/src/prove/isabelle/pure/unify.ts +753 -0
  98. package/src/prove/isabelle/pure/variable.ts +25 -0
  99. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  100. package/src/prove/isabelle/tla/context.ts +74 -0
  101. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  102. package/src/prove/isabelle/tla/logic.ts +215 -0
  103. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  104. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  105. package/src/prove/ocaml.ts +22 -0
  106. package/src/prove/prep/action.ts +508 -0
  107. package/src/prove/prep/defs.ts +33 -0
  108. package/src/prove/prep/elab.ts +156 -0
  109. package/src/prove/prep/enabled-axioms.ts +189 -0
  110. package/src/prove/prep/enabled.ts +43 -0
  111. package/src/prove/prep/fingerprint.ts +388 -0
  112. package/src/prove/prep/flatten.ts +70 -0
  113. package/src/prove/prep/level-comparison.ts +529 -0
  114. package/src/prove/prep/md5.ts +67 -0
  115. package/src/prove/prep/pragma.ts +221 -0
  116. package/src/prove/prep/trivial.ts +22 -0
  117. package/src/prove/prove-worker.ts +22 -0
  118. package/src/prove/prove.ts +498 -0
  119. package/src/prove/ptl/decide.ts +68 -0
  120. package/src/prove/ptl/encode.ts +255 -0
  121. package/src/prove/ptl/sat.ts +151 -0
  122. package/src/prove/ptl/tableau.ts +276 -0
  123. package/src/prove/smt/axiomatize.ts +69 -0
  124. package/src/prove/smt/axioms.ts +209 -0
  125. package/src/prove/smt/context.ts +108 -0
  126. package/src/prove/smt/data.ts +636 -0
  127. package/src/prove/smt/encode.ts +164 -0
  128. package/src/prove/smt/extensionality.ts +65 -0
  129. package/src/prove/smt/flatten.ts +112 -0
  130. package/src/prove/smt/format.ts +154 -0
  131. package/src/prove/smt/instances.ts +181 -0
  132. package/src/prove/smt/rewrite.ts +772 -0
  133. package/src/prove/smt/simplify.ts +57 -0
  134. package/src/prove/smt/solver/act-cache.ts +265 -0
  135. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  136. package/src/prove/smt/solver/array.ts +22 -0
  137. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  138. package/src/prove/smt/solver/ast-lt.ts +157 -0
  139. package/src/prove/smt/solver/ast-util.ts +147 -0
  140. package/src/prove/smt/solver/ast.ts +1315 -0
  141. package/src/prove/smt/solver/auf-solver.ts +572 -0
  142. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  143. package/src/prove/smt/solver/cg-table.ts +175 -0
  144. package/src/prove/smt/solver/clause.ts +276 -0
  145. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  146. package/src/prove/smt/solver/context.ts +1292 -0
  147. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  148. package/src/prove/smt/solver/der.ts +224 -0
  149. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  150. package/src/prove/smt/solver/e-matching.ts +659 -0
  151. package/src/prove/smt/solver/enode.ts +259 -0
  152. package/src/prove/smt/solver/expr-ref.ts +21 -0
  153. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  154. package/src/prove/smt/solver/fingerprints.ts +92 -0
  155. package/src/prove/smt/solver/flat-literals.ts +51 -0
  156. package/src/prove/smt/solver/goal.ts +138 -0
  157. package/src/prove/smt/solver/hash.ts +173 -0
  158. package/src/prove/smt/solver/hashtable.ts +166 -0
  159. package/src/prove/smt/solver/internalizer.ts +1381 -0
  160. package/src/prove/smt/solver/lbool.ts +5 -0
  161. package/src/prove/smt/solver/literal.ts +24 -0
  162. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  163. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  164. package/src/prove/smt/solver/lp/containers.ts +296 -0
  165. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  166. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  167. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  168. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  169. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  170. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  171. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  172. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  173. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  174. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  175. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  176. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  177. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  178. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  179. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  180. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  181. package/src/prove/smt/solver/lp/nex.ts +120 -0
  182. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  183. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  184. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  185. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  186. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  187. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  188. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  189. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  190. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  191. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  192. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  193. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  194. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  195. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  196. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  197. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  198. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  199. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  200. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  201. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  202. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  203. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  204. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  205. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  206. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  207. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  208. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  209. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  210. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  211. package/src/prove/smt/solver/model-checker.ts +347 -0
  212. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  213. package/src/prove/smt/solver/model-finder.ts +155 -0
  214. package/src/prove/smt/solver/model-generator.ts +97 -0
  215. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  216. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  217. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  218. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  219. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  220. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  221. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  222. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  223. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  224. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  225. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  226. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  227. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  228. package/src/prove/smt/solver/nnf.ts +469 -0
  229. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  230. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  231. package/src/prove/smt/solver/propagate-values.ts +83 -0
  232. package/src/prove/smt/solver/proto-model.ts +551 -0
  233. package/src/prove/smt/solver/pull-quant.ts +139 -0
  234. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  235. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  236. package/src/prove/smt/solver/qe-lite.ts +381 -0
  237. package/src/prove/smt/solver/qi-queue.ts +362 -0
  238. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  239. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  240. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  241. package/src/prove/smt/solver/random-gen.ts +10 -0
  242. package/src/prove/smt/solver/rational.ts +165 -0
  243. package/src/prove/smt/solver/ref-vector.ts +62 -0
  244. package/src/prove/smt/solver/relevancy.ts +247 -0
  245. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  246. package/src/prove/smt/solver/rewriter.ts +843 -0
  247. package/src/prove/smt/solver/rlimit.ts +79 -0
  248. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  249. package/src/prove/smt/solver/solver.ts +71 -0
  250. package/src/prove/smt/solver/sort.ts +35 -0
  251. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  252. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  253. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  254. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  255. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  256. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  257. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  258. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  259. package/src/prove/smt/solver/theory-lra.ts +56 -0
  260. package/src/prove/smt/solver/var-subst.ts +258 -0
  261. package/src/prove/smt/solver/z3-license.txt +10 -0
  262. package/src/prove/smt/table.ts +170 -0
  263. package/src/prove/tlapm/tlapm.ts +96 -0
  264. package/src/prove/tlaps-module.ts +510 -0
  265. package/src/prove/verdict.ts +18 -0
  266. package/src/prove/zenon/LICENSE +32 -0
  267. package/src/prove/zenon/check/check.ts +105 -0
  268. package/src/prove/zenon/check/definitions.ts +144 -0
  269. package/src/prove/zenon/check/equality.ts +182 -0
  270. package/src/prove/zenon/check/functions.ts +62 -0
  271. package/src/prove/zenon/check/keys.ts +125 -0
  272. package/src/prove/zenon/check/propositional.ts +104 -0
  273. package/src/prove/zenon/check/records.ts +188 -0
  274. package/src/prove/zenon/check/relations.ts +121 -0
  275. package/src/prove/zenon/check/rewrites.ts +224 -0
  276. package/src/prove/zenon/check/sets.ts +302 -0
  277. package/src/prove/zenon/check/terms.ts +127 -0
  278. package/src/prove/zenon/check/tla.ts +126 -0
  279. package/src/prove/zenon/decide.ts +113 -0
  280. package/src/prove/zenon/encode.ts +379 -0
  281. package/src/prove/zenon/eqrel.ts +300 -0
  282. package/src/prove/zenon/equality-rules.ts +435 -0
  283. package/src/prove/zenon/expr.ts +551 -0
  284. package/src/prove/zenon/index-table.ts +350 -0
  285. package/src/prove/zenon/isar-case.ts +513 -0
  286. package/src/prove/zenon/isar.ts +1249 -0
  287. package/src/prove/zenon/limits.ts +15 -0
  288. package/src/prove/zenon/llproof.ts +173 -0
  289. package/src/prove/zenon/mltoll.ts +1566 -0
  290. package/src/prove/zenon/node.ts +297 -0
  291. package/src/prove/zenon/ocaml.ts +169 -0
  292. package/src/prove/zenon/parse.ts +247 -0
  293. package/src/prove/zenon/phrase.ts +191 -0
  294. package/src/prove/zenon/proof.ts +198 -0
  295. package/src/prove/zenon/propositional-rules.ts +387 -0
  296. package/src/prove/zenon/rules.ts +94 -0
  297. package/src/prove/zenon/search.ts +288 -0
  298. package/src/prove/zenon/tla/functions.ts +151 -0
  299. package/src/prove/zenon/tla/llproof.ts +480 -0
  300. package/src/prove/zenon/tla/records.ts +225 -0
  301. package/src/prove/zenon/tla/rewrites.ts +447 -0
  302. package/src/prove/zenon/tla/sets.ts +304 -0
  303. package/src/prove/zenon/tla/terms.ts +181 -0
  304. package/src/prove/zenon/tla/tla.ts +506 -0
  305. package/src/run-cli.ts +283 -81
  306. package/src/standard-modules.ts +5 -2
  307. package/src/successors.ts +24 -5
  308. package/src/tlapm-cache.ts +236 -0
  309. package/src/tlc-random.ts +55 -32
  310. package/src/tlc-version.ts +8 -7
  311. package/src/values.ts +97 -47
  312. package/src/worker.ts +65 -0
  313. package/dist/parallel.cjs +0 -12
  314. package/dist/parallel.js +0 -12
@@ -0,0 +1,281 @@
1
+ // Ported from Z3 (src/math/lp/hnf.h, src/math/lp/general_matrix.h,
2
+ // src/math/lp/permutation_matrix.h, and the extended gcd of src/util/mpz.cpp), MIT license, see
3
+ // z3-license.txt. The Hermite normal form of an integer matrix, computed modulo a multiple of the
4
+ // determinant of its rows, as the HNF cutter needs it.
5
+ import { Rational } from "../rational";
6
+
7
+ // rem of mpq: the remainder of the numerators, truncated toward zero.
8
+ const getRem = (first: Rational, second: Rational) => Rational.of(first.num % second.num);
9
+
10
+ // mpz_manager::gcd(r1, r2, a, b, g): the gcd g of r1 and r2, with a * r1 + b * r2 equal to it.
11
+ const getExtendedGcd = (first: Rational, second: Rational) => {
12
+ let left = first.num < 0n ? -first.num : first.num;
13
+ let right = second.num < 0n ? -second.num : second.num;
14
+ let a = 1n;
15
+ let b = 0n;
16
+ let nextA = 0n;
17
+ let nextB = 1n;
18
+ if (left < right) {
19
+ [left, right] = [right, left];
20
+ [a, b] = [b, a];
21
+ [nextA, nextB] = [nextB, nextA];
22
+ }
23
+ while (right > 0n) {
24
+ const quotient = left / right;
25
+ [left, right] = [right, left % right];
26
+ [a, nextA] = [nextA, a - quotient * nextA];
27
+ [b, nextB] = [nextB, b - quotient * nextB];
28
+ }
29
+ return {
30
+ gcd: Rational.of(left),
31
+ u: Rational.of(first.num < 0n ? -a : a),
32
+ v: Rational.of(second.num < 0n ? -b : b),
33
+ };
34
+ };
35
+
36
+ // extended_gcd_minimal_uv: the gcd d of a and b with a * u + b * v = d, where v is the smallest
37
+ // coefficient of its residue class with the sign of -b.
38
+ const getExtendedGcdMinimalUv = (a: Rational, b: Rational) => {
39
+ if (a.isZero()) return { d: b, u: Rational.zero, v: Rational.one };
40
+ if (b.isZero()) return { d: a, u: Rational.one, v: Rational.zero };
41
+ const result = getExtendedGcd(a, b);
42
+ let d = result.gcd;
43
+ let u = result.u;
44
+ let v = result.v;
45
+ if (d.isNegative()) {
46
+ d = d.neg();
47
+ u = u.neg();
48
+ v = v.neg();
49
+ }
50
+ if (d.equals(a)) return { d, u: Rational.one, v: Rational.zero };
51
+ if (d.equals(a.neg())) return { d, u: Rational.minusOne, v: Rational.zero };
52
+ const aOverD = a.abs().div(d);
53
+ let k = Rational.of(v.num / aOverD.num);
54
+ let r = Rational.of(v.num % aOverD.num);
55
+ if (r.isNegative()) {
56
+ r = r.add(aOverD);
57
+ k = k.sub(Rational.one);
58
+ }
59
+ const bOverD = b.div(d);
60
+ const shift = b.isPositive() ? k.add(Rational.one) : k;
61
+ v = b.isPositive() ? r.sub(aOverD) : r;
62
+ u = a.isPositive() ? u.add(shift.mul(bOverD)) : u.sub(shift.mul(bOverD));
63
+ return { d, u, v };
64
+ };
65
+
66
+ // permutation_matrix: a permutation and its inverse.
67
+ class Permutation {
68
+ constructor(
69
+ readonly forward: number[],
70
+ readonly reverse: number[],
71
+ ) {}
72
+
73
+ static identity(length: number) {
74
+ const getIndex = (_: unknown, index: number) => index;
75
+ return new Permutation(Array.from({ length }, getIndex), Array.from({ length }, getIndex));
76
+ }
77
+
78
+ copy() {
79
+ return new Permutation([...this.forward], [...this.reverse]);
80
+ }
81
+
82
+ private setValue(index: number, value: number) {
83
+ this.forward[index] = value;
84
+ this.reverse[value] = index;
85
+ }
86
+
87
+ transposeFromLeft(first: number, second: number) {
88
+ const firstIndex = this.reverse[first];
89
+ const secondIndex = this.reverse[second];
90
+ this.setValue(firstIndex, second);
91
+ this.setValue(secondIndex, first);
92
+ }
93
+
94
+ transposeFromRight(first: number, second: number) {
95
+ const firstValue = this.forward[first];
96
+ const secondValue = this.forward[second];
97
+ this.setValue(first, secondValue);
98
+ this.setValue(second, firstValue);
99
+ }
100
+ }
101
+
102
+ // general_matrix: dense rows behind a row and a column permutation.
103
+ export class GeneralMatrix {
104
+ private rowPermutation: Permutation;
105
+ private columnPermutation: Permutation;
106
+ data: Rational[][];
107
+
108
+ constructor(rowCount: number, columnCount: number) {
109
+ this.rowPermutation = Permutation.identity(rowCount);
110
+ this.columnPermutation = Permutation.identity(columnCount);
111
+ this.data = Array.from({ length: rowCount }, () =>
112
+ Array.from({ length: columnCount }, () => Rational.zero),
113
+ );
114
+ }
115
+
116
+ copy() {
117
+ const result = new GeneralMatrix(0, 0);
118
+ result.rowPermutation = this.rowPermutation.copy();
119
+ result.columnPermutation = this.columnPermutation.copy();
120
+ result.data = this.data.map((row) => [...row]);
121
+ return result;
122
+ }
123
+
124
+ getRowCount() {
125
+ return this.data.length;
126
+ }
127
+
128
+ getColumnCount() {
129
+ return this.data.length > 0 ? this.data[0].length : 0;
130
+ }
131
+
132
+ adjustRow(row: number) {
133
+ return this.rowPermutation.forward[row];
134
+ }
135
+
136
+ get(row: number, column: number) {
137
+ return this.data[this.adjustRow(row)][this.columnPermutation.reverse[column]];
138
+ }
139
+
140
+ set(row: number, column: number, value: Rational) {
141
+ this.data[this.adjustRow(row)][this.columnPermutation.reverse[column]] = value;
142
+ }
143
+
144
+ transposeRows(first: number, second: number) {
145
+ this.rowPermutation.transposeFromRight(first, second);
146
+ }
147
+
148
+ transposeColumns(first: number, second: number) {
149
+ this.columnPermutation.transposeFromLeft(first, second);
150
+ }
151
+
152
+ // shrink_to_rank: only the given data rows, leaving the permutations as they are.
153
+ shrinkToRank(basisRows: number[]) {
154
+ if (basisRows.length === this.getRowCount()) return;
155
+ this.data = basisRows.map((row) => this.data[row]);
156
+ }
157
+ }
158
+
159
+ // prepare_pivot_for_lower_triangle: moves a nonzero entry of the lower right block to (r, r).
160
+ const preparePivot = (matrix: GeneralMatrix, r: number) => {
161
+ for (let row = r; row < matrix.getRowCount(); row++)
162
+ for (let column = r; column < matrix.getColumnCount(); column++) {
163
+ if (matrix.get(row, column).isZero()) continue;
164
+ if (row !== r) matrix.transposeRows(row, r);
165
+ if (column !== r) matrix.transposeColumns(column, r);
166
+ return true;
167
+ }
168
+ return false;
169
+ };
170
+
171
+ // pivot_column_non_fractional: a fraction-free elimination step under (r, r); false when an entry
172
+ // reaches the big number.
173
+ const pivotColumnNonFractional = (matrix: GeneralMatrix, r: number, bigNumber: Rational) => {
174
+ const pivot = matrix.get(r, r);
175
+ const denominator = r > 0 ? matrix.get(r - 1, r - 1) : undefined;
176
+ for (let column = r + 1; column < matrix.getColumnCount(); column++) {
177
+ const top = matrix.get(r, column);
178
+ for (let row = r + 1; row < matrix.getRowCount(); row++) {
179
+ let value = matrix.get(row, column).mul(pivot).sub(matrix.get(row, r).mul(top));
180
+ if (denominator !== undefined) value = value.div(denominator);
181
+ matrix.set(row, column, value);
182
+ if (value.compare(bigNumber) >= 0) return false;
183
+ }
184
+ }
185
+ return true;
186
+ };
187
+
188
+ // determinant_of_rectangular_matrix: the gcd of the last row of the triangulated matrix, a
189
+ // multiple of the gcd of its maximal minors, and the data rows of a basis; the big number when an
190
+ // entry grows too large.
191
+ export const getDeterminantOfRectangularMatrix = (
192
+ matrix: GeneralMatrix,
193
+ basisRows: number[],
194
+ bigNumber: Rational,
195
+ ) => {
196
+ const triangle = matrix.copy();
197
+ let rank = 0;
198
+ for (; rank < triangle.getRowCount(); rank++) {
199
+ if (!preparePivot(triangle, rank)) break;
200
+ if (!pivotColumnNonFractional(triangle, rank, bigNumber)) return bigNumber;
201
+ }
202
+ if (rank === 0) return Rational.one;
203
+ for (let row = 0; row < rank; row++) basisRows.push(triangle.adjustRow(row));
204
+ const last = rank - 1;
205
+ let gcd = Rational.zero;
206
+ let column = last;
207
+ for (; column < triangle.getColumnCount() && gcd.isZero(); column++) {
208
+ const value = triangle.get(last, column);
209
+ if (!value.isZero()) gcd = value.abs();
210
+ }
211
+ for (; column < triangle.getColumnCount(); column++) {
212
+ const value = triangle.get(last, column);
213
+ if (!value.isZero()) gcd = getExtendedGcd(gcd, value).gcd;
214
+ }
215
+ return gcd;
216
+ };
217
+
218
+ // hnf: W, the Hermite normal form of the rows of the matrix, computed modulo d. Undefined when
219
+ // canceled.
220
+ export const getHermiteNormalForm = (
221
+ matrix: GeneralMatrix,
222
+ d: Rational,
223
+ isCanceled: () => boolean,
224
+ ) => {
225
+ const w = matrix.data.map((row) => [...row]);
226
+ const rowCount = matrix.getRowCount();
227
+ const columnCount = matrix.getColumnCount();
228
+ if (rowCount === 0 || columnCount === 0 || d.isZero()) return w;
229
+ const buffer: Rational[] = [];
230
+ let r = d;
231
+ let halfR = r.div(Rational.of(2n)).floor();
232
+ const getModBalanced = (value: Rational) => {
233
+ const rem = getRem(value, r);
234
+ if (rem.compare(halfR) > 0) return rem.sub(r);
235
+ return rem.compare(halfR.neg()) < 0 ? rem.add(r) : rem;
236
+ };
237
+ const getMod = (value: Rational) => {
238
+ const rem = getRem(value, r);
239
+ return rem.isNegative() ? rem.add(r) : rem;
240
+ };
241
+ for (let i = 0; i < rowCount; i++) {
242
+ if (isCanceled()) return undefined;
243
+ for (let j = i + 1; j < columnCount; j++) {
244
+ const result = getExtendedGcdMinimalUv(w[i][i], w[i][j]);
245
+ if (result.d.isZero()) continue;
246
+ const iiOverD = getMod(w[i][i].div(result.d));
247
+ const ijOverD = getMod(w[i][j].div(result.d));
248
+ for (let k = i; k < rowCount; k++)
249
+ buffer[k] = getModBalanced(
250
+ getModBalanced(result.u.mul(w[k][i])).add(getModBalanced(result.v.mul(w[k][j]))),
251
+ );
252
+ w[i][j] = Rational.zero;
253
+ for (let k = i + 1; k < rowCount; k++)
254
+ w[k][j] = getModBalanced(
255
+ getModBalanced(ijOverD.neg().mul(w[k][i])).add(getModBalanced(iiOverD.mul(w[k][j]))),
256
+ );
257
+ for (let k = i; k < rowCount; k++) w[k][i] = buffer[k];
258
+ }
259
+ let gcd = r;
260
+ let u = Rational.one;
261
+ if (w[i][i].isZero()) w[i][i] = r;
262
+ else {
263
+ const result = getExtendedGcdMinimalUv(w[i][i], r);
264
+ gcd = result.d;
265
+ u = result.u;
266
+ }
267
+ w[i][i] = getMod(w[i][i].mul(u));
268
+ if (w[i][i].isZero()) w[i][i] = gcd;
269
+ const diagonal = w[i][i];
270
+ for (let k = i + 1; k < rowCount; k++) w[k][i] = getModBalanced(w[k][i].mul(u));
271
+ for (let j = 0; j < i; j++) {
272
+ const value = w[i][j];
273
+ if (!value.isPositive() && value.neg().compare(diagonal) < 0) continue;
274
+ const quotient = value.div(diagonal).ceil();
275
+ for (let k = i; k < rowCount; k++) w[k][j] = w[k][j].sub(quotient.mul(w[k][i]));
276
+ }
277
+ r = r.div(w[i][i]);
278
+ halfR = r.div(Rational.of(2n)).floor();
279
+ }
280
+ return w;
281
+ };
@@ -0,0 +1,295 @@
1
+ // Ported from Z3 (src/math/lp/int_cube.cpp, and tighten_term_bounds_by_delta and
2
+ // round_to_integer_solution in src/math/lp/lar_solver.cpp), MIT license, see z3-license.txt. The
3
+ // cube test: when the bounds of every term shrunk by half the sum of its integer coefficients still
4
+ // admit a solution, rounding that solution gives an integer one. The largest cube test maximizes
5
+ // the edge of that cube instead, and when the edge is below 1 it rounds the center and flips
6
+ // rounded columns to repair the bounds the rounding broke.
7
+ import { Rational } from "../rational";
8
+ import { type ConstraintKind, KIND_GE, KIND_GT, KIND_LE, KIND_LT } from "./constraints";
9
+ import { LP_FEASIBLE, LP_OPTIMAL } from "./core-solver";
10
+ import { type LarSolver, NULL_LPVAR } from "./lar-solver";
11
+ import type { LarTerm } from "./lar-term";
12
+ import { maximizeTerm } from "./maximize-term";
13
+ import { Impq } from "./numeric-pair";
14
+
15
+ const HALF = Rational.of(1n, 2n);
16
+
17
+ // get_cube_delta_for_term: an infinitesimal for x - y over integers, nothing for x + y, and
18
+ // otherwise half the sum of the integer coefficients.
19
+ const getCubeDelta = (solver: LarSolver, term: LarTerm) => {
20
+ const entries = [...term.coeffs];
21
+ if (entries.length === 2) {
22
+ let isPlusSeen = false;
23
+ let isMinusSeen = false;
24
+ const isUnit = entries.every((entry) => {
25
+ if (!solver.isInt(entry[0])) return false;
26
+ if (entry[1].equals(Rational.one)) isPlusSeen = true;
27
+ else if (entry[1].equals(Rational.minusOne)) isMinusSeen = true;
28
+ else return false;
29
+ return true;
30
+ });
31
+ if (isUnit)
32
+ return isPlusSeen && isMinusSeen ? Impq.zero : new Impq(Rational.zero, Rational.one);
33
+ }
34
+ let delta = Rational.zero;
35
+ for (const entry of entries) if (solver.isInt(entry[0])) delta = delta.add(entry[1].abs());
36
+ return new Impq(delta.mul(HALF));
37
+ };
38
+
39
+ const addVarBound = (solver: LarSolver, column: number, kind: ConstraintKind, rhs: Rational) =>
40
+ solver.activate(solver.mkVarBound(column, kind, rhs));
41
+
42
+ // tighten_term_bounds_by_delta: whether the bounds of the column stay apart when each moves inward
43
+ // by delta.
44
+ const tightenTermBounds = (solver: LarSolver, column: number, delta: Impq) => {
45
+ const core = solver.core;
46
+ const hasUpper = core.hasUpperBound(column);
47
+ const hasLower = core.hasLowerBound(column);
48
+ if (
49
+ hasUpper &&
50
+ hasLower &&
51
+ solver.getUpperBound(column).sub(delta).compare(solver.getLowerBound(column).add(delta)) < 0
52
+ )
53
+ return false;
54
+ if (hasUpper) {
55
+ const upper = solver.getUpperBound(column);
56
+ const isStrict = !delta.y.isZero() || !upper.y.isZero();
57
+ addVarBound(solver, column, isStrict ? KIND_LT : KIND_LE, upper.x.sub(delta.x));
58
+ }
59
+ if (hasLower) {
60
+ const lower = solver.getLowerBound(column);
61
+ const isStrict = !delta.y.isZero() || !lower.y.isZero();
62
+ addVarBound(solver, column, isStrict ? KIND_GT : KIND_GE, lower.x.add(delta.x));
63
+ }
64
+ return true;
65
+ };
66
+
67
+ // round_to_integer_solution: integer columns without terms round to the nearest integer, and the
68
+ // terms that use them take their new values.
69
+ const roundToIntegerSolution = (solver: LarSolver) => {
70
+ const x = solver.core.x;
71
+ const rounded = new Set<number>();
72
+ for (let column = 0; column < solver.getColumnCount(); column++) {
73
+ if (!solver.isInt(column) || solver.hasTerm(column)) continue;
74
+ const value = x[column];
75
+ if (value.isInt()) continue;
76
+ const floor = new Impq(value.floor());
77
+ x[column] = floor.sub(value).compare(new Impq(HALF.neg())) < 0 ? new Impq(value.ceil()) : floor;
78
+ rounded.add(column);
79
+ }
80
+ if (rounded.size === 0) return;
81
+ for (const term of solver.terms)
82
+ if ([...term.coeffs].some((entry) => rounded.has(entry[0]))) x[term.column] = term.apply(x);
83
+ };
84
+
85
+ // r_basis_has_inf_int.
86
+ const hasBasicInfInt = (solver: LarSolver) =>
87
+ solver.core.basis.some((column) => solver.isInt(column) && !solver.getValue(column).isInt());
88
+
89
+ // int_cube::operator(): whether the cube test found an integer solution.
90
+ export const findCube = (solver: LarSolver) => {
91
+ solver.push();
92
+ for (const term of solver.terms) {
93
+ const delta = getCubeDelta(solver, term);
94
+ if (delta.isZero() || tightenTermBounds(solver, term.column, delta)) continue;
95
+ solver.pop(1);
96
+ solver.status = LP_OPTIMAL;
97
+ return false;
98
+ }
99
+ const status = solver.findFeasibleSolution();
100
+ if (status !== LP_FEASIBLE && status !== LP_OPTIMAL) {
101
+ solver.pop(1);
102
+ solver.moveNonBasicColumnsToBounds();
103
+ return !hasBasicInfInt(solver);
104
+ }
105
+ solver.pop(1);
106
+ roundToIntegerSolution(solver);
107
+ solver.status = LP_FEASIBLE;
108
+ return true;
109
+ };
110
+
111
+ // add_edge_rows_for_term: the term column moved inward by the edge times delta stays within its
112
+ // bounds, through a new term for each bound.
113
+ const addEdgeRows = (solver: LarSolver, column: number, edge: number) => {
114
+ const delta = getCubeDelta(solver, solver.getTerm(column));
115
+ if (delta.isZero()) return true;
116
+ if (!delta.y.isZero()) return tightenTermBounds(solver, column, delta);
117
+ const core = solver.core;
118
+ if (core.hasUpperBound(column)) {
119
+ const upper = solver.getUpperBound(column);
120
+ const sum = solver.addTerm(
121
+ [
122
+ [column, Rational.one],
123
+ [edge, delta.x],
124
+ ],
125
+ NULL_LPVAR,
126
+ );
127
+ addVarBound(solver, sum, upper.y.isZero() ? KIND_LE : KIND_LT, upper.x);
128
+ }
129
+ if (core.hasLowerBound(column)) {
130
+ const lower = solver.getLowerBound(column);
131
+ const difference = solver.addTerm(
132
+ [
133
+ [column, Rational.one],
134
+ [edge, delta.x.neg()],
135
+ ],
136
+ NULL_LPVAR,
137
+ );
138
+ addVarBound(solver, difference, lower.y.isZero() ? KIND_GE : KIND_GT, lower.x);
139
+ }
140
+ return true;
141
+ };
142
+
143
+ // sat_after_rounding.
144
+ const roundCenter = (solver: LarSolver) => {
145
+ roundToIntegerSolution(solver);
146
+ solver.status = LP_FEASIBLE;
147
+ solver.settings.stats.lcubeSuccess++;
148
+ return true;
149
+ };
150
+
151
+ // A rounded column, its floor, and whether it sits at its floor plus one.
152
+ interface FlipCandidate {
153
+ column: number;
154
+ floor: Rational;
155
+ isAtHigh: boolean;
156
+ }
157
+
158
+ // A term column with a bound, and its value while the repair flips columns.
159
+ interface BoundedRow {
160
+ column: number;
161
+ value: Impq;
162
+ }
163
+
164
+ // repair_rounded_candidate: while the bounded terms are violated, flips the rounded column that
165
+ // decreases the total violation most, within a budget, and keeps the values when none is left.
166
+ const repairRoundedCandidate = (solver: LarSolver, flips: FlipCandidate[]) => {
167
+ const core = solver.core;
168
+ const rows: BoundedRow[] = [];
169
+ for (const term of solver.terms)
170
+ if (core.hasUpperBound(term.column) || core.hasLowerBound(term.column))
171
+ rows.push({ column: term.column, value: term.apply(core.x) });
172
+ const getRowViolation = (rowIndex: number, value: Impq) => {
173
+ const column = rows[rowIndex].column;
174
+ let violation = Impq.zero;
175
+ if (core.hasUpperBound(column) && value.compare(core.upperBounds[column]) > 0)
176
+ violation = violation.add(value.sub(core.upperBounds[column]));
177
+ if (core.hasLowerBound(column) && value.compare(core.lowerBounds[column]) < 0)
178
+ violation = violation.add(core.lowerBounds[column].sub(value));
179
+ return violation;
180
+ };
181
+ let violation = Impq.zero;
182
+ for (let rowIndex = 0; rowIndex < rows.length; rowIndex++)
183
+ violation = violation.add(getRowViolation(rowIndex, rows[rowIndex].value));
184
+ if (violation.isZero()) return true;
185
+ if (flips.length === 0) return false;
186
+ const flipOfColumn = new Map(flips.map((flip, flipIndex) => [flip.column, flipIndex]));
187
+ const occurrences: [number, Rational][][] = flips.map(() => []);
188
+ for (let rowIndex = 0; rowIndex < rows.length; rowIndex++)
189
+ for (const entry of solver.getTerm(rows[rowIndex].column).coeffs) {
190
+ const flipIndex = flipOfColumn.get(entry[0]);
191
+ if (flipIndex !== undefined) occurrences[flipIndex].push([rowIndex, entry[1]]);
192
+ }
193
+ let budget = Math.min(2 * flips.length, solver.settings.lcubeFlips);
194
+ let isFlipped = false;
195
+ const getStep = (flip: FlipCandidate) => (flip.isAtHigh ? Rational.minusOne : Rational.one);
196
+ while (!violation.isZero() && budget-- > 0) {
197
+ let bestFlip = -1;
198
+ let bestGain = Impq.zero;
199
+ for (let flipIndex = 0; flipIndex < flips.length; flipIndex++) {
200
+ if (occurrences[flipIndex].length === 0) continue;
201
+ const step = getStep(flips[flipIndex]);
202
+ let gain = Impq.zero;
203
+ for (const occurrence of occurrences[flipIndex]) {
204
+ const value = rows[occurrence[0]].value;
205
+ const flipped = value.add(new Impq(step.mul(occurrence[1])));
206
+ gain = gain.add(
207
+ getRowViolation(occurrence[0], flipped).sub(getRowViolation(occurrence[0], value)),
208
+ );
209
+ }
210
+ if (gain.compare(bestGain) < 0) {
211
+ bestGain = gain;
212
+ bestFlip = flipIndex;
213
+ }
214
+ }
215
+ if (bestFlip === -1) return false;
216
+ const step = getStep(flips[bestFlip]);
217
+ for (const occurrence of occurrences[bestFlip]) {
218
+ const row = rows[occurrence[0]];
219
+ row.value = row.value.add(new Impq(step.mul(occurrence[1])));
220
+ }
221
+ flips[bestFlip].isAtHigh = !flips[bestFlip].isAtHigh;
222
+ violation = violation.add(bestGain);
223
+ isFlipped = true;
224
+ }
225
+ if (!violation.isZero()) return false;
226
+ for (const flip of flips)
227
+ core.x[flip.column] = new Impq(flip.isAtHigh ? flip.floor.add(Rational.one) : flip.floor);
228
+ for (const term of solver.terms) core.x[term.column] = term.apply(core.x);
229
+ if (isFlipped) solver.settings.stats.lcubeFlipSuccess++;
230
+ return true;
231
+ };
232
+
233
+ // round_and_repair: rounds the center of the cube and repairs it, or restores the center.
234
+ const roundAndRepair = (solver: LarSolver) => {
235
+ const core = solver.core;
236
+ const backup = core.x.slice();
237
+ const flips: FlipCandidate[] = [];
238
+ for (let column = 0; column < solver.getColumnCount(); column++) {
239
+ if (!solver.isInt(column) || solver.hasTerm(column)) continue;
240
+ const value = core.x[column];
241
+ if (!value.isInt()) flips.push({ column, floor: value.floor(), isAtHigh: false });
242
+ }
243
+ roundToIntegerSolution(solver);
244
+ for (const flip of flips) flip.isAtHigh = core.x[flip.column].x.compare(flip.floor) > 0;
245
+ solver.status = LP_FEASIBLE;
246
+ if (repairRoundedCandidate(solver, flips)) {
247
+ solver.settings.stats.lcubeSuccess++;
248
+ return true;
249
+ }
250
+ core.x.splice(0, backup.length, ...backup);
251
+ return false;
252
+ };
253
+
254
+ // find_largest_cube: whether an integer solution comes from the largest cube that fits in the
255
+ // bounds of the terms, with its edge as a new column that the optimizing simplex maximizes.
256
+ export const findLargestCube = (solver: LarSolver) => {
257
+ solver.settings.stats.lcubeCalls++;
258
+ solver.push();
259
+ const onAddTerm = solver.onAddTerm;
260
+ solver.onAddTerm = undefined;
261
+ const edge = solver.addVar(NULL_LPVAR, false);
262
+ addVarBound(solver, edge, KIND_GE, Rational.zero);
263
+ const isAdded = solver.terms
264
+ .map((term) => term.column)
265
+ .every((column) => addEdgeRows(solver, column, edge));
266
+ solver.onAddTerm = onAddTerm;
267
+ if (!isAdded) {
268
+ solver.pop(1);
269
+ solver.status = LP_OPTIMAL;
270
+ return false;
271
+ }
272
+ const status = solver.findFeasibleSolution();
273
+ if (status !== LP_FEASIBLE && status !== LP_OPTIMAL) {
274
+ solver.pop(1);
275
+ solver.moveNonBasicColumnsToBounds();
276
+ return !hasBasicInfInt(solver);
277
+ }
278
+ const maximum = maximizeTerm(solver, edge);
279
+ if (solver.settings.isCanceled()) {
280
+ solver.pop(1);
281
+ return false;
282
+ }
283
+ if (maximum === undefined) {
284
+ addVarBound(solver, edge, KIND_GE, Rational.one);
285
+ const boundedStatus = solver.findFeasibleSolution();
286
+ solver.pop(1);
287
+ return boundedStatus === LP_FEASIBLE || boundedStatus === LP_OPTIMAL
288
+ ? roundCenter(solver)
289
+ : false;
290
+ }
291
+ solver.pop(1);
292
+ return maximum.compare(new Impq(Rational.one)) >= 0
293
+ ? roundCenter(solver)
294
+ : roundAndRepair(solver);
295
+ };