tla-ts 0.0.10-dev.99796fe03 → 0.0.10-dev.a17d6d9fa

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 (226) 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 +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +3 -2
  7. package/dist/index.d.ts +3 -2
  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 +60 -60
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -44
  16. package/dist/run.js +44 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +43 -43
  20. package/dist/transfer.js +39 -39
  21. package/dist/worker.cjs +6 -6
  22. package/dist/worker.js +6 -6
  23. package/package.json +1 -1
  24. package/src/ast.ts +1 -0
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +1 -1
  28. package/src/check-trace.ts +90 -51
  29. package/src/check.ts +367 -178
  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 +1 -2
  33. package/src/cli/tlc.ts +16 -10
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +26 -9
  36. package/src/dependencies.ts +49 -9
  37. package/src/dfid.ts +22 -10
  38. package/src/environment.ts +58 -33
  39. package/src/errors.ts +7 -0
  40. package/src/evaluate.ts +117 -41
  41. package/src/exit-codes.ts +4 -2
  42. package/src/instances.ts +5 -5
  43. package/src/java-hash.ts +14 -0
  44. package/src/java-overrides.ts +2 -2
  45. package/src/levels.ts +138 -90
  46. package/src/liveness-checker.ts +81 -33
  47. package/src/liveness.ts +49 -11
  48. package/src/obligations/index.ts +1 -1
  49. package/src/obligations/normalize.ts +1 -4
  50. package/src/obligations/printer.ts +5 -5
  51. package/src/parallel-worker.ts +8 -2
  52. package/src/parallel.ts +5 -0
  53. package/src/parser.ts +112 -145
  54. package/src/prover/isabelle/isar/attrib.ts +4 -4
  55. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  56. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  57. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  58. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  59. package/src/prover/isabelle/pure/term.ts +3 -3
  60. package/src/prover/prep/md5.ts +26 -29
  61. package/src/prover/smt/rewrite.ts +2 -7
  62. package/src/prover/smt/simplify.ts +1 -1
  63. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  64. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  65. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  66. package/src/prover/smt/solver/ast-lt.ts +1 -1
  67. package/src/prover/smt/solver/ast.ts +63 -14
  68. package/src/prover/smt/solver/auf-solver.ts +23 -12
  69. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  70. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  71. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  72. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  73. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  74. package/src/prover/smt/solver/card2bv.ts +32 -18
  75. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  76. package/src/prover/smt/solver/context.ts +47 -9
  77. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  78. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  79. package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
  80. package/src/prover/smt/solver/diff-neq.ts +1 -2
  81. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  82. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  83. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  84. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  87. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  88. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  89. package/src/prover/smt/solver/euf/mam.ts +1 -5
  90. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  91. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  92. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  93. package/src/prover/smt/solver/factor.ts +36 -14
  94. package/src/prover/smt/solver/fd-solver.ts +2 -0
  95. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  96. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  97. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  98. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  99. package/src/prover/smt/solver/goal.ts +6 -3
  100. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  101. package/src/prover/smt/solver/hashtable.ts +4 -0
  102. package/src/prover/smt/solver/internalizer.ts +1 -1
  103. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  104. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  105. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  106. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  107. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  108. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  109. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  110. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  111. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  112. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  113. package/src/prover/smt/solver/model-generator.ts +85 -43
  114. package/src/prover/smt/solver/mpf.ts +2 -4
  115. package/src/prover/smt/solver/mus.ts +2 -3
  116. package/src/prover/smt/solver/muz/dl-context.ts +10 -4
  117. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  118. package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
  119. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  120. package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
  121. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  122. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  123. package/src/prover/smt/solver/nlqsat.ts +1 -1
  124. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  125. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  126. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  127. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  128. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  129. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  130. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  131. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  132. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  133. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  134. package/src/prover/smt/solver/nnf.ts +6 -2
  135. package/src/prover/smt/solver/opt-context.ts +20 -7
  136. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  137. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  138. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  139. package/src/prover/smt/solver/opt-solver.ts +9 -5
  140. package/src/prover/smt/solver/optsmt.ts +1 -1
  141. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  142. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  143. package/src/prover/smt/solver/probes.ts +88 -23
  144. package/src/prover/smt/solver/proto-model.ts +8 -8
  145. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  146. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  147. package/src/prover/smt/solver/qe-lite.ts +2 -2
  148. package/src/prover/smt/solver/qe.ts +3 -2
  149. package/src/prover/smt/solver/qsat.ts +16 -6
  150. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  151. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  152. package/src/prover/smt/solver/rewriter.ts +31 -25
  153. package/src/prover/smt/solver/rlimit.ts +4 -0
  154. package/src/prover/smt/solver/sat/config.ts +1 -1
  155. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  156. package/src/prover/smt/solver/sat/inc-sat-solver.ts +39 -5
  157. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  158. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  159. package/src/prover/smt/solver/sat/sat-tactic.ts +13 -5
  160. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  161. package/src/prover/smt/solver/sat/solver.ts +25 -47
  162. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  163. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  164. package/src/prover/smt/solver/seq-derive.ts +2 -2
  165. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  166. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  167. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  168. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  169. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  170. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  171. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  172. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  173. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  174. package/src/prover/smt/solver/smt-kernel.ts +39 -5
  175. package/src/prover/smt/solver/smt-setup.ts +96 -10
  176. package/src/prover/smt/solver/smtlib-parser.ts +584 -223
  177. package/src/prover/smt/solver/smtlib-script.ts +509 -154
  178. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  179. package/src/prover/smt/solver/solver.ts +18 -3
  180. package/src/prover/smt/solver/tactic.ts +284 -168
  181. package/src/prover/smt/solver/theory-bv.ts +13 -3
  182. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  183. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  184. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  185. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  186. package/src/prover/smt/solver/theory-lra.ts +1 -1
  187. package/src/prover/smt/solver/theory-pb.ts +24 -7
  188. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  189. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  190. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  191. package/src/prover/tlapm/cache.ts +8 -8
  192. package/src/prover/zenon/index-table.ts +5 -2
  193. package/src/prover/zenon/isar-case.ts +1 -1
  194. package/src/prover/zenon/isar.ts +2 -2
  195. package/src/prover/zenon/phrase.ts +1 -1
  196. package/src/resolve.ts +959 -243
  197. package/src/runtime.ts +7 -1
  198. package/src/sany/builtins.ts +10 -10
  199. package/src/sany/generation.ts +2 -13
  200. package/src/sany/generator-definitions.ts +3 -1
  201. package/src/sany/generator-expressions.ts +36 -30
  202. package/src/sany/generator-proofs.ts +5 -3
  203. package/src/sany/generator.ts +2 -1
  204. package/src/sany/lexer.ts +3 -3
  205. package/src/sany/modules.ts +4 -2
  206. package/src/sany/nodes.ts +1 -1
  207. package/src/sany/selectors.ts +11 -6
  208. package/src/sany/xml.ts +2 -3
  209. package/src/search.ts +166 -101
  210. package/src/simulate.ts +110 -50
  211. package/src/spec-description.ts +5 -6
  212. package/src/standard-modules.ts +15 -6
  213. package/src/subexpressions.ts +398 -108
  214. package/src/successors.ts +4 -2
  215. package/src/symmetry.ts +1 -1
  216. package/src/tlc/jar-data.ts +10 -0
  217. package/src/tlc/messages.ts +3 -3
  218. package/src/tlc/order.ts +14 -3
  219. package/src/tlc/random.ts +2 -1
  220. package/src/tlc/replay.ts +3 -2
  221. package/src/tlc/tlc-operators.ts +10 -8
  222. package/src/tlc/tlcext-operators.ts +44 -15
  223. package/src/tlc/trace-spec.ts +9 -22
  224. package/src/typed-tier.ts +32 -25
  225. package/src/typescript/types.ts +2 -2
  226. package/src/values.ts +135 -78
@@ -81,8 +81,8 @@ const getQfnraSolver = (solver: QfnraSolver) =>
81
81
  `${solver.simpleCheck})`,
82
82
  ...(solver.heuristic === undefined ? [] : [`(try-for ${QFNRA_NLSAT} ${solver.heuristic})`]),
83
83
  ...solver.orders.map(
84
- ([strategy, limit]) =>
85
- `(try-for (using-params ${QFNRA_NLSAT} :variable_ordering_strategy ${strategy}) ${limit})`,
84
+ (order) =>
85
+ `(try-for (using-params ${QFNRA_NLSAT} :variable_ordering_strategy ${order[0]}) ${order[1]})`,
86
86
  ),
87
87
  `(using-params smt :use_ls true :ls_time ${solver.ls})`,
88
88
  `(and-then (try-for (using-params smt :arith.greatest_error_pivot true) ${solver.smt}) ` +
@@ -256,6 +256,12 @@ export const QFUFBV_ACKR_PREAMBLE =
256
256
  ":pull_cheap_ite true :push_ite_bv false :local_ctx true :local_ctx_limit 10000000 " +
257
257
  ":ite_extra_rules true :mul2concat true :flat_and_or false))";
258
258
 
259
+ const QFUFBV =
260
+ "(using-params (and-then (and-then (using-params simplify :flat_and_or false) (using-params " +
261
+ "propagate-values :flat_and_or false) solve-eqs elim-uncnstr (if-no-proofs (if-no-unsat-cores " +
262
+ "reduce-args)) (if-no-proofs (if-no-unsat-cores reduce-bv-size)) max-bv-sharing (if-no-proofs " +
263
+ "(if-no-unsat-cores ackermannize_bv))) (if is-qfbv qfbv smt)) :elim_and true :blast_distinct true)";
264
+
259
265
  const QFAUFLIA =
260
266
  "(and-then (using-params (and-then simplify propagate-values solve-eqs elim-uncnstr simplify) " +
261
267
  ":elim_and true :som true :sort_store true) (using-params smt :array.simplify false))";
@@ -302,6 +308,7 @@ export const LOGIC_TACTICS: ReadonlyMap<string, string> = new Map([
302
308
  ["bv", UFBV],
303
309
  ["qfbv", QFBV],
304
310
  ["qfaufbv", QFAUFBV],
311
+ ["qfufbv", QFUFBV],
305
312
  ["qfauflia", QFAUFLIA],
306
313
  ["qfuf", QFUF],
307
314
  ["qffp", QFFP],
@@ -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;
@@ -70,6 +70,10 @@ export class LpSettings {
70
70
 
71
71
  constructor(readonly isCanceled: () => boolean) {}
72
72
 
73
+ setRandomSeed(seed: number) {
74
+ this.random = new RandomGen(seed);
75
+ }
76
+
73
77
  getRandomNext(bound?: number) {
74
78
  const value = this.random.next();
75
79
  return bound === undefined ? value : value % bound;
@@ -795,7 +795,7 @@ export class NlaCore {
795
795
  this.limit.popChild(this.nraLimit);
796
796
  stats.nraCalls++;
797
797
  }
798
- if (result === L_UNDEF && !hasNoEffect()) result = L_FALSE;
798
+ if (result === L_UNDEF && !hasNoEffect() && this.limit.inc()) result = L_FALSE;
799
799
  stats.nlaLemmas += this.lemmas.length;
800
800
  return result;
801
801
  }
@@ -919,12 +919,12 @@ export class Grobner {
919
919
  private setLevel2var() {
920
920
  const core = this.core;
921
921
  const count = core.lra.getColumnCount();
922
- const weights = Array.from({ length: count }, (_, lpVar) => core.getVarWeight(lpVar));
922
+ const weights = Array.from({ length: count }, (_value, lpVar) => core.getVarWeight(lpVar));
923
923
  for (let lpVar = 0; lpVar < count; lpVar++) {
924
924
  if (!core.isMonicVar(lpVar) || !core.toRefine.has(lpVar)) continue;
925
925
  for (const factor of core.emons.get(lpVar).vars) weights[factor] += 6;
926
926
  }
927
- const level2var = Array.from({ length: count }, (_, lpVar) => lpVar).sort(
927
+ const level2var = Array.from({ length: count }, (_value, lpVar) => lpVar).sort(
928
928
  (first, second) => weights[first] - weights[second] || first - second,
929
929
  );
930
930
  this.manager.reset(level2var);
@@ -1,9 +1,9 @@
1
- import { NlsatUnsupportedError, SmtCanceledError, SmtInvariantError } from "../../../../errors";
1
+ import { SmtCanceledError, SmtInvariantError } from "../../../../errors";
2
2
  import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
3
3
  import { Rational, getLcm } from "../rational";
4
4
  import { Anum } from "../nlsat/algebraic";
5
5
  import { NlsatSolver } from "../nlsat/solver";
6
- import type { Polynomial } from "../nlsat/polynomial";
6
+ import { type Polynomial, PolynomialRef, PolynomialRefVector } from "../nlsat/polynomial";
7
7
  import { isIneqAtom } from "../nlsat/types";
8
8
  import {
9
9
  KIND_EQ,
@@ -92,13 +92,15 @@ const isDyadicArtifact = (lra: LarSolver, constraint: LarConstraint) =>
92
92
  getConstraintCoeffs(lra, constraint).some((entry) => hasLargeDyadicDenominator(entry[1])));
93
93
 
94
94
  export class NraSolver {
95
- private solver = new NlsatSolver();
95
+ private solver: NlsatSolver;
96
96
  private values: Anum[] = [];
97
97
  private lp2nl = new Map<number, number>();
98
98
  private literal2constraint = new Map<number, number>();
99
99
  private vars2mon = new Map<string, number>();
100
100
 
101
- constructor(private core: NlaCore) {}
101
+ constructor(private core: NlaCore) {
102
+ this.solver = new NlsatSolver(core.nraLimit);
103
+ }
102
104
 
103
105
  get am() {
104
106
  return this.solver.am;
@@ -115,53 +117,48 @@ export class NraSolver {
115
117
  const lra = core.lra;
116
118
  const solver = this.solver;
117
119
  const pm = solver.pm;
118
- const definitions: (Polynomial | null)[] = [];
120
+ const definitions = new PolynomialRefVector(pm);
119
121
  const denominators: bigint[] = [];
122
+ const p = new PolynomialRef(pm);
123
+ const constant = new PolynomialRef(pm);
124
+ const product = new PolynomialRef(pm);
120
125
  for (let lpVar = 0; lpVar < lra.columns.length; lpVar++) {
121
126
  if (!isIncluded(lpVar)) {
122
- definitions.push(null);
127
+ definitions.push(pm.zero);
123
128
  denominators.push(0n);
124
129
  continue;
125
130
  }
126
131
  const variable = solver.mkVar(lra.isInt(lpVar));
127
132
  this.lp2nl.set(lpVar, variable);
133
+ let denominator = 1n;
128
134
  if (core.emons.isMonicVar(lpVar)) {
129
- let definition: Polynomial | null = null;
130
- let denominator = 1n;
131
- for (const factor of core.emons.get(lpVar).vars) {
135
+ for (const [index, factor] of core.emons.get(lpVar).vars.entries()) {
132
136
  denominator = denominators[factor] * denominator;
133
- definition =
134
- definition === null ? definitions[factor] : pm.mul(definition, definitions[factor]!);
137
+ p.set(index === 0 ? definitions.get(factor) : pm.mul(p.get(), definitions.get(factor)));
135
138
  }
136
- definitions.push(definition ?? pm.mkVar(variable));
137
- denominators.push(denominator);
138
- continue;
139
- }
140
- if (lra.hasTerm(lpVar)) {
139
+ } else if (lra.hasTerm(lpVar)) {
141
140
  const term = [...lra.getTerm(lpVar).coeffs];
142
- const denominator = term.reduce(
143
- (result, entry) => getLcm(entry[1].div(Rational.of(denominators[entry[0]])).den, result),
144
- 1n,
145
- );
146
- let definition: Polynomial | null = null;
147
- for (const entry of term) {
141
+ for (const entry of term)
142
+ denominator = getLcm(entry[1].div(Rational.of(denominators[entry[0]])).den, denominator);
143
+ for (const [index, entry] of term.entries()) {
148
144
  const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
149
- const scaled = pm.mul(pm.mkConst(coeff.num), definitions[entry[0]]!);
150
- definition = definition === null ? scaled : pm.add(definition, scaled);
145
+ constant.set(pm.mkConst(coeff.num));
146
+ product.set(pm.mul(constant.get(), definitions.get(entry[0])));
147
+ p.set(index === 0 ? product.get() : pm.add(p.get(), product.get()));
148
+ product.reset();
149
+ constant.reset();
151
150
  }
152
- definitions.push(definition ?? pm.zero);
153
- denominators.push(denominator);
154
- continue;
155
- }
156
- definitions.push(pm.mkVar(variable));
157
- denominators.push(1n);
151
+ } else p.set(pm.mkVar(variable));
152
+ definitions.push(p.getOrNull() ?? pm.zero);
153
+ denominators.push(denominator);
154
+ p.reset();
158
155
  }
159
156
  return { definitions, denominators };
160
157
  }
161
158
 
162
159
  private addConstraint(
163
160
  constraintIndex: number,
164
- definitions: readonly (Polynomial | null)[],
161
+ definitions: PolynomialRefVector,
165
162
  denominators: readonly bigint[],
166
163
  ) {
167
164
  const lra = this.core.lra;
@@ -174,23 +171,32 @@ export class NraSolver {
174
171
  (result, entry) => getLcm(result, entry[1].div(Rational.of(denominators[entry[0]])).den),
175
172
  rhs.den,
176
173
  );
177
- let polynomial = pm.mkConst(-(rhs.num * denominator) / rhs.den);
174
+ const p = new PolynomialRef(pm);
175
+ const poly = new PolynomialRef(pm);
176
+ const constant = new PolynomialRef(pm);
177
+ p.set(pm.mkConst(-(rhs.num * denominator) / rhs.den));
178
178
  for (const entry of coeffs) {
179
179
  const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
180
- polynomial = pm.add(polynomial, pm.mul(definitions[entry[0]]!, pm.mkConst(coeff.num)));
180
+ poly.set(definitions.get(entry[0]));
181
+ constant.set(pm.mkConst(coeff.num));
182
+ poly.set(pm.mul(poly.get(), constant.get()));
183
+ constant.reset();
184
+ p.set(pm.add(p.get(), poly.get()));
185
+ poly.reset();
181
186
  }
182
187
  const kind = constraint.kind;
183
188
  const literal =
184
189
  kind === KIND_LE
185
- ? solver.mkIneqLiteral("GT", [polynomial], [false]) ^ 1
190
+ ? solver.mkIneqLiteral("GT", [p.get()], [false]) ^ 1
186
191
  : kind === KIND_GE
187
- ? solver.mkIneqLiteral("LT", [polynomial], [false]) ^ 1
192
+ ? solver.mkIneqLiteral("LT", [p.get()], [false]) ^ 1
188
193
  : solver.mkIneqLiteral(
189
194
  kind === KIND_LT ? "LT" : kind === KIND_GT ? "GT" : "EQ",
190
- [polynomial],
195
+ [p.get()],
191
196
  [false],
192
197
  );
193
198
  solver.mkExternalClause([literal], constraintIndex);
199
+ p.reset();
194
200
  return literal;
195
201
  }
196
202
 
@@ -234,6 +240,7 @@ export class NraSolver {
234
240
  }
235
241
  this.addConstraint(constraintIndex, definitions.definitions, definitions.denominators);
236
242
  }
243
+ definitions.definitions.reset();
237
244
  this.registerTranscendentals();
238
245
  const result = this.solver.check();
239
246
  if (result === L_TRUE) {
@@ -344,6 +351,7 @@ export class NraSolver {
344
351
  );
345
352
  this.literal2constraint.set(literal, constraintIndex);
346
353
  }
354
+ definitions.definitions.reset();
347
355
  this.registerTranscendentals();
348
356
  }
349
357
 
@@ -356,7 +364,7 @@ export class NraSolver {
356
364
  for (let index = 0; index < polynomial.size; index++) {
357
365
  const monomial = polynomial.ms[index];
358
366
  const coeff = Rational.of(polynomial.as[index]);
359
- // A linear cell leaves every new lemma polynomial linear, so like Z3 this ignores degrees.
367
+ // Like Z3, this drops degrees: only an axiom's ¬best can be nonlinear, and ¬cell is valid alone.
360
368
  if (monomial.size === 0) bound = bound.sub(coeff);
361
369
  else if (monomial.size === 1) term.addMonomial(coeff, nl2lp[monomial.vars[0]]);
362
370
  else {
@@ -377,8 +385,6 @@ export class NraSolver {
377
385
  try {
378
386
  return this.checkAssignmentCore();
379
387
  } catch (error) {
380
- // Deviation from Z3: a linear cell around an irrational section answers unknown, where Z3 exits.
381
- if (error instanceof NlsatUnsupportedError) return L_UNDEF;
382
388
  if (error instanceof SmtCanceledError && this.core.nraLimit.isExhausted()) return L_UNDEF;
383
389
  throw error;
384
390
  }
@@ -76,7 +76,7 @@ export class PddManager {
76
76
  private freezeValue = Rational.zero;
77
77
 
78
78
  constructor(numVars: number) {
79
- this.initNodes(Array.from({ length: numVars }, (_, index) => index));
79
+ this.initNodes(Array.from({ length: numVars }, (_value, index) => index));
80
80
  }
81
81
 
82
82
  reset(level2var: number[]) {
@@ -309,8 +309,7 @@ export class PddManager {
309
309
  if (this.level(this.firstLeading(q)) > this.level(p)) return p;
310
310
  break;
311
311
  }
312
- // Z3's op_entry equality compares the cached first operand with the new second one, so
313
- // only an operation on two equal operands finds its cached result.
312
+ // Z3's op_entry equality compares the cached first operand with the new second one, so only equal operands hit.
314
313
  // Deviation from Z3: on a hash collision Z3 returns that result for unequal operands too.
315
314
  const isCached = p === q;
316
315
  if (isCached) {
@@ -20,7 +20,7 @@ export class TrailStack {
20
20
  }
21
21
  }
22
22
 
23
- export interface UnionFindTrail {
23
+ interface UnionFindTrail {
24
24
  push(undo: () => void): void;
25
25
  }
26
26
 
@@ -72,7 +72,7 @@ export interface MamEnode<E> {
72
72
  }
73
73
 
74
74
  // The context that undoes a compiler's updates of shared code trees.
75
- export interface CompilerContext {
75
+ interface CompilerContext {
76
76
  readonly manager: AstManager;
77
77
  pushTrail(undo: () => void): void;
78
78
  }
@@ -28,7 +28,7 @@ export const DEF_ADD = 0;
28
28
  export const DEF_MUL = 1;
29
29
  export const DEF_DIV = 2;
30
30
  export const DEF_CONST = 3;
31
- export const DEF_VAR = 4;
31
+ const DEF_VAR = 4;
32
32
 
33
33
  interface AddDef {
34
34
  readonly kind: typeof DEF_ADD;
@@ -64,6 +64,8 @@ export class ModelEvaluator extends RewriterTpl {
64
64
  this.rewriter = new Rewriter(manager, {
65
65
  ...TACTIC_REWRITER_OPTIONS,
66
66
  bv: { ...DEFAULT_BV_OPTIONS, isHiDiv0: manager.isHiDiv0, isMkbv2num: true },
67
+ isExpandingSelects: true,
68
+ isKeepingDistinct: true,
67
69
  });
68
70
  this.rewriter.releaseResult = () => this.setLastResult(-1);
69
71
  }
@@ -2,7 +2,7 @@ import { FAMILY_BASIC, FAMILY_USER, SORT_BOOL } from "./ast";
2
2
  import type { Context } from "./context";
3
3
  import { Enode } from "./enode";
4
4
  import { FuncInterp, ProtoModel } from "./proto-model";
5
- import type { DependentValue } from "./theory";
5
+ import type { DependentValue, ExtraFreshValue } from "./theory";
6
6
 
7
7
  export interface GeneratedModel {
8
8
  model: ProtoModel;
@@ -19,6 +19,9 @@ const isIncludedFuncInterp = (context: Context, decl: number) => {
19
19
  return context.getTheory(family)?.includeFuncInterp(decl) ?? true;
20
20
  };
21
21
 
22
+ const GREY = 1;
23
+ const BLACK = 2;
24
+
22
25
  export const mkModel = (context: Context): GeneratedModel => {
23
26
  const manager = context.manager;
24
27
  const model = new ProtoModel(manager);
@@ -34,58 +37,95 @@ export const mkModel = (context: Context): GeneratedModel => {
34
37
  context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr,
35
38
  );
36
39
  }
37
- const root2value = new Map<Enode, number>();
38
- const freshRoots: Enode[] = [];
39
- const dependentValues = new Map<Enode, DependentValue>();
40
+ const roots: Enode[] = [];
41
+ const procs = new Map<Enode, number | DependentValue>();
42
+ const freshRoots = new Set<Enode>();
43
+ const extraFreshValues = new Set<ExtraFreshValue>();
40
44
  for (const node of context.enodes) {
41
45
  if (node.root !== node) continue;
42
46
  const expr = node.owner;
43
47
  if (!context.isRelevant(expr) && !manager.isValue(expr)) continue;
48
+ roots.push(node);
44
49
  const sort = manager.sorts[expr];
45
50
  const theory = context.getTheory(manager.getSortFamily(sort));
46
51
  if (sort === SORT_BOOL)
47
- root2value.set(node, context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr);
48
- else if (manager.isModelValue(expr)) root2value.set(node, expr);
52
+ procs.set(node, context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr);
53
+ else if (manager.isModelValue(expr)) procs.set(node, expr);
49
54
  else if (theory !== undefined && theory.buildModels()) {
50
- const value = node.getThVar(theory.id) < 0 ? undefined : theory.mkValue(node);
51
- if (value === undefined) freshRoots.push(node);
52
- else if (typeof value === "number")
53
- root2value.set(node, manager.isValue(expr) ? expr : value);
54
- else dependentValues.set(node, value);
55
- } else {
56
- const value = model.getFreshValue(sort) ?? model.getSomeValue(sort);
57
- root2value.set(node, manager.isValue(expr) ? expr : value);
58
- }
55
+ const proc = node.getThVar(theory.id) < 0 ? undefined : theory.mkValue(node);
56
+ if (proc === undefined) {
57
+ const freshValue: ExtraFreshValue = { sort, value: undefined };
58
+ freshRoots.add(node);
59
+ extraFreshValues.add(freshValue);
60
+ procs.set(node, { dependencies: [freshValue], mkValue: (values) => values[0] });
61
+ } else {
62
+ if (typeof proc !== "number")
63
+ for (const dependency of proc.dependencies)
64
+ if (!(dependency instanceof Enode)) extraFreshValues.add(dependency);
65
+ procs.set(node, proc);
66
+ }
67
+ } else procs.set(node, model.getFreshValue(sort) ?? model.getSomeValue(sort));
59
68
  }
60
- for (const value of root2value.values()) model.registerValue(value);
61
- // A value that depends on others comes after them, and before the fresh values of its sort.
62
- const getFreshValue = (node: Enode) => {
63
- const sort = manager.sorts[node.owner];
64
- const freshValue = model.getFreshValue(sort) ?? model.getSomeValue(sort);
65
- const value = manager.isValue(node.owner) ? node.owner : freshValue;
66
- root2value.set(node, value);
67
- return value;
69
+ const colors = new Map<Enode | ExtraFreshValue, number>();
70
+ const traversedSorts = new Set<number>();
71
+ const sortedSources: (Enode | ExtraFreshValue)[] = [];
72
+ const todo: (Enode | ExtraFreshValue)[] = [];
73
+ const visitChild = (source: Enode | ExtraFreshValue) => {
74
+ if (!colors.has(source)) todo.push(source);
68
75
  };
69
- const getDependentValue = (node: Enode): number => {
70
- const existing = root2value.get(node);
71
- if (existing !== undefined) return existing;
72
- const dependent = dependentValues.get(node);
73
- if (dependent === undefined) return getFreshValue(node);
74
- dependentValues.delete(node);
75
- const values = dependent.dependencies.map((dependency) => {
76
- if (dependency instanceof Enode) return getDependentValue(dependency.root);
77
- dependency.value ??=
78
- model.getFreshValue(dependency.sort) ?? model.getSomeValue(dependency.sort);
79
- return dependency.value;
80
- });
81
- // A class whose root is a value, such as a constant array, takes it after its dependencies.
82
- const value = manager.isValue(node.owner) ? node.owner : dependent.mkValue(values);
83
- model.registerValue(value);
84
- root2value.set(node, value);
85
- return value;
76
+ const processSource = (source: Enode | ExtraFreshValue) => {
77
+ if (colors.get(source) === BLACK) return;
78
+ todo.push(source);
79
+ while (todo.length > 0) {
80
+ const current = todo[todo.length - 1];
81
+ const color = colors.get(current);
82
+ if (color === BLACK) todo.pop();
83
+ else if (color === GREY) {
84
+ colors.set(current, BLACK);
85
+ sortedSources.push(current);
86
+ } else {
87
+ colors.set(current, GREY);
88
+ if (current instanceof Enode) {
89
+ const proc = procs.get(current);
90
+ if (proc !== undefined && typeof proc !== "number")
91
+ for (const dependency of proc.dependencies)
92
+ visitChild(dependency instanceof Enode ? dependency.root : dependency);
93
+ } else if (!traversedSorts.has(current.sort)) {
94
+ for (const root of roots)
95
+ if (manager.sorts[root.owner] === current.sort && !freshRoots.has(root))
96
+ visitChild(root);
97
+ traversedSorts.add(current.sort);
98
+ }
99
+ }
100
+ }
86
101
  };
87
- for (const node of dependentValues.keys()) getDependentValue(node);
88
- for (const node of freshRoots) if (!root2value.has(node)) getFreshValue(node);
102
+ for (const freshValue of extraFreshValues) processSource(freshValue);
103
+ for (const root of freshRoots) processSource(root);
104
+ for (const root of roots) processSource(root);
105
+ const root2value = new Map<Enode, number>();
106
+ for (const source of sortedSources) {
107
+ if (!(source instanceof Enode)) {
108
+ source.value = model.getFreshValue(source.sort) ?? undefined;
109
+ continue;
110
+ }
111
+ const expr = source.owner;
112
+ const sort = manager.sorts[expr];
113
+ const proc = procs.get(source) ?? model.getFreshValue(sort) ?? model.getSomeValue(sort);
114
+ const value = manager.isValue(expr)
115
+ ? expr
116
+ : typeof proc === "number"
117
+ ? proc
118
+ : proc.mkValue(
119
+ proc.dependencies.map((dependency) =>
120
+ dependency instanceof Enode
121
+ ? (root2value.get(dependency.root) ??
122
+ model.getSomeValue(manager.sorts[dependency.owner]))
123
+ : (dependency.value ?? model.getSomeValue(dependency.sort)),
124
+ ),
125
+ );
126
+ model.registerValue(value);
127
+ root2value.set(source, value);
128
+ }
89
129
  const getValue = (node: Enode) =>
90
130
  root2value.get(node.root) ?? model.getSomeValue(manager.sorts[node.owner]);
91
131
  for (const node of context.enodes)
@@ -104,7 +144,9 @@ export const mkModel = (context: Context): GeneratedModel => {
104
144
  interp = new FuncInterp(manager, node.numArgs);
105
145
  model.registerFunc(node.decl, interp);
106
146
  }
107
- const args = Array.from({ length: node.numArgs }, (_, index) => getValue(node.getArg(index)));
147
+ const args = Array.from({ length: node.numArgs }, (_value, index) =>
148
+ getValue(node.getArg(index)),
149
+ );
108
150
  if (interp.getEntry(args) === undefined) interp.insertNewEntry(args, getValue(node));
109
151
  }
110
152
  for (const theory of context.theories) theory.finalizeModel();
@@ -44,9 +44,9 @@ const getRoot = (value: bigint) => {
44
44
  return low * low === value ? { root: low, isExact: true } : { root: low + 1n, isExact: false };
45
45
  };
46
46
 
47
- export const mkBotExp = (ebits: number) => -(2 ** (ebits - 1) - 1);
47
+ const mkBotExp = (ebits: number) => -(2 ** (ebits - 1) - 1);
48
48
 
49
- export const mkTopExp = (ebits: number) => 2 ** (ebits - 1);
49
+ const mkTopExp = (ebits: number) => 2 ** (ebits - 1);
50
50
 
51
51
  export const mkMinExp = (ebits: number) => mkBotExp(ebits) + 1;
52
52
 
@@ -98,8 +98,6 @@ export const isPzero = (value: Mpf) => !value.sign && isZero(value);
98
98
 
99
99
  export const isNeg = (value: Mpf) => value.sign && !isNan(value);
100
100
 
101
- export const isPos = (value: Mpf) => !value.sign && !isNan(value);
102
-
103
101
  export const isDenormal = (value: Mpf) => !isZero(value) && hasBotExp(value);
104
102
 
105
103
  export const isNormal = (value: Mpf) => !(hasTopExp(value) || isDenormal(value) || isZero(value));
@@ -10,7 +10,7 @@ export class Mus {
10
10
 
11
11
  constructor(
12
12
  private manager: AstManager,
13
- private solver: MaxsatSolver,
13
+ private solver: Pick<MaxsatSolver, "checkSat" | "getUnsatCore">,
14
14
  ) {
15
15
  this.lit2expr = new RefVector(manager);
16
16
  this.trail = new RefVector(manager);
@@ -33,8 +33,7 @@ export class Mus {
33
33
  return L_TRUE;
34
34
  }
35
35
  let unknown = [...literals];
36
- while (unknown.length > 0) {
37
- const literal = unknown.pop() as number;
36
+ for (let literal = unknown.pop(); literal !== undefined; literal = unknown.pop()) {
38
37
  const notLiteral = mkNot(this.manager, literal);
39
38
  this.trail.push(notLiteral);
40
39
  const status = this.solver.checkSat([...mus.items, ...unknown, notLiteral]);
@@ -38,9 +38,13 @@ const ENGINE_NAMES = new Map([
38
38
  ["ddnf", ENGINE_DDNF],
39
39
  ]);
40
40
 
41
- // The fp module's parameters, which Z3 keeps as global parameters across resets.
41
+ // As in Z3, these are copied when the context is made, so a later fp option doesn't apply.
42
42
  export class FpParams {
43
- constructor(private parameters: ReadonlyMap<string, string>) {}
43
+ private parameters: ReadonlyMap<string, string>;
44
+
45
+ constructor(parameters: ReadonlyMap<string, string>) {
46
+ this.parameters = new Map(parameters);
47
+ }
44
48
 
45
49
  getBool(name: string, defaultValue: boolean) {
46
50
  const value = this.parameters.get(`fp.${name}`);
@@ -117,6 +121,7 @@ export class DatalogContext {
117
121
  readonly rewriter: Rewriter;
118
122
  // m_mc: the converters since the last query, or undefined before one.
119
123
  modelConverters: ModelConverter[] | undefined;
124
+ isBounded = false;
120
125
 
121
126
  constructor(
122
127
  readonly manager: AstManager,
@@ -328,6 +333,7 @@ export class DatalogContext {
328
333
 
329
334
  query(query: number) {
330
335
  this.modelConverters = [];
336
+ this.isBounded = false;
331
337
  this.getEngine(query);
332
338
  this.flushAddRules();
333
339
  return this.ensureEngine(query).query(query);
@@ -362,7 +368,7 @@ export class DatalogContext {
362
368
  : mkExists(
363
369
  manager,
364
370
  [...domain].reverse(),
365
- domain.map((_, index) => String(index)).reverse(),
371
+ domain.map((_value, index) => String(index)).reverse(),
366
372
  atom,
367
373
  );
368
374
  manager.incRef(query);
@@ -395,7 +401,7 @@ export class DatalogContext {
395
401
  ...conjs.items.map((conj) => this.ruleManager.ensureApp(conj)),
396
402
  ];
397
403
  const isNegated = tail.map(
398
- (_, index) => index < rule.uninterpretedSize && rule.isNegated[index],
404
+ (_value, index) => index < rule.uninterpretedSize && rule.isNegated[index],
399
405
  );
400
406
  const reduced = this.ruleManager.mk(rule.head, tail, isNegated, rule.name);
401
407
  conjs.reset();
@@ -213,7 +213,7 @@ export class MkSlice implements RuleTransformerPlugin {
213
213
  const manager = this.context.manager;
214
214
  let hasOutput = false;
215
215
  for (const [predicate, slice] of this.sliceable) {
216
- const domain = manager.funcDecls[predicate].domain.filter((_, index) => !slice[index]);
216
+ const domain = manager.funcDecls[predicate].domain.filter((_value, index) => !slice[index]);
217
217
  if (domain.length < slice.length) {
218
218
  const sliced = this.context.mkFreshHeadPredicate(
219
219
  getSymbolName(manager.funcDecls[predicate].name),
@@ -238,7 +238,7 @@ export class MkSlice implements RuleTransformerPlugin {
238
238
  const slice = this.getPredicateSlice(manager.decls[atom]);
239
239
  return manager.mkApp(
240
240
  sliced,
241
- manager.getArgs(atom).filter((_, index) => !slice[index]),
241
+ manager.getArgs(atom).filter((_value, index) => !slice[index]),
242
242
  SORT_BOOL,
243
243
  );
244
244
  }
@@ -303,7 +303,7 @@ export class MkSlice implements RuleTransformerPlugin {
303
303
  const domain = manager.funcDecls[predicate].domain;
304
304
  const subst = domain
305
305
  .map((sort, index) => manager.mkVar(index, sort))
306
- .filter((_, index) => !slice[index]);
306
+ .filter((_value, index) => !slice[index]);
307
307
  const interp = model.funcInterps.get(sliced);
308
308
  if (interp === undefined) continue;
309
309
  const oldInterp = new FuncInterp(manager, slice.length);
@@ -382,7 +382,7 @@ export class RuleManager {
382
382
  return mkForall(
383
383
  manager,
384
384
  sorts,
385
- sorts.map((_, index) => getVarName(index)),
385
+ sorts.map((_value, index) => getVarName(index)),
386
386
  matrix,
387
387
  );
388
388
  }
@@ -479,7 +479,7 @@ export class RuleManager {
479
479
  const preQuant = this.pin(varSubst.apply(unboundTail, subst));
480
480
  varSubst.release();
481
481
  sorts.reverse();
482
- const names = sorts.map((_, index) => String(sorts.length - 1 - index));
482
+ const names = sorts.map((_value, index) => String(sorts.length - 1 - index));
483
483
  const quantified = this.pin(mkExists(manager, sorts, names, preQuant));
484
484
  let fixed = isTryingQe ? this.pin(simplifyQuantifiers(manager, quantified)) : quantified;
485
485
  if (manager.kinds[fixed] !== KIND_APP) fixed = this.pin(manager.mkEq(fixed, manager.trueExpr));
@@ -64,7 +64,7 @@ export class HornSubsumeModelConverter {
64
64
  const quantified = manager.mkQuantifier({
65
65
  kind: QUANTIFIER_EXISTS,
66
66
  sorts: sorts.reverse(),
67
- names: sorts.map((_, index) => sorts.length - index - 1),
67
+ names: sorts.map((_value, index) => sorts.length - index - 1),
68
68
  body: substituted,
69
69
  patterns: [],
70
70
  noPatterns: [],
@@ -138,7 +138,7 @@ class HornTactic {
138
138
  );
139
139
  if (sorts.length === 0) return formula;
140
140
  sorts.reverse();
141
- const names = sorts.map((_, index) => String(sorts.length - index - 1));
141
+ const names = sorts.map((_value, index) => String(sorts.length - index - 1));
142
142
  const result = mkForall(manager, sorts, names, formula);
143
143
  manager.incRef(result);
144
144
  return result;