tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.94c3dd828

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 (196) hide show
  1. package/dist/deciders.cjs +37 -36
  2. package/dist/deciders.js +55 -54
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +3 -0
  5. package/dist/index.d.ts +3 -0
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove.cjs +146 -58
  10. package/dist/prove.js +142 -54
  11. package/dist/run.cjs +45 -43
  12. package/dist/run.js +47 -45
  13. package/dist/transfer.cjs +39 -36
  14. package/dist/transfer.js +23 -20
  15. package/dist/worker.cjs +1 -1
  16. package/dist/worker.js +1 -1
  17. package/package.json +1 -1
  18. package/src/ast.ts +3 -3
  19. package/src/check.ts +203 -33
  20. package/src/cli/tlapm.ts +261 -68
  21. package/src/dependencies.ts +23 -2
  22. package/src/errors.ts +1 -1
  23. package/src/exit-codes.ts +1 -0
  24. package/src/liveness-checker.ts +530 -201
  25. package/src/liveness.ts +47 -32
  26. package/src/obligations/anonymize.ts +2 -4
  27. package/src/obligations/index.ts +5 -3
  28. package/src/obligations/pragma.ts +2 -2
  29. package/src/parallel.ts +2 -2
  30. package/src/parser.ts +151 -42
  31. package/src/prover/deciders.ts +1 -8
  32. package/src/prover/isabelle/isar/attrib.ts +86 -45
  33. package/src/prover/isabelle/isar/context.ts +25 -22
  34. package/src/prover/isabelle/isar/induct.ts +2 -5
  35. package/src/prover/isabelle/isar/method.ts +5 -7
  36. package/src/prover/isabelle/isar/proof.ts +33 -16
  37. package/src/prover/isabelle/isar/rule-cases.ts +6 -14
  38. package/src/prover/isabelle/isar/theory.ts +16 -17
  39. package/src/prover/isabelle/isar/toplevel.ts +46 -52
  40. package/src/prover/isabelle/provers/classical.ts +1 -1
  41. package/src/prover/ocaml.ts +4 -1
  42. package/src/prover/prep/action.ts +1 -0
  43. package/src/prover/prep/methods.ts +50 -3
  44. package/src/prover/prep/normalize.ts +4 -1
  45. package/src/prover/prove.ts +58 -32
  46. package/src/prover/ptl/decide.ts +43 -63
  47. package/src/prover/smt/data.ts +51 -45
  48. package/src/prover/smt/encode.ts +1 -2
  49. package/src/prover/smt/rewrite.ts +1 -0
  50. package/src/prover/smt/solver/aig-tactic.ts +25 -15
  51. package/src/prover/smt/solver/arith-rewriter.ts +3 -5
  52. package/src/prover/smt/solver/asserted-formulas.ts +1 -1
  53. package/src/prover/smt/solver/ast-util.ts +3 -1
  54. package/src/prover/smt/solver/ast.ts +110 -152
  55. package/src/prover/smt/solver/bound-manager.ts +39 -28
  56. package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
  57. package/src/prover/smt/solver/bv-rewriter.ts +14 -16
  58. package/src/prover/smt/solver/bv1-blast.ts +1 -9
  59. package/src/prover/smt/solver/cg-table.ts +19 -14
  60. package/src/prover/smt/solver/check-logic.ts +6 -1
  61. package/src/prover/smt/solver/context.ts +20 -10
  62. package/src/prover/smt/solver/demodulator.ts +2 -2
  63. package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
  64. package/src/prover/smt/solver/distribute-forall.ts +1 -10
  65. package/src/prover/smt/solver/dom-simplify.ts +1 -1
  66. package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
  67. package/src/prover/smt/solver/e-matching.ts +6 -6
  68. package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
  69. package/src/prover/smt/solver/enode.ts +15 -1
  70. package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
  71. package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
  72. package/src/prover/smt/solver/euf/egraph.ts +65 -32
  73. package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
  74. package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
  75. package/src/prover/smt/solver/euf/mam.ts +6 -48
  76. package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
  77. package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
  78. package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
  79. package/src/prover/smt/solver/euf/q-solver.ts +2 -0
  80. package/src/prover/smt/solver/euf/th-solver.ts +1 -1
  81. package/src/prover/smt/solver/factor.ts +1 -11
  82. package/src/prover/smt/solver/fd-solver.ts +1 -2
  83. package/src/prover/smt/solver/fm-tactic.ts +19 -13
  84. package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
  85. package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
  86. package/src/prover/smt/solver/internalizer.ts +41 -2
  87. package/src/prover/smt/solver/lia2pb.ts +18 -4
  88. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  89. package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
  90. package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
  91. package/src/prover/smt/solver/macro-finder.ts +1 -1
  92. package/src/prover/smt/solver/mam-compiler.ts +13 -13
  93. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
  94. package/src/prover/smt/solver/maxcore.ts +4 -12
  95. package/src/prover/smt/solver/maxlex.ts +0 -7
  96. package/src/prover/smt/solver/maxsmt-base.ts +7 -0
  97. package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
  98. package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
  99. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
  100. package/src/prover/smt/solver/model-evaluator.ts +9 -5
  101. package/src/prover/smt/solver/model-macro-solver.ts +3 -3
  102. package/src/prover/smt/solver/muz/dl-context.ts +57 -3
  103. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
  104. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
  105. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
  106. package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
  107. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
  108. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
  109. package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
  110. package/src/prover/smt/solver/muz/hnf.ts +6 -5
  111. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
  112. package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
  113. package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
  114. package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
  115. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
  116. package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
  117. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
  118. package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
  119. package/src/prover/smt/solver/muz/substitution.ts +88 -37
  120. package/src/prover/smt/solver/nlqsat.ts +2 -2
  121. package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
  122. package/src/prover/smt/solver/nlsat/explain.ts +5 -0
  123. package/src/prover/smt/solver/nlsat/solver.ts +36 -25
  124. package/src/prover/smt/solver/opt-context.ts +9 -8
  125. package/src/prover/smt/solver/opt-nlsat.ts +68 -58
  126. package/src/prover/smt/solver/opt-solver.ts +16 -7
  127. package/src/prover/smt/solver/optsmt.ts +12 -9
  128. package/src/prover/smt/solver/pattern-inference.ts +2 -2
  129. package/src/prover/smt/solver/pb-rewriter.ts +13 -13
  130. package/src/prover/smt/solver/poly-rewriter.ts +2 -2
  131. package/src/prover/smt/solver/probes.ts +1 -1
  132. package/src/prover/smt/solver/propagate-values.ts +4 -0
  133. package/src/prover/smt/solver/proto-model.ts +5 -5
  134. package/src/prover/smt/solver/purify-arith.ts +50 -15
  135. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
  136. package/src/prover/smt/solver/qe-mbp.ts +13 -23
  137. package/src/prover/smt/solver/qe.ts +45 -53
  138. package/src/prover/smt/solver/qsat.ts +70 -90
  139. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
  140. package/src/prover/smt/solver/quasi-macros.ts +9 -18
  141. package/src/prover/smt/solver/rational.ts +17 -0
  142. package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
  143. package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
  144. package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
  145. package/src/prover/smt/solver/rewriter.ts +1 -1
  146. package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
  147. package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
  148. package/src/prover/smt/solver/sat/clause.ts +1 -3
  149. package/src/prover/smt/solver/sat/config.ts +3 -3
  150. package/src/prover/smt/solver/sat/consequences.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -15
  154. package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
  155. package/src/prover/smt/solver/sat/probing.ts +22 -19
  156. package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
  157. package/src/prover/smt/solver/sat/simplifier.ts +15 -56
  158. package/src/prover/smt/solver/sat/solver.ts +20 -19
  159. package/src/prover/smt/solver/sat/watch-list.ts +7 -0
  160. package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
  161. package/src/prover/smt/solver/seq-derive.ts +6 -7
  162. package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
  163. package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
  164. package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
  165. package/src/prover/smt/solver/seq-re-util.ts +1 -2
  166. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-live.ts +4 -4
  168. package/src/prover/smt/solver/seq-rewriter.ts +1 -4
  169. package/src/prover/smt/solver/smt-setup.ts +15 -9
  170. package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
  171. package/src/prover/smt/solver/smtlib-script.ts +866 -728
  172. package/src/prover/smt/solver/tactic.ts +66 -14
  173. package/src/prover/smt/solver/theory-array.ts +25 -58
  174. package/src/prover/smt/solver/theory-bv.ts +13 -50
  175. package/src/prover/smt/solver/theory-fpa.ts +46 -78
  176. package/src/prover/smt/solver/theory-pb.ts +10 -6
  177. package/src/prover/smt/solver/theory-recfun.ts +2 -2
  178. package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
  179. package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
  180. package/src/prover/smt/solver/theory-seq-state.ts +6 -3
  181. package/src/prover/smt/solver/theory-seq.ts +32 -54
  182. package/src/prover/smt/solver/theory.ts +16 -1
  183. package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
  184. package/src/prover/smt/solver/var-subst.ts +2 -2
  185. package/src/prover/smt/table.ts +3 -2
  186. package/src/prover/zenon/decide.ts +9 -11
  187. package/src/prover/zenon/node.ts +12 -11
  188. package/src/prover/zenon/tla/sets.ts +1 -1
  189. package/src/search.ts +131 -16
  190. package/src/successors.ts +1 -1
  191. package/src/symmetry.ts +2 -2
  192. package/src/tableau.ts +2 -2
  193. package/src/tlc/fingerprint.ts +81 -9
  194. package/src/tlc/summary.ts +29 -14
  195. package/src/typed-tier.ts +6535 -0
  196. package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
@@ -1,18 +1,20 @@
1
1
  // Ported from Z3 (src/ast/substitution/substitution.cpp, src/ast/substitution/unifier.cpp), MIT
2
2
  // license, see z3-license.txt.
3
3
  import { type AstManager, KIND_APP, KIND_VAR } from "../ast";
4
+ import { VarShifter } from "../rewriter-tpl";
4
5
 
5
6
  interface Binding {
6
7
  expr: number;
7
8
  offset: number;
8
9
  }
9
10
 
10
- const getKey = (index: number, offset: number) => `${offset}:${index}`;
11
+ // A variable index or an expression at one of the two offsets.
12
+ const getKey = (index: number, offset: number) => 2 * index + offset;
11
13
 
12
14
  // Bindings of variables at offsets to expressions at offsets. Applying it renames each unbound
13
15
  // variable at offset i by deltas[i].
14
16
  export class Substitution {
15
- private bindings = new Map<string, Binding>();
17
+ private bindings = new Map<number, Binding>();
16
18
 
17
19
  constructor(private manager: AstManager) {}
18
20
 
@@ -24,13 +26,15 @@ export class Substitution {
24
26
  // bindings of variables to variables, where the larger class becomes the root.
25
27
  unify(first: number, firstOffset: number, second: number, secondOffset: number) {
26
28
  const manager = this.manager;
27
- const parents = new Map<string, Binding>();
28
- const sizes = new Map<string, number>();
29
- const getNodeKey = (node: Binding) => `${node.expr}@${node.offset}`;
29
+ const parents = new Map<number, Binding>();
30
+ const sizes = new Map<number, number>();
31
+ const getNodeKey = (node: Binding) => getKey(node.expr, node.offset);
30
32
  for (const [key, root] of [...this.bindings].reverse()) {
31
33
  if (manager.kinds[root.expr] !== KIND_VAR) continue;
32
- const [offset, index] = key.split(":").map(Number);
33
- const child = { expr: manager.mkVar(index, manager.sorts[root.expr]), offset };
34
+ const child = {
35
+ expr: manager.mkVar(Math.floor(key / 2), manager.sorts[root.expr]),
36
+ offset: key % 2,
37
+ };
34
38
  const childSize = sizes.get(getNodeKey(child)) ?? 1;
35
39
  const rootSize = sizes.get(getNodeKey(root)) ?? 1;
36
40
  parents.set(getNodeKey(child), root);
@@ -95,8 +99,8 @@ export class Substitution {
95
99
 
96
100
  private isAcyclic() {
97
101
  const manager = this.manager;
98
- const visiting = new Set<string>();
99
- const done = new Set<string>();
102
+ const visiting = new Set<number>();
103
+ const done = new Set<number>();
100
104
  const visit = (expr: number, offset: number): boolean => {
101
105
  if (manager.isGround(expr)) return true;
102
106
  if (manager.kinds[expr] === KIND_VAR) {
@@ -113,11 +117,9 @@ export class Substitution {
113
117
  if (manager.kinds[expr] !== KIND_APP) return true;
114
118
  return manager.getArgs(expr).every((arg) => visit(arg, offset));
115
119
  };
116
- for (const key of this.bindings.keys()) {
117
- const [offset, index] = key.split(":").map(Number);
118
- const binding = this.bindings.get(key) as Binding;
120
+ for (const [key, binding] of this.bindings) {
119
121
  visiting.clear();
120
- visiting.add(getKey(index, offset));
122
+ visiting.add(key);
121
123
  if (!visit(binding.expr, binding.offset)) return false;
122
124
  }
123
125
  return true;
@@ -125,30 +127,79 @@ export class Substitution {
125
127
 
126
128
  apply(expr: number, offset: number, deltas: readonly number[] = [0]) {
127
129
  const manager = this.manager;
128
- const cache = new Map<string, number>();
129
- const visit = (current: number, currentOffset: number): number => {
130
- if (manager.isGround(current)) return current;
131
- const key = getKey(current, currentOffset);
132
- const cached = cache.get(key);
133
- if (cached !== undefined) return cached;
134
- const result = (() => {
135
- if (manager.kinds[current] === KIND_VAR) {
136
- const binding = this.bindings.get(getKey(manager.values[current], currentOffset));
137
- if (binding !== undefined) return visit(binding.expr, binding.offset);
138
- const delta = deltas[currentOffset] ?? 0;
139
- return delta === 0
140
- ? current
141
- : manager.mkVar(manager.values[current] + delta, manager.sorts[current]);
130
+ const cache = new Map<number, number>();
131
+ const todo = [{ expr, offset }];
132
+ while (todo.length > 0) {
133
+ const node = todo[todo.length - 1];
134
+ const key = getKey(node.expr, node.offset);
135
+ if (cache.has(key)) {
136
+ todo.pop();
137
+ continue;
138
+ }
139
+ const kind = manager.kinds[node.expr];
140
+ if (manager.isGround(node.expr)) cache.set(key, node.expr);
141
+ else if (kind === KIND_VAR) {
142
+ const binding = this.bindings.get(getKey(manager.values[node.expr], node.offset));
143
+ const bound =
144
+ binding === undefined ? undefined : cache.get(getKey(binding.expr, binding.offset));
145
+ if (binding !== undefined && bound === undefined) {
146
+ todo.push(binding);
147
+ continue;
142
148
  }
143
- if (manager.kinds[current] !== KIND_APP) return current;
144
- const args = manager.getArgs(current).map((arg) => visit(arg, currentOffset));
145
- return args.every((arg, index) => arg === manager.getArg(current, index))
146
- ? current
147
- : manager.mkApp(manager.decls[current], args, manager.sorts[current]);
148
- })();
149
- cache.set(key, result);
150
- return result;
151
- };
152
- return visit(expr, offset);
149
+ const delta = deltas[node.offset] ?? 0;
150
+ cache.set(
151
+ key,
152
+ bound ??
153
+ (delta === 0
154
+ ? node.expr
155
+ : manager.mkVar(manager.values[node.expr] + delta, manager.sorts[node.expr])),
156
+ );
157
+ } else if (kind === KIND_APP) {
158
+ let isVisited = true;
159
+ for (let index = manager.getNumArgs(node.expr); index > 0; index--) {
160
+ const arg = manager.getArg(node.expr, index - 1);
161
+ if (cache.has(getKey(arg, node.offset))) continue;
162
+ todo.push({ expr: arg, offset: node.offset });
163
+ isVisited = false;
164
+ }
165
+ if (!isVisited) continue;
166
+ const args = manager
167
+ .getArgs(node.expr)
168
+ .map((arg) => cache.get(getKey(arg, node.offset)) ?? arg);
169
+ cache.set(
170
+ key,
171
+ args.every((arg, index) => arg === manager.getArg(node.expr, index))
172
+ ? node.expr
173
+ : manager.mkApp(manager.decls[node.expr], args, manager.sorts[node.expr]),
174
+ );
175
+ } else cache.set(key, this.applyQuantifier(node.expr, node.offset, deltas));
176
+ todo.pop();
177
+ }
178
+ return cache.get(getKey(expr, offset)) ?? expr;
179
+ }
180
+
181
+ // The bindings move under the bound variables, by offset and then by variable.
182
+ private applyQuantifier(expr: number, offset: number, deltas: readonly number[]) {
183
+ const manager = this.manager;
184
+ const quantifier = manager.getQuantifier(expr);
185
+ const numVars = quantifier.sorts.length;
186
+ const nested = new Substitution(manager);
187
+ const shifter = new VarShifter(manager);
188
+ const shifted = [...this.bindings]
189
+ .sort((first, second) => (first[0] % 2) - (second[0] % 2) || first[0] - second[0])
190
+ .map((entry) => {
191
+ const moved = shifter.shift(entry[1].expr, 0, numVars, 0);
192
+ nested.bindings.set(entry[0] + 2 * numVars, { expr: moved, offset: entry[1].offset });
193
+ return moved;
194
+ });
195
+ const patterns = quantifier.patterns.map((pattern) => nested.apply(pattern, offset, deltas));
196
+ const noPatterns = quantifier.noPatterns.map((pattern) =>
197
+ nested.apply(pattern, offset, deltas),
198
+ );
199
+ const body = nested.apply(quantifier.body, offset, deltas);
200
+ const result = manager.mkQuantifier({ ...quantifier, patterns, noPatterns, body });
201
+ for (const moved of shifted) manager.decRef(moved);
202
+ shifter.release();
203
+ return result;
153
204
  }
154
205
  }
@@ -76,7 +76,7 @@ class DivRewriter extends RewriterTpl {
76
76
  manager.incRef(result);
77
77
  return result;
78
78
  }
79
- if (!manager.isGround(num) || !manager.isGround(den)) return -1;
79
+ if (!manager.isGroundApp(num) || !manager.isGroundApp(den)) return -1;
80
80
  const name = manager.mkFreshConst("div", SORT_REAL);
81
81
  this.trail.push(name);
82
82
  this.trail.push(num);
@@ -315,7 +315,7 @@ class Nlqsat {
315
315
  isUnsignedPositive(manager.getRationalValue(exponent))
316
316
  )
317
317
  continue;
318
- if (op === OP_DIV && manager.isGround(current)) {
318
+ if (op === OP_DIV && manager.isGroundApp(current)) {
319
319
  hasDivs = true;
320
320
  continue;
321
321
  }
@@ -925,8 +925,7 @@ export class AlgebraicManager {
925
925
  if (anum.value instanceof Rational) return [anum.value, anum.value];
926
926
  const cell = anum.value;
927
927
  const refined = this.um.refineToPrecision(cell.p, cell.lower, cell.upper, precision * 4);
928
- const lower = refined.lower.toRational();
929
- return [lower, refined.isInterval ? refined.upper.toRational() : lower];
928
+ return [refined.lower.toRational(), refined.upper.toRational()];
930
929
  }
931
930
 
932
931
  displayRootSmt2(anum: Anum) {
@@ -102,6 +102,11 @@ export class Explain {
102
102
  this.result = null;
103
103
  }
104
104
 
105
+ reset() {
106
+ this.resetResult();
107
+ this.core.reset();
108
+ }
109
+
105
110
  private collectPolys(literals: readonly number[]) {
106
111
  return literals.flatMap((literal) => {
107
112
  const atom = this.getAtom(literal);
@@ -405,7 +405,9 @@ export class NlsatSolver {
405
405
  this.checkpoint();
406
406
  if (this.value(literal) === L_FALSE) continue;
407
407
  if (this.value(literal) === L_TRUE) return true;
408
- const atom = this.atoms.getAtom(literal)!;
408
+ const atom = this.atoms.getAtom(literal);
409
+ if (atom === null)
410
+ throw new SmtInvariantError("a literal of an arithmetic clause has no atom");
409
411
  const set = this.evaluator.infeasibleIntervals(atom, (literal & 1) === 1, clause);
410
412
  if (set === null) {
411
413
  this.propagate(literal, null);
@@ -657,8 +659,7 @@ export class NlsatSolver {
657
659
  for (let index = 0; index < sorted.length; index++) clauses[index] = sorted[index];
658
660
  }
659
661
 
660
- private projectModel() {
661
- const cube = new ScopedLiterals(this.atoms);
662
+ private projectModel(cube: ScopedLiterals) {
662
663
  const seen = new Set<number>();
663
664
  for (const clause of this.clauses) {
664
665
  this.checkpoint();
@@ -670,15 +671,17 @@ export class NlsatSolver {
670
671
  }
671
672
  // Strict sector bounds keep every point of the projection extensible.
672
673
  this.explain.isFullDimensional = false;
673
- for (let variable = this.isInt.length - 1; variable >= 1 && cube.size > 0; variable--) {
674
- this.checkpoint();
675
- const projected = new ScopedLiterals(this.atoms);
676
- this.explain.projectVariable(variable, cube.literals, projected);
677
- cube.reset();
678
- for (const literal of projected.literals) cube.push(literal);
674
+ const projected = new ScopedLiterals(this.atoms);
675
+ try {
676
+ for (let variable = this.isInt.length - 1; variable >= 1 && cube.size > 0; variable--) {
677
+ this.checkpoint();
678
+ projected.reset();
679
+ this.explain.projectVariable(variable, cube.literals, projected);
680
+ [cube.literals, projected.literals] = [projected.literals, cube.literals];
681
+ }
682
+ } finally {
679
683
  projected.reset();
680
684
  }
681
- return cube;
682
685
  }
683
686
 
684
687
  private getCubeSup(cube: ScopedLiterals) {
@@ -717,28 +720,36 @@ export class NlsatSolver {
717
720
  this.checkpoint();
718
721
  const status = this.check();
719
722
  if (status !== L_TRUE) return status;
720
- const cube = this.projectModel();
721
- const sup = this.getCubeSup(cube);
722
- if (
723
- limit === null
724
- ? sup === null
725
- : sup !== null && !sup.isAttained && this.am.compare(sup.sup, limit) === 0
726
- )
727
- return L_TRUE;
728
- this.mkExternalClause(
729
- cube.literals.map((literal) => literal ^ 1),
730
- tag,
731
- );
732
- cube.reset();
723
+ const cube = new ScopedLiterals(this.atoms);
724
+ try {
725
+ this.projectModel(cube);
726
+ const sup = this.getCubeSup(cube);
727
+ if (
728
+ limit === null
729
+ ? sup === null
730
+ : sup !== null && !sup.isAttained && this.am.compare(sup.sup, limit) === 0
731
+ )
732
+ return L_TRUE;
733
+ this.mkExternalClause(
734
+ cube.literals.map((literal) => literal ^ 1),
735
+ tag,
736
+ );
737
+ } finally {
738
+ cube.reset();
739
+ }
733
740
  }
734
741
  } finally {
735
- this.maxVar = savedMaxVar;
736
742
  this.retract(tag);
743
+ this.maxVar = savedMaxVar;
737
744
  }
738
745
  }
739
746
 
740
747
  retract(tag: number, maxLemmas = Infinity) {
741
748
  this.initSearch();
749
+ this.explain.reset();
750
+ this.lemma.reset();
751
+ this.lazyClause.reset();
752
+ this.lemmaAssumptions = null;
742
753
  const isKept = (clause: Clause) => {
743
754
  const isFound = linearize([clause.assumptions]).includes(tag);
744
755
  if (isFound) this.delClause(clause);
@@ -748,7 +759,7 @@ export class NlsatSolver {
748
759
  this.learned = this.learned.filter(isKept);
749
760
  if (this.learned.length <= maxLemmas) return;
750
761
  this.learned.sort((first, second) => first.literals.length - second.literals.length);
751
- for (const clause of this.learned.splice(maxLemmas)) this.delClause(clause);
762
+ for (const clause of this.learned.splice(maxLemmas).reverse()) this.delClause(clause);
752
763
  }
753
764
 
754
765
  // Like Z3, only a falsified clause restores the assignment.
@@ -23,7 +23,7 @@ import { mkBvApp } from "./bv-decl-plugin";
23
23
  import { Goal } from "./goal";
24
24
  import { getPbSum } from "./lia2card";
25
25
  import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
26
- import type { MaxsatContext, MaxsatParams } from "./maxsmt-base";
26
+ import type { MaxsatContext, MaxsatParams, MaxsatSolver } from "./maxsmt-base";
27
27
  import { Maxsmt } from "./maxsmt";
28
28
  import { isInNraFragment } from "./opt-nlsat";
29
29
  import { canReuseNlsatSolver, giaPareto, ParetoNlsatSolver, type ParetoSolver } from "./opt-pareto";
@@ -245,19 +245,20 @@ export class OptContext {
245
245
  private getMaxsatContext(optSolver: OptSolver, options: OptOptions): MaxsatContext {
246
246
  const getSolver = () => this.satSolver ?? optSolver;
247
247
  const isSatEnabled = () => this.satSolver !== null;
248
+ const solver: MaxsatSolver = {
249
+ assertExpr: (expr) => getSolver().assertExpr(expr),
250
+ checkSat: (assumptions) => getSolver().check(assumptions),
251
+ getModel: () => getSolver().getModel(),
252
+ getUnsatCore: () => getSolver().getUnsatCore(),
253
+ findMutexes: (vars) => ({ status: L_TRUE, mutexes: getSolver().findMutexes(vars) }),
254
+ };
248
255
  return {
249
256
  manager: this.manager,
250
257
  params: options.maxsat,
251
258
  get isSatEnabled() {
252
259
  return isSatEnabled();
253
260
  },
254
- getSolver: () => ({
255
- assertExpr: (expr) => getSolver().assertExpr(expr),
256
- checkSat: (assumptions) => getSolver().check(assumptions),
257
- getModel: () => getSolver().getModel(),
258
- getUnsatCore: () => getSolver().getUnsatCore(),
259
- findMutexes: (vars) => ({ status: L_TRUE, mutexes: getSolver().findMutexes(vars) }),
260
- }),
261
+ getSolver: () => solver,
261
262
  getBaseModel: () => this.rawModel,
262
263
  hide: (decl) => {
263
264
  this.hiddenDecls.push(decl);
@@ -34,31 +34,44 @@ const PREPROCESSOR =
34
34
  "(using-params simplify :elim_and true :blast_distinct true) tseitin-cnf-core " +
35
35
  "(using-params simplify :elim_and true :blast_distinct true))";
36
36
 
37
- export interface NlsatOptResult {
38
- value: Anum | null;
37
+ interface NlsatSupremum {
38
+ value: Anum;
39
39
  lower: Rational;
40
40
  upper: Rational;
41
- isAttained: boolean;
42
- isUnbounded: boolean;
43
- hasSup: boolean;
44
41
  isOpen: boolean;
45
- sup: Anum | null;
46
- supLower: Rational;
47
- supUpper: Rational;
48
- model: ProtoModel | null;
42
+ }
43
+
44
+ interface NlsatNoModel {
45
+ hasModel: false;
46
+ }
47
+
48
+ interface NlsatOptimum {
49
+ hasModel: true;
50
+ model: ProtoModel;
51
+ value: Anum;
52
+ lower: Rational;
53
+ upper: Rational;
54
+ isUnbounded: boolean;
55
+ sup: NlsatSupremum | null;
49
56
  }
50
57
 
51
58
  interface NlsatOptOutcome {
52
59
  status: number;
53
- result: NlsatOptResult;
60
+ result: NlsatNoModel | NlsatOptimum;
54
61
  }
55
62
 
56
- interface Preprocessed {
57
- status: number;
58
- goal: Goal | null;
63
+ interface PreprocessedGoal {
64
+ status: typeof L_TRUE;
65
+ goal: Goal;
59
66
  objective: number;
60
67
  }
61
68
 
69
+ interface PreprocessedNothing {
70
+ status: typeof L_FALSE | typeof L_UNDEF;
71
+ }
72
+
73
+ const NO_MODEL: NlsatNoModel = { hasModel: false };
74
+
62
75
  interface Loaded {
63
76
  solver: NlsatSolver;
64
77
  variable: number;
@@ -175,7 +188,7 @@ export class NlsatOpt {
175
188
  objective: number,
176
189
  lower: Rational,
177
190
  upper: Rational | null,
178
- ): Preprocessed {
191
+ ): PreprocessedGoal | PreprocessedNothing {
179
192
  const manager = this.manager;
180
193
  const pinned = new RefVector(manager);
181
194
  const pin = (expr: number) => {
@@ -199,10 +212,11 @@ export class NlsatOpt {
199
212
  })();
200
213
  pinned.reset();
201
214
  const result = goals?.length === 1 ? goals[0] : null;
202
- if (result?.isInconsistent === true) return { status: L_FALSE, goal: null, objective: target };
203
- const isKept =
204
- result !== null && result.forms.items.some((form) => isOccurring(manager, target, form));
205
- return { status: isKept ? L_TRUE : L_UNDEF, goal: isKept ? result : null, objective: target };
215
+ if (result === null) return { status: L_UNDEF };
216
+ if (result.isInconsistent) return { status: L_FALSE };
217
+ return result.forms.items.some((form) => isOccurring(manager, target, form))
218
+ ? { status: L_TRUE, goal: result, objective: target }
219
+ : { status: L_UNDEF };
206
220
  }
207
221
 
208
222
  // The objective is nlsat's first variable and its maximization target.
@@ -270,23 +284,22 @@ export class NlsatOpt {
270
284
  proveUnbounded(hard: readonly number[], objective: number, lower: Rational) {
271
285
  if (!isInNraFragment(this.manager, [...hard, objective])) return L_UNDEF;
272
286
  const preprocessed = this.preprocess(hard, objective, lower, null);
273
- if (preprocessed.status === L_FALSE) return L_FALSE;
274
- if (preprocessed.goal === null) return L_UNDEF;
287
+ if (preprocessed.status !== L_TRUE) return preprocessed.status;
275
288
  return this.checkLimit(preprocessed.goal, preprocessed.objective, null);
276
289
  }
277
290
 
278
291
  // Refuting T >= sup, at a model below an open candidate supremum, proves a strict upper bound,
279
292
  // but not that feasible values approach it.
280
- private proveStrictUpperBound(loaded: Loaded, sup: Anum, best: Anum, result: NlsatOptResult) {
293
+ private proveStrictUpperBound(loaded: Loaded, sup: Anum, best: Anum): NlsatSupremum | null {
281
294
  const solver = loaded.solver;
282
- if (solver.am.compare(sup, best) <= 0) return;
295
+ if (solver.am.compare(sup, best) <= 0) return null;
283
296
  const literal = mkLowerBound(solver, loaded.variable, sup, false);
284
- if (literal === null) return;
297
+ if (literal === null) return null;
285
298
  solver.mkExternalClause([literal], null);
286
- if (solver.check() !== L_FALSE) return;
287
- result.sup = solver.am.copy(sup);
288
- [result.supLower, result.supUpper] = getBracket(solver, result.sup);
289
- result.hasSup = true;
299
+ if (solver.check() !== L_FALSE) return null;
300
+ const value = solver.am.copy(sup);
301
+ const bracket = getBracket(solver, value);
302
+ return { value, lower: bracket[0], upper: bracket[1], isOpen: false };
290
303
  }
291
304
 
292
305
  maximize(
@@ -297,30 +310,20 @@ export class NlsatOpt {
297
310
  maxRounds: number,
298
311
  supremumRlimit: number,
299
312
  ): NlsatOptOutcome {
300
- const result: NlsatOptResult = {
301
- value: null,
302
- lower: Rational.zero,
303
- upper: Rational.zero,
304
- isAttained: false,
305
- isUnbounded: false,
306
- hasSup: false,
307
- isOpen: false,
308
- sup: null,
309
- supLower: Rational.zero,
310
- supUpper: Rational.zero,
311
- model: null,
312
- };
313
- if (!isInNraFragment(this.manager, [...hard, objective])) return { status: L_UNDEF, result };
313
+ if (!isInNraFragment(this.manager, [...hard, objective]))
314
+ return { status: L_UNDEF, result: NO_MODEL };
314
315
  const preprocessed = this.preprocess(hard, objective, lower, upper);
316
+ if (preprocessed.status !== L_TRUE) return { status: preprocessed.status, result: NO_MODEL };
315
317
  const goal = preprocessed.goal;
316
- if (goal === null) return { status: preprocessed.status, result };
317
318
  const loaded = this.load(goal, preprocessed.objective);
318
- if (loaded === null) return { status: L_UNDEF, result };
319
+ if (loaded === null) return { status: L_UNDEF, result: NO_MODEL };
319
320
  const solver = loaded.solver;
320
321
  const am = solver.am;
321
322
  let status = L_UNDEF;
322
323
  let best: Anum | null = null;
323
324
  let sup: Anum | null = null;
325
+ let model: ProtoModel | null = null;
326
+ let isUnbounded = false;
324
327
  let unboundedRounds = 0;
325
328
  // A round without a candidate supremum is inconclusive, since bounds through later variables
326
329
  // reach the objective only through conflicts, so five in a row probe for a feasible ray.
@@ -330,13 +333,13 @@ export class NlsatOpt {
330
333
  best = am.copy(solver.getValue(loaded.variable));
331
334
  const found = solver.getMaxVarSup();
332
335
  sup = found === null ? null : found.sup;
333
- result.model?.decRef();
334
- result.model = this.extractModel(loaded, goal, preprocessed.objective);
335
- result.model.incRef();
336
+ model?.decRef();
337
+ model = this.extractModel(loaded, goal, preprocessed.objective);
338
+ model.incRef();
336
339
  if (sup === null) {
337
340
  if (++unboundedRounds > 4) {
338
341
  if (upper === null && this.checkLimit(goal, preprocessed.objective, null) === L_TRUE)
339
- result.isUnbounded = true;
342
+ isUnbounded = true;
340
343
  break;
341
344
  }
342
345
  } else unboundedRounds = 0;
@@ -347,20 +350,27 @@ export class NlsatOpt {
347
350
  }
348
351
  solver.mkExternalClause([literal], null);
349
352
  }
350
- if (best === null) return { status: status === L_FALSE ? L_FALSE : L_UNDEF, result };
351
- result.value = best;
352
- [result.lower, result.upper] = getBracket(solver, best);
353
- result.isAttained = status === L_FALSE;
354
- if (status === L_TRUE && sup !== null) this.proveStrictUpperBound(loaded, sup, best, result);
355
- const certifiedSup = result.sup;
356
- if (certifiedSup !== null)
357
- result.isOpen =
353
+ if (best === null || model === null)
354
+ return { status: status === L_FALSE ? L_FALSE : L_UNDEF, result: NO_MODEL };
355
+ const bracket = getBracket(solver, best);
356
+ const certified =
357
+ status === L_TRUE && sup !== null ? this.proveStrictUpperBound(loaded, sup, best) : null;
358
+ if (certified !== null)
359
+ certified.isOpen =
358
360
  this.getBoundedLimit(supremumRlimit, () =>
359
- this.checkLimit(goal, preprocessed.objective, certifiedSup),
361
+ this.checkLimit(goal, preprocessed.objective, certified.value),
360
362
  ) === L_TRUE;
361
363
  return {
362
- status: result.isAttained || result.isUnbounded || result.isOpen ? L_TRUE : L_UNDEF,
363
- result,
364
+ status: status === L_FALSE || isUnbounded || certified?.isOpen === true ? L_TRUE : L_UNDEF,
365
+ result: {
366
+ hasModel: true,
367
+ model,
368
+ value: best,
369
+ lower: bracket[0],
370
+ upper: bracket[1],
371
+ isUnbounded,
372
+ sup: certified,
373
+ },
364
374
  };
365
375
  }
366
376
  }
@@ -1,5 +1,5 @@
1
1
  // Ported from Z3 (src/opt/opt_solver.cpp, src/opt/opt_search.h), MIT license, see z3-license.txt.
2
- import { SmtCanceledError } from "../../../errors";
2
+ import { SmtCanceledError, SmtInvariantError } from "../../../errors";
3
3
  import { type AstManager, FAMILY_ARITH, FAMILY_PB } from "./ast";
4
4
  import { InfEps } from "./inf-eps";
5
5
  import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
@@ -9,10 +9,9 @@ import type { ProtoModel } from "./proto-model";
9
9
  import { Rational } from "./rational";
10
10
  import { RefVector } from "./ref-vector";
11
11
  import { SmtKernel } from "./smt-kernel";
12
- import type { KernelParams } from "./solver";
12
+ import type { TacticEnvironment } from "./tactic";
13
13
 
14
14
  const MODEL_BOUND_SCALE = Rational.of(10n ** 12n);
15
- const DUAL_BOUND_RLIMIT = 100;
16
15
 
17
16
  export interface MaximizeResult {
18
17
  // The no-model path accepts the hint without validating it.
@@ -53,12 +52,14 @@ export class OptSolver {
53
52
  private pinned: RefVector;
54
53
  private isFirst = true;
55
54
  private numScopes = 0;
55
+ private readonly dualBoundRlimit: number;
56
56
  wasUnknown = false;
57
57
 
58
58
  constructor(
59
59
  private readonly manager: AstManager,
60
- params: KernelParams,
60
+ params: TacticEnvironment,
61
61
  ) {
62
+ this.dualBoundRlimit = Number(params.parameters.get("opt.optsmt_dual_bound_rlimit") ?? 100);
62
63
  // opt_solver turns relevancy off under the default case split strategy, so a decided bound,
63
64
  // such as one optsmt made for a lower bound, reaches the arithmetic solver.
64
65
  this.kernel = new SmtKernel(manager, {
@@ -84,7 +85,9 @@ export class OptSolver {
84
85
  private get arith() {
85
86
  const context = this.kernel.context;
86
87
  context.registerFamily(FAMILY_ARITH);
87
- return context.arith!;
88
+ if (context.arith === undefined)
89
+ throw new SmtInvariantError("get_optimizer found no arithmetic theory");
90
+ return context.arith;
88
91
  }
89
92
 
90
93
  assertExpr(expr: number) {
@@ -200,7 +203,13 @@ export class OptSolver {
200
203
  if (bound !== undefined && InfEps.of(bound).compare(this.objectiveValues[index]) > 0)
201
204
  this.objectiveValues[index] = InfEps.of(bound);
202
205
  if (this.manager.limit.isExhausted()) return outcome;
203
- if (isProbing && value.isFinite() && upper !== null && !upper.isGlobal) {
206
+ if (
207
+ isProbing &&
208
+ value.isFinite() &&
209
+ upper !== null &&
210
+ !upper.isGlobal &&
211
+ this.dualBoundRlimit !== 0
212
+ ) {
204
213
  if (this.checkUpperBound(index, upper.value) === L_FALSE) result.upperBound = upper.value;
205
214
  if (!this.manager.limit.inc() || !this.checkBound(index, value, result)) return outcome;
206
215
  } else if (value.isFinite()) {
@@ -224,7 +233,7 @@ export class OptSolver {
224
233
  if (!(error instanceof SmtCanceledError)) throw error;
225
234
  return L_UNDEF;
226
235
  }
227
- limit.push(DUAL_BOUND_RLIMIT);
236
+ limit.push(this.dualBoundRlimit);
228
237
  const result = (() => {
229
238
  try {
230
239
  this.assertExpr(this.mkGe(index, InfEps.of(value, Rational.one)));