tla-ts 0.0.4-dev.0be9567 → 0.0.4-dev.22c041b

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 +77 -122
  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 -1153
  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} +115 -721
  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 +135 -120
  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 +38 -22
  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 -190
  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/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +119 -71
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -0,0 +1,35 @@
1
+ // Array.prototype.sort copies its array before sorting, which makes most of the garbage of short
2
+ // clauses and disjunctions. Insertion sort is stable like it and sorts a short array in place, so
3
+ // both give the same order.
4
+ const MAX_INSERTION_SORT_LENGTH = 16;
5
+
6
+ export const sortByKey = (values: number[], getKey: (value: number) => number) => {
7
+ if (values.length > MAX_INSERTION_SORT_LENGTH) {
8
+ values.sort((first, second) => getKey(first) - getKey(second));
9
+ return;
10
+ }
11
+ for (let index = 1; index < values.length; index++) {
12
+ const value = values[index];
13
+ const key = getKey(value);
14
+ let position = index;
15
+ for (; position > 0 && getKey(values[position - 1]) > key; position--)
16
+ values[position] = values[position - 1];
17
+ values[position] = value;
18
+ }
19
+ };
20
+
21
+ // std::sort of literals: sortByKey with the number as its key, which a call site of its own keeps
22
+ // cheap.
23
+ export const sortNumbers = (values: number[]) => {
24
+ if (values.length > MAX_INSERTION_SORT_LENGTH) {
25
+ values.sort((first, second) => first - second);
26
+ return;
27
+ }
28
+ for (let index = 1; index < values.length; index++) {
29
+ const value = values[index];
30
+ let position = index;
31
+ for (; position > 0 && values[position - 1] > value; position--)
32
+ values[position] = values[position - 1];
33
+ values[position] = value;
34
+ }
35
+ };
@@ -0,0 +1,69 @@
1
+ // Ported from Z3 (src/smt/smt_context.cpp), MIT license, see z3-license.txt.
2
+ // m_sticky_generation_updates: the generations that update_generation lowered, by node. Only a node
3
+ // of the same declaration can be congruent to another, so the updates are grouped by declaration.
4
+ // Each group keeps its updates in the order of insertion, as a Map does, in arrays that iterate
5
+ // without allocating. A deleted update leaves a hole until holes are half of its group.
6
+ import { shrink } from "./array";
7
+ import type { Enode } from "./enode";
8
+
9
+ interface Group {
10
+ nodes: (Enode | null)[];
11
+ generations: number[];
12
+ indices: Map<Enode, number>;
13
+ numHoles: number;
14
+ }
15
+
16
+ export class StickyGenerations {
17
+ private groups = new Map<number, Group>();
18
+
19
+ set(node: Enode, generation: number) {
20
+ const group = this.groups.get(node.decl);
21
+ if (group === undefined) {
22
+ this.groups.set(node.decl, {
23
+ nodes: [node],
24
+ generations: [generation],
25
+ indices: new Map([[node, 0]]),
26
+ numHoles: 0,
27
+ });
28
+ return;
29
+ }
30
+ const index = group.indices.get(node);
31
+ if (index !== undefined) {
32
+ group.generations[index] = generation;
33
+ return;
34
+ }
35
+ group.indices.set(node, group.nodes.length);
36
+ group.nodes.push(node);
37
+ group.generations.push(generation);
38
+ }
39
+
40
+ delete(node: Enode) {
41
+ const group = this.groups.get(node.decl);
42
+ const index = group?.indices.get(node);
43
+ if (group === undefined || index === undefined) return;
44
+ group.indices.delete(node);
45
+ group.nodes[index] = null;
46
+ group.numHoles++;
47
+ if (2 * group.numHoles > group.nodes.length) compact(group);
48
+ }
49
+
50
+ // The updates of the declaration in the order of insertion, where a deleted one is null.
51
+ getGroup(decl: number): Readonly<Pick<Group, "nodes" | "generations">> | undefined {
52
+ return this.groups.get(decl);
53
+ }
54
+ }
55
+
56
+ const compact = (group: Group) => {
57
+ let size = 0;
58
+ for (let index = 0; index < group.nodes.length; index++) {
59
+ const node = group.nodes[index];
60
+ if (node === null) continue;
61
+ group.nodes[size] = node;
62
+ group.generations[size] = group.generations[index];
63
+ group.indices.set(node, size);
64
+ size++;
65
+ }
66
+ shrink(group.nodes, size);
67
+ shrink(group.generations, size);
68
+ group.numHoles = 0;
69
+ };
@@ -0,0 +1,340 @@
1
+ // Ported from Z3 (src/smt/theory_lra.cpp, src/smt/arith_eq_adapter.cpp), MIT license, see
2
+ // z3-license.txt. The axioms of theory_lra: those of div, mod, to_int and is_int, and the
3
+ // arith_eq_adapter axioms that tie an equality of terms to their two inequalities.
4
+ import { SmtInvariantError } from "../../../errors";
5
+ import {
6
+ OP_ADD,
7
+ OP_DIV,
8
+ OP_GE,
9
+ OP_IDIV,
10
+ OP_IS_INT,
11
+ OP_LE,
12
+ OP_MOD,
13
+ OP_MUL,
14
+ OP_SUB,
15
+ OP_TO_INT,
16
+ OP_TO_REAL,
17
+ SORT_BOOL,
18
+ SORT_INT,
19
+ SORT_REAL,
20
+ } from "./ast";
21
+ import { Enode } from "./enode";
22
+ import { FALSE_LITERAL, getVar, isNegated, Literal, negate, TRUE_LITERAL } from "./literal";
23
+ import { Rational } from "./rational";
24
+ import { TheoryLraState } from "./theory-lra-state";
25
+
26
+ export abstract class TheoryLraAxioms extends TheoryLraState {
27
+ private processedEqs = new Set<string>();
28
+
29
+ // m_restart_pairs: equalities whose axioms a backjump to the base level drops, remade on restart.
30
+ protected restartPairs: Enode[][] = [];
31
+
32
+ // The enode of a term, internalized first if it has none.
33
+ protected getInternalizedEnode(expr: number) {
34
+ const context = this.context;
35
+ if (!context.isEInternalized(expr)) context.internalize(expr, false);
36
+ const node = context.getEnode(expr);
37
+ if (node === undefined) throw new SmtInvariantError("the term was not internalized");
38
+ return node;
39
+ }
40
+
41
+ protected isZeroNumeral(expr: number) {
42
+ return this.manager.isNumeral(expr) && this.manager.getRationalValue(expr).isZero();
43
+ }
44
+
45
+ protected mkEqAxioms(inputFirst: Enode, inputSecond: Enode) {
46
+ if (inputFirst === inputSecond) return;
47
+ const context = this.context;
48
+ const manager = this.manager;
49
+ const isSwapped = manager.ids[inputFirst.owner] > manager.ids[inputSecond.owner];
50
+ const first = isSwapped ? inputSecond : inputFirst;
51
+ const second = isSwapped ? inputFirst : inputSecond;
52
+ let t1 = first.owner;
53
+ let t2 = second.owner;
54
+ if (manager.isNumeral(t1) && manager.isNumeral(t2)) return;
55
+ const key = `${t1}:${t2}`;
56
+ if (this.processedEqs.has(key)) return;
57
+ this.processedEqs.add(key);
58
+ context.pushTrail(() => this.processedEqs.delete(key));
59
+ const eq = context.mkEqAtom(t1, t2);
60
+ if (manager.isNumeral(t1)) {
61
+ const saved = t1;
62
+ t1 = t2;
63
+ t2 = saved;
64
+ }
65
+ const sort = manager.sorts[t1];
66
+ let le: number;
67
+ let ge: number;
68
+ if (manager.isNumeral(t2)) {
69
+ le = manager.mkApp(OP_LE, [t1, t2], SORT_BOOL);
70
+ ge = manager.mkApp(OP_GE, [t1, t2], SORT_BOOL);
71
+ } else {
72
+ const minusOne = manager.mkNumeralOfSort(Rational.minusOne, sort);
73
+ const zero = manager.mkNumeralOfSort(Rational.zero, sort);
74
+ const difference = manager.mkApp(
75
+ OP_ADD,
76
+ [t1, manager.mkApp(OP_MUL, [minusOne, t2], sort)],
77
+ sort,
78
+ );
79
+ le = manager.mkApp(OP_LE, [difference, zero], SORT_BOOL);
80
+ ge = manager.mkApp(OP_GE, [difference, zero], SORT_BOOL);
81
+ }
82
+ context.internalize(eq, true);
83
+ context.internalize(le, true);
84
+ context.internalize(ge, true);
85
+ const eqLiteral = context.getLiteral(eq);
86
+ const leLiteral = context.getLiteral(le);
87
+ const geLiteral = context.getLiteral(ge);
88
+ if (context.isTrueFirst(getVar(eqLiteral))) {
89
+ context.setTrueFirstFlag(getVar(leLiteral));
90
+ context.setTrueFirstFlag(getVar(geLiteral));
91
+ }
92
+ context.mkThAxiom([negate(eqLiteral), leLiteral]);
93
+ context.mkThAxiom([negate(eqLiteral), geLiteral]);
94
+ context.mkThAxiom([eqLiteral, negate(leLiteral), negate(geLiteral)]);
95
+ const handler = () => {
96
+ if (!context.isRelevant(first.owner) || !context.isRelevant(second.owner)) return;
97
+ context.relevancy.markAsRelevant(eq);
98
+ context.relevancy.markAsRelevant(le);
99
+ context.relevancy.markAsRelevant(ge);
100
+ };
101
+ context.relevancy.addHandler(first.owner, handler);
102
+ context.relevancy.addHandler(second.owner, handler);
103
+ if (
104
+ context.scopeLevel !== context.baseLevel &&
105
+ first.iscopeLevel <= context.baseLevel &&
106
+ second.iscopeLevel <= context.baseLevel
107
+ )
108
+ this.restartPairs.push([first, second]);
109
+ }
110
+
111
+ internalizeEqEh(expr: number) {
112
+ const context = this.context;
113
+ const first = context.getEnode(this.manager.getArg(expr, 0));
114
+ const second = context.getEnode(this.manager.getArg(expr, 1));
115
+ if (first === undefined || second === undefined) return;
116
+ if (first.thVar >= 0 && second.thVar >= 0 && first !== second) this.mkEqAxioms(first, second);
117
+ }
118
+
119
+ newEqEh(first: number, second: number) {
120
+ this.mkEqAxioms(this.getEnode(first), this.getEnode(second));
121
+ }
122
+
123
+ newDiseqEh(first: number, second: number) {
124
+ this.mkEqAxioms(this.getEnode(first), this.getEnode(second));
125
+ }
126
+
127
+ relevantEh(expr: number) {
128
+ const manager = this.manager;
129
+ const op = manager.getOp(expr);
130
+ if (op === OP_DIV) this.mkDivAxiom(manager.getArg(expr, 0), manager.getArg(expr, 1));
131
+ else if (op === OP_TO_INT) this.mkToIntAxiom(expr);
132
+ else if (op === OP_IS_INT) this.mkIsIntAxiom(expr);
133
+ else if (op === OP_MOD) this.mkIdivModAxioms(manager.getArg(expr, 0), manager.getArg(expr, 1));
134
+ }
135
+
136
+ // mk_literal.
137
+ protected mkLiteral(atom: number) {
138
+ const context = this.context;
139
+ if (!context.isEInternalized(atom)) context.internalize(atom, false);
140
+ return context.getLiteral(atom);
141
+ }
142
+
143
+ // ensure_enode: the relevant enode of a term.
144
+ private ensureEnode(expr: number) {
145
+ const node = this.getInternalizedEnode(expr);
146
+ this.context.markAsRelevant(expr);
147
+ return node;
148
+ }
149
+
150
+ // mk_axiom: a theory axiom whose literals are relevant. Of two literals, the second becomes
151
+ // relevant only once the first is false. A unit axiom is the clause of false and the literal, so
152
+ // mk_clause drops false and the literal is justified by unit resolution with true, which lemma
153
+ // minimization can see through, rather than by an axiom.
154
+ protected mkAxiom(literals: Literal[]) {
155
+ const context = this.context;
156
+ // mkThAxiom simplifies the literals it is given, which this reads after.
157
+ context.mkThAxiom(
158
+ literals.length === 1 ? [context.falseLiteral, literals[0]] : literals.slice(),
159
+ );
160
+ if (!context.relevancy.isEnabled) return;
161
+ if (literals.length !== 2) {
162
+ for (const literal of literals) context.markLiteralAsRelevant(literal);
163
+ return;
164
+ }
165
+ context.markLiteralAsRelevant(literals[0]);
166
+ const consequent = context.boolVar2Expr[getVar(literals[1])];
167
+ context.relevancy.addWatch(
168
+ context.boolVar2Expr[getVar(literals[0])],
169
+ isNegated(literals[0]),
170
+ // simple_relevancy_eh marks the consequent without propagating.
171
+ () => context.relevancy.markAsRelevant(consequent),
172
+ );
173
+ }
174
+
175
+ // mk_div_axiom: q = 0 or q * (p / q) = p.
176
+ private mkDivAxiom(dividend: number, divisor: number) {
177
+ const manager = this.manager;
178
+ if (this.isZeroNumeral(divisor)) return;
179
+ const isZero = this.mkEq(divisor, manager.mkRealNumeral(Rational.zero));
180
+ const product = manager.mkApp(
181
+ OP_MUL,
182
+ [divisor, manager.mkApp(OP_DIV, [dividend, divisor], SORT_REAL)],
183
+ SORT_REAL,
184
+ );
185
+ this.mkAxiom([isZero, this.mkEq(product, dividend)]);
186
+ }
187
+
188
+ // mk_to_int_axiom: to_int (to_real x) = x, and to_real (to_int x) <= x < to_real (to_int x) + 1.
189
+ private mkToIntAxiom(term: number) {
190
+ const manager = this.manager;
191
+ const arg = manager.getArg(term, 0);
192
+ if (manager.getOp(arg) === OP_TO_REAL) {
193
+ this.mkAxiom([this.mkEq(manager.getArg(arg, 0), term)]);
194
+ return;
195
+ }
196
+ const toReal = manager.mkApp(OP_TO_REAL, [term], SORT_REAL);
197
+ const lower = manager.mkApp(
198
+ OP_LE,
199
+ [manager.mkApp(OP_SUB, [toReal, arg], SORT_REAL), manager.mkRealNumeral(Rational.zero)],
200
+ SORT_BOOL,
201
+ );
202
+ const upper = manager.mkApp(
203
+ OP_GE,
204
+ [manager.mkApp(OP_SUB, [arg, toReal], SORT_REAL), manager.mkRealNumeral(Rational.one)],
205
+ SORT_BOOL,
206
+ );
207
+ const lowerLiteral = this.mkLiteral(lower);
208
+ const upperLiteral = this.mkLiteral(upper);
209
+ this.mkAxiom([lowerLiteral]);
210
+ this.mkAxiom([negate(upperLiteral)]);
211
+ }
212
+
213
+ // mk_is_int_axiom: is_int x if and only if to_real (to_int x) = x.
214
+ protected mkIsIntAxiom(atom: number) {
215
+ const manager = this.manager;
216
+ const arg = manager.getArg(atom, 0);
217
+ const eq = this.mkEq(
218
+ manager.mkApp(OP_TO_REAL, [manager.mkApp(OP_TO_INT, [arg], SORT_INT)], SORT_REAL),
219
+ arg,
220
+ );
221
+ const isInt = this.context.getLiteral(atom);
222
+ this.mkAxiom([negate(isInt), eq]);
223
+ this.mkAxiom([isInt, negate(eq)]);
224
+ }
225
+
226
+ // theory::mk_eq: the literal of an equality between two terms, internalized.
227
+ protected mkEq(first: number, second: number) {
228
+ const manager = this.manager;
229
+ if (first === second) return TRUE_LITERAL;
230
+ if (manager.isUniqueValue(first) && manager.isUniqueValue(second)) return FALSE_LITERAL;
231
+ const atom = this.context.mkEqAtom(first, second);
232
+ this.context.internalize(atom, false);
233
+ return this.context.getLiteral(atom);
234
+ }
235
+
236
+ // mk_idiv_mod_axioms: q * (div p q) + (mod p q) = p and 0 <= (mod p q) < |q| when q is not 0.
237
+ protected mkIdivModAxioms(dividend: number, divisor: number) {
238
+ const manager = this.manager;
239
+ if (manager.getNumeral(divisor) === 0n) return;
240
+ // The expr_refs of mk_idiv_mod_axioms, released in reverse when it returns.
241
+ const refs: number[] = [];
242
+ const hold = (expr: number) => {
243
+ manager.incRef(expr);
244
+ refs.push(expr);
245
+ return expr;
246
+ };
247
+ manager.withoutTemporaries(() => this.mkIdivModAxiomsCore(dividend, divisor, hold));
248
+ for (let index = refs.length - 1; index >= 0; index--) manager.decRef(refs[index]);
249
+ }
250
+
251
+ private mkIdivModAxiomsCore(dividend: number, divisor: number, hold: (expr: number) => number) {
252
+ const manager = this.manager;
253
+ const context = this.context;
254
+ const quotient = hold(manager.mkApp(OP_IDIV, [dividend, divisor], SORT_INT));
255
+ const remainder = hold(manager.mkApp(OP_MOD, [dividend, divisor], SORT_INT));
256
+ const zero = hold(manager.mkNumeral(0n));
257
+ if (manager.getNumeral(dividend) === 0n) {
258
+ // q != 0 implies div 0 q = 0 and mod 0 q = 0.
259
+ const isDivisorNonnegative = this.mkLiteral(manager.mkApp(OP_GE, [divisor, zero], SORT_BOOL));
260
+ const isDivisorNonpositive = this.mkLiteral(manager.mkApp(OP_LE, [divisor, zero], SORT_BOOL));
261
+ const consequents = [
262
+ manager.mkApp(OP_GE, [quotient, zero], SORT_BOOL),
263
+ manager.mkApp(OP_LE, [quotient, zero], SORT_BOOL),
264
+ manager.mkApp(OP_GE, [remainder, zero], SORT_BOOL),
265
+ manager.mkApp(OP_LE, [remainder, zero], SORT_BOOL),
266
+ ].map((atom) => this.mkLiteral(atom));
267
+ for (const antecedent of [isDivisorNonnegative, isDivisorNonpositive])
268
+ for (const consequent of consequents) this.mkAxiom([antecedent, consequent]);
269
+ return;
270
+ }
271
+ const combination = hold(
272
+ manager.mkApp(
273
+ OP_ADD,
274
+ [manager.mkApp(OP_MUL, [divisor, quotient], SORT_INT), remainder],
275
+ SORT_INT,
276
+ ),
277
+ );
278
+ const eqAtom = hold(context.mkEqAtom(combination, dividend));
279
+ context.internalize(eqAtom, false);
280
+ const eq = context.getLiteral(eqAtom);
281
+ const divisorValue = manager.getNumeral(divisor);
282
+ if (divisorValue !== undefined) {
283
+ const upper = hold(
284
+ manager.mkNumeral((divisorValue < 0n ? -divisorValue : divisorValue) - 1n),
285
+ );
286
+ this.mkAxiom([eq]);
287
+ this.mkEqAxioms(this.ensureEnode(combination), this.ensureEnode(dividend));
288
+ this.mkAxiom([this.mkLiteral(manager.mkApp(OP_GE, [remainder, zero], SORT_BOOL))]);
289
+ this.mkAxiom([this.mkLiteral(manager.mkApp(OP_LE, [remainder, upper], SORT_BOOL))]);
290
+ return;
291
+ }
292
+ // q = 0 or (mod p q) >= 0, q >= 0 or (mod p q) + q <= -1, and q <= 0 or (mod p q) - q <= -1.
293
+ const minusOne = hold(manager.mkNumeral(-1n));
294
+ const minusDivisor = hold(manager.mkApp(OP_MUL, [minusOne, divisor], SORT_INT));
295
+ const isZero = this.mkLiteral(manager.mkEq(divisor, zero));
296
+ const isRemainderNonnegative = this.mkLiteral(
297
+ manager.mkApp(OP_GE, [remainder, zero], SORT_BOOL),
298
+ );
299
+ this.mkAxiom([isZero, eq]);
300
+ this.mkAxiom([isZero, isRemainderNonnegative]);
301
+ const isDivisorNonpositive = this.mkLiteral(manager.mkApp(OP_LE, [divisor, zero], SORT_BOOL));
302
+ const isBelowDivisor = this.mkLiteral(
303
+ manager.mkApp(
304
+ OP_LE,
305
+ [manager.mkApp(OP_ADD, [remainder, minusDivisor], SORT_INT), minusOne],
306
+ SORT_BOOL,
307
+ ),
308
+ );
309
+ this.mkAxiom([isDivisorNonpositive, isBelowDivisor]);
310
+ const isDivisorNonnegative = this.mkLiteral(manager.mkApp(OP_GE, [divisor, zero], SORT_BOOL));
311
+ const isBelowNegatedDivisor = this.mkLiteral(
312
+ manager.mkApp(
313
+ OP_LE,
314
+ [manager.mkApp(OP_ADD, [remainder, divisor], SORT_INT), minusOne],
315
+ SORT_BOOL,
316
+ ),
317
+ );
318
+ this.mkAxiom([isDivisorNonnegative, isBelowNegatedDivisor]);
319
+ this.mkEqAxioms(this.ensureEnode(combination), this.ensureEnode(dividend));
320
+ // q = 0 or q * (div p q) <= p. The rewritten atom replaces the unrewritten one, which Z3
321
+ // releases at once, and its own expr_ref goes at the end of the block.
322
+ const unrewritten = manager.mkApp(
323
+ OP_GE,
324
+ [
325
+ manager.mkApp(
326
+ OP_SUB,
327
+ [dividend, manager.mkApp(OP_MUL, [divisor, quotient], SORT_INT)],
328
+ SORT_INT,
329
+ ),
330
+ zero,
331
+ ],
332
+ SORT_BOOL,
333
+ );
334
+ manager.incRef(unrewritten);
335
+ const isProductBelow = context.rewriter.rewrite(unrewritten);
336
+ manager.decRef(unrewritten);
337
+ this.mkAxiom([isZero, this.mkLiteral(isProductBelow)]);
338
+ manager.decRef(isProductBelow);
339
+ }
340
+ }
@@ -0,0 +1,226 @@
1
+ // Ported from Z3 (src/smt/theory_lra.cpp, src/math/lp/lp_api.h), MIT license, see z3-license.txt.
2
+ // The atoms of theory_lra: each is a bound on a column, with axioms between the bounds of the same
3
+ // column.
4
+ import { OP_GE, OP_IS_INT, OP_LE } from "./ast";
5
+ import { BoolVar, Literal, mkLiteral, negate } from "./literal";
6
+ import { Rational } from "./rational";
7
+ import { KIND_GE, KIND_GT, KIND_LE, KIND_LT } from "./lp/constraints";
8
+ import { type ApiBound, TheoryLraInternalize } from "./theory-lra-internalize";
9
+
10
+ interface AssertedAtom {
11
+ boolVar: BoolVar;
12
+ isTrue: boolean;
13
+ }
14
+
15
+ export const getAtomLiteral = (bound: ApiBound) => mkLiteral(bound.boolVar);
16
+
17
+ export abstract class TheoryLraBounds extends TheoryLraInternalize {
18
+ protected assertedAtoms: AssertedAtom[] = [];
19
+ protected boundsTrail: number[] = [];
20
+ protected boolVarToBound: (ApiBound | undefined)[] = [];
21
+ protected newBounds: ApiBound[] = [];
22
+ protected delayIneqs: number[] = [];
23
+
24
+ internalizeAtom(expr: number) {
25
+ const manager = this.manager;
26
+ const context = this.context;
27
+ const op = manager.getOp(expr);
28
+ const boolVar = context.mkBoolVar(expr);
29
+ this.boolVarToBound[boolVar] = undefined;
30
+ context.setVarTheory(boolVar);
31
+ if (op === OP_IS_INT) {
32
+ this.mkEnode(expr);
33
+ if (!context.relevancy.isEnabled) this.mkIsIntAxiom(expr);
34
+ return true;
35
+ }
36
+ if (op !== OP_LE && op !== OP_GE) {
37
+ this.foundUnsupported(expr);
38
+ return true;
39
+ }
40
+ const isRightNumeral = manager.isNumeral(manager.getArg(expr, 1));
41
+ if (!isRightNumeral && !manager.isNumeral(manager.getArg(expr, 0))) {
42
+ this.delayIneqs.push(expr);
43
+ context.pushTrail(() => this.delayIneqs.pop());
44
+ return true;
45
+ }
46
+ const term = isRightNumeral ? manager.getArg(expr, 0) : manager.getArg(expr, 1);
47
+ const bound = manager.getRationalValue(
48
+ isRightNumeral ? manager.getArg(expr, 1) : manager.getArg(expr, 0),
49
+ );
50
+ const isLower = (op === OP_GE) === isRightNumeral;
51
+ const thVar = this.internalizeDef(term);
52
+ const value =
53
+ this.isIntVar(thVar) && !bound.isInt() ? (isLower ? bound.ceil() : bound.floor()) : bound;
54
+ const apiBound = this.mkVarBound(boolVar, thVar, isLower, value);
55
+ this.bounds[thVar].push(apiBound);
56
+ this.updateUnassignedBounds(thVar, 1);
57
+ this.boundsTrail.push(thVar);
58
+ this.boolVarToBound[boolVar] = apiBound;
59
+ this.mkBoundAxioms(apiBound);
60
+ return true;
61
+ }
62
+
63
+ private updateUnassignedBounds(thVar: number, increment: number) {
64
+ const saved = this.unassignedBounds[thVar];
65
+ this.context.pushTrail(() => {
66
+ this.unassignedBounds[thVar] = saved;
67
+ });
68
+ this.unassignedBounds[thVar] = saved + increment;
69
+ }
70
+
71
+ // bound2constraint_kind: the kind of the bound when its atom is true or false.
72
+ protected getBoundKind(bound: ApiBound, isTrue: boolean) {
73
+ if (bound.isLower) return isTrue ? KIND_GE : bound.isInt ? KIND_LE : KIND_LT;
74
+ return isTrue ? KIND_LE : bound.isInt ? KIND_GE : KIND_GT;
75
+ }
76
+
77
+ private mkVarBound(boolVar: BoolVar, thVar: number, isLower: boolean, value: Rational) {
78
+ this.pushInternalizeState();
79
+ this.internalizeHead--;
80
+ const column = this.registerVar(thVar);
81
+ const isInt = this.isIntVar(thVar);
82
+ const partial = { isLower, isInt };
83
+ const kindTrue = isLower ? KIND_GE : KIND_LE;
84
+ const kindFalse = isLower ? (isInt ? KIND_LE : KIND_LT) : isInt ? KIND_GE : KIND_GT;
85
+ const constraintTrue = this.solver.mkVarBound(column, kindTrue, value);
86
+ const falseValue = isInt
87
+ ? isLower
88
+ ? value.sub(Rational.one)
89
+ : value.add(Rational.one)
90
+ : value;
91
+ const constraintFalse = this.solver.mkVarBound(column, kindFalse, falseValue);
92
+ this.constraintSources[constraintTrue] = mkLiteral(boolVar);
93
+ this.constraintSources[constraintFalse] = mkLiteral(boolVar, true);
94
+ return { boolVar, thVar, column, value, constraintTrue, constraintFalse, ...partial };
95
+ }
96
+
97
+ // mk_bound_axioms: implications between a new bound and its closest neighbors on the variable.
98
+ private mkBoundAxioms(bound: ApiBound) {
99
+ if (!this.context.isSearching) {
100
+ this.newBounds.push(bound);
101
+ return;
102
+ }
103
+ let loInf: ApiBound | undefined;
104
+ let loSup: ApiBound | undefined;
105
+ let hiInf: ApiBound | undefined;
106
+ let hiSup: ApiBound | undefined;
107
+ for (const other of this.bounds[bound.thVar]) {
108
+ if (other === bound || other.boolVar === bound.boolVar) continue;
109
+ const comparison = other.value.compare(bound.value);
110
+ if (comparison === 0 && other.isLower === bound.isLower) continue;
111
+ if (other.isLower) {
112
+ if (comparison < 0) {
113
+ if (loInf === undefined || other.value.compare(loInf.value) > 0) loInf = other;
114
+ } else if (loSup === undefined || other.value.compare(loSup.value) < 0) loSup = other;
115
+ } else if (comparison < 0) {
116
+ if (hiInf === undefined || other.value.compare(hiInf.value) > 0) hiInf = other;
117
+ } else if (hiSup === undefined || other.value.compare(hiSup.value) < 0) hiSup = other;
118
+ }
119
+ for (const other of [loInf, loSup, hiInf, hiSup])
120
+ if (other !== undefined) this.mkBoundAxiom(bound, other);
121
+ }
122
+
123
+ private mkBoundAxiom(first: ApiBound, second: ApiBound) {
124
+ const l1 = getAtomLiteral(first);
125
+ const l2 = getAtomLiteral(second);
126
+ const k1 = first.value;
127
+ const k2 = second.value;
128
+ if (k1.equals(k2) && first.isLower === second.isLower) return;
129
+ const mkClause = (literals: Literal[]) => this.context.mkThAxiom(literals);
130
+ if (first.isLower) {
131
+ if (second.isLower) {
132
+ if (k2.compare(k1) <= 0) mkClause([negate(l1), l2]);
133
+ else mkClause([l1, negate(l2)]);
134
+ } else if (k1.compare(k2) <= 0) mkClause([l1, l2]);
135
+ else {
136
+ mkClause([negate(l1), negate(l2)]);
137
+ if (first.isInt && k1.equals(k2.add(Rational.one))) mkClause([l1, l2]);
138
+ }
139
+ } else if (second.isLower) {
140
+ if (k1.compare(k2) >= 0) mkClause([l1, l2]);
141
+ else {
142
+ mkClause([negate(l1), negate(l2)]);
143
+ if (first.isInt && k1.equals(k2.sub(Rational.one))) mkClause([l1, l2]);
144
+ }
145
+ } else if (k1.compare(k2) >= 0) mkClause([l1, negate(l2)]);
146
+ else mkClause([negate(l1), l2]);
147
+ }
148
+
149
+ // flush_bound_axioms: the axioms of the bounds created before the search, per variable.
150
+ protected flushBoundAxioms() {
151
+ while (this.newBounds.length > 0) {
152
+ const pending = this.newBounds.slice().sort((first, second) => first.thVar - second.thVar);
153
+ this.newBounds = [];
154
+ for (let index = 0; index < pending.length;) {
155
+ const thVar = pending[index].thVar;
156
+ const atoms: ApiBound[] = [];
157
+ for (; index < pending.length && pending[index].thVar === thVar; index++)
158
+ atoms.push(pending[index]);
159
+ const byValue = (first: ApiBound, second: ApiBound) => first.value.compare(second.value);
160
+ atoms.sort(byValue);
161
+ const occs = this.bounds[thVar].slice().sort(byValue);
162
+ const end = occs.length;
163
+ const getFirst = (isLower: boolean) => {
164
+ const position = occs.findIndex((bound) => bound.isLower === isLower);
165
+ return position === -1 ? end : position;
166
+ };
167
+ const nextInf = (atom: ApiBound, isLower: boolean, start: number) => {
168
+ let result = end;
169
+ let isFound = false;
170
+ for (let position = start; position < end; position++) {
171
+ const other = occs[position];
172
+ if (other === atom || other.isLower !== isLower) continue;
173
+ isFound = true;
174
+ if (other.value.compare(atom.value) <= 0) result = position;
175
+ else break;
176
+ }
177
+ return { result, isFound };
178
+ };
179
+ const nextSup = (atom: ApiBound, isLower: boolean, start: number) => {
180
+ let isFound = false;
181
+ for (let position = start; position < end; position++) {
182
+ const other = occs[position];
183
+ if (other === atom || other.isLower !== isLower) continue;
184
+ isFound = true;
185
+ if (atom.value.compare(other.value) < 0) return { result: position, isFound };
186
+ }
187
+ return { result: end, isFound };
188
+ };
189
+ let loInf = getFirst(true);
190
+ let loSup = loInf;
191
+ let hiInf = getFirst(false);
192
+ let hiSup = hiInf;
193
+ const visited = new Set<ApiBound>();
194
+ for (const atom of atoms) {
195
+ const loInf1 = nextInf(atom, true, loInf);
196
+ const hiInf1 = nextInf(atom, false, hiInf);
197
+ const loSup1 = nextSup(atom, true, loSup);
198
+ const hiSup1 = nextSup(atom, false, hiSup);
199
+ if (loInf1.result !== end) loInf = loInf1.result;
200
+ if (loSup1.result !== end) loSup = loSup1.result;
201
+ if (hiInf1.result !== end) hiInf = hiInf1.result;
202
+ if (hiSup1.result !== end) hiSup = hiSup1.result;
203
+ if (!loInf1.isFound) loInf = end;
204
+ if (!hiInf1.isFound) hiInf = end;
205
+ if (!loSup1.isFound) loSup = end;
206
+ if (!hiSup1.isFound) hiSup = end;
207
+ visited.add(atom);
208
+ const tryAxiom = (found: number, position: number) => {
209
+ if (found !== end && position !== end && !visited.has(occs[position]))
210
+ this.mkBoundAxiom(atom, occs[position]);
211
+ };
212
+ tryAxiom(loInf1.result, loInf);
213
+ tryAxiom(loSup1.result, loSup);
214
+ tryAxiom(hiInf1.result, hiInf);
215
+ tryAxiom(hiSup1.result, hiSup);
216
+ }
217
+ }
218
+ }
219
+ }
220
+
221
+ assignEh(boolVar: BoolVar, isTrue: boolean) {
222
+ this.assertedAtoms.push({ boolVar, isTrue });
223
+ const bound = this.boolVarToBound[boolVar];
224
+ if (bound !== undefined) this.updateUnassignedBounds(bound.thVar, -1);
225
+ }
226
+ }