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
@@ -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) {
@@ -227,6 +227,8 @@ export const getFdConsequences = (
227
227
  result: found.result,
228
228
  consequences,
229
229
  model: model === null ? undefined : convertModel(fmls, model),
230
+ core: solver.getUnsatCore().map((dep) => assumptions[asms1.indexOf(dep)] ?? dep),
231
+ reasonUnknown: solver.reasonUnknown,
230
232
  };
231
233
  } finally {
232
234
  solver.release();
@@ -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