tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9

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 (235) 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 +13 -3
  7. package/dist/index.d.ts +13 -3
  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 +68 -68
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -42
  16. package/dist/run.js +44 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +45 -43
  20. package/dist/transfer.js +45 -43
  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 +11 -1
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +9 -6
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +356 -173
  30. package/src/cli/tlc-output.ts +1 -0
  31. package/src/cli/tlc.ts +4 -3
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +34 -13
  34. package/src/coverage.ts +3 -0
  35. package/src/dependencies.ts +61 -13
  36. package/src/dfid.ts +22 -10
  37. package/src/environment.ts +71 -35
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +149 -54
  40. package/src/exit-codes.ts +29 -15
  41. package/src/instances.ts +16 -6
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +186 -97
  45. package/src/liveness-checker.ts +131 -83
  46. package/src/liveness.ts +52 -11
  47. package/src/obligations/index.ts +1 -1
  48. package/src/obligations/normalize.ts +1 -4
  49. package/src/obligations/printer.ts +5 -5
  50. package/src/obligations/source.ts +2 -0
  51. package/src/parser.ts +115 -145
  52. package/src/prover/isabelle/isar/attrib.ts +4 -4
  53. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  54. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  55. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  56. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  57. package/src/prover/isabelle/pure/term.ts +3 -3
  58. package/src/prover/prep/md5.ts +26 -29
  59. package/src/prover/smt/rewrite.ts +2 -7
  60. package/src/prover/smt/simplify.ts +1 -1
  61. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  62. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  63. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  64. package/src/prover/smt/solver/ast-lt.ts +1 -1
  65. package/src/prover/smt/solver/ast.ts +63 -14
  66. package/src/prover/smt/solver/auf-solver.ts +23 -12
  67. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  68. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  69. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  70. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  71. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  72. package/src/prover/smt/solver/card2bv.ts +35 -18
  73. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  74. package/src/prover/smt/solver/context.ts +67 -13
  75. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  76. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  77. package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
  78. package/src/prover/smt/solver/diff-neq.ts +1 -2
  79. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  80. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  81. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  82. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  83. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  84. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  87. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  88. package/src/prover/smt/solver/euf/mam.ts +1 -5
  89. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  90. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  91. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  92. package/src/prover/smt/solver/factor.ts +36 -14
  93. package/src/prover/smt/solver/fd-solver.ts +148 -39
  94. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  95. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  96. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  97. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  98. package/src/prover/smt/solver/goal.ts +6 -3
  99. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  100. package/src/prover/smt/solver/hashtable.ts +4 -0
  101. package/src/prover/smt/solver/internalizer.ts +1 -1
  102. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  103. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  104. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  105. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  106. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  107. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  108. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  109. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  110. package/src/prover/smt/solver/maxcore.ts +2 -1
  111. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  112. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  113. package/src/prover/smt/solver/model-checker.ts +1 -1
  114. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  115. package/src/prover/smt/solver/model-generator.ts +85 -43
  116. package/src/prover/smt/solver/mpf.ts +2 -4
  117. package/src/prover/smt/solver/mus.ts +2 -3
  118. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  119. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  120. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  121. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  122. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  123. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  124. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  125. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  126. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  127. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  128. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  129. package/src/prover/smt/solver/nlqsat.ts +1 -1
  130. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  131. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  132. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  133. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  134. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  135. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  136. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  137. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  138. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  139. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  140. package/src/prover/smt/solver/nnf.ts +6 -2
  141. package/src/prover/smt/solver/opt-context.ts +21 -7
  142. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  143. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  144. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  145. package/src/prover/smt/solver/opt-solver.ts +10 -6
  146. package/src/prover/smt/solver/optsmt.ts +1 -1
  147. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  148. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  149. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  150. package/src/prover/smt/solver/probes.ts +88 -23
  151. package/src/prover/smt/solver/proto-model.ts +8 -8
  152. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  153. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  154. package/src/prover/smt/solver/qe-lite.ts +2 -2
  155. package/src/prover/smt/solver/qe.ts +3 -2
  156. package/src/prover/smt/solver/qsat.ts +23 -8
  157. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  158. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  159. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  160. package/src/prover/smt/solver/rewriter.ts +31 -25
  161. package/src/prover/smt/solver/rlimit.ts +4 -0
  162. package/src/prover/smt/solver/sat/config.ts +1 -1
  163. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  164. package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
  165. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  166. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  167. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  168. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  169. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  170. package/src/prover/smt/solver/sat/solver.ts +25 -47
  171. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  172. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  173. package/src/prover/smt/solver/seq-derive.ts +2 -2
  174. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  175. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  176. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  177. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  178. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  179. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  180. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  181. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  182. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  183. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  184. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  185. package/src/prover/smt/solver/smt-setup.ts +96 -10
  186. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  187. package/src/prover/smt/solver/smtlib-script.ts +674 -195
  188. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  189. package/src/prover/smt/solver/solver.ts +18 -3
  190. package/src/prover/smt/solver/tactic.ts +332 -189
  191. package/src/prover/smt/solver/theory-bv.ts +13 -3
  192. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  193. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  194. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  195. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  196. package/src/prover/smt/solver/theory-lra.ts +1 -1
  197. package/src/prover/smt/solver/theory-pb.ts +24 -7
  198. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  199. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  200. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  201. package/src/prover/tlapm/cache.ts +8 -8
  202. package/src/prover/zenon/index-table.ts +5 -2
  203. package/src/prover/zenon/isar-case.ts +1 -1
  204. package/src/prover/zenon/isar.ts +2 -2
  205. package/src/prover/zenon/phrase.ts +1 -1
  206. package/src/resolve.ts +1071 -251
  207. package/src/runtime.ts +5 -1
  208. package/src/sany/builtins.ts +10 -10
  209. package/src/sany/generation.ts +2 -13
  210. package/src/sany/generator-definitions.ts +3 -1
  211. package/src/sany/generator-expressions.ts +38 -30
  212. package/src/sany/generator-proofs.ts +6 -3
  213. package/src/sany/generator.ts +2 -1
  214. package/src/sany/lexer.ts +3 -3
  215. package/src/sany/modules.ts +4 -2
  216. package/src/sany/nodes.ts +1 -1
  217. package/src/sany/selectors.ts +11 -6
  218. package/src/sany/xml.ts +2 -3
  219. package/src/search.ts +197 -117
  220. package/src/simulate.ts +165 -102
  221. package/src/spec-description.ts +8 -6
  222. package/src/standard-modules.ts +56 -22
  223. package/src/subexpressions.ts +518 -123
  224. package/src/successors.ts +10 -3
  225. package/src/symmetry.ts +2 -1
  226. package/src/tlc/jar-data.ts +10 -0
  227. package/src/tlc/messages.ts +3 -3
  228. package/src/tlc/random.ts +2 -1
  229. package/src/tlc/replay.ts +27 -14
  230. package/src/tlc/tlc-operators.ts +10 -8
  231. package/src/tlc/tlcext-operators.ts +26 -10
  232. package/src/tlc/trace-spec.ts +9 -22
  233. package/src/typed-tier.ts +44 -27
  234. package/src/typescript/types.ts +2 -2
  235. package/src/values.ts +135 -78
@@ -12,105 +12,227 @@ import {
12
12
  SORT_INT,
13
13
  SORT_REAL,
14
14
  } from "./ast";
15
- import type { Polynomial, PolynomialManager } from "./nlsat/polynomial";
15
+ import {
16
+ type Polynomial,
17
+ type PolynomialManager,
18
+ PolynomialRef,
19
+ PolynomialRefVector,
20
+ } from "./nlsat/polynomial";
16
21
  import { getLcm, Rational } from "./rational";
17
22
  import { RefVector } from "./ref-vector";
18
23
 
19
- export interface PolynomialResult {
20
- polynomial: Polynomial;
21
- denominator: bigint;
24
+ interface Frame {
25
+ term: number;
26
+ index: number;
22
27
  }
23
28
 
24
- export const toPolynomial = (
25
- manager: AstManager,
26
- pm: PolynomialManager,
27
- term: number,
28
- mkVar: (term: number) => number,
29
- ): PolynomialResult => {
30
- const convert = (expr: number): PolynomialResult => {
31
- if (manager.kinds[expr] !== KIND_APP || manager.getFamily(expr) !== FAMILY_ARITH)
32
- return { polynomial: pm.mkVar(mkVar(expr)), denominator: 1n };
33
- const op = manager.getOp(expr);
34
- switch (op) {
29
+ export class Expr2Polynomial {
30
+ private cache = new Map<number, number>();
31
+ private cachedDomain: RefVector;
32
+ private cachedPolynomials: PolynomialRefVector;
33
+ private cachedDenominators: bigint[] = [];
34
+ private frames: Frame[] = [];
35
+ private presult: PolynomialRefVector;
36
+ private dresult: bigint[] = [];
37
+ private var2expr: RefVector;
38
+
39
+ constructor(
40
+ private manager: AstManager,
41
+ readonly pm: PolynomialManager,
42
+ private t2x: Map<number, number>,
43
+ private mkVar: (isInt: boolean) => number,
44
+ ) {
45
+ this.cachedDomain = new RefVector(manager);
46
+ this.cachedPolynomials = new PolynomialRefVector(pm);
47
+ this.presult = new PolynomialRefVector(pm);
48
+ this.var2expr = new RefVector(manager);
49
+ }
50
+
51
+ private reset() {
52
+ this.frames.length = 0;
53
+ this.presult.reset();
54
+ this.dresult.length = 0;
55
+ }
56
+
57
+ private cacheResult(term: number) {
58
+ if (this.manager.getRefCount(term) <= 1) return;
59
+ this.cache.set(term, this.cachedPolynomials.size);
60
+ this.cachedDomain.push(term);
61
+ this.cachedPolynomials.push(this.presult.get(this.presult.size - 1));
62
+ this.cachedDenominators.push(this.dresult[this.dresult.length - 1]);
63
+ }
64
+
65
+ private storeResult(term: number, polynomial: Polynomial, denominator: bigint) {
66
+ this.presult.push(polynomial);
67
+ this.dresult.push(denominator);
68
+ this.cacheResult(term);
69
+ }
70
+
71
+ private storeVarPoly(term: number) {
72
+ let variable = this.t2x.get(term);
73
+ if (variable === undefined) {
74
+ variable = this.mkVar(this.manager.sorts[term] === SORT_INT);
75
+ this.t2x.set(term, variable);
76
+ if (variable >= this.var2expr.size) this.var2expr.resize(variable + 1);
77
+ this.var2expr.set(variable, term);
78
+ }
79
+ this.storeResult(term, this.pm.mkVar(variable), 1n);
80
+ }
81
+
82
+ private visitArithApp(term: number) {
83
+ const manager = this.manager;
84
+ switch (manager.getOp(term)) {
35
85
  case OP_NUM: {
36
- const value = manager.getRationalValue(expr);
37
- return { polynomial: pm.mkConst(value.num), denominator: value.den };
86
+ const value = manager.getRationalValue(term);
87
+ this.storeResult(term, this.pm.mkConst(value.num), value.den);
88
+ return true;
38
89
  }
39
90
  case OP_ADD:
40
- case OP_SUB: {
41
- const args = manager.getArgs(expr).map(convert);
42
- const denominator = args.reduce((lcm, arg) => getLcm(lcm, arg.denominator), 1n);
43
- let polynomial = pm.zero;
44
- for (const [index, arg] of args.entries()) {
45
- const scaled = pm.mulConst(denominator / arg.denominator, arg.polynomial);
46
- polynomial =
47
- index === 0
48
- ? scaled
49
- : op === OP_ADD
50
- ? pm.add(polynomial, scaled)
51
- : pm.sub(polynomial, scaled);
52
- }
53
- return { polynomial, denominator };
54
- }
55
- case OP_MUL: {
56
- let polynomial = pm.one;
57
- let denominator = 1n;
58
- for (const arg of manager.getArgs(expr).map(convert)) {
59
- polynomial = pm.mul(polynomial, arg.polynomial);
60
- denominator *= arg.denominator;
61
- }
62
- return { polynomial, denominator };
63
- }
64
- case OP_UMINUS: {
65
- const arg = convert(manager.getArg(expr, 0));
66
- return { polynomial: pm.neg(arg.polynomial), denominator: arg.denominator };
67
- }
91
+ case OP_SUB:
92
+ case OP_MUL:
93
+ case OP_UMINUS:
68
94
  case OP_TO_REAL:
69
- return convert(manager.getArg(expr, 0));
95
+ this.frames.push({ term, index: 0 });
96
+ return false;
70
97
  case OP_POWER: {
71
- const exponent = manager.getArg(expr, 1);
98
+ const exponent = manager.getArg(term, 1);
72
99
  const value = manager.isNumeral(exponent) ? manager.getRationalValue(exponent) : undefined;
73
- if (value === undefined || !value.isInt() || value.num <= 0n || value.num > 0xffffffffn)
74
- return { polynomial: pm.mkVar(mkVar(expr)), denominator: 1n };
75
- const base = convert(manager.getArg(expr, 0));
76
- return {
77
- polynomial: pm.pw(base.polynomial, Number(value.num)),
78
- denominator: base.denominator ** value.num,
79
- };
100
+ if (value === undefined || !value.isInt() || value.num <= 0n || value.num > 0xffffffffn) {
101
+ this.storeVarPoly(term);
102
+ return true;
103
+ }
104
+ this.frames.push({ term, index: 0 });
105
+ return false;
80
106
  }
81
107
  default:
82
- return { polynomial: pm.mkVar(mkVar(expr)), denominator: 1n };
108
+ this.storeVarPoly(term);
109
+ return true;
83
110
  }
84
- };
85
- return convert(term);
86
- };
111
+ }
87
112
 
88
- export class Expr2Polynomial {
89
- private termToVar = new Map<number, number>();
90
- private varToTerm: RefVector;
113
+ private visit(term: number) {
114
+ const manager = this.manager;
115
+ const cached = manager.getRefCount(term) > 1 ? this.cache.get(term) : undefined;
116
+ if (cached !== undefined) {
117
+ this.presult.push(this.cachedPolynomials.get(cached));
118
+ this.dresult.push(this.cachedDenominators[cached]);
119
+ return true;
120
+ }
121
+ if (manager.kinds[term] !== KIND_APP || manager.getFamily(term) !== FAMILY_ARITH) {
122
+ this.storeVarPoly(term);
123
+ return true;
124
+ }
125
+ return this.visitArithApp(term);
126
+ }
91
127
 
92
- constructor(
93
- private manager: AstManager,
94
- readonly pm: PolynomialManager,
95
- ) {
96
- this.varToTerm = new RefVector(manager);
128
+ private pop(numArgs: number) {
129
+ this.presult.shrink(this.presult.size - numArgs);
130
+ this.dresult.length -= numArgs;
97
131
  }
98
132
 
99
- private getVar(term: number) {
100
- const existing = this.termToVar.get(term);
101
- if (existing !== undefined) return existing;
102
- const variable = this.varToTerm.size;
103
- this.termToVar.set(term, variable);
104
- this.varToTerm.push(term);
105
- return variable;
133
+ private processAddSub(term: number, numArgs: number, isAdd: boolean) {
134
+ const pm = this.pm;
135
+ const first = this.presult.size - numArgs;
136
+ const p = new PolynomialRef(pm);
137
+ const pAux = new PolynomialRef(pm);
138
+ let denominator = 1n;
139
+ for (let index = 0; index < numArgs; index++)
140
+ denominator = getLcm(denominator, this.dresult[first + index]);
141
+ p.set(pm.zero);
142
+ for (let index = 0; index < numArgs; index++) {
143
+ pAux.set(
144
+ pm.mulConst(denominator / this.dresult[first + index], this.presult.get(first + index)),
145
+ );
146
+ if (index === 0) p.copy(pAux);
147
+ else p.set(isAdd ? pm.add(p.get(), pAux.get()) : pm.sub(p.get(), pAux.get()));
148
+ }
149
+ this.pop(numArgs);
150
+ this.storeResult(term, p.get(), denominator);
151
+ pAux.reset();
152
+ p.reset();
106
153
  }
107
154
 
108
- private isIntVar(variable: number) {
109
- return this.manager.sorts[this.varToTerm.items[variable]] === SORT_INT;
155
+ private processMul(term: number, numArgs: number) {
156
+ const first = this.presult.size - numArgs;
157
+ const p = new PolynomialRef(this.pm);
158
+ let denominator = 1n;
159
+ p.set(this.pm.one);
160
+ for (let index = 0; index < numArgs; index++) {
161
+ p.set(this.pm.mul(p.get(), this.presult.get(first + index)));
162
+ denominator *= this.dresult[first + index];
163
+ }
164
+ this.pop(numArgs);
165
+ this.storeResult(term, p.get(), denominator);
166
+ p.reset();
167
+ }
168
+
169
+ private processUminus(term: number) {
170
+ const negP = new PolynomialRef(this.pm);
171
+ negP.set(this.pm.neg(this.presult.get(this.presult.size - 1)));
172
+ this.presult.shrink(this.presult.size - 1);
173
+ this.presult.push(negP.get());
174
+ this.cacheResult(term);
175
+ negP.reset();
110
176
  }
111
177
 
112
- toPolynomial(term: number) {
113
- return toPolynomial(this.manager, this.pm, term, (expr) => this.getVar(expr));
178
+ private processPower(term: number, numArgs: number) {
179
+ const first = this.presult.size - numArgs;
180
+ const k = Number(this.manager.getRationalValue(this.manager.getArg(term, 1)).num);
181
+ const p = new PolynomialRef(this.pm);
182
+ this.pm.pw(this.presult.get(first), k, p);
183
+ const denominator = this.dresult[first] ** BigInt(k);
184
+ this.pop(numArgs);
185
+ this.storeResult(term, p.get(), denominator);
186
+ p.reset();
187
+ }
188
+
189
+ private processApp(term: number) {
190
+ const numArgs = this.manager.getNumArgs(term);
191
+ switch (this.manager.getOp(term)) {
192
+ case OP_ADD:
193
+ return this.processAddSub(term, numArgs, true);
194
+ case OP_SUB:
195
+ return this.processAddSub(term, numArgs, false);
196
+ case OP_MUL:
197
+ return this.processMul(term, numArgs);
198
+ case OP_POWER:
199
+ return this.processPower(term, numArgs);
200
+ case OP_UMINUS:
201
+ return this.processUminus(term);
202
+ default:
203
+ return this.cacheResult(term);
204
+ }
205
+ }
206
+
207
+ toPolynomial(term: number, p: PolynomialRef) {
208
+ this.reset();
209
+ if (!this.visit(term)) {
210
+ const frames = this.frames;
211
+ while (frames.length > 0) {
212
+ const frame = frames[frames.length - 1];
213
+ const numArgs = this.manager.getNumArgs(frame.term);
214
+ let isPushed = false;
215
+ while (frame.index < numArgs) {
216
+ const arg = this.manager.getArg(frame.term, frame.index);
217
+ frame.index++;
218
+ if (!this.visit(arg)) {
219
+ isPushed = true;
220
+ break;
221
+ }
222
+ }
223
+ if (isPushed) continue;
224
+ this.processApp(frame.term);
225
+ frames.pop();
226
+ }
227
+ }
228
+ p.set(this.presult.get(this.presult.size - 1));
229
+ const denominator = this.dresult[this.dresult.length - 1];
230
+ this.reset();
231
+ return denominator;
232
+ }
233
+
234
+ private isIntVar(variable: number) {
235
+ return this.manager.sorts[this.var2expr.items[variable]] === SORT_INT;
114
236
  }
115
237
 
116
238
  toExpr(polynomial: Polynomial, isUsingPower: boolean) {
@@ -125,7 +247,7 @@ export class Expr2Polynomial {
125
247
  const coeff = polynomial.as[index];
126
248
  if (coeff !== 1n) factors.push(mkNumeral(coeff));
127
249
  for (const [position, variable] of monomial.vars.entries()) {
128
- const term = this.varToTerm.items[variable];
250
+ const term = this.var2expr.items[variable];
129
251
  const base =
130
252
  this.isIntVar(variable) && !isInt ? manager.mkApp(OP_TO_REAL, [term], SORT_REAL) : term;
131
253
  const degree = monomial.degrees[position];
@@ -141,6 +263,9 @@ export class Expr2Polynomial {
141
263
  }
142
264
 
143
265
  release() {
144
- this.varToTerm.reset();
266
+ this.presult.reset();
267
+ this.cachedPolynomials.reset();
268
+ this.cachedDomain.reset();
269
+ this.var2expr.reset();
145
270
  }
146
271
  }
@@ -18,7 +18,7 @@ import { runSimplifier } from "./dependent-expr-state";
18
18
  import { Expr2Polynomial } from "./expr2polynomial";
19
19
  import type { Goal } from "./goal";
20
20
  import { getLcm, Rational } from "./rational";
21
- import { PolynomialManager } from "./nlsat/polynomial";
21
+ import { Factors, type Polynomial, PolynomialManager, PolynomialRef } from "./nlsat/polynomial";
22
22
  import type { Rewrite } from "./rewriter-tpl";
23
23
  import { RewriterTpl } from "./rewriter-tpl";
24
24
 
@@ -37,7 +37,13 @@ class FactorRewriter extends RewriterTpl {
37
37
  private isSplittingFactors: boolean,
38
38
  ) {
39
39
  super(manager);
40
- this.expr2poly = new Expr2Polynomial(manager, new PolynomialManager());
40
+ let variableCount = 0;
41
+ this.expr2poly = new Expr2Polynomial(
42
+ manager,
43
+ new PolynomialManager(manager.limit),
44
+ new Map(),
45
+ () => variableCount++,
46
+ );
41
47
  }
42
48
 
43
49
  private mkZeroFor(expr: number) {
@@ -51,20 +57,36 @@ class FactorRewriter extends RewriterTpl {
51
57
  : this.manager.mkApp(OP_MUL, args, this.manager.sorts[args[0]]);
52
58
  }
53
59
 
54
- private factor(op: number, lhs: number, rhs: number): number {
55
- const manager = this.manager;
60
+ private factor(op: number, lhs: number, rhs: number) {
56
61
  const pm = this.expr2poly.pm;
57
- const first = this.expr2poly.toPolynomial(lhs);
58
- const second = this.expr2poly.toPolynomial(rhs);
59
- const lcm = getLcm(first.denominator, second.denominator);
60
- const polynomial = pm.addmul(
61
- lcm / first.denominator,
62
- first.polynomial,
63
- -(lcm / second.denominator),
64
- second.polynomial,
62
+ const first = new PolynomialRef(pm);
63
+ const second = new PolynomialRef(pm);
64
+ const p = new PolynomialRef(pm);
65
+ const firstDenominator = this.expr2poly.toPolynomial(lhs, first);
66
+ const secondDenominator = this.expr2poly.toPolynomial(rhs, second);
67
+ const lcm = getLcm(firstDenominator, secondDenominator);
68
+ p.set(
69
+ pm.addmulTerms(
70
+ lcm / firstDenominator,
71
+ pm.unit,
72
+ first.get(),
73
+ -(lcm / secondDenominator),
74
+ pm.unit,
75
+ second.get(),
76
+ ),
65
77
  );
66
- if (pm.isConst(polynomial)) return -1;
67
- const factors = pm.factor(polynomial);
78
+ const factors = new Factors(pm);
79
+ const result = pm.isConst(p.get()) ? -1 : this.factorPolynomial(op, p.get(), factors);
80
+ factors.reset();
81
+ p.reset();
82
+ second.reset();
83
+ first.reset();
84
+ return result;
85
+ }
86
+
87
+ private factorPolynomial(op: number, polynomial: Polynomial, factors: Factors): number {
88
+ const manager = this.manager;
89
+ this.expr2poly.pm.factor(polynomial, factors);
68
90
  if (factors.factors.length === 1 && factors.degrees[0] === 1) return -1;
69
91
  const terms = factors.factors.map((factor) => this.expr2poly.toExpr(factor, true));
70
92
  if (op === OP_EQ) {
@@ -1,4 +1,4 @@
1
- import { SmtCanceledError } from "../../../errors";
1
+ import { SmtCanceledError, SmtTacticError } from "../../../errors";
2
2
  import {
3
3
  type AstManager,
4
4
  KIND_APP,
@@ -7,27 +7,29 @@ import {
7
7
  OP_AND,
8
8
  OP_EQ,
9
9
  OP_IMPLIES,
10
+ OP_OR,
10
11
  OP_UBV2INT,
11
12
  OP_ULEQ,
12
13
  SORT_BOOL,
13
14
  SORT_INT,
14
15
  } from "./ast";
16
+ import { mkNot } from "./ast-util";
15
17
  import { BoundManager } from "./bound-manager";
16
18
  import { mkBvApp } from "./bv-decl-plugin";
17
19
  import { Bv2IntContext, Bv2IntRewriter } from "./bv2int-rewriter";
18
- import { card2bv } from "./card2bv";
20
+ import { createCard2Bv } from "./card2bv";
21
+ import { DependentExprState } from "./dependent-expr-state";
19
22
  import { runEnum2Bv } from "./dt2bv-tactic";
23
+ import { release } from "./expr-ref";
20
24
  import { ExprSafeReplace } from "./expr-safe-replace";
21
25
  import { type Definition, Goal } from "./goal";
22
- import { ObjMap } from "./hashtable";
23
- import { L_FALSE, L_TRUE } from "./lbool";
26
+ import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
24
27
  import { RefVector } from "./ref-vector";
25
28
  import { Rewriter } from "./rewriter";
26
29
  import { convertModel, getRewriterOptions } from "./tactic";
27
30
  import { UINT_MAX } from "./sat/clause";
28
31
  import type { SatParams } from "./sat/config";
29
32
  import { IncSatSolver } from "./sat/inc-sat-solver";
30
- import { SubstReplacer } from "./solve-eqs";
31
33
 
32
34
  const getNumBits = (value: bigint) => {
33
35
  let bound = 1n;
@@ -50,9 +52,10 @@ const collectBounds = (manager: AstManager, bounds: BoundManager, form: number)
50
52
  // bounded_int2bv_simplifier: an integer constant between two bounds becomes an unsigned
51
53
  // bit-vector plus the lower bound.
52
54
  const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
55
+ const state = new DependentExprState(manager, goal);
53
56
  const bounds = new BoundManager(manager);
54
- for (const form of goal.forms.items) collectBounds(manager, bounds, form);
55
- const substitution = new ObjMap<number>((expr) => manager.hashes[expr]);
57
+ state.forEachIndex((index) => collectBounds(manager, bounds, goal.forms.items[index]));
58
+ const substitution = new ExprSafeReplace(manager);
56
59
  const trail = new RefVector(manager);
57
60
  const sideConditions = new RefVector(manager);
58
61
  const definitions: Definition[] = [];
@@ -77,7 +80,6 @@ const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
77
80
  const replacement = offset.isZero()
78
81
  ? unsigned
79
82
  : manager.mkApp(OP_ADD, [unsigned, manager.mkNumeral(offset.num)], SORT_INT);
80
- trail.push(replacement);
81
83
  definitions.push(
82
84
  { decl: manager.decls[bits], def: -1 },
83
85
  { decl: manager.decls[expr], def: replacement },
@@ -86,36 +88,118 @@ const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
86
88
  sideConditions.push(
87
89
  mkBvApp(manager, OP_ULEQ, [bits, manager.mkBvNumeral(domainSize - 1n, numBits)]),
88
90
  );
89
- substitution.set(expr, replacement);
91
+ substitution.insert(expr, replacement);
90
92
  }
91
- if (substitution.size > 0) {
92
- const replacer = new SubstReplacer(manager, substitution);
93
- const context = new Bv2IntContext(manager, UINT_MAX);
94
- const rewriter = new Bv2IntRewriter(manager, context);
95
- for (let index = 0; index < goal.forms.size; index++) {
96
- const form = goal.forms.items[index];
97
- const replaced = replacer.rewrite(form);
98
- const result = rewriter.rewrite(replaced);
99
- manager.decRef(replaced);
100
- if (result !== form) goal.update(index, result);
101
- manager.decRef(result);
93
+ try {
94
+ if (substitution.sources.size > 0) {
95
+ const context = new Bv2IntContext(manager, UINT_MAX);
96
+ const rewriter = new Bv2IntRewriter(manager, context);
97
+ let replaced = -1;
98
+ let result = -1;
99
+ try {
100
+ state.forEachIndex((index) => {
101
+ const form = goal.forms.items[index];
102
+ const nextReplaced = substitution.apply(form);
103
+ release(manager, replaced);
104
+ replaced = nextReplaced;
105
+ const nextResult = rewriter.rewrite(replaced);
106
+ release(manager, result);
107
+ result = nextResult;
108
+ if (result !== form) goal.update(index, result);
109
+ });
110
+ } finally {
111
+ release(manager, result);
112
+ release(manager, replaced);
113
+ rewriter.release();
114
+ context.release();
115
+ }
102
116
  }
103
- rewriter.release();
104
- context.release();
105
- replacer.release();
117
+ for (const condition of sideConditions.items) goal.assert(condition);
118
+ if (definitions.length > 0) goal.addDefinitions(definitions);
119
+ } finally {
120
+ substitution.release();
121
+ sideConditions.reset();
122
+ trail.reset();
106
123
  }
107
- for (const condition of sideConditions.items) goal.assert(condition);
108
- if (definitions.length > 0) goal.addDefinitions(definitions);
109
- sideConditions.reset();
110
- trail.reset();
111
124
  };
112
125
 
126
+ class SolverFormulas extends Goal {
127
+ override assert(form: number) {
128
+ if (this.manager.isFalse(form)) this.isInconsistent = true;
129
+ this.forms.push(form);
130
+ }
131
+
132
+ override update(index: number, form: number) {
133
+ if (this.manager.isFalse(form)) this.isInconsistent = true;
134
+ this.forms.set(index, form);
135
+ }
136
+
137
+ flattenSuffix() {
138
+ const manager = this.manager;
139
+ const forms = this.forms;
140
+ const seen = new Set<number>();
141
+ const pinned = new RefVector(manager);
142
+ let kept = 0;
143
+ for (let index = 0; index < forms.size; index++) {
144
+ const form = forms.items[index];
145
+ pinned.push(form);
146
+ if (seen.has(form)) continue;
147
+ seen.add(form);
148
+ if (manager.isTrue(form)) continue;
149
+ if (manager.getOp(form) === OP_AND) {
150
+ const numArgs = manager.getNumArgs(form);
151
+ for (let argIndex = 0; argIndex < numArgs; argIndex++)
152
+ this.assert(manager.getArg(form, argIndex));
153
+ continue;
154
+ }
155
+ if (manager.isNot(form) && manager.getOp(manager.getArg(form, 0)) === OP_OR) {
156
+ const disjunction = manager.getArg(form, 0);
157
+ const numArgs = manager.getNumArgs(disjunction);
158
+ for (let argIndex = 0; argIndex < numArgs; argIndex++)
159
+ this.assert(mkNot(manager, manager.getArg(disjunction, argIndex)));
160
+ continue;
161
+ }
162
+ if (index !== kept) forms.set(kept, form);
163
+ kept++;
164
+ }
165
+ while (forms.size > kept) forms.pop();
166
+ pinned.reset();
167
+ }
168
+ }
169
+
113
170
  const runFdSimplifier = (manager: AstManager, forms: readonly number[]) => {
114
- const fmls = new Goal(manager);
171
+ const fmls = new SolverFormulas(manager);
115
172
  for (const form of forms) fmls.assert(form);
116
- runBoundedInt2Bv(manager, fmls);
117
- card2bv(manager, fmls, getRewriterOptions(manager, new Map()));
118
- runEnum2Bv(manager, fmls);
173
+ if (fmls.forms.size === 0) return fmls;
174
+ const state = new DependentExprState(manager, fmls);
175
+ const simplifiers = [
176
+ () => runBoundedInt2Bv(manager, fmls),
177
+ () => {
178
+ const simplifier = createCard2Bv(manager, getRewriterOptions(manager, new Map()))(state);
179
+ try {
180
+ simplifier.reduce();
181
+ } finally {
182
+ simplifier.release();
183
+ }
184
+ },
185
+ () => runEnum2Bv(manager, fmls, (visit) => state.forEachIndex(visit)),
186
+ ];
187
+ try {
188
+ if (!fmls.isInconsistent && manager.limit.inc())
189
+ for (const simplify of simplifiers) {
190
+ if (fmls.isInconsistent || !manager.limit.inc()) break;
191
+ try {
192
+ simplify();
193
+ } catch (error) {
194
+ if (!(error instanceof SmtCanceledError)) throw error;
195
+ break;
196
+ }
197
+ fmls.flattenSuffix();
198
+ }
199
+ } finally {
200
+ state.release();
201
+ }
202
+ if (!manager.limit.inc()) fmls.reset();
119
203
  return fmls;
120
204
  };
121
205
 
@@ -176,7 +260,6 @@ export const getFdConsequences = (
176
260
  const solver = new IncSatSolver(manager, params);
177
261
  try {
178
262
  for (const form of fmls.forms.items) solver.assertExpr(form);
179
- if (fmls.isInconsistent) solver.assertExpr(manager.falseExpr);
180
263
  const found = solver.getConsequences(asms1, queryVars);
181
264
  const coreReplace = new ExprSafeReplace(manager);
182
265
  asms1.forEach((assumption, index) => coreReplace.insert(assumption, assumptions[index]));
@@ -227,6 +310,8 @@ export const getFdConsequences = (
227
310
  result: found.result,
228
311
  consequences,
229
312
  model: model === null ? undefined : convertModel(fmls, model),
313
+ core: solver.getUnsatCore().map((dep) => assumptions[asms1.indexOf(dep)] ?? dep),
314
+ reasonUnknown: solver.reasonUnknown,
230
315
  };
231
316
  } finally {
232
317
  solver.release();
@@ -242,18 +327,16 @@ export const createFdTactic = (manager: AstManager, params: SatParams) => (goal:
242
327
  const solver = new IncSatSolver(manager, params, false);
243
328
  try {
244
329
  for (const form of fmls.forms.items) solver.assertExpr(form);
245
- const result = fmls.isInconsistent ? L_FALSE : solver.check();
330
+ const result = solver.check();
246
331
  goal.reset();
247
332
  if (result === L_TRUE) {
248
333
  const model = solver.getModel();
249
- model?.incRef();
250
- if (model !== null) {
251
- goal.converters = [...goal.converters, ...fmls.converters];
252
- goal.model = model;
253
- }
334
+ const converted = model === null ? null : convertModel(fmls, model);
335
+ converted?.incRef();
336
+ if (converted !== null) goal.model = converted;
254
337
  } else if (result === L_FALSE) goal.assert(manager.falseExpr);
255
338
  else {
256
- if (!manager.limit.inc()) throw new SmtCanceledError();
339
+ if (!manager.limit.inc()) throw new SmtTacticError("canceled");
257
340
  for (const form of solver.getAssertions()) goal.assert(form);
258
341
  goal.converters = [...goal.converters, ...fmls.converters, ...solver.getConverters()];
259
342
  }
@@ -263,3 +346,29 @@ export const createFdTactic = (manager: AstManager, params: SatParams) => (goal:
263
346
  solver.release();
264
347
  }
265
348
  };
349
+
350
+ export const checkFdSolver = (manager: AstManager, params: SatParams, forms: readonly number[]) => {
351
+ const fmls = runFdSimplifier(manager, forms);
352
+ const solver = new IncSatSolver(manager, params);
353
+ const limit = manager.limit;
354
+ const wasSuspended = limit.isSuspended;
355
+ try {
356
+ for (const form of fmls.forms.items) solver.assertExpr(form);
357
+ const result = (() => {
358
+ try {
359
+ return solver.check();
360
+ } catch (error) {
361
+ if (!(error instanceof SmtCanceledError)) throw error;
362
+ return L_UNDEF;
363
+ }
364
+ })();
365
+ const model = result === L_TRUE ? solver.getModel() : null;
366
+ limit.isSuspended = true;
367
+ const converted = model === null ? undefined : convertModel(fmls, model);
368
+ converted?.incRef();
369
+ return { result, model: converted, reasonUnknown: solver.reasonUnknown };
370
+ } finally {
371
+ limit.isSuspended = wasSuspended;
372
+ solver.release();
373
+ }
374
+ };
@@ -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