tla-ts 0.0.4-dev.2be6058 → 0.0.4-dev.2da24e1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (314) hide show
  1. package/README.md +37 -126
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +35 -1
  6. package/dist/index.d.ts +35 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +996 -0
  15. package/dist/prove.js +996 -0
  16. package/dist/run-cli.cjs +37 -47
  17. package/dist/run-cli.js +37 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +26 -7
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +255 -56
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +247 -69
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
  35. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  36. package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
  37. package/src/{obligations.ts → obligations/index.ts} +32 -16
  38. package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
  39. package/src/{obligation-module.ts → obligations/module.ts} +113 -121
  40. package/src/obligations/pickle.ts +98 -0
  41. package/src/obligations/pragma.ts +189 -0
  42. package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
  43. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  44. package/src/{obligation-source.ts → obligations/source.ts} +154 -99
  45. package/src/obligations/temporal.ts +321 -0
  46. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  47. package/src/ocaml-marshal.ts +166 -0
  48. package/src/parallel-worker.ts +2 -18
  49. package/src/parallel.ts +10 -43
  50. package/src/prove/decide-pool.ts +95 -0
  51. package/src/prove/deciders.ts +33 -0
  52. package/src/prove/first-order.ts +78 -0
  53. package/src/prove/isabelle/LICENSE +36 -0
  54. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  55. package/src/prove/isabelle/decide.ts +47 -0
  56. package/src/prove/isabelle/encode.ts +446 -0
  57. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  58. package/src/prove/isabelle/isar/method.ts +367 -0
  59. package/src/prove/isabelle/isar/proof.ts +28 -0
  60. package/src/prove/isabelle/isar/statement.ts +57 -0
  61. package/src/prove/isabelle/isar/theory.ts +192 -0
  62. package/src/prove/isabelle/isar/type-check.ts +278 -0
  63. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  64. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  65. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  66. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  67. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  68. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  69. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  70. package/src/prove/isabelle/provers/classical.ts +389 -0
  71. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  72. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  73. package/src/prove/isabelle/pure/consts.ts +32 -0
  74. package/src/prove/isabelle/pure/conv.ts +79 -0
  75. package/src/prove/isabelle/pure/drule.ts +264 -0
  76. package/src/prove/isabelle/pure/envir.ts +363 -0
  77. package/src/prove/isabelle/pure/goal.ts +53 -0
  78. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  79. package/src/prove/isabelle/pure/list.ts +12 -0
  80. package/src/prove/isabelle/pure/logic.ts +402 -0
  81. package/src/prove/isabelle/pure/name.ts +110 -0
  82. package/src/prove/isabelle/pure/net.ts +262 -0
  83. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  84. package/src/prove/isabelle/pure/pattern.ts +650 -0
  85. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  86. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  87. package/src/prove/isabelle/pure/search.ts +68 -0
  88. package/src/prove/isabelle/pure/seq.ts +156 -0
  89. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  90. package/src/prove/isabelle/pure/table.ts +208 -0
  91. package/src/prove/isabelle/pure/tactic.ts +276 -0
  92. package/src/prove/isabelle/pure/tactical.ts +347 -0
  93. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  94. package/src/prove/isabelle/pure/term.ts +808 -0
  95. package/src/prove/isabelle/pure/thm.ts +806 -0
  96. package/src/prove/isabelle/pure/type.ts +133 -0
  97. package/src/prove/isabelle/pure/unify.ts +753 -0
  98. package/src/prove/isabelle/pure/variable.ts +25 -0
  99. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  100. package/src/prove/isabelle/tla/context.ts +74 -0
  101. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  102. package/src/prove/isabelle/tla/logic.ts +215 -0
  103. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  104. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  105. package/src/prove/ocaml.ts +22 -0
  106. package/src/prove/prep/action.ts +508 -0
  107. package/src/prove/prep/defs.ts +33 -0
  108. package/src/prove/prep/elab.ts +156 -0
  109. package/src/prove/prep/enabled-axioms.ts +189 -0
  110. package/src/prove/prep/enabled.ts +43 -0
  111. package/src/prove/prep/fingerprint.ts +388 -0
  112. package/src/prove/prep/flatten.ts +70 -0
  113. package/src/prove/prep/level-comparison.ts +529 -0
  114. package/src/prove/prep/md5.ts +67 -0
  115. package/src/prove/prep/pragma.ts +221 -0
  116. package/src/prove/prep/trivial.ts +22 -0
  117. package/src/prove/prove-worker.ts +22 -0
  118. package/src/prove/prove.ts +498 -0
  119. package/src/prove/ptl/decide.ts +68 -0
  120. package/src/prove/ptl/encode.ts +255 -0
  121. package/src/prove/ptl/sat.ts +151 -0
  122. package/src/prove/ptl/tableau.ts +276 -0
  123. package/src/prove/smt/axiomatize.ts +69 -0
  124. package/src/prove/smt/axioms.ts +209 -0
  125. package/src/prove/smt/context.ts +108 -0
  126. package/src/prove/smt/data.ts +636 -0
  127. package/src/prove/smt/encode.ts +164 -0
  128. package/src/prove/smt/extensionality.ts +65 -0
  129. package/src/prove/smt/flatten.ts +112 -0
  130. package/src/prove/smt/format.ts +154 -0
  131. package/src/prove/smt/instances.ts +181 -0
  132. package/src/prove/smt/rewrite.ts +772 -0
  133. package/src/prove/smt/simplify.ts +57 -0
  134. package/src/prove/smt/solver/act-cache.ts +265 -0
  135. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  136. package/src/prove/smt/solver/array.ts +22 -0
  137. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  138. package/src/prove/smt/solver/ast-lt.ts +157 -0
  139. package/src/prove/smt/solver/ast-util.ts +147 -0
  140. package/src/prove/smt/solver/ast.ts +1315 -0
  141. package/src/prove/smt/solver/auf-solver.ts +572 -0
  142. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  143. package/src/prove/smt/solver/cg-table.ts +175 -0
  144. package/src/prove/smt/solver/clause.ts +276 -0
  145. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  146. package/src/prove/smt/solver/context.ts +1292 -0
  147. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  148. package/src/prove/smt/solver/der.ts +224 -0
  149. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  150. package/src/prove/smt/solver/e-matching.ts +659 -0
  151. package/src/prove/smt/solver/enode.ts +259 -0
  152. package/src/prove/smt/solver/expr-ref.ts +21 -0
  153. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  154. package/src/prove/smt/solver/fingerprints.ts +92 -0
  155. package/src/prove/smt/solver/flat-literals.ts +51 -0
  156. package/src/prove/smt/solver/goal.ts +138 -0
  157. package/src/prove/smt/solver/hash.ts +173 -0
  158. package/src/prove/smt/solver/hashtable.ts +166 -0
  159. package/src/prove/smt/solver/internalizer.ts +1381 -0
  160. package/src/prove/smt/solver/lbool.ts +5 -0
  161. package/src/prove/smt/solver/literal.ts +24 -0
  162. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  163. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  164. package/src/prove/smt/solver/lp/containers.ts +296 -0
  165. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  166. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  167. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  168. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  169. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  170. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  171. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  172. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  173. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  174. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  175. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  176. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  177. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  178. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  179. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  180. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  181. package/src/prove/smt/solver/lp/nex.ts +120 -0
  182. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  183. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  184. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  185. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  186. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  187. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  188. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  189. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  190. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  191. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  192. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  193. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  194. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  195. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  196. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  197. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  198. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  199. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  200. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  201. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  202. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  203. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  204. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  205. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  206. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  207. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  208. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  209. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  210. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  211. package/src/prove/smt/solver/model-checker.ts +347 -0
  212. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  213. package/src/prove/smt/solver/model-finder.ts +155 -0
  214. package/src/prove/smt/solver/model-generator.ts +97 -0
  215. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  216. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  217. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  218. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  219. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  220. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  221. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  222. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  223. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  224. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  225. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  226. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  227. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  228. package/src/prove/smt/solver/nnf.ts +469 -0
  229. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  230. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  231. package/src/prove/smt/solver/propagate-values.ts +83 -0
  232. package/src/prove/smt/solver/proto-model.ts +551 -0
  233. package/src/prove/smt/solver/pull-quant.ts +139 -0
  234. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  235. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  236. package/src/prove/smt/solver/qe-lite.ts +381 -0
  237. package/src/prove/smt/solver/qi-queue.ts +362 -0
  238. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  239. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  240. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  241. package/src/prove/smt/solver/random-gen.ts +10 -0
  242. package/src/prove/smt/solver/rational.ts +165 -0
  243. package/src/prove/smt/solver/ref-vector.ts +62 -0
  244. package/src/prove/smt/solver/relevancy.ts +247 -0
  245. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  246. package/src/prove/smt/solver/rewriter.ts +843 -0
  247. package/src/prove/smt/solver/rlimit.ts +79 -0
  248. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  249. package/src/prove/smt/solver/solver.ts +71 -0
  250. package/src/prove/smt/solver/sort.ts +35 -0
  251. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  252. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  253. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  254. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  255. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  256. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  257. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  258. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  259. package/src/prove/smt/solver/theory-lra.ts +56 -0
  260. package/src/prove/smt/solver/var-subst.ts +258 -0
  261. package/src/prove/smt/solver/z3-license.txt +10 -0
  262. package/src/prove/smt/table.ts +170 -0
  263. package/src/prove/tlapm/tlapm.ts +96 -0
  264. package/src/prove/tlaps-module.ts +510 -0
  265. package/src/prove/verdict.ts +18 -0
  266. package/src/prove/zenon/LICENSE +32 -0
  267. package/src/prove/zenon/check/check.ts +105 -0
  268. package/src/prove/zenon/check/definitions.ts +144 -0
  269. package/src/prove/zenon/check/equality.ts +182 -0
  270. package/src/prove/zenon/check/functions.ts +62 -0
  271. package/src/prove/zenon/check/keys.ts +125 -0
  272. package/src/prove/zenon/check/propositional.ts +104 -0
  273. package/src/prove/zenon/check/records.ts +188 -0
  274. package/src/prove/zenon/check/relations.ts +121 -0
  275. package/src/prove/zenon/check/rewrites.ts +224 -0
  276. package/src/prove/zenon/check/sets.ts +302 -0
  277. package/src/prove/zenon/check/terms.ts +127 -0
  278. package/src/prove/zenon/check/tla.ts +126 -0
  279. package/src/prove/zenon/decide.ts +113 -0
  280. package/src/prove/zenon/encode.ts +379 -0
  281. package/src/prove/zenon/eqrel.ts +300 -0
  282. package/src/prove/zenon/equality-rules.ts +435 -0
  283. package/src/prove/zenon/expr.ts +551 -0
  284. package/src/prove/zenon/index-table.ts +350 -0
  285. package/src/prove/zenon/isar-case.ts +513 -0
  286. package/src/prove/zenon/isar.ts +1249 -0
  287. package/src/prove/zenon/limits.ts +15 -0
  288. package/src/prove/zenon/llproof.ts +173 -0
  289. package/src/prove/zenon/mltoll.ts +1566 -0
  290. package/src/prove/zenon/node.ts +297 -0
  291. package/src/prove/zenon/ocaml.ts +169 -0
  292. package/src/prove/zenon/parse.ts +247 -0
  293. package/src/prove/zenon/phrase.ts +191 -0
  294. package/src/prove/zenon/proof.ts +198 -0
  295. package/src/prove/zenon/propositional-rules.ts +387 -0
  296. package/src/prove/zenon/rules.ts +94 -0
  297. package/src/prove/zenon/search.ts +288 -0
  298. package/src/prove/zenon/tla/functions.ts +151 -0
  299. package/src/prove/zenon/tla/llproof.ts +480 -0
  300. package/src/prove/zenon/tla/records.ts +225 -0
  301. package/src/prove/zenon/tla/rewrites.ts +447 -0
  302. package/src/prove/zenon/tla/sets.ts +304 -0
  303. package/src/prove/zenon/tla/terms.ts +181 -0
  304. package/src/prove/zenon/tla/tla.ts +506 -0
  305. package/src/run-cli.ts +283 -81
  306. package/src/standard-modules.ts +5 -2
  307. package/src/successors.ts +25 -6
  308. package/src/tlapm-cache.ts +236 -0
  309. package/src/tlc-random.ts +55 -32
  310. package/src/tlc-version.ts +8 -7
  311. package/src/values.ts +97 -47
  312. package/src/worker.ts +65 -0
  313. package/dist/parallel.cjs +0 -12
  314. package/dist/parallel.js +0 -12
@@ -0,0 +1,476 @@
1
+ // Ported from Z3 (src/smt/theory_lra.cpp), MIT license, see z3-license.txt. How theory_lra
2
+ // internalizes terms: a term becomes a column of the lp solver, a linear sum becomes a term column,
3
+ // nonlinear products and divisions go to nla, and numerals are fixed columns.
4
+ import {
5
+ FAMILY_ARITH,
6
+ OP_ADD,
7
+ OP_DIV,
8
+ OP_DIV0,
9
+ OP_IDIV,
10
+ OP_IDIV0,
11
+ OP_MOD,
12
+ OP_MOD0,
13
+ OP_MUL,
14
+ OP_NUM,
15
+ OP_SUB,
16
+ OP_TO_INT,
17
+ OP_TO_REAL,
18
+ OP_UMINUS,
19
+ SORT_INT,
20
+ SORT_REAL,
21
+ } from "./ast";
22
+ import { Enode } from "./enode";
23
+ import { BoolVar, getVar, Literal } from "./literal";
24
+ import { Rational } from "./rational";
25
+ import { RefVector } from "./ref-vector";
26
+ import { type ConstraintKind, KIND_GE, KIND_LE } from "./lp/constraints";
27
+ import { NULL_LPVAR } from "./lp/lar-solver";
28
+ import { NlaCore } from "./lp/nla-core";
29
+ import type { Division } from "./lp/nla-divisions";
30
+ import { TheoryLraAxioms } from "./theory-lra-axioms";
31
+
32
+ // api_bound: an atom v <= value or v >= value, with its constraints when true and when false.
33
+ export interface ApiBound {
34
+ readonly boolVar: BoolVar;
35
+ readonly thVar: number;
36
+ readonly column: number;
37
+ readonly isInt: boolean;
38
+ readonly value: Rational;
39
+ readonly isLower: boolean;
40
+ readonly constraintTrue: number;
41
+ readonly constraintFalse: number;
42
+ }
43
+
44
+ interface Scope {
45
+ boundsLimit: number;
46
+ assertedQhead: number;
47
+ assertedAtomsLimit: number;
48
+ numVars: number;
49
+ }
50
+
51
+ // The theory variables of a linear sum and their coefficients.
52
+ interface LinearizedSum {
53
+ vars: number[];
54
+ coeffs: Rational[];
55
+ }
56
+
57
+ export abstract class TheoryLraInternalize extends TheoryLraAxioms {
58
+ protected abstract reportEqualityOfFixedVars(first: number, second: number): void;
59
+
60
+ protected oneVar = NULL_LPVAR;
61
+ protected zeroVar = NULL_LPVAR;
62
+ protected realOneVar = NULL_LPVAR;
63
+ protected realZeroVar = NULL_LPVAR;
64
+
65
+ // The literal of each inequality constraint, and null for a definition.
66
+ protected constraintSources: (Literal | null)[] = [];
67
+
68
+ protected bounds: ApiBound[][] = [];
69
+ protected unassignedBounds: number[] = [];
70
+ protected isNewDef = false;
71
+
72
+ // m_internalize_states: the terms of each nesting depth of internalize_def and mk_var_bound, which
73
+ // hold references until the next one at that depth resets them.
74
+ private internalizeStates: RefVector[] = [];
75
+
76
+ protected internalizeHead = 0;
77
+ protected scopes: Scope[] = [];
78
+ protected value2var = new Map<string, number>();
79
+
80
+ // m_not_handled: terms that the theory treats as uninterpreted, so a model may not satisfy them.
81
+ // Their arguments have variables, as the factors of an nla monomial do.
82
+ protected unsupportedTerms: number[] = [];
83
+
84
+ protected underspecifiedTerms: number[] = [];
85
+ protected nla: NlaCore | undefined;
86
+
87
+ // init: the constants 1 and 0, integer and then real, each in a scope of its own. The context
88
+ // runs it once, when it registers the theory.
89
+ init() {
90
+ const manager = this.manager;
91
+ this.oneVar = this.addConst(manager.mkNumeral(1n));
92
+ this.realOneVar = this.addConst(manager.mkRealNumeral(Rational.one));
93
+ this.zeroVar = this.addConst(manager.mkNumeral(0n));
94
+ this.realZeroVar = this.addConst(manager.mkRealNumeral(Rational.zero));
95
+ }
96
+
97
+ private addConst(expr: number) {
98
+ const value = this.manager.getRationalValue(expr);
99
+ this.mkEnode(expr);
100
+ const column = this.solver.addVar(this.mkVar(expr), this.isIntExpr(expr));
101
+ this.solver.push();
102
+ this.addDefConstraintAndEquality(column, KIND_GE, value);
103
+ this.addDefConstraintAndEquality(column, KIND_LE, value);
104
+ return column;
105
+ }
106
+
107
+ isAttachedToVar(node: Enode) {
108
+ return node.thVar >= 0 && this.varEnodes[node.thVar] === node;
109
+ }
110
+
111
+ private mkVar(expr: number) {
112
+ const node = this.getInternalizedEnode(expr);
113
+ if (this.isAttachedToVar(node)) return node.thVar;
114
+ const thVar = this.varEnodes.length;
115
+ this.varEnodes.push(node);
116
+ while (this.bounds.length <= thVar) {
117
+ this.bounds.push([]);
118
+ this.unassignedBounds.push(0);
119
+ }
120
+ this.context.attachThVar(node, thVar);
121
+ return thVar;
122
+ }
123
+
124
+ protected registerVar(thVar: number) {
125
+ const column = this.solver.externalToLocalColumn(thVar);
126
+ return column !== NULL_LPVAR ? column : this.solver.addVar(thVar, this.isIntVar(thVar));
127
+ }
128
+
129
+ // mk_enode: the arguments, which become relevant, then the term.
130
+ protected mkEnode(expr: number) {
131
+ const context = this.context;
132
+ for (let index = 0; index < this.manager.getNumArgs(expr); index++) {
133
+ const arg = this.manager.getArg(expr, index);
134
+ if (context.isEInternalized(arg)) continue;
135
+ context.internalize(arg, false);
136
+ context.markAsRelevant(arg);
137
+ }
138
+ if (context.isEInternalized(expr)) return;
139
+ const op = this.manager.getOp(expr);
140
+ const isArith = this.manager.getFamily(expr) === FAMILY_ARITH;
141
+ context.mkEnode(expr, false, false, !(isArith && (op === OP_ADD || op === OP_MUL)));
142
+ }
143
+
144
+ private internalizeArgs(expr: number) {
145
+ const context = this.context;
146
+ for (let index = 0; index < this.manager.getNumArgs(expr); index++) {
147
+ const arg = this.manager.getArg(expr, index);
148
+ if (!context.isEInternalized(arg)) context.internalize(arg, false);
149
+ }
150
+ }
151
+
152
+ // found_unsupported: the list of unsupported terms is on the trail.
153
+ protected foundUnsupported(expr: number) {
154
+ this.unsupportedTerms.push(expr);
155
+ this.context.pushTrail(() => this.unsupportedTerms.pop());
156
+ }
157
+
158
+ // found_underspecified: a division by a term or by zero equals the division by zero it stands
159
+ // for, which the model interprets freely.
160
+ private foundUnderspecified(expr: number) {
161
+ const manager = this.manager;
162
+ const context = this.context;
163
+ this.underspecifiedTerms.push(expr);
164
+ context.pushTrail(() => this.underspecifiedTerms.pop());
165
+ const op = manager.getOp(expr);
166
+ const zero = manager.mkNumeral(0n);
167
+ const dividend =
168
+ op === OP_MOD ? manager.mkApp(OP_MOD, [manager.getArg(expr, 0), zero], SORT_INT) : expr;
169
+ const byZero =
170
+ op === OP_DIV
171
+ ? manager.mkApp(OP_DIV0, manager.getArgs(expr), SORT_REAL)
172
+ : op === OP_IDIV
173
+ ? manager.mkApp(OP_IDIV0, manager.getArgs(expr), SORT_INT)
174
+ : manager.mkApp(OP_MOD0, [manager.getArg(expr, 0), zero], SORT_INT);
175
+ const literal = this.mkEq(byZero, dividend);
176
+ if (context.relevancy.isEnabled)
177
+ context.relevancy.addDependency(dividend, context.boolVar2Expr[getVar(literal)]);
178
+ context.assign(literal, null);
179
+ }
180
+
181
+ private registerFixedVar(thVar: number, value: Rational) {
182
+ const key = `${this.isIntVar(thVar)}:${value}`;
183
+ if (this.value2var.has(key)) return;
184
+ this.value2var.set(key, thVar);
185
+ this.context.pushTrail(() => this.value2var.delete(key));
186
+ }
187
+
188
+ private internalizeNumeral(expr: number, value: Rational) {
189
+ if (!this.context.isEInternalized(expr)) this.mkEnode(expr);
190
+ const thVar = this.mkVar(expr);
191
+ if (this.solver.externalToLocalColumn(thVar) === NULL_LPVAR) {
192
+ const column = this.solver.addVar(thVar, this.isIntExpr(expr));
193
+ this.addDefConstraintAndEquality(column, KIND_GE, value);
194
+ this.addDefConstraintAndEquality(column, KIND_LE, value);
195
+ this.registerFixedVar(thVar, value);
196
+ }
197
+ return thVar;
198
+ }
199
+
200
+ // internalize_mul: a product of terms is a variable whose arguments have variables.
201
+ private internalizeMul(expr: number) {
202
+ this.internalizeArgs(expr);
203
+ const hasVar = this.context.isEInternalized(expr) && this.isAttachedExpr(expr);
204
+ this.mkEnode(expr);
205
+ const thVar = this.mkVar(expr);
206
+ if (!hasVar) {
207
+ const vars = this.manager.mapArgs(expr, (arg) => {
208
+ this.internalizeTermCore(arg);
209
+ return this.registerVar(this.mkVar(arg));
210
+ });
211
+ this.solver.registerExistingTerms();
212
+ this.ensureNla().addMonic(this.registerVar(thVar), vars);
213
+ }
214
+ return thVar;
215
+ }
216
+
217
+ // ensure_nla: the nonlinear solver, made on the first nonlinear term, in the current scopes.
218
+ private ensureNla() {
219
+ if (this.nla !== undefined) return this.nla;
220
+ const nla = new NlaCore(this.solver, this.manager.limit);
221
+ for (let index = 0; index < this.scopes.length; index++) nla.push();
222
+ nla.isRelevant = (lpVar) =>
223
+ this.context.isRelevant(this.getExpr(this.solver.getExternal(lpVar)));
224
+ this.nla = nla;
225
+ return nla;
226
+ }
227
+
228
+ // The columns of a quotient, its dividend and divisor, and the remainder, internalized in that
229
+ // order.
230
+ private registerDivision(quotient: number, remainder: number): Division {
231
+ const register = (expr: number) => {
232
+ this.internalizeTermCore(expr);
233
+ return this.registerVar(this.mkVar(expr));
234
+ };
235
+ return {
236
+ quotient: register(quotient),
237
+ dividend: register(this.manager.getArg(quotient, 0)),
238
+ divisor: register(this.manager.getArg(quotient, 1)),
239
+ remainder: register(remainder),
240
+ };
241
+ }
242
+
243
+ private isNonzeroNumeral(expr: number) {
244
+ return this.manager.isNumeral(expr) && !this.manager.getRationalValue(expr).isZero();
245
+ }
246
+
247
+ // arith_util::is_bounded: a numeral, a mod by a numeral, or a div by a numeral of a bounded term.
248
+ private isBounded(expr: number): boolean {
249
+ const manager = this.manager;
250
+ const op = manager.getOp(expr);
251
+ if (op === OP_IDIV && manager.isNumeral(manager.getArg(expr, 1)))
252
+ return this.isBounded(manager.getArg(expr, 0));
253
+ return (op === OP_MOD && manager.isNumeral(manager.getArg(expr, 1))) || manager.isNumeral(expr);
254
+ }
255
+
256
+ private isAttachedExpr(expr: number) {
257
+ const node = this.context.getEnode(expr);
258
+ return node !== undefined && this.isAttachedToVar(node);
259
+ }
260
+
261
+ // scoped_internalize_state: the terms of the next depth, reset. The caller decrements the head.
262
+ protected pushInternalizeState() {
263
+ const terms = (this.internalizeStates[this.internalizeHead] ??= new RefVector(this.manager));
264
+ this.internalizeHead++;
265
+ terms.reset();
266
+ return terms;
267
+ }
268
+
269
+ // linearize: the theory variables of a weighted sum of terms, with their coefficients.
270
+ private linearize(terms: RefVector, coeffs: Rational[]) {
271
+ const manager = this.manager;
272
+ const context = this.context;
273
+ const vars: number[] = [];
274
+ const toEnsureEnode: number[] = [];
275
+ const toEnsureVar: number[] = [];
276
+ const push = (term: number, coeff: Rational) => {
277
+ terms.push(term);
278
+ coeffs.push(coeff);
279
+ };
280
+ const addVar = (index: number, thVar: number) => {
281
+ coeffs[vars.length] = coeffs[index];
282
+ vars.push(thVar);
283
+ };
284
+ let index = 0;
285
+ while (index < terms.size) {
286
+ const term = terms.items[index];
287
+ toEnsureEnode.push(term);
288
+ const op = manager.getOp(term);
289
+ if (op === OP_ADD) {
290
+ for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
291
+ const arg = manager.getArg(term, argIndex);
292
+ push(arg, coeffs[index]);
293
+ }
294
+ if (terms.size !== index + 1) {
295
+ terms.set(index, terms.items[terms.size - 1]);
296
+ coeffs[index] = coeffs[coeffs.length - 1];
297
+ terms.pop();
298
+ coeffs.pop();
299
+ }
300
+ } else if (op === OP_SUB) {
301
+ terms.set(index, manager.getArg(term, 0));
302
+ for (let position = 1; position < manager.getNumArgs(term); position++)
303
+ push(manager.getArg(term, position), coeffs[index].neg());
304
+ } else if (
305
+ op === OP_MUL &&
306
+ manager.getNumArgs(term) === 2 &&
307
+ manager.isNumeral(manager.getArg(term, 0))
308
+ ) {
309
+ coeffs[index] = coeffs[index].mul(manager.getRationalValue(manager.getArg(term, 0)));
310
+ terms.set(index, manager.getArg(term, 1));
311
+ toEnsureEnode.push(manager.getArg(term, 0));
312
+ } else if (
313
+ op === OP_MUL &&
314
+ manager.getNumArgs(term) === 2 &&
315
+ manager.isNumeral(manager.getArg(term, 1))
316
+ ) {
317
+ coeffs[index] = coeffs[index].mul(manager.getRationalValue(manager.getArg(term, 1)));
318
+ terms.set(index, manager.getArg(term, 0));
319
+ toEnsureEnode.push(manager.getArg(term, 1));
320
+ } else if (op === OP_MUL) {
321
+ addVar(index, this.internalizeMul(term));
322
+ index++;
323
+ } else if (op === OP_NUM) {
324
+ addVar(index, this.internalizeNumeral(term, manager.getRationalValue(term)));
325
+ index++;
326
+ } else if (op === OP_UMINUS) {
327
+ coeffs[index] = coeffs[index].neg();
328
+ terms.set(index, manager.getArg(term, 0));
329
+ } else if (op === OP_TO_REAL) {
330
+ terms.set(index, manager.getArg(term, 0));
331
+ if (!context.isEInternalized(term)) {
332
+ this.internalizeTermCore(manager.getArg(term, 0));
333
+ this.mkEnode(term);
334
+ const column = this.registerVar(this.mkVar(term));
335
+ const argColumn = this.registerVar(this.mkVar(manager.getArg(term, 0)));
336
+ for (const constraint of this.solver.addEquality(column, argColumn))
337
+ this.constraintSources[constraint] = null;
338
+ }
339
+ } else if (manager.getFamily(term) === FAMILY_ARITH) {
340
+ const isFirst = !context.isEInternalized(term);
341
+ this.internalizeArgs(term);
342
+ this.mkEnode(term);
343
+ addVar(index, this.mkVar(term));
344
+ index++;
345
+ if (isFirst) {
346
+ if (op === OP_DIV) {
347
+ const divisor = context.rewriter.rewrite(manager.getArg(term, 1));
348
+ if (!this.isNonzeroNumeral(divisor)) this.foundUnderspecified(term);
349
+ for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
350
+ const arg = manager.getArg(term, argIndex);
351
+ toEnsureVar.push(arg);
352
+ }
353
+ } else if (op === OP_IDIV) {
354
+ if (!this.isNonzeroNumeral(manager.getArg(term, 1))) this.foundUnderspecified(term);
355
+ const remainder = manager.mkApp(OP_MOD, manager.getArgs(term), SORT_INT);
356
+ context.internalize(remainder, false);
357
+ if (context.relevancy.isEnabled) context.relevancy.addDependency(term, remainder);
358
+ if (this.nla !== undefined && !manager.isNumeral(manager.getArg(term, 1)))
359
+ this.nla.divisions.addIdivision(this.registerDivision(term, remainder));
360
+ if (
361
+ manager.isNumeral(manager.getArg(term, 1)) &&
362
+ this.isBounded(manager.getArg(term, 0))
363
+ ) {
364
+ const nla = this.ensureNla();
365
+ nla.divisions.addBoundedDivision(this.registerDivision(term, remainder));
366
+ }
367
+ } else if (op === OP_MOD) {
368
+ const isNonzeroDivisor = this.isNonzeroNumeral(manager.getArg(term, 1));
369
+ if (!isNonzeroDivisor) this.foundUnderspecified(term);
370
+ // Without relevancy, Z3 makes the axioms before it registers the division with nla.
371
+ if (!context.relevancy.isEnabled)
372
+ this.mkIdivModAxioms(manager.getArg(term, 0), manager.getArg(term, 1));
373
+ if (this.nla !== undefined && isNonzeroDivisor) {
374
+ const quotient = manager.mkApp(OP_IDIV, manager.getArgs(term), SORT_INT);
375
+ context.internalize(quotient, false);
376
+ this.nla.divisions.addBoundedDivision(this.registerDivision(quotient, term));
377
+ }
378
+ if (
379
+ !manager.isNumeral(manager.getArg(term, 1)) &&
380
+ !this.isZeroNumeral(manager.getArg(term, 0))
381
+ ) {
382
+ const nla = this.ensureNla();
383
+ const quotient = manager.mkApp(OP_IDIV, manager.getArgs(term), SORT_INT);
384
+ context.internalize(quotient, false);
385
+ nla.divisions.addDivisibility(this.registerDivision(quotient, term));
386
+ }
387
+ } else if (op === OP_IDIV0 || op === OP_MOD0) {
388
+ for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
389
+ const arg = manager.getArg(term, argIndex);
390
+ toEnsureVar.push(arg);
391
+ }
392
+ } else if (op !== OP_TO_INT && op !== OP_DIV0) {
393
+ this.foundUnsupported(term);
394
+ for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++) {
395
+ const arg = manager.getArg(term, argIndex);
396
+ toEnsureVar.push(arg);
397
+ }
398
+ }
399
+ if (!context.relevancy.isEnabled && op !== OP_MOD) this.relevantEh(term);
400
+ }
401
+ } else {
402
+ this.internalizeArgs(term);
403
+ addVar(index, this.mkVar(term));
404
+ index++;
405
+ }
406
+ }
407
+ for (let position = toEnsureEnode.length; position-- > 0;)
408
+ this.mkEnode(toEnsureEnode[position]);
409
+ for (let position = toEnsureVar.length; position-- > 0;)
410
+ this.internalizeTermCore(toEnsureVar[position]);
411
+ return { vars, coeffs: coeffs.slice(0, vars.length) };
412
+ }
413
+
414
+ // init_left_side: the coefficients of the variables summed, in the order of the variables.
415
+ private initLeftSide(vars: number[], coeffs: Rational[]) {
416
+ const sums = new Map<number, Rational>();
417
+ vars.forEach((thVar, index) =>
418
+ sums.set(thVar, (sums.get(thVar) ?? Rational.zero).add(coeffs[index])),
419
+ );
420
+ const leftSide: [number, Rational][] = [];
421
+ for (const thVar of vars) {
422
+ const sum = sums.get(thVar);
423
+ if (sum === undefined || sum.isZero()) continue;
424
+ leftSide.push([this.registerVar(thVar), sum]);
425
+ sums.delete(thVar);
426
+ }
427
+ return leftSide;
428
+ }
429
+
430
+ // internalize_def: the variable of a term, with a column for its linear combination.
431
+ protected internalizeDef(expr: number) {
432
+ const terms = this.pushInternalizeState();
433
+ terms.push(expr);
434
+ const thVar = this.internalizeLinearizedDef(expr, this.linearize(terms, [Rational.one]));
435
+ this.internalizeHead--;
436
+ return thVar;
437
+ }
438
+
439
+ // internalize_linearized_def: term - v = 0, unless the term is its own variable.
440
+ private internalizeLinearizedDef(expr: number, linearized: LinearizedSum) {
441
+ const thVar = this.mkVar(expr);
442
+ if (
443
+ linearized.vars.length === 1 &&
444
+ linearized.coeffs[0].equals(Rational.one) &&
445
+ thVar === linearized.vars[0]
446
+ )
447
+ return thVar;
448
+ const leftSide = this.initLeftSide(linearized.vars, linearized.coeffs);
449
+ if (this.solver.externalToLocalColumn(thVar) !== NULL_LPVAR) return thVar;
450
+ if (leftSide.length === 0) {
451
+ const column = this.solver.addVar(thVar, this.isIntExpr(expr));
452
+ this.addDefConstraintAndEquality(column, KIND_GE, Rational.zero);
453
+ this.addDefConstraintAndEquality(column, KIND_LE, Rational.zero);
454
+ } else this.solver.addTerm(leftSide, thVar);
455
+ return thVar;
456
+ }
457
+
458
+ private internalizeTermCore(expr: number) {
459
+ if (this.manager.getFamily(expr) !== FAMILY_ARITH && this.manager.isBool(expr)) return;
460
+ if (this.context.isEInternalized(expr) && this.isAttachedExpr(expr)) return;
461
+ this.internalizeDef(expr);
462
+ }
463
+
464
+ internalizeTerm(expr: number) {
465
+ this.internalizeTermCore(expr);
466
+ return true;
467
+ }
468
+
469
+ private addDefConstraintAndEquality(column: number, kind: ConstraintKind, bound: Rational) {
470
+ const index = this.solver.mkVarBound(column, kind, bound);
471
+ const equal = this.solver.activateCheckOnEqual(index);
472
+ this.constraintSources[index] = null;
473
+ if (equal !== NULL_LPVAR) this.reportEqualityOfFixedVars(column, equal);
474
+ this.isNewDef = true;
475
+ }
476
+ }