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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (311) hide show
  1. package/README.md +26 -141
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +35 -1
  6. package/dist/index.d.ts +35 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +515 -0
  15. package/dist/prove.js +515 -0
  16. package/dist/run-cli.cjs +30 -47
  17. package/dist/run-cli.js +30 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +5 -3
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +54 -19
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  35. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  36. package/src/{obligations.ts → obligations/index.ts} +26 -12
  37. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  38. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  39. package/src/obligations/pickle.ts +100 -0
  40. package/src/obligations/pragma.ts +189 -0
  41. package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
  42. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  43. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  44. package/src/obligations/temporal.ts +319 -0
  45. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  46. package/src/parallel-worker.ts +2 -18
  47. package/src/parallel.ts +10 -43
  48. package/src/prove/decide-pool.ts +100 -0
  49. package/src/prove/deciders.ts +27 -0
  50. package/src/prove/isabelle/LICENSE +36 -0
  51. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  52. package/src/prove/isabelle/decide.ts +47 -0
  53. package/src/prove/isabelle/encode.ts +477 -0
  54. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  55. package/src/prove/isabelle/isar/method.ts +367 -0
  56. package/src/prove/isabelle/isar/proof.ts +28 -0
  57. package/src/prove/isabelle/isar/statement.ts +57 -0
  58. package/src/prove/isabelle/isar/theory.ts +192 -0
  59. package/src/prove/isabelle/isar/type-check.ts +278 -0
  60. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  61. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  62. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  63. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  64. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  65. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  66. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  67. package/src/prove/isabelle/provers/classical.ts +389 -0
  68. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  69. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  70. package/src/prove/isabelle/pure/consts.ts +32 -0
  71. package/src/prove/isabelle/pure/conv.ts +79 -0
  72. package/src/prove/isabelle/pure/drule.ts +264 -0
  73. package/src/prove/isabelle/pure/envir.ts +363 -0
  74. package/src/prove/isabelle/pure/goal.ts +53 -0
  75. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  76. package/src/prove/isabelle/pure/list.ts +12 -0
  77. package/src/prove/isabelle/pure/logic.ts +402 -0
  78. package/src/prove/isabelle/pure/name.ts +110 -0
  79. package/src/prove/isabelle/pure/net.ts +262 -0
  80. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  81. package/src/prove/isabelle/pure/pattern.ts +650 -0
  82. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  83. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  84. package/src/prove/isabelle/pure/search.ts +68 -0
  85. package/src/prove/isabelle/pure/seq.ts +156 -0
  86. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  87. package/src/prove/isabelle/pure/table.ts +208 -0
  88. package/src/prove/isabelle/pure/tactic.ts +276 -0
  89. package/src/prove/isabelle/pure/tactical.ts +347 -0
  90. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  91. package/src/prove/isabelle/pure/term.ts +808 -0
  92. package/src/prove/isabelle/pure/thm.ts +806 -0
  93. package/src/prove/isabelle/pure/type.ts +133 -0
  94. package/src/prove/isabelle/pure/unify.ts +753 -0
  95. package/src/prove/isabelle/pure/variable.ts +25 -0
  96. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  97. package/src/prove/isabelle/tla/context.ts +74 -0
  98. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  99. package/src/prove/isabelle/tla/logic.ts +215 -0
  100. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  101. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  102. package/src/prove/ocaml.ts +22 -0
  103. package/src/prove/prep/action.ts +520 -0
  104. package/src/prove/prep/defs.ts +27 -0
  105. package/src/prove/prep/elab.ts +156 -0
  106. package/src/prove/prep/enabled-axioms.ts +189 -0
  107. package/src/prove/prep/enabled.ts +43 -0
  108. package/src/prove/prep/fingerprint.ts +388 -0
  109. package/src/prove/prep/flatten.ts +70 -0
  110. package/src/prove/prep/level-comparison.ts +552 -0
  111. package/src/prove/prep/md5.ts +67 -0
  112. package/src/prove/prep/pragma.ts +221 -0
  113. package/src/prove/prep/trivial.ts +22 -0
  114. package/src/prove/prove-worker.ts +29 -0
  115. package/src/prove/prove.ts +417 -0
  116. package/src/prove/ptl/decide.ts +68 -0
  117. package/src/prove/ptl/encode.ts +256 -0
  118. package/src/prove/ptl/sat.ts +151 -0
  119. package/src/prove/ptl/tableau.ts +276 -0
  120. package/src/prove/smt/axiomatize.ts +69 -0
  121. package/src/prove/smt/axioms.ts +210 -0
  122. package/src/prove/smt/context.ts +108 -0
  123. package/src/prove/smt/data.ts +665 -0
  124. package/src/prove/smt/encode.ts +169 -0
  125. package/src/prove/smt/extensionality.ts +63 -0
  126. package/src/prove/smt/flatten.ts +127 -0
  127. package/src/prove/smt/format.ts +143 -0
  128. package/src/prove/smt/instances.ts +182 -0
  129. package/src/prove/smt/rewrite.ts +784 -0
  130. package/src/prove/smt/simplify.ts +57 -0
  131. package/src/prove/smt/solver/act-cache.ts +265 -0
  132. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  133. package/src/prove/smt/solver/array.ts +22 -0
  134. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  135. package/src/prove/smt/solver/ast-lt.ts +157 -0
  136. package/src/prove/smt/solver/ast-util.ts +147 -0
  137. package/src/prove/smt/solver/ast.ts +1315 -0
  138. package/src/prove/smt/solver/auf-solver.ts +572 -0
  139. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  140. package/src/prove/smt/solver/cg-table.ts +175 -0
  141. package/src/prove/smt/solver/clause.ts +276 -0
  142. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  143. package/src/prove/smt/solver/context.ts +1292 -0
  144. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  145. package/src/prove/smt/solver/der.ts +224 -0
  146. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  147. package/src/prove/smt/solver/e-matching.ts +659 -0
  148. package/src/prove/smt/solver/enode.ts +259 -0
  149. package/src/prove/smt/solver/expr-ref.ts +21 -0
  150. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  151. package/src/prove/smt/solver/fingerprints.ts +92 -0
  152. package/src/prove/smt/solver/flat-literals.ts +51 -0
  153. package/src/prove/smt/solver/goal.ts +138 -0
  154. package/src/prove/smt/solver/hash.ts +173 -0
  155. package/src/prove/smt/solver/hashtable.ts +166 -0
  156. package/src/prove/smt/solver/internalizer.ts +1381 -0
  157. package/src/prove/smt/solver/lbool.ts +5 -0
  158. package/src/prove/smt/solver/literal.ts +24 -0
  159. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  160. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  161. package/src/prove/smt/solver/lp/containers.ts +296 -0
  162. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  163. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  164. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  165. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  166. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  167. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  168. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  169. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  170. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  171. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  172. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  173. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  174. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  175. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  176. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  177. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  178. package/src/prove/smt/solver/lp/nex.ts +120 -0
  179. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  180. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  181. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  182. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  183. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  184. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  185. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  186. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  187. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  188. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  189. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  190. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  191. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  192. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  193. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  194. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  195. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  196. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  197. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  198. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  199. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  200. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  201. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  202. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  203. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  204. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  205. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  206. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  207. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  208. package/src/prove/smt/solver/model-checker.ts +347 -0
  209. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  210. package/src/prove/smt/solver/model-finder.ts +155 -0
  211. package/src/prove/smt/solver/model-generator.ts +97 -0
  212. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  213. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  214. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  215. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  216. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  217. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  218. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  219. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  220. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  221. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  222. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  223. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  224. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  225. package/src/prove/smt/solver/nnf.ts +469 -0
  226. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  227. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  228. package/src/prove/smt/solver/propagate-values.ts +83 -0
  229. package/src/prove/smt/solver/proto-model.ts +551 -0
  230. package/src/prove/smt/solver/pull-quant.ts +139 -0
  231. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  232. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  233. package/src/prove/smt/solver/qe-lite.ts +381 -0
  234. package/src/prove/smt/solver/qi-queue.ts +362 -0
  235. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  236. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  237. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  238. package/src/prove/smt/solver/random-gen.ts +10 -0
  239. package/src/prove/smt/solver/rational.ts +165 -0
  240. package/src/prove/smt/solver/ref-vector.ts +62 -0
  241. package/src/prove/smt/solver/relevancy.ts +247 -0
  242. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  243. package/src/prove/smt/solver/rewriter.ts +843 -0
  244. package/src/prove/smt/solver/rlimit.ts +79 -0
  245. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  246. package/src/prove/smt/solver/solver.ts +71 -0
  247. package/src/prove/smt/solver/sort.ts +35 -0
  248. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  249. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  250. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  251. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  252. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  253. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  254. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  255. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  256. package/src/prove/smt/solver/theory-lra.ts +56 -0
  257. package/src/prove/smt/solver/var-subst.ts +258 -0
  258. package/src/prove/smt/solver/z3-license.txt +10 -0
  259. package/src/prove/smt/table.ts +170 -0
  260. package/src/prove/tlapm/tlapm.ts +96 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +13 -0
  263. package/src/prove/zenon/LICENSE +32 -0
  264. package/src/prove/zenon/check/check.ts +105 -0
  265. package/src/prove/zenon/check/definitions.ts +144 -0
  266. package/src/prove/zenon/check/equality.ts +182 -0
  267. package/src/prove/zenon/check/functions.ts +62 -0
  268. package/src/prove/zenon/check/keys.ts +125 -0
  269. package/src/prove/zenon/check/propositional.ts +104 -0
  270. package/src/prove/zenon/check/records.ts +188 -0
  271. package/src/prove/zenon/check/relations.ts +121 -0
  272. package/src/prove/zenon/check/rewrites.ts +224 -0
  273. package/src/prove/zenon/check/sets.ts +302 -0
  274. package/src/prove/zenon/check/terms.ts +127 -0
  275. package/src/prove/zenon/check/tla.ts +126 -0
  276. package/src/prove/zenon/decide.ts +113 -0
  277. package/src/prove/zenon/encode.ts +444 -0
  278. package/src/prove/zenon/eqrel.ts +300 -0
  279. package/src/prove/zenon/equality-rules.ts +435 -0
  280. package/src/prove/zenon/expr.ts +551 -0
  281. package/src/prove/zenon/index-table.ts +350 -0
  282. package/src/prove/zenon/isar-case.ts +513 -0
  283. package/src/prove/zenon/isar.ts +1249 -0
  284. package/src/prove/zenon/limits.ts +15 -0
  285. package/src/prove/zenon/llproof.ts +173 -0
  286. package/src/prove/zenon/mltoll.ts +1566 -0
  287. package/src/prove/zenon/node.ts +297 -0
  288. package/src/prove/zenon/ocaml.ts +169 -0
  289. package/src/prove/zenon/parse.ts +247 -0
  290. package/src/prove/zenon/phrase.ts +191 -0
  291. package/src/prove/zenon/proof.ts +198 -0
  292. package/src/prove/zenon/propositional-rules.ts +387 -0
  293. package/src/prove/zenon/rules.ts +94 -0
  294. package/src/prove/zenon/search.ts +288 -0
  295. package/src/prove/zenon/tla/functions.ts +151 -0
  296. package/src/prove/zenon/tla/llproof.ts +480 -0
  297. package/src/prove/zenon/tla/records.ts +225 -0
  298. package/src/prove/zenon/tla/rewrites.ts +447 -0
  299. package/src/prove/zenon/tla/sets.ts +304 -0
  300. package/src/prove/zenon/tla/terms.ts +181 -0
  301. package/src/prove/zenon/tla/tla.ts +506 -0
  302. package/src/run-cli.ts +73 -20
  303. package/src/standard-modules.ts +5 -2
  304. package/src/successors.ts +24 -5
  305. package/src/tlc-random.ts +55 -32
  306. package/src/tlc-version.ts +8 -7
  307. package/src/values.ts +80 -35
  308. package/src/worker.ts +65 -0
  309. package/dist/parallel.cjs +0 -12
  310. package/dist/parallel.js +0 -12
  311. /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
@@ -0,0 +1,656 @@
1
+ // Ported from Z3 (src/math/interval/interval.h, src/math/interval/interval_def.h,
2
+ // src/math/interval/dep_intervals.h, src/math/interval/dep_intervals.cpp), MIT license, see
3
+ // z3-license.txt. Exact rational intervals with open, closed, or infinite bounds, where each bound
4
+ // carries the dependency that justifies it. Only the operations nla_intervals, horner,
5
+ // pdd_interval, and monomial_bounds call are here; mpq is exact, so there is no rounding.
6
+ import { Rational } from "../rational";
7
+ import { type Dependency, linearize, mkJoin } from "./dependency";
8
+
9
+ export interface DepInterval {
10
+ lower: Rational;
11
+ upper: Rational;
12
+ isLowerOpen: boolean;
13
+ isUpperOpen: boolean;
14
+ isLowerInf: boolean;
15
+ isUpperInf: boolean;
16
+ lowerDep: Dependency;
17
+ upperDep: Dependency;
18
+ }
19
+
20
+ // with_deps_t: whether an operation also computes the dependencies of the result.
21
+ export type DepsMode = "with-deps" | "without-deps";
22
+
23
+ interface ExtNumeral {
24
+ readonly kind: "minus-inf" | "numeral" | "plus-inf";
25
+ readonly value: Rational;
26
+ }
27
+
28
+ // interval_deps_combine_rule: bitmasks of the argument bounds that justify each result bound.
29
+ interface CombineRule {
30
+ readonly lower: number;
31
+ readonly upper: number;
32
+ }
33
+
34
+ const DEP_IN_LOWER1 = 1;
35
+ const DEP_IN_UPPER1 = 2;
36
+ const DEP_IN_LOWER2 = 4;
37
+ const DEP_IN_UPPER2 = 8;
38
+
39
+ export const mkDepInterval = (): DepInterval => ({
40
+ lower: Rational.zero,
41
+ upper: Rational.zero,
42
+ isLowerOpen: true,
43
+ isUpperOpen: true,
44
+ isLowerInf: true,
45
+ isUpperInf: true,
46
+ lowerDep: null,
47
+ upperDep: null,
48
+ });
49
+
50
+ const MINUS_INF: ExtNumeral = { kind: "minus-inf", value: Rational.zero };
51
+ const PLUS_INF: ExtNumeral = { kind: "plus-inf", value: Rational.zero };
52
+ const mkNumeral = (value: Rational): ExtNumeral => ({ kind: "numeral", value });
53
+
54
+ const getLowerExt = (interval: DepInterval) =>
55
+ interval.isLowerInf ? MINUS_INF : mkNumeral(interval.lower);
56
+ const getUpperExt = (interval: DepInterval) =>
57
+ interval.isUpperInf ? PLUS_INF : mkNumeral(interval.upper);
58
+
59
+ const extIsZero = (numeral: ExtNumeral) => numeral.kind === "numeral" && numeral.value.isZero();
60
+ const extIsPos = (numeral: ExtNumeral) =>
61
+ numeral.kind === "plus-inf" || (numeral.kind === "numeral" && numeral.value.isPositive());
62
+ const extIsNeg = (numeral: ExtNumeral) =>
63
+ numeral.kind === "minus-inf" || (numeral.kind === "numeral" && numeral.value.isNegative());
64
+
65
+ const extAdd = (first: ExtNumeral, second: ExtNumeral) => {
66
+ if (first.kind !== "numeral") return first;
67
+ if (second.kind !== "numeral") return second;
68
+ return mkNumeral(first.value.add(second.value));
69
+ };
70
+
71
+ const extMul = (first: ExtNumeral, second: ExtNumeral) => {
72
+ if (extIsZero(first) || extIsZero(second)) return mkNumeral(Rational.zero);
73
+ if (first.kind !== "numeral" || second.kind !== "numeral")
74
+ return extIsPos(first) === extIsPos(second) ? PLUS_INF : MINUS_INF;
75
+ return mkNumeral(first.value.mul(second.value));
76
+ };
77
+
78
+ const extDiv = (first: ExtNumeral, second: ExtNumeral) => {
79
+ if (extIsZero(first)) return mkNumeral(Rational.zero);
80
+ if (first.kind !== "numeral") return extIsPos(first) === extIsPos(second) ? PLUS_INF : MINUS_INF;
81
+ if (second.kind !== "numeral") return mkNumeral(Rational.zero);
82
+ return mkNumeral(first.value.div(second.value));
83
+ };
84
+
85
+ const extPower = (numeral: ExtNumeral, exponent: number) => {
86
+ if (numeral.kind === "numeral") return mkNumeral(numeral.value.pow(exponent));
87
+ return numeral.kind === "minus-inf" && exponent % 2 === 0 ? PLUS_INF : numeral;
88
+ };
89
+
90
+ const extEq = (first: ExtNumeral, second: ExtNumeral) =>
91
+ first.kind === "numeral"
92
+ ? second.kind === "numeral" && first.value.equals(second.value)
93
+ : first.kind === second.kind;
94
+
95
+ const extLt = (first: ExtNumeral, second: ExtNumeral) => {
96
+ if (first.kind === "minus-inf") return second.kind !== "minus-inf";
97
+ if (first.kind === "plus-inf") return false;
98
+ if (second.kind === "numeral") return first.value.compare(second.value) < 0;
99
+ return second.kind === "plus-inf";
100
+ };
101
+
102
+ // The bounds of a result go in only after every bound of the arguments is read, since the result
103
+ // may be one of the arguments.
104
+ const setBounds = (
105
+ result: DepInterval,
106
+ lower: ExtNumeral,
107
+ isLowerOpen: boolean,
108
+ upper: ExtNumeral,
109
+ isUpperOpen: boolean,
110
+ ) => {
111
+ result.lower = lower.value;
112
+ result.isLowerInf = lower.kind === "minus-inf";
113
+ result.isLowerOpen = isLowerOpen;
114
+ result.upper = upper.value;
115
+ result.isUpperInf = upper.kind === "plus-inf";
116
+ result.isUpperOpen = isUpperOpen;
117
+ };
118
+
119
+ const lowerIsNeg = (interval: DepInterval) => extIsNeg(getLowerExt(interval));
120
+ const lowerIsPos = (interval: DepInterval) => extIsPos(getLowerExt(interval));
121
+ const lowerIsZero = (interval: DepInterval) => extIsZero(getLowerExt(interval));
122
+ const upperIsNeg = (interval: DepInterval) => extIsNeg(getUpperExt(interval));
123
+ const upperIsPos = (interval: DepInterval) => extIsPos(getUpperExt(interval));
124
+ const upperIsZero = (interval: DepInterval) => extIsZero(getUpperExt(interval));
125
+ const isP0 = (interval: DepInterval) => lowerIsZero(interval) && !interval.isLowerOpen;
126
+ const isP1 = (interval: DepInterval) =>
127
+ lowerIsPos(interval) || (lowerIsZero(interval) && interval.isLowerOpen);
128
+ const isN = (interval: DepInterval) => upperIsNeg(interval) || upperIsZero(interval);
129
+ const isN0 = (interval: DepInterval) => upperIsZero(interval) && !interval.isUpperOpen;
130
+ const isN1 = (interval: DepInterval) =>
131
+ upperIsNeg(interval) || (upperIsZero(interval) && interval.isUpperOpen);
132
+ const isM = (interval: DepInterval) => lowerIsNeg(interval) && upperIsPos(interval);
133
+ // interval_manager::is_zero, which unlike dep_intervals::is_zero ignores openness.
134
+ const areBoundsZero = (interval: DepInterval) => lowerIsZero(interval) && upperIsZero(interval);
135
+
136
+ const imSet = (target: DepInterval, source: DepInterval) => {
137
+ if (target === source) return;
138
+ if (!source.isLowerInf) target.lower = source.lower;
139
+ target.isLowerInf = source.isLowerInf;
140
+ if (!source.isUpperInf) target.upper = source.upper;
141
+ target.isUpperInf = source.isUpperInf;
142
+ target.isLowerOpen = source.isLowerOpen;
143
+ target.isUpperOpen = source.isUpperOpen;
144
+ };
145
+
146
+ const imAdd = (first: DepInterval, second: DepInterval, result: DepInterval) =>
147
+ setBounds(
148
+ result,
149
+ extAdd(getLowerExt(first), getLowerExt(second)),
150
+ first.isLowerOpen || second.isLowerOpen,
151
+ extAdd(getUpperExt(first), getUpperExt(second)),
152
+ first.isUpperOpen || second.isUpperOpen,
153
+ );
154
+
155
+ // div_mul with inv_k false.
156
+ const imMulScalar = (scalar: Rational, interval: DepInterval, result: DepInterval) => {
157
+ if (scalar.isZero()) return setBounds(result, MINUS_INF, true, PLUS_INF, true);
158
+ const factor = mkNumeral(scalar);
159
+ const lower = extMul(getLowerExt(interval), factor);
160
+ const upper = extMul(getUpperExt(interval), factor);
161
+ if (scalar.isPositive())
162
+ return setBounds(result, lower, interval.isLowerOpen, upper, interval.isUpperOpen);
163
+ setBounds(result, upper, interval.isUpperOpen, lower, interval.isLowerOpen);
164
+ };
165
+
166
+ const imMul = (first: DepInterval, second: DepInterval, result: DepInterval) => {
167
+ if (areBoundsZero(first)) return imSet(result, first);
168
+ if (areBoundsZero(second)) return imSet(result, second);
169
+ const a = getLowerExt(first);
170
+ const b = getUpperExt(first);
171
+ const c = getLowerExt(second);
172
+ const d = getUpperExt(second);
173
+ const isAOpen = first.isLowerOpen;
174
+ const isBOpen = first.isUpperOpen;
175
+ const isCOpen = second.isLowerOpen;
176
+ const isDOpen = second.isUpperOpen;
177
+ if (isN(first)) {
178
+ if (isN(second))
179
+ return setBounds(
180
+ result,
181
+ extMul(b, d),
182
+ isN0(first) || isN0(second) ? false : isBOpen || isDOpen,
183
+ extMul(a, c),
184
+ isAOpen || isCOpen,
185
+ );
186
+ if (isM(second))
187
+ return setBounds(result, extMul(a, d), isAOpen || isDOpen, extMul(a, c), isAOpen || isCOpen);
188
+ return setBounds(
189
+ result,
190
+ extMul(a, d),
191
+ isAOpen || isDOpen,
192
+ extMul(b, c),
193
+ isN0(first) || isP0(second) ? false : isBOpen || isCOpen,
194
+ );
195
+ }
196
+ if (isM(first)) {
197
+ if (isN(second))
198
+ return setBounds(result, extMul(b, c), isBOpen || isCOpen, extMul(a, c), isAOpen || isCOpen);
199
+ if (isM(second)) {
200
+ const ad = extMul(a, d);
201
+ const bc = extMul(b, c);
202
+ const ac = extMul(a, c);
203
+ const bd = extMul(b, d);
204
+ const isAdOpen = isAOpen || isDOpen;
205
+ const isBcOpen = isBOpen || isCOpen;
206
+ const isAcOpen = isAOpen || isCOpen;
207
+ const isBdOpen = isBOpen || isDOpen;
208
+ const isAdLower = extLt(ad, bc) || (extEq(ad, bc) && !isAdOpen && isBcOpen);
209
+ const isAcUpper = extLt(bd, ac) || (extEq(ac, bd) && !isAcOpen && isBdOpen);
210
+ return setBounds(
211
+ result,
212
+ isAdLower ? ad : bc,
213
+ isAdLower ? isAdOpen : isBcOpen,
214
+ isAcUpper ? ac : bd,
215
+ isAcUpper ? isAcOpen : isBdOpen,
216
+ );
217
+ }
218
+ return setBounds(result, extMul(a, d), isAOpen || isDOpen, extMul(b, d), isBOpen || isDOpen);
219
+ }
220
+ if (isN(second))
221
+ return setBounds(
222
+ result,
223
+ extMul(b, c),
224
+ isBOpen || isCOpen,
225
+ extMul(a, d),
226
+ isP0(first) || isN0(second) ? false : isAOpen || isDOpen,
227
+ );
228
+ if (isM(second))
229
+ return setBounds(result, extMul(b, c), isBOpen || isCOpen, extMul(b, d), isBOpen || isDOpen);
230
+ setBounds(
231
+ result,
232
+ extMul(a, c),
233
+ isP0(first) || isP0(second) ? false : isAOpen || isCOpen,
234
+ extMul(b, d),
235
+ isBOpen || isDOpen,
236
+ );
237
+ };
238
+
239
+ // The divisor must not contain zero. Like Z3, a zero test of c or d reads the stored value.
240
+ const imDiv = (first: DepInterval, second: DepInterval, result: DepInterval) => {
241
+ if (areBoundsZero(first))
242
+ return setBounds(result, mkNumeral(Rational.zero), false, mkNumeral(Rational.zero), false);
243
+ const a = getLowerExt(first);
244
+ const b = getUpperExt(first);
245
+ const c = getLowerExt(second);
246
+ const d = getUpperExt(second);
247
+ const isAOpen = first.isLowerOpen;
248
+ const isBOpen = first.isUpperOpen;
249
+ const isCOpen = second.isLowerOpen;
250
+ const isDOpen = second.isUpperOpen;
251
+ const isCZero = second.lower.isZero();
252
+ const isDZero = second.upper.isZero();
253
+ if (isN(first)) {
254
+ if (isN1(second))
255
+ return setBounds(
256
+ result,
257
+ extDiv(b, c),
258
+ isN0(first) ? false : isBOpen || isCOpen,
259
+ isDZero ? PLUS_INF : extDiv(a, d),
260
+ isAOpen || isDOpen,
261
+ );
262
+ return setBounds(
263
+ result,
264
+ isCZero ? MINUS_INF : extDiv(a, c),
265
+ isAOpen || isCOpen,
266
+ extDiv(b, d),
267
+ isN0(first) ? false : isBOpen || isDOpen,
268
+ );
269
+ }
270
+ if (isM(first)) {
271
+ if (isN1(second))
272
+ return setBounds(
273
+ result,
274
+ isDZero ? MINUS_INF : extDiv(b, d),
275
+ isBOpen || isDOpen,
276
+ isDZero ? PLUS_INF : extDiv(a, d),
277
+ isAOpen || isDOpen,
278
+ );
279
+ return setBounds(
280
+ result,
281
+ isCZero ? MINUS_INF : extDiv(a, c),
282
+ isAOpen || isCOpen,
283
+ isCZero ? PLUS_INF : extDiv(b, c),
284
+ isBOpen || isCOpen,
285
+ );
286
+ }
287
+ if (isN1(second))
288
+ return setBounds(
289
+ result,
290
+ isDZero ? MINUS_INF : extDiv(b, d),
291
+ isBOpen || isDOpen,
292
+ extDiv(a, c),
293
+ isP0(first) ? false : isAOpen || isCOpen,
294
+ );
295
+ setBounds(
296
+ result,
297
+ extDiv(a, d),
298
+ isP0(first) ? false : isAOpen || isDOpen,
299
+ isCZero ? PLUS_INF : extDiv(b, c),
300
+ isBOpen || isCOpen,
301
+ );
302
+ };
303
+
304
+ const imPower = (interval: DepInterval, exponent: number, result: DepInterval) => {
305
+ if (exponent === 1) return imSet(result, interval);
306
+ const lower = getLowerExt(interval);
307
+ const upper = getUpperExt(interval);
308
+ if (exponent % 2 === 1)
309
+ return setBounds(
310
+ result,
311
+ interval.isLowerInf ? MINUS_INF : extPower(lower, exponent),
312
+ interval.isLowerInf || interval.isLowerOpen,
313
+ interval.isUpperInf ? PLUS_INF : extPower(upper, exponent),
314
+ interval.isUpperInf || interval.isUpperOpen,
315
+ );
316
+ if (lowerIsPos(interval))
317
+ return setBounds(
318
+ result,
319
+ extPower(lower, exponent),
320
+ interval.isLowerOpen,
321
+ interval.isUpperInf ? PLUS_INF : extPower(upper, exponent),
322
+ interval.isUpperInf || interval.isUpperOpen,
323
+ );
324
+ if (upperIsNeg(interval))
325
+ return setBounds(
326
+ result,
327
+ extPower(upper, exponent),
328
+ interval.isUpperOpen,
329
+ interval.isLowerInf ? PLUS_INF : extPower(lower, exponent),
330
+ interval.isLowerInf || interval.isLowerOpen,
331
+ );
332
+ const lowerPower = extPower(lower, exponent);
333
+ const upperPower = extPower(upper, exponent);
334
+ const isLowerPowerMax =
335
+ extLt(upperPower, lowerPower) ||
336
+ (extEq(lowerPower, upperPower) && !interval.isLowerOpen && interval.isUpperOpen);
337
+ setBounds(
338
+ result,
339
+ mkNumeral(Rational.zero),
340
+ false,
341
+ isLowerPowerMax ? lowerPower : upperPower,
342
+ isLowerPowerMax ? interval.isLowerOpen : interval.isUpperOpen,
343
+ );
344
+ };
345
+
346
+ const getAddRule = (): CombineRule => ({
347
+ lower: DEP_IN_LOWER1 | DEP_IN_LOWER2,
348
+ upper: DEP_IN_UPPER1 | DEP_IN_UPPER2,
349
+ });
350
+
351
+ const getMulRule = (first: DepInterval, second: DepInterval): CombineRule => {
352
+ if (areBoundsZero(first))
353
+ return { lower: DEP_IN_LOWER1 | DEP_IN_UPPER1, upper: DEP_IN_LOWER1 | DEP_IN_UPPER1 };
354
+ if (areBoundsZero(second))
355
+ return { lower: DEP_IN_LOWER2 | DEP_IN_UPPER2, upper: DEP_IN_LOWER2 | DEP_IN_UPPER2 };
356
+ if (isN(first)) {
357
+ if (isN(second))
358
+ return {
359
+ lower: DEP_IN_UPPER1 | DEP_IN_UPPER2,
360
+ upper: DEP_IN_LOWER1 | DEP_IN_LOWER2 | DEP_IN_UPPER1,
361
+ };
362
+ if (isM(second))
363
+ return {
364
+ lower: DEP_IN_LOWER1 | DEP_IN_UPPER2 | DEP_IN_UPPER1,
365
+ upper: DEP_IN_LOWER1 | DEP_IN_LOWER2 | DEP_IN_UPPER1,
366
+ };
367
+ return {
368
+ lower: DEP_IN_LOWER1 | DEP_IN_UPPER2 | DEP_IN_UPPER1,
369
+ upper: DEP_IN_UPPER1 | DEP_IN_LOWER2,
370
+ };
371
+ }
372
+ if (isM(first)) {
373
+ if (isN(second))
374
+ return {
375
+ lower: DEP_IN_UPPER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
376
+ upper: DEP_IN_LOWER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
377
+ };
378
+ if (isM(second))
379
+ return {
380
+ lower: DEP_IN_LOWER1 | DEP_IN_UPPER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
381
+ upper: DEP_IN_LOWER1 | DEP_IN_UPPER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
382
+ };
383
+ return {
384
+ lower: DEP_IN_LOWER1 | DEP_IN_UPPER2 | DEP_IN_LOWER2,
385
+ upper: DEP_IN_UPPER1 | DEP_IN_UPPER2 | DEP_IN_LOWER2,
386
+ };
387
+ }
388
+ if (isN(second))
389
+ return {
390
+ lower: DEP_IN_UPPER1 | DEP_IN_LOWER2 | DEP_IN_LOWER1,
391
+ upper: DEP_IN_LOWER1 | DEP_IN_UPPER2,
392
+ };
393
+ if (isM(second))
394
+ return {
395
+ lower: DEP_IN_UPPER1 | DEP_IN_LOWER2 | DEP_IN_LOWER1,
396
+ upper: DEP_IN_UPPER1 | DEP_IN_UPPER2 | DEP_IN_LOWER1,
397
+ };
398
+ return {
399
+ lower: DEP_IN_LOWER1 | DEP_IN_LOWER2,
400
+ upper: DEP_IN_UPPER1 | DEP_IN_UPPER2 | DEP_IN_LOWER1,
401
+ };
402
+ };
403
+
404
+ const getDivRule = (first: DepInterval, second: DepInterval): CombineRule => {
405
+ if (areBoundsZero(first))
406
+ return isP1(second)
407
+ ? { lower: DEP_IN_LOWER1 | DEP_IN_LOWER2, upper: DEP_IN_UPPER1 | DEP_IN_LOWER2 }
408
+ : { lower: DEP_IN_UPPER1 | DEP_IN_UPPER2, upper: DEP_IN_LOWER1 | DEP_IN_UPPER2 };
409
+ if (isN(first))
410
+ return isN1(second)
411
+ ? {
412
+ lower: DEP_IN_UPPER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
413
+ upper: DEP_IN_LOWER1 | DEP_IN_UPPER2,
414
+ }
415
+ : {
416
+ lower: DEP_IN_LOWER1 | DEP_IN_LOWER2,
417
+ upper: DEP_IN_UPPER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
418
+ };
419
+ if (isM(first))
420
+ return isN1(second)
421
+ ? { lower: DEP_IN_UPPER1 | DEP_IN_UPPER2, upper: DEP_IN_LOWER1 | DEP_IN_UPPER2 }
422
+ : { lower: DEP_IN_LOWER1 | DEP_IN_LOWER2, upper: DEP_IN_UPPER1 | DEP_IN_LOWER2 };
423
+ return isN1(second)
424
+ ? {
425
+ lower: DEP_IN_UPPER1 | DEP_IN_UPPER2,
426
+ upper: DEP_IN_LOWER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
427
+ }
428
+ : {
429
+ lower: DEP_IN_LOWER1 | DEP_IN_LOWER2 | DEP_IN_UPPER2,
430
+ upper: DEP_IN_UPPER1 | DEP_IN_LOWER2,
431
+ };
432
+ };
433
+
434
+ const getPowerRule = (interval: DepInterval, exponent: number): CombineRule => {
435
+ if (exponent === 1) return { lower: DEP_IN_LOWER1, upper: DEP_IN_UPPER1 };
436
+ if (exponent % 2 === 1)
437
+ return {
438
+ lower: interval.isLowerInf ? 0 : DEP_IN_LOWER1,
439
+ upper: interval.isUpperInf ? 0 : DEP_IN_UPPER1,
440
+ };
441
+ if (lowerIsPos(interval))
442
+ return {
443
+ lower: DEP_IN_LOWER1,
444
+ upper: interval.isUpperInf ? 0 : DEP_IN_LOWER1 | DEP_IN_UPPER1,
445
+ };
446
+ if (upperIsNeg(interval))
447
+ return {
448
+ lower: DEP_IN_UPPER1,
449
+ upper: interval.isLowerInf ? 0 : DEP_IN_LOWER1 | DEP_IN_UPPER1,
450
+ };
451
+ return { lower: 0, upper: DEP_IN_LOWER1 | DEP_IN_UPPER1 };
452
+ };
453
+
454
+ // im_config::mk_dependency: the joined dependencies of the bounds in the mask.
455
+ const mkDependency = (first: DepInterval, second: DepInterval | null, mask: number) => {
456
+ const withLower1 = mask & DEP_IN_LOWER1 ? first.lowerDep : null;
457
+ const withLower2 =
458
+ second !== null && mask & DEP_IN_LOWER2 ? mkJoin(withLower1, second.lowerDep) : withLower1;
459
+ const withUpper1 = mask & DEP_IN_UPPER1 ? mkJoin(withLower2, first.upperDep) : withLower2;
460
+ return second !== null && mask & DEP_IN_UPPER2 ? mkJoin(withUpper1, second.upperDep) : withUpper1;
461
+ };
462
+
463
+ // im_config::add_deps.
464
+ const combineDeps = (
465
+ first: DepInterval,
466
+ second: DepInterval | null,
467
+ rule: CombineRule,
468
+ result: DepInterval,
469
+ ) => {
470
+ const lowerDep = result.isLowerInf ? null : mkDependency(first, second, rule.lower);
471
+ const upperDep = result.isUpperInf ? null : mkDependency(first, second, rule.upper);
472
+ result.lowerDep = lowerDep;
473
+ result.upperDep = upperDep;
474
+ };
475
+
476
+ export const set = (target: DepInterval, source: DepInterval, mode: DepsMode) => {
477
+ imSet(target, source);
478
+ if (mode === "without-deps") return;
479
+ target.lowerDep = source.lowerDep;
480
+ target.upperDep = source.upperDep;
481
+ };
482
+
483
+ export const power = (
484
+ interval: DepInterval,
485
+ exponent: number,
486
+ result: DepInterval,
487
+ mode: DepsMode,
488
+ ) => {
489
+ if (exponent === 1 && interval === result) return;
490
+ const rule = getPowerRule(interval, exponent);
491
+ imPower(interval, exponent, result);
492
+ if (mode === "with-deps") combineDeps(interval, null, rule, result);
493
+ };
494
+
495
+ export const mulScalar = (
496
+ scalar: Rational,
497
+ interval: DepInterval,
498
+ result: DepInterval,
499
+ mode: DepsMode,
500
+ ) => {
501
+ const lowerDep = interval.lowerDep;
502
+ const upperDep = interval.upperDep;
503
+ imMulScalar(scalar, interval, result);
504
+ if (mode === "without-deps") return;
505
+ result.lowerDep = scalar.isPositive() ? lowerDep : upperDep;
506
+ result.upperDep = scalar.isPositive() ? upperDep : lowerDep;
507
+ };
508
+
509
+ export const mul = (
510
+ first: DepInterval,
511
+ second: DepInterval,
512
+ result: DepInterval,
513
+ mode: DepsMode,
514
+ ) => {
515
+ const rule = getMulRule(first, second);
516
+ imMul(first, second, result);
517
+ if (mode === "with-deps") combineDeps(first, second, rule, result);
518
+ };
519
+
520
+ export const div = (
521
+ first: DepInterval,
522
+ second: DepInterval,
523
+ result: DepInterval,
524
+ mode: DepsMode,
525
+ ) => {
526
+ const rule = getDivRule(first, second);
527
+ imDiv(first, second, result);
528
+ if (mode === "with-deps") combineDeps(first, second, rule, result);
529
+ };
530
+
531
+ export const add = (
532
+ first: DepInterval,
533
+ second: DepInterval,
534
+ result: DepInterval,
535
+ mode: DepsMode,
536
+ ) => {
537
+ imAdd(first, second, result);
538
+ if (mode === "with-deps") combineDeps(first, second, getAddRule(), result);
539
+ };
540
+
541
+ // add(rational, interval): shifts the finite bounds and keeps the dependencies.
542
+ export const addScalar = (scalar: Rational, interval: DepInterval) => {
543
+ if (!interval.isLowerInf) interval.lower = interval.lower.add(scalar);
544
+ if (!interval.isUpperInf) interval.upper = interval.upper.add(scalar);
545
+ };
546
+
547
+ const copyLowerBound = (source: DepInterval, target: DepInterval, mode: DepsMode) => {
548
+ target.isLowerInf = false;
549
+ target.lower = source.lower;
550
+ target.isLowerOpen = source.isLowerOpen;
551
+ if (mode === "with-deps") target.lowerDep = source.lowerDep;
552
+ };
553
+
554
+ const copyUpperBound = (source: DepInterval, target: DepInterval, mode: DepsMode) => {
555
+ target.isUpperInf = false;
556
+ target.upper = source.upper;
557
+ target.isUpperOpen = source.isUpperOpen;
558
+ if (mode === "with-deps") target.upperDep = source.upperDep;
559
+ };
560
+
561
+ // On equal bounds the bound of first wins if it is open, else the bound of second.
562
+ export const intersect = (
563
+ first: DepInterval,
564
+ second: DepInterval,
565
+ result: DepInterval,
566
+ mode: DepsMode,
567
+ ) => {
568
+ if (!first.isLowerInf || !second.isLowerInf) {
569
+ const isFirstLower =
570
+ second.isLowerInf ||
571
+ (!first.isLowerInf &&
572
+ (first.lower.compare(second.lower) > 0 ||
573
+ (first.lower.equals(second.lower) && first.isLowerOpen)));
574
+ copyLowerBound(isFirstLower ? first : second, result, mode);
575
+ }
576
+ if (!first.isUpperInf || !second.isUpperInf) {
577
+ const isFirstUpper =
578
+ second.isUpperInf ||
579
+ (!first.isUpperInf &&
580
+ (first.upper.compare(second.upper) < 0 ||
581
+ (first.upper.equals(second.upper) && first.isUpperOpen)));
582
+ copyUpperBound(isFirstUpper ? first : second, result, mode);
583
+ }
584
+ };
585
+
586
+ // set_value and set_interval_for_scalar: the closed point interval, keeping the dependencies.
587
+ export const setValue = (interval: DepInterval, value: Rational) =>
588
+ setBounds(interval, mkNumeral(value), false, mkNumeral(value), false);
589
+
590
+ // reset: both bounds infinite, keeping the values, openness, and dependencies.
591
+ export const reset = (interval: DepInterval) => {
592
+ interval.isLowerInf = true;
593
+ interval.isUpperInf = true;
594
+ };
595
+
596
+ export const setZeroIntervalDepsForMult = (interval: DepInterval) => {
597
+ interval.lowerDep = mkJoin(interval.lowerDep, interval.upperDep);
598
+ interval.upperDep = interval.lowerDep;
599
+ };
600
+
601
+ export const isZero = (interval: DepInterval) =>
602
+ !interval.isLowerInf &&
603
+ !interval.isUpperInf &&
604
+ !interval.isLowerOpen &&
605
+ !interval.isUpperOpen &&
606
+ interval.lower.isZero() &&
607
+ interval.upper.isZero();
608
+
609
+ export const isEmpty = (interval: DepInterval) => {
610
+ if (interval.isLowerInf || interval.isUpperInf) return false;
611
+ const comparison = interval.lower.compare(interval.upper);
612
+ return comparison > 0 || (comparison === 0 && (interval.isLowerOpen || interval.isUpperOpen));
613
+ };
614
+
615
+ const separatedFromZeroOnLower = (interval: DepInterval) =>
616
+ !interval.isLowerInf &&
617
+ !interval.lower.isNegative() &&
618
+ !(interval.lower.isZero() && !interval.isLowerOpen);
619
+
620
+ const separatedFromZeroOnUpper = (interval: DepInterval) =>
621
+ !interval.isUpperInf &&
622
+ !interval.upper.isPositive() &&
623
+ !(interval.upper.isZero() && !interval.isUpperOpen);
624
+
625
+ export const separatedFromZero = (interval: DepInterval) =>
626
+ separatedFromZeroOnUpper(interval) || separatedFromZeroOnLower(interval);
627
+
628
+ // When the interval excludes zero, reports the joined dependency of dep and the separating bound,
629
+ // lower first.
630
+ export const checkIntervalForConflictOnZero = (
631
+ interval: DepInterval,
632
+ dep: Dependency,
633
+ report: (explanation: number[]) => void,
634
+ ) => {
635
+ if (separatedFromZeroOnLower(interval)) {
636
+ report(linearize([mkJoin(dep, interval.lowerDep)]));
637
+ return true;
638
+ }
639
+ if (!separatedFromZeroOnUpper(interval)) return false;
640
+ report(linearize([mkJoin(dep, interval.upperDep)]));
641
+ return true;
642
+ };
643
+
644
+ export const displayDepInterval = (interval: DepInterval) => {
645
+ const lower = interval.isLowerInf
646
+ ? "(-oo"
647
+ : `${interval.isLowerOpen ? "(" : "["}${interval.lower.toString()}`;
648
+ const upper = interval.isUpperInf
649
+ ? "oo)"
650
+ : `${interval.upper.toString()}${interval.isUpperOpen ? ")" : "]"}`;
651
+ const lowerDeps =
652
+ interval.lowerDep === null ? "" : ` ld ${linearize([interval.lowerDep]).join(" ")}`;
653
+ const upperDeps =
654
+ interval.upperDep === null ? "" : ` ud ${linearize([interval.upperDep]).join(" ")}`;
655
+ return `${lower},${upper}${lowerDeps}${upperDeps}`;
656
+ };
@@ -0,0 +1,51 @@
1
+ // Ported from Z3 (src/util/dependency.h), MIT license, see z3-license.txt. The witnesses of bounds:
2
+ // a DAG whose leaves are constraint indices. Without proofs, lar_solver's evidence_manager is the
3
+ // plain u_dependency_manager.
4
+
5
+ export interface DependencyLeaf {
6
+ readonly isLeaf: true;
7
+ readonly value: number;
8
+ isMarked: boolean;
9
+ }
10
+
11
+ export interface DependencyJoin {
12
+ readonly isLeaf: false;
13
+ readonly first: Dependency;
14
+ readonly second: Dependency;
15
+ isMarked: boolean;
16
+ }
17
+
18
+ export type Dependency = DependencyLeaf | DependencyJoin | null;
19
+
20
+ export const mkLeaf = (value: number): Dependency => ({ isLeaf: true, value, isMarked: false });
21
+
22
+ export const mkJoin = (first: Dependency, second: Dependency): Dependency => {
23
+ if (first === null) return second;
24
+ if (second === null || first === second) return first;
25
+ return { isLeaf: false, first, second, isMarked: false };
26
+ };
27
+
28
+ // linearize: the leaves in breadth-first order, each once, from the given roots.
29
+ export const linearize = (roots: Dependency[]) => {
30
+ const todo: (DependencyLeaf | DependencyJoin)[] = [];
31
+ for (const root of roots) {
32
+ if (root === null || root.isMarked) continue;
33
+ root.isMarked = true;
34
+ todo.push(root);
35
+ }
36
+ const values: number[] = [];
37
+ for (let head = 0; head < todo.length; head++) {
38
+ const node = todo[head];
39
+ if (node.isLeaf) {
40
+ values.push(node.value);
41
+ continue;
42
+ }
43
+ for (const child of [node.first, node.second]) {
44
+ if (child === null || child.isMarked) continue;
45
+ child.isMarked = true;
46
+ todo.push(child);
47
+ }
48
+ }
49
+ for (const node of todo) node.isMarked = false;
50
+ return values;
51
+ };