tla-ts 0.0.10-dev.3a85c3a9e → 0.0.10-dev.45c0eaef5

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 (260) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +56 -56
  14. package/dist/prove.js +79 -79
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +97 -92
  20. package/dist/transfer.js +97 -92
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +31 -3
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -107
  29. package/src/check.ts +535 -281
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +21 -7
  33. package/src/cli/tlc.ts +31 -11
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +255 -18
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +131 -41
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -13
  43. package/src/instances.ts +135 -11
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +204 -62
  49. package/src/liveness.ts +55 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  67. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  68. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  69. package/src/prover/smt/solver/ast-lt.ts +1 -1
  70. package/src/prover/smt/solver/ast.ts +66 -14
  71. package/src/prover/smt/solver/auf-solver.ts +23 -12
  72. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  73. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  74. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  75. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  76. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  77. package/src/prover/smt/solver/card2bv.ts +35 -18
  78. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  79. package/src/prover/smt/solver/context.ts +84 -15
  80. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  81. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  82. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  83. package/src/prover/smt/solver/diff-neq.ts +1 -2
  84. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  85. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  86. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  87. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  88. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  89. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  90. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  91. package/src/prover/smt/solver/euf/egraph.ts +4 -10
  92. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  93. package/src/prover/smt/solver/euf/mam.ts +1 -5
  94. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  95. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  96. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  97. package/src/prover/smt/solver/factor.ts +36 -14
  98. package/src/prover/smt/solver/fd-solver.ts +608 -139
  99. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  100. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  101. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  102. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  103. package/src/prover/smt/solver/goal.ts +6 -3
  104. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  105. package/src/prover/smt/solver/hashtable.ts +4 -0
  106. package/src/prover/smt/solver/internalizer.ts +1 -1
  107. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  108. package/src/prover/smt/solver/lp/containers.ts +7 -1
  109. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  110. package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
  111. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  112. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  113. package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
  114. package/src/prover/smt/solver/lp/nex.ts +2 -1
  115. package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
  116. package/src/prover/smt/solver/lp/nla-core.ts +26 -6
  117. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -81
  118. package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
  119. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  120. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  121. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  122. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  123. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  124. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  125. package/src/prover/smt/solver/maxcore.ts +2 -1
  126. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  127. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  128. package/src/prover/smt/solver/model-checker.ts +1 -1
  129. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  130. package/src/prover/smt/solver/model-generator.ts +85 -43
  131. package/src/prover/smt/solver/mpf.ts +2 -4
  132. package/src/prover/smt/solver/mus.ts +2 -3
  133. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  134. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  135. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  136. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  137. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  138. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  139. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  140. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  141. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  142. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  143. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  144. package/src/prover/smt/solver/nlqsat.ts +1 -1
  145. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  146. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  147. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  148. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  149. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  150. package/src/prover/smt/solver/nlsat/solver.ts +74 -71
  151. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  152. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  153. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  154. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  155. package/src/prover/smt/solver/nnf.ts +6 -2
  156. package/src/prover/smt/solver/opt-context.ts +21 -7
  157. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  158. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  159. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  160. package/src/prover/smt/solver/opt-solver.ts +10 -6
  161. package/src/prover/smt/solver/optsmt.ts +1 -1
  162. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  163. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  164. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  165. package/src/prover/smt/solver/probes.ts +88 -23
  166. package/src/prover/smt/solver/proto-model.ts +8 -8
  167. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  168. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  169. package/src/prover/smt/solver/qe-lite.ts +2 -2
  170. package/src/prover/smt/solver/qe.ts +3 -2
  171. package/src/prover/smt/solver/qsat.ts +23 -8
  172. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  173. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  174. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  175. package/src/prover/smt/solver/rewriter.ts +31 -25
  176. package/src/prover/smt/solver/rlimit.ts +20 -3
  177. package/src/prover/smt/solver/sat/config.ts +1 -1
  178. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  179. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  180. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  181. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  182. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  183. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  184. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  185. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  186. package/src/prover/smt/solver/sat/solver.ts +27 -47
  187. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  188. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  189. package/src/prover/smt/solver/seq-derive.ts +4 -7
  190. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  191. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  192. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  193. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  194. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  195. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  196. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  197. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  198. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  199. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  200. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  201. package/src/prover/smt/solver/smt-setup.ts +106 -13
  202. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  203. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  204. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  205. package/src/prover/smt/solver/solver.ts +18 -3
  206. package/src/prover/smt/solver/tactic.ts +350 -195
  207. package/src/prover/smt/solver/theory-bv.ts +13 -3
  208. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  209. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  210. package/src/prover/smt/solver/theory-lra-internalize.ts +10 -0
  211. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  212. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  213. package/src/prover/smt/solver/theory-lra.ts +1 -1
  214. package/src/prover/smt/solver/theory-pb.ts +24 -7
  215. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  216. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  217. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  218. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  219. package/src/prover/tlapm/cache.ts +8 -8
  220. package/src/prover/zenon/equality-rules.ts +24 -0
  221. package/src/prover/zenon/expr.ts +21 -0
  222. package/src/prover/zenon/index-table.ts +7 -2
  223. package/src/prover/zenon/isar-case.ts +1 -1
  224. package/src/prover/zenon/isar.ts +2 -2
  225. package/src/prover/zenon/phrase.ts +1 -1
  226. package/src/prover/zenon/rules.ts +2 -1
  227. package/src/resolve.ts +1274 -258
  228. package/src/runtime.ts +25 -2
  229. package/src/sany/builtins.ts +10 -10
  230. package/src/sany/generation.ts +5 -15
  231. package/src/sany/generator-def-entries.ts +123 -36
  232. package/src/sany/generator-definitions.ts +5 -3
  233. package/src/sany/generator-expressions.ts +60 -37
  234. package/src/sany/generator-proofs.ts +18 -12
  235. package/src/sany/generator.ts +12 -6
  236. package/src/sany/lexer.ts +15 -7
  237. package/src/sany/modules.ts +4 -2
  238. package/src/sany/nodes.ts +1 -1
  239. package/src/sany/selectors.ts +11 -6
  240. package/src/sany/xml.ts +2 -3
  241. package/src/search.ts +348 -153
  242. package/src/simulate.ts +250 -185
  243. package/src/spec-description.ts +15 -7
  244. package/src/standard-definitions.ts +5 -0
  245. package/src/standard-modules.ts +56 -22
  246. package/src/subexpressions.ts +564 -138
  247. package/src/successors.ts +50 -20
  248. package/src/symmetry.ts +2 -1
  249. package/src/tlc/jar-data.ts +10 -0
  250. package/src/tlc/messages.ts +3 -3
  251. package/src/tlc/order.ts +14 -3
  252. package/src/tlc/random.ts +2 -1
  253. package/src/tlc/replay.ts +147 -46
  254. package/src/tlc/tlc-operators.ts +10 -8
  255. package/src/tlc/tlcext-operators.ts +87 -26
  256. package/src/tlc/trace-spec.ts +11 -25
  257. package/src/trace-liveness.ts +529 -0
  258. package/src/typed-tier.ts +52 -31
  259. package/src/typescript/types.ts +2 -2
  260. package/src/values.ts +150 -79
@@ -97,8 +97,7 @@ class TargetFinder {
97
97
  if (this.isArithApp(expr)) return this.processArith(expr, false);
98
98
  this.todo.push(expr);
99
99
  this.visited.add(expr);
100
- while (this.todo.length > 0) {
101
- const current = this.todo.pop() as number;
100
+ for (let current = this.todo.pop(); current !== undefined; current = this.todo.pop()) {
102
101
  const isProcessed =
103
102
  manager.kinds[current] !== KIND_APP
104
103
  ? false
@@ -403,8 +403,7 @@ const mkIsInfOfInt = (
403
403
  ? mkCompare(OP_LE, -threshold)
404
404
  : manager.falseExpr;
405
405
  }
406
- // Deviation from Z3: Z3 gives up from an exponent width of 34. From 31, MAX_FINITE is a numeral of
407
- // 2^30 bits, more than a BigInt holds, so those widths give up too.
406
+ // Deviation from Z3: it runs out of memory from an exponent width of 31, so this gives up as Z3 does from 34.
408
407
  if (ebits > 30) return -1;
409
408
  const maxFinite = mpfToRational(mkMaxValue(ebits, sbits, false)).num;
410
409
  const halfUlp = 1n << BigInt(maxExp - sbits);
@@ -1,6 +1,6 @@
1
1
  // A statement that discards its result builds a term that upstream builds and never uses, so the
2
2
  // terms after it get the ids Z3 gives them.
3
- import { SmtUnsupportedError } from "../../../errors";
3
+ import { SmtCanceledError, SmtUnsupportedError } from "../../../errors";
4
4
  import {
5
5
  type AstManager,
6
6
  OP_BADD,
@@ -1440,6 +1440,8 @@ export class Fpa2BvConverter {
1440
1440
  const manager = this.manager;
1441
1441
  const ebits = manager.getEbits(sort);
1442
1442
  const sbits = manager.getSbits(sort);
1443
+ // Deviation from Z3: it runs out of memory from an exponent width of 31, where this gives up as at a resource limit.
1444
+ if (ebits > 30) throw new SmtCanceledError();
1443
1445
  const x =
1444
1446
  manager.sorts[input] === SORT_INT ? manager.mkApp(OP_TO_REAL, [input], SORT_REAL) : input;
1445
1447
  const real = (op: number, ...args: number[]) => manager.mkApp(op, args, SORT_REAL);
@@ -214,6 +214,7 @@ export class Fpa2BvRewriter extends RewriterTpl {
214
214
  isSwapped ? args[1] : args[2],
215
215
  );
216
216
  }
217
+ // Deviation from Z3: mk_sub hands mk_add a rounding mode under bv2rm, so fpa2bv fails on fp.sub.
217
218
  case OP_FPA_SUB:
218
219
  return converter.mkSub(sort, getRm(), args[1], args[2]);
219
220
  case OP_FPA_NEG:
@@ -20,7 +20,6 @@ export const joinDependencies = (
20
20
  ? first
21
21
  : { value: -1, children: [first, second] };
22
22
 
23
- // Breadth first and once per node, so a value that two leaves hold is listed twice.
24
23
  export const getDependencyValues = (dependency: Dependency | undefined) => {
25
24
  if (dependency === undefined) return [];
26
25
  const todo = [dependency];
@@ -35,7 +34,7 @@ export const getDependencyValues = (dependency: Dependency | undefined) => {
35
34
  todo.push(child);
36
35
  }
37
36
  }
38
- return values;
37
+ return [...new Set(values)];
39
38
  };
40
39
 
41
40
  interface Polarized {
@@ -43,7 +42,7 @@ interface Polarized {
43
42
  isPositive: boolean;
44
43
  }
45
44
 
46
- export const PRECISE = 0;
45
+ const PRECISE = 0;
47
46
  export const UNDER = 1;
48
47
  export const OVER = 2;
49
48
  const UNDER_OVER = 3;
@@ -81,7 +80,10 @@ export class Goal {
81
80
  converters: (HiddenDecl | Definitions | ModelConversion)[] = [];
82
81
  model: ProtoModel | undefined;
83
82
  isProofsEnabled = false;
83
+ isModelsEnabled = true;
84
84
  isCoresEnabled = false;
85
+ // As in Z3, it isn't copied with the goal.
86
+ reasonUnknown = "";
85
87
 
86
88
  constructor(readonly manager: AstManager) {
87
89
  this.forms = new RefVector(manager);
@@ -103,6 +105,7 @@ export class Goal {
103
105
  this.precision = getPrecisionUnion(source.precision, this.precision);
104
106
  this.converters = source.converters;
105
107
  this.isProofsEnabled = source.isProofsEnabled;
108
+ this.isModelsEnabled = source.isModelsEnabled;
106
109
  this.isCoresEnabled = source.isCoresEnabled;
107
110
  }
108
111
 
@@ -22,9 +22,10 @@ import {
22
22
  SORT_INT,
23
23
  SORT_REAL,
24
24
  } from "./ast";
25
- import { toPolynomial } from "./expr2polynomial";
25
+ import { Expr2Polynomial } from "./expr2polynomial";
26
26
  import { getLcm } from "./rational";
27
27
  import { flipKind } from "./nlsat/atoms";
28
+ import { Factors, type Polynomial, PolynomialRef } from "./nlsat/polynomial";
28
29
  import type { NlsatSolver } from "./nlsat/solver";
29
30
  import { TRANSCENDENTAL_OPS } from "./nlsat/transcendental-eval";
30
31
  import type { IneqKind } from "./nlsat/types";
@@ -39,38 +40,54 @@ export const goal2nlsat = (
39
40
  isFactoring = true,
40
41
  ) => {
41
42
  const pm = solver.pm;
43
+ const expr2poly = new Expr2Polynomial(manager, pm, t2x, (isInt) => solver.mkVar(isInt));
42
44
 
43
- const mkVar = (term: number) => {
44
- let variable = t2x.get(term);
45
- if (variable === undefined) {
46
- variable = solver.mkVar(manager.sorts[term] === SORT_INT);
47
- t2x.set(term, variable);
48
- }
49
- return variable;
45
+ const factorAtom = (polynomial: Polynomial, kind: IneqKind) => {
46
+ const factors = new Factors(pm);
47
+ pm.factor(polynomial, factors);
48
+ const literal = solver.mkIneqLiteral(
49
+ factors.constant < 0n ? flipKind(kind) : kind,
50
+ factors.factors,
51
+ factors.degrees.map((degree) => degree % 2 === 0),
52
+ );
53
+ factors.reset();
54
+ return literal;
50
55
  };
51
56
 
52
- const processIneq = (atom: number, kind: IneqKind) => {
53
- const lhs = toPolynomial(manager, pm, manager.getArg(atom, 0), mkVar);
54
- const rhs = toPolynomial(manager, pm, manager.getArg(atom, 1), mkVar);
55
- const lcm = getLcm(lhs.denominator, rhs.denominator);
56
- const polynomial = pm.addmul(
57
- lcm / lhs.denominator,
58
- lhs.polynomial,
59
- -(lcm / rhs.denominator),
60
- rhs.polynomial,
61
- );
57
+ const processIneqPolynomial = (p: PolynomialRef, kind: IneqKind) => {
58
+ const polynomial = p.get();
62
59
  if (pm.isConst(polynomial)) {
63
60
  const sign = pm.isZero(polynomial) ? 0 : polynomial.as[0] > 0n ? 1 : -1;
64
61
  const isTrue = kind === "EQ" ? sign === 0 : kind === "LT" ? sign < 0 : sign > 0;
65
62
  return isTrue ? 0 : 1;
66
63
  }
67
- if (!isFactoring) return solver.mkIneqLiteral(kind, [polynomial], [false]);
68
- const factors = pm.factor(polynomial);
69
- return solver.mkIneqLiteral(
70
- factors.constant < 0n ? flipKind(kind) : kind,
71
- factors.factors,
72
- factors.degrees.map((degree) => degree % 2 === 0),
64
+ return isFactoring
65
+ ? factorAtom(polynomial, kind)
66
+ : solver.mkIneqLiteral(kind, [polynomial], [false]);
67
+ };
68
+
69
+ const processIneq = (atom: number, kind: IneqKind) => {
70
+ const first = new PolynomialRef(pm);
71
+ const second = new PolynomialRef(pm);
72
+ const p = new PolynomialRef(pm);
73
+ const firstDenominator = expr2poly.toPolynomial(manager.getArg(atom, 0), first);
74
+ const secondDenominator = expr2poly.toPolynomial(manager.getArg(atom, 1), second);
75
+ const lcm = getLcm(firstDenominator, secondDenominator);
76
+ p.set(
77
+ pm.addmulTerms(
78
+ lcm / firstDenominator,
79
+ pm.unit,
80
+ first.get(),
81
+ -(lcm / secondDenominator),
82
+ pm.unit,
83
+ second.get(),
84
+ ),
73
85
  );
86
+ const literal = processIneqPolynomial(p, kind);
87
+ p.reset();
88
+ second.reset();
89
+ first.reset();
90
+ return literal;
74
91
  };
75
92
 
76
93
  const processBoolVar = (atom: number) => {
@@ -129,20 +146,29 @@ export const goal2nlsat = (
129
146
  // The polynomial conversion treats a transcendental application, argument included, as one
130
147
  // variable, so its argument gets a variable here, through an equation unless it is one already.
131
148
  const mkArgVar = (term: number) => {
132
- const result = toPolynomial(manager, pm, term, mkVar);
133
- const polynomial = result.polynomial;
149
+ const p = new PolynomialRef(pm);
150
+ const denominator = expr2poly.toPolynomial(term, p);
151
+ const polynomial = p.get();
134
152
  const monomial = polynomial.ms[0];
135
153
  if (
136
- result.denominator === 1n &&
154
+ denominator === 1n &&
137
155
  polynomial.ms.length === 1 &&
138
156
  polynomial.as[0] === 1n &&
139
157
  monomial.size === 1 &&
140
158
  monomial.degrees[0] === 1
141
- )
159
+ ) {
160
+ p.reset();
142
161
  return monomial.vars[0];
162
+ }
143
163
  const variable = solver.mkVar(false);
144
- const equation = pm.addmul(result.denominator, pm.mkVar(variable), -1n, polynomial);
145
- solver.mkExternalClause([solver.mkIneqLiteral("EQ", [equation], [false])], null);
164
+ const vp = new PolynomialRef(pm);
165
+ const equation = new PolynomialRef(pm);
166
+ vp.set(pm.mkVar(variable));
167
+ equation.set(pm.addmulTerms(denominator, pm.unit, vp.get(), -1n, pm.unit, polynomial));
168
+ solver.mkExternalClause([solver.mkIneqLiteral("EQ", [equation.get()], [false])], null);
169
+ equation.reset();
170
+ vp.reset();
171
+ p.reset();
146
172
  return variable;
147
173
  };
148
174
 
@@ -174,6 +200,7 @@ export const goal2nlsat = (
174
200
  }
175
201
  }
176
202
  if (piVar !== undefined) solver.transcendentals.addPi(piVar);
203
+ expr2poly.release();
177
204
  };
178
205
 
179
206
  const hasTermIte = (manager: AstManager, form: number) => {
@@ -163,6 +163,10 @@ export class ObjHashtable {
163
163
  this.map.delete(key);
164
164
  }
165
165
 
166
+ clear() {
167
+ this.map.clear();
168
+ }
169
+
166
170
  [Symbol.iterator]() {
167
171
  return this.map.keys();
168
172
  }
@@ -172,7 +172,7 @@ export abstract class Internalizer {
172
172
  falseEnode: Enode;
173
173
  protected generation = 0;
174
174
  protected cachedGeneration = new Map<number, number>();
175
- private randomSeed = 0;
175
+ protected randomSeed = 0;
176
176
  isSearching = false;
177
177
  config = DEFAULT_CONFIG;
178
178
 
@@ -19,7 +19,8 @@ const QFLIA_PREAMBLE =
19
19
  ":lia2card.max_range 1 :lia2card.max_ite_nesting 1) elim-uncnstr)";
20
20
 
21
21
  const getNoCutSmt = (seed: number) =>
22
- `(using-params smt :smt.logic QF_LIA :arith.branch_cut_ratio 10000000 :random_seed ${seed})`;
22
+ `(using-params smt :auto_config false :smt.logic QF_LIA :arith.branch_cut_ratio 10000000 ` +
23
+ `:random_seed ${seed})`;
23
24
 
24
25
  const LIA2SAT =
25
26
  "(and-then (fail-if is-unbounded) (fail-if produce-proofs) (fail-if produce-unsat-cores) " +
@@ -42,7 +43,8 @@ const PB =
42
43
 
43
44
  const BOUNDED =
44
45
  `(and-then (fail-if is-unbounded) (or-else (try-for ${getNoCutSmt(100)} 5000) (try-for ` +
45
- "(using-params smt :arith.branch_cut_ratio 10000000 :random_seed 200 :relevancy 0) 5000) " +
46
+ "(using-params smt :auto_config false :arith.branch_cut_ratio 10000000 :random_seed 200 " +
47
+ ":relevancy 0) 5000) " +
46
48
  `(try-for ${getNoCutSmt(300)} 15000)) fail-if-undecided)`;
47
49
 
48
50
  const QFLIA =
@@ -81,8 +83,8 @@ const getQfnraSolver = (solver: QfnraSolver) =>
81
83
  `${solver.simpleCheck})`,
82
84
  ...(solver.heuristic === undefined ? [] : [`(try-for ${QFNRA_NLSAT} ${solver.heuristic})`]),
83
85
  ...solver.orders.map(
84
- ([strategy, limit]) =>
85
- `(try-for (using-params ${QFNRA_NLSAT} :variable_ordering_strategy ${strategy}) ${limit})`,
86
+ (order) =>
87
+ `(try-for (using-params ${QFNRA_NLSAT} :variable_ordering_strategy ${order[0]}) ${order[1]})`,
86
88
  ),
87
89
  `(using-params smt :use_ls true :ls_time ${solver.ls})`,
88
90
  `(and-then (try-for (using-params smt :arith.greatest_error_pivot true) ${solver.smt}) ` +
@@ -223,7 +225,8 @@ const UFBV_PREPROCESSOR =
223
225
  `(and-then ${DER_FP} simplify) simplify)`;
224
226
 
225
227
  const UFBV =
226
- `(using-params (and-then (repeat ${UFBV_PREPROCESSOR} 2) smt) :mbqi true ` +
228
+ `(using-params (and-then (repeat ${UFBV_PREPROCESSOR} 2) (using-params smt :auto_config false)) ` +
229
+ ":mbqi true " +
227
230
  ":mbqi.max_iterations 4294967295 :elim_and true)";
228
231
 
229
232
  const QFBV_PREAMBLE =
@@ -256,6 +259,12 @@ export const QFUFBV_ACKR_PREAMBLE =
256
259
  ":pull_cheap_ite true :push_ite_bv false :local_ctx true :local_ctx_limit 10000000 " +
257
260
  ":ite_extra_rules true :mul2concat true :flat_and_or false))";
258
261
 
262
+ const QFUFBV =
263
+ "(using-params (and-then (and-then (using-params simplify :flat_and_or false) (using-params " +
264
+ "propagate-values :flat_and_or false) solve-eqs elim-uncnstr (if-no-proofs (if-no-unsat-cores " +
265
+ "reduce-args)) (if-no-proofs (if-no-unsat-cores reduce-bv-size)) max-bv-sharing (if-no-proofs " +
266
+ "(if-no-unsat-cores ackermannize_bv))) (if is-qfbv qfbv smt)) :elim_and true :blast_distinct true)";
267
+
259
268
  const QFAUFLIA =
260
269
  "(and-then (using-params (and-then simplify propagate-values solve-eqs elim-uncnstr simplify) " +
261
270
  ":elim_and true :som true :sort_store true) (using-params smt :array.simplify false))";
@@ -302,6 +311,7 @@ export const LOGIC_TACTICS: ReadonlyMap<string, string> = new Map([
302
311
  ["bv", UFBV],
303
312
  ["qfbv", QFBV],
304
313
  ["qfaufbv", QFAUFBV],
314
+ ["qfufbv", QFUFBV],
305
315
  ["qfauflia", QFAUFLIA],
306
316
  ["qfuf", QFUF],
307
317
  ["qffp", QFFP],
@@ -159,7 +159,7 @@ interface HashLink<V> {
159
159
  }
160
160
 
161
161
  interface HashNode<V> extends HashLink<V> {
162
- readonly value: V;
162
+ value: V;
163
163
  }
164
164
 
165
165
  const constrainHash = (hash: number, count: number) =>
@@ -197,6 +197,12 @@ export class UnorderedUintMap<V> {
197
197
  for (let node = this.anchor.next; node !== null; node = node.next) yield [node.key, node.value];
198
198
  }
199
199
 
200
+ set(key: number, value: V) {
201
+ const node = this.nodes.get(key);
202
+ if (node === undefined) this.insert(key, value);
203
+ else node.value = value;
204
+ }
205
+
200
206
  insert(key: number, value: V) {
201
207
  const node: HashNode<V> = { key, value, next: null };
202
208
  const count = this.buckets.length;
@@ -426,11 +426,16 @@ export class CoreSolver {
426
426
  this.status = LP_INFEASIBLE;
427
427
  return;
428
428
  }
429
- if (this.settings.isCanceled()) {
429
+ const entering = enteringCell.column;
430
+ const matrix = this.matrix;
431
+ if (
432
+ this.settings.isCanceled(
433
+ matrix.rows[this.heading[leaving]].length * matrix.columns[entering].length,
434
+ )
435
+ ) {
430
436
  this.status = LP_CANCELLED;
431
437
  return;
432
438
  }
433
- const entering = enteringCell.column;
434
439
  const newValue = this.getValForLeaving(leaving);
435
440
  const theta = this.x[leaving].sub(newValue).div(enteringCell.coeff);
436
441
  this.x[leaving] = newValue;
@@ -461,12 +466,11 @@ export class CoreSolver {
461
466
  return;
462
467
  }
463
468
  this.oneIterationTableauRows();
464
- } while (
465
- this.status !== LP_OPTIMAL &&
466
- this.status !== LP_INFEASIBLE &&
467
- this.status !== LP_CANCELLED &&
468
- !this.isFeasible()
469
- );
469
+ if (this.settings.isCanceled()) {
470
+ this.status = LP_CANCELLED;
471
+ break;
472
+ }
473
+ } while (this.status !== LP_OPTIMAL && this.status !== LP_INFEASIBLE && !this.isFeasible());
470
474
  }
471
475
 
472
476
  solve() {
@@ -1,5 +1,3 @@
1
- // Deviation from Z3: the occurrence map iterates in insertion order where Z3 has an unordered_map,
2
- // so an extracted common factor may list its variables in another order.
3
1
  import { Rational } from "../rational";
4
2
  import {
5
3
  type Nex,
@@ -146,7 +144,7 @@ export class CrossNested {
146
144
  private getVarsFromOccurencesMap() {
147
145
  const occurences = this.nexCreator.occurencesMap;
148
146
  const isRandomBit = this.nextRandom() % 2 === 1;
149
- return [...occurences.keys()].sort((first, second) => {
147
+ return Array.from(occurences, (entry) => entry[0]).sort((first, second) => {
150
148
  const firstOcc = occurences.get(first);
151
149
  const secondOcc = occurences.get(second);
152
150
  if (firstOcc === undefined || secondOcc === undefined) return 0;
@@ -100,7 +100,7 @@ export class LarSolver {
100
100
  onAddTerm: ((term: LarTerm) => void) | undefined;
101
101
  onColumnBoundUpdate: ((column: number) => void) | undefined;
102
102
 
103
- constructor(isCanceled: () => boolean) {
103
+ constructor(isCanceled: (cost?: number) => boolean) {
104
104
  this.settings = new LpSettings(isCanceled);
105
105
  this.core = new CoreSolver(this.settings);
106
106
  this.core.touchedRows = this.touchedRows;
@@ -54,7 +54,7 @@ export class LpSettings {
54
54
  nraCalls: 0,
55
55
  };
56
56
  readonly maxRowLengthForBoundPropagation = 300;
57
- readonly isPropagatingEqs = true;
57
+ isPropagatingEqs = true;
58
58
  readonly intFindCubePeriod = 4;
59
59
  readonly lcubeFlips = 16;
60
60
  readonly hnfCutPeriod = 4;
@@ -68,7 +68,11 @@ export class LpSettings {
68
68
  readonly isDioIgnoringBigNums = true;
69
69
  readonly dioUndoMaxWork = 1000000;
70
70
 
71
- constructor(readonly isCanceled: () => boolean) {}
71
+ constructor(readonly isCanceled: (cost?: number) => boolean) {}
72
+
73
+ setRandomSeed(seed: number) {
74
+ this.random = new RandomGen(seed);
75
+ }
72
76
 
73
77
  getRandomNext(bound?: number) {
74
78
  const value = this.random.next();
@@ -1,4 +1,5 @@
1
1
  import { Rational } from "../rational";
2
+ import { UnorderedUintMap } from "./containers";
2
3
  import {
3
4
  type Nex,
4
5
  type NexMul,
@@ -24,8 +25,8 @@ interface MapEntry<Value> {
24
25
  }
25
26
 
26
27
  export class NexCreator {
27
- readonly occurencesMap = new Map<number, Occ>();
28
- readonly powers = new Map<number, number>();
28
+ readonly occurencesMap = new UnorderedUintMap<Occ>();
29
+ readonly powers = new UnorderedUintMap<number>();
29
30
  private activeVarsWeights: number[] = [];
30
31
 
31
32
  setNumberOfVars(count: number) {
@@ -1,4 +1,5 @@
1
1
  import { Rational } from "../rational";
2
+ import type { UnorderedUintMap } from "./containers";
2
3
 
3
4
  interface NexScalar {
4
5
  readonly kind: "scalar";
@@ -63,7 +64,7 @@ export const isALinearTerm = (sum: NexSum) => {
63
64
  return numberOfNonScalars > 1;
64
65
  };
65
66
 
66
- export const getPowersFromMul = (mul: NexMul, powers: Map<number, number>) => {
67
+ export const getPowersFromMul = (mul: NexMul, powers: UnorderedUintMap<number>) => {
67
68
  powers.clear();
68
69
  for (const child of mul.children)
69
70
  if (child.expr.kind === "var") powers.set(child.expr.variable, child.power);
@@ -1,5 +1,6 @@
1
1
  import { Rational } from "../rational";
2
2
  import { KIND_EQ, KIND_GE, KIND_GT, KIND_LE, KIND_LT, KIND_NE } from "./constraints";
3
+ import { NULL_LPVAR } from "./lar-solver";
3
4
  import { LarTerm } from "./lar-term";
4
5
  import type { NlaCore } from "./nla-core";
5
6
  import type { Factorization } from "./nla-factorization";
@@ -305,8 +306,52 @@ export class Basics {
305
306
  );
306
307
  }
307
308
 
308
- // Deviation from Z3: the monic-to-factor neutral lemma is left out because it never fires (nla_basics_lemmas.cpp).
309
+ private basicLemmaForMonNeutralMonicToFactorModelBased(
310
+ rooted: Monic,
311
+ factorization: Factorization,
312
+ ) {
313
+ const core = this.core;
314
+ const monicVar = core.emons.get(rooted.variable).variable;
315
+ const absMonicValue = core.val(monicVar).abs();
316
+ if (absMonicValue.isZero()) return;
317
+ let sameAbsVar = NULL_LPVAR;
318
+ let nonUnitVar = NULL_LPVAR;
319
+ let isAllInt = true;
320
+ for (const factor of factorization.factors) {
321
+ const lpVar = factor.variable;
322
+ isAllInt &&= core.varIsInt(lpVar);
323
+ // Z3 tests the factor's variable against null_lpvar, which never holds, so the lemma never fires.
324
+ if (lpVar === NULL_LPVAR && core.valFactor(factor).abs().equals(absMonicValue))
325
+ sameAbsVar = lpVar;
326
+ else if (!core.valFactor(factor).abs().equals(Rational.one)) nonUnitVar = lpVar;
327
+ }
328
+ if (sameAbsVar === NULL_LPVAR || nonUnitVar === NULL_LPVAR) return;
329
+ if (!isAllInt && factorization.factors.length > 2) return;
330
+ const lemma = new LemmaBuilder(core);
331
+ lemma.addIneq(mkIneq(monicVar, KIND_EQ, 0));
332
+ lemma.addIneq(
333
+ mkIneq(
334
+ new LarTerm([
335
+ [sameAbsVar, Rational.one],
336
+ [
337
+ monicVar,
338
+ core.val(sameAbsVar).equals(core.val(monicVar).neg())
339
+ ? Rational.one
340
+ : Rational.minusOne,
341
+ ],
342
+ ]),
343
+ KIND_NE,
344
+ 0,
345
+ ),
346
+ );
347
+ lemma.addIneq(mkIneq(nonUnitVar, KIND_EQ, 1));
348
+ lemma.addIneq(mkIneq(nonUnitVar, KIND_EQ, -1));
349
+ lemma.explainMonic(rooted);
350
+ lemma.explainFactorization(factorization);
351
+ }
352
+
309
353
  private basicLemmaForMonNeutralModelBased(rooted: Monic, factorization: Factorization) {
354
+ this.basicLemmaForMonNeutralMonicToFactorModelBased(rooted, factorization);
310
355
  if (factorization.mon !== null)
311
356
  this.basicLemmaForMonNeutralFromFactorsToMonicModelBasedFm(factorization.mon);
312
357
  else this.basicLemmaForMonNeutralFromFactorsToMonicModelBased(rooted, factorization);
@@ -1,5 +1,6 @@
1
+ import { SmtInvariantError } from "../../../../errors";
1
2
  import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
2
- import type { ResourceLimit } from "../rlimit";
3
+ import { ResourceLimit } from "../rlimit";
3
4
  import { Rational } from "../rational";
4
5
  import { IndexedUintSet } from "./containers";
5
6
  import { COLUMN_BOXED, COLUMN_FIXED, COLUMN_FREE, COLUMN_LOWER, COLUMN_UPPER } from "./core-solver";
@@ -143,6 +144,7 @@ export class NlaCore {
143
144
  private readonly patcher: Patcher;
144
145
  private readonly horner: Horner;
145
146
  readonly grobner: Grobner;
147
+ readonly nraLimit = new ResourceLimit(Infinity);
146
148
  readonly nra = new NraSolver(this);
147
149
  readonly transcendentals = new NlaTranscendentals(this);
148
150
  isUsingNraModel = false;
@@ -150,6 +152,9 @@ export class NlaCore {
150
152
  private checkAssignmentFailCount = 0;
151
153
  private squeezeSchedule = new SqueezeSchedule();
152
154
  isRelevant: (lpVar: number) => boolean = () => true;
155
+ addMulDefHook: (vars: number[]) => number = () => {
156
+ throw new SmtInvariantError("nla has no hook to define a product");
157
+ };
153
158
 
154
159
  constructor(
155
160
  readonly lra: LarSolver,
@@ -344,6 +349,12 @@ export class NlaCore {
344
349
  this.monicsWithChangedBounds.add(lpVar);
345
350
  }
346
351
 
352
+ addMulDef(vars: number[]) {
353
+ const lpVar = this.addMulDefHook(vars);
354
+ this.addMonic(lpVar, vars);
355
+ return lpVar;
356
+ }
357
+
347
358
  checkMonic(monic: Monic) {
348
359
  const value = this.lra.getValue(monic.variable);
349
360
  if (this.lra.isInt(monic.variable) && !value.x.isInt()) return true;
@@ -757,7 +768,9 @@ export class NlaCore {
757
768
  NLA_PARAMS.nraCheckAssignment &&
758
769
  this.checkAssignmentFailCount < NLA_PARAMS.nraCheckAssignmentMaxFail
759
770
  ) {
771
+ this.limit.pushChild(this.nraLimit);
760
772
  result = this.nra.checkAssignment();
773
+ this.limit.popChild(this.nraLimit);
761
774
  if (result !== L_TRUE) this.checkAssignmentFailCount++;
762
775
  }
763
776
  if (hasNoEffect() && this.shouldRunBoundedNlsat()) result = this.boundedNlsat();
@@ -777,10 +790,12 @@ export class NlaCore {
777
790
  result = this.boundedNlsat();
778
791
  }
779
792
  if (hasNoEffect() && NLA_PARAMS.nra && level >= 2) {
780
- result = this.nra.check(Infinity, Infinity);
793
+ this.limit.pushChild(this.nraLimit);
794
+ result = this.nra.check(Infinity);
795
+ this.limit.popChild(this.nraLimit);
781
796
  stats.nraCalls++;
782
797
  }
783
- if (result === L_UNDEF && !hasNoEffect()) result = L_FALSE;
798
+ if (result === L_UNDEF && !hasNoEffect() && this.limit.inc()) result = L_FALSE;
784
799
  stats.nlaLemmas += this.lemmas.length;
785
800
  return result;
786
801
  }
@@ -790,10 +805,15 @@ export class NlaCore {
790
805
  }
791
806
 
792
807
  private boundedNlsat() {
793
- const budget = 100000;
794
- const result = this.nra.check(100, budget);
808
+ const rlimitBudget = 100000;
809
+ this.limit.pushChild(this.nraLimit);
810
+ this.nraLimit.push(rlimitBudget);
811
+ const result = this.nra.check(100);
812
+ const rlimitConsumed = this.nraLimit.count;
813
+ this.nraLimit.pop();
814
+ this.limit.popChild(this.nraLimit);
795
815
  this.stats.nraCalls++;
796
- this.nlsatBackoff.update(result === L_FALSE || this.nra.steps < budget / 10);
816
+ this.nlsatBackoff.update(result === L_FALSE || rlimitConsumed < rlimitBudget / 10);
797
817
  if (result === L_TRUE) this.clear();
798
818
  return result;
799
819
  }