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
@@ -3,11 +3,10 @@
3
3
  import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
4
4
  import { RandomGen } from "../random-gen";
5
5
  import { Big } from "./big";
6
+ import { UINT_MAX } from "./clause";
6
7
  import { getBool, getNumber, type SatParams } from "./config";
7
8
  import type { Solver } from "./solver";
8
9
 
9
- const UINT_MAX = 4294967295;
10
-
11
10
  export class AsymmBranch {
12
11
  private counter = 0;
13
12
  private rand = new RandomGen(0);
@@ -68,22 +67,30 @@ export class AsymmBranch {
68
67
  clauses.sort((first, second) => solver.arena.size[second] - solver.arena.size[first]);
69
68
  this.counter -= clauses.length;
70
69
  let next = 0;
71
- for (let index = 0; index < clauses.length; index++) {
72
- const clause = clauses[index];
73
- if (solver.isInconsistent) {
74
- for (; index < clauses.length; index++) clauses[next++] = clauses[index];
75
- break;
76
- }
77
- if (this.counter < limit || solver.arena.wasRemoved(clause)) {
70
+ let index = 0;
71
+ try {
72
+ for (; index < clauses.length; index++) {
73
+ const clause = clauses[index];
74
+ if (solver.isInconsistent) {
75
+ for (; index < clauses.length; index++) clauses[next++] = clauses[index];
76
+ break;
77
+ }
78
+ if (this.counter < limit || solver.arena.wasRemoved(clause)) {
79
+ clauses[next++] = clause;
80
+ continue;
81
+ }
82
+ solver.checkpoint();
83
+ if (big === undefined ? !this.processClause(clause) : !this.processSampled(big, clause))
84
+ continue;
78
85
  clauses[next++] = clause;
79
- continue;
80
86
  }
81
- solver.checkpoint();
82
- if (big === undefined ? !this.processClause(clause) : !this.processSampled(big, clause))
83
- continue;
84
- clauses[next++] = clause;
87
+ clauses.length = next;
88
+ } catch (error) {
89
+ for (; index < clauses.length; index++) clauses[next++] = clauses[index];
90
+ clauses.length = next;
91
+ this.counter = -this.counter;
92
+ throw error;
85
93
  }
86
- clauses.length = next;
87
94
  }
88
95
 
89
96
  run(isForced: boolean) {
@@ -101,38 +108,40 @@ export class AsymmBranch {
101
108
  const wasProbing = solver.isProbing;
102
109
  solver.isProbing = true;
103
110
  let isChanged = true;
104
- for (let count = 0; isChanged && count < 2; count++) {
105
- isChanged = false;
106
- solver.touchIndex++;
107
- if (this.isSampled && this.processBig(new Big(solver.rand), true)) isChanged = true;
108
- if (this.isSampled && this.processBig(new Big(solver.rand), false)) isChanged = true;
109
- if (this.isEnabled) {
110
- this.counter = 0;
111
- const elim = this.elimLiterals;
112
- this.processClauses(undefined, solver.clauses);
113
- solver.propagate(false);
114
- if (this.elimLiterals > elim) isChanged = true;
115
- this.counter = -this.counter;
111
+ try {
112
+ for (let count = 0; isChanged && count < 2; count++) {
113
+ isChanged = false;
114
+ solver.touchIndex++;
115
+ if (this.isSampled && this.processBig(new Big(solver.rand), true)) isChanged = true;
116
+ if (this.isSampled && this.processBig(new Big(solver.rand), false)) isChanged = true;
117
+ if (this.isEnabled) {
118
+ this.counter = 0;
119
+ const elim = this.elimLiterals;
120
+ this.processClauses(undefined, solver.clauses);
121
+ solver.propagate(false);
122
+ if (this.elimLiterals > elim) isChanged = true;
123
+ this.counter = -this.counter;
124
+ }
125
+ this.touchIndex = solver.touchIndex;
116
126
  }
117
- this.touchIndex = solver.touchIndex;
127
+ } finally {
128
+ solver.isProbing = wasProbing;
118
129
  }
119
130
  for (let index = 0; index < savedPhase.length; index++) solver.phase[index] = savedPhase[index];
120
- solver.isProbing = wasProbing;
121
131
  this.limit = Math.min(2 * this.limit, UINT_MAX);
122
132
  }
123
133
 
124
134
  private processAll(clause: number) {
125
135
  this.detachScoped(clause);
126
- let result = true;
127
- for (let index = this.solver.arena.size[clause]; index-- > 0;) {
128
- const newSize = this.flipLiteralAt(clause, index);
129
- if (newSize !== -1) {
130
- result = this.cleanup(clause, index, newSize);
131
- break;
136
+ try {
137
+ for (let index = this.solver.arena.size[clause]; index-- > 0;) {
138
+ const newSize = this.flipLiteralAt(clause, index);
139
+ if (newSize !== -1) return this.cleanup(clause, index, newSize);
132
140
  }
141
+ return true;
142
+ } finally {
143
+ this.attachScoped(clause);
133
144
  }
134
- this.attachScoped(clause);
135
- return result;
136
145
  }
137
146
 
138
147
  private sort(big: Big, clause: number) {
@@ -286,10 +295,12 @@ export class AsymmBranch {
286
295
 
287
296
  private processSampled(big: Big, clause: number) {
288
297
  this.detachScoped(clause);
289
- this.sort(big, clause);
290
- const result = this.isHiddenTautology(big) || this.eliminateHiddenLiterals(big, clause);
291
- this.attachScoped(clause);
292
- return result;
298
+ try {
299
+ this.sort(big, clause);
300
+ return this.isHiddenTautology(big) || this.eliminateHiddenLiterals(big, clause);
301
+ } finally {
302
+ this.attachScoped(clause);
303
+ }
293
304
  }
294
305
 
295
306
  private processClause(clause: number) {
@@ -305,10 +316,12 @@ export class AsymmBranch {
305
316
  this.counter -= size;
306
317
  if (this.isAll) return this.processAll(clause);
307
318
  this.detachScoped(clause);
308
- const flipIndex = this.rand.next() % size;
309
- const newSize = this.flipLiteralAt(clause, flipIndex);
310
- const result = newSize === -1 || this.cleanup(clause, flipIndex, newSize);
311
- this.attachScoped(clause);
312
- return result;
319
+ try {
320
+ const flipIndex = this.rand.next() % size;
321
+ const newSize = this.flipLiteralAt(clause, flipIndex);
322
+ return newSize === -1 || this.cleanup(clause, flipIndex, newSize);
323
+ } finally {
324
+ this.attachScoped(clause);
325
+ }
313
326
  }
314
327
  }
@@ -46,12 +46,6 @@ export class UseList {
46
46
  this.numRedundant[arena.get(clause, index)]++;
47
47
  }
48
48
 
49
- unblock(clause: number) {
50
- const arena = this.arena;
51
- for (let index = 0; index < arena.size[clause]; index++)
52
- this.numRedundant[arena.get(clause, index)]--;
53
- }
54
-
55
49
  erase(clause: number, exceptLit = NULL_LITERAL) {
56
50
  const arena = this.arena;
57
51
  const isLearned = arena.isLearned(clause);
@@ -3,6 +3,7 @@
3
3
 
4
4
  export const NULL_LITERAL = -2;
5
5
  export const NULL_BOOL_VAR = -1;
6
+ export const UINT_MAX = 4294967295;
6
7
 
7
8
  const STRENGTHENED = 1;
8
9
  const REMOVED = 2;
@@ -31,7 +32,6 @@ export class ClauseArena {
31
32
  private numIds = 0;
32
33
  start = new Int32Array(64);
33
34
  size = new Int32Array(64);
34
- capacity = new Int32Array(64);
35
35
  flags = new Int32Array(64);
36
36
  approx = new Int32Array(64);
37
37
  inactRounds = new Int32Array(64);
@@ -44,7 +44,6 @@ export class ClauseArena {
44
44
  const length = this.start.length * 2;
45
45
  this.start = grow(this.start, length);
46
46
  this.size = grow(this.size, length);
47
- this.capacity = grow(this.capacity, length);
48
47
  this.flags = grow(this.flags, length);
49
48
  this.approx = grow(this.approx, length);
50
49
  this.inactRounds = grow(this.inactRounds, length);
@@ -61,7 +60,6 @@ export class ClauseArena {
61
60
  this.start[id] = this.top;
62
61
  this.top += numLits;
63
62
  this.size[id] = numLits;
64
- this.capacity[id] = numLits;
65
63
  this.flags[id] = isLearned ? LEARNED : 0;
66
64
  this.inactRounds[id] = 0;
67
65
  this.glue[id] = 255;
@@ -2,6 +2,7 @@
2
2
  // src/sat/sat_simplifier_params.pyg, src/sat/sat_asymm_branch_params.pyg,
3
3
  // src/sat/sat_scc_params.pyg), MIT license, see z3-license.txt.
4
4
  import { SmtTacticError } from "../../../../errors";
5
+ import { UINT_MAX } from "./clause";
5
6
 
6
7
  export const PS_ALWAYS_TRUE = 0;
7
8
  export const PS_ALWAYS_FALSE = 1;
@@ -21,8 +22,6 @@ export const GC_GLUE = 2;
21
22
  export const GC_GLUE_PSM = 3;
22
23
  export const GC_PSM_GLUE = 4;
23
24
 
24
- const UINT_MAX = 4294967295;
25
-
26
25
  export type SatParams = ReadonlyMap<string, boolean | number | string>;
27
26
 
28
27
  const PHASES = new Map([
@@ -91,11 +90,12 @@ export const getSatConfig = (params: SatParams) => ({
91
90
  "invalid phase selection strategy: always_false, always_true, basic_caching, caching, random",
92
91
  ),
93
92
  rephaseBase: getNumber(params, "rephase.base", 1000),
94
- activityScale: getNumber(params, "reorder.activity_scale", 100),
95
93
  searchSatConflicts: getNumber(params, "search.sat.conflicts", 400),
96
94
  searchUnsatConflicts: getNumber(params, "search.unsat.conflicts", 400),
97
95
  restartInitial: getNumber(params, "restart.initial", 2),
98
96
  restartFactor: getNumber(params, "restart.factor", 1.5),
97
+ restartMax: getNumber(params, "restart.max", UINT_MAX),
98
+ inprocessMax: getNumber(params, "inprocess.max", UINT_MAX),
99
99
  randomFreq: getNumber(params, "random_freq", 0.01),
100
100
  randomSeed: getNumber(params, "random_seed", 0),
101
101
  burstSearch: getNumber(params, "burst_search", 100),
@@ -133,7 +133,7 @@ class ConsequenceFinder {
133
133
  solver.initSearch();
134
134
  solver.propagate(false);
135
135
  if (solver.isInconsistent) return L_FALSE;
136
- solver.initAssumptions(asms.length > 0 ? asms : [2 * solver.mkVar(true, false)]);
136
+ solver.initAssumptions(asms.length > 0 ? asms : [2 * solver.mkVar(true)]);
137
137
  solver.propagate(false);
138
138
  if (solver.checkInconsistent()) return L_FALSE;
139
139
  this.extractFixedConsequences(unfixedLits, assumptions, unfixedVars);
@@ -185,7 +185,7 @@ export class Goal2Sat implements SatInternalizer, EufInternalizer {
185
185
 
186
186
  private addVar(isExternal: boolean, expr: number) {
187
187
  const replayed = this.expr2varReplay?.get(expr);
188
- return replayed ?? this.solver.mkVar(isExternal, true);
188
+ return replayed ?? this.solver.mkVar(isExternal);
189
189
  }
190
190
 
191
191
  private mkBoolVar(expr: number) {
@@ -11,7 +11,7 @@ import { convertModel, mkIncSatEufPreprocess, mkIncSatPreprocess } from "../tact
11
11
  import type { SatParams } from "./config";
12
12
  import { Goal2Sat } from "./goal2sat";
13
13
  import { getConsequences } from "./consequences";
14
- import { sat2goal } from "./sat2goal";
14
+ import { isLiteral, sat2goal } from "./sat2goal";
15
15
  import { Solver } from "./solver";
16
16
 
17
17
  const BIT_BLAST_PARAMS = {
@@ -68,18 +68,10 @@ export class IncSatSolver {
68
68
  this.internalized = new RefVector(manager);
69
69
  }
70
70
 
71
- private isLiteral(expr: number) {
72
- const manager = this.manager;
73
- return (
74
- manager.isUninterpretedConst(expr) ||
75
- (manager.isNot(expr) && manager.isUninterpretedConst(manager.getArg(expr, 0)))
76
- );
77
- }
78
-
79
71
  private isClause(expr: number): boolean {
80
72
  const manager = this.manager;
81
73
  if (manager.depths[expr] > 4) return false;
82
- if (this.isLiteral(expr)) return true;
74
+ if (isLiteral(manager, expr)) return true;
83
75
  if (!manager.isApp(expr)) return false;
84
76
  const op = manager.getOp(expr);
85
77
  const isConnective =
@@ -199,7 +191,7 @@ export class IncSatSolver {
199
191
  const literals: number[] = [];
200
192
  const asm2fml = new Map<number, number>();
201
193
  for (const assumption of assumptions) {
202
- if (this.isLiteral(assumption)) {
194
+ if (isLiteral(this.manager, assumption)) {
203
195
  literals.push(assumption);
204
196
  asm2fml.set(assumption, assumption);
205
197
  continue;
@@ -254,7 +246,7 @@ export class IncSatSolver {
254
246
  const consequences: number[] = [];
255
247
  const internalized = this.internalizeFormulas();
256
248
  if (internalized !== L_TRUE) return { result: internalized, consequences };
257
- if (!assumptions.every((assumption) => this.isLiteral(assumption)))
249
+ if (!assumptions.every((assumption) => isLiteral(this.manager, assumption)))
258
250
  throw new SmtUnsupportedError("get-consequences assumptions that are not literals");
259
251
  this.internalizeAssumptions(assumptions);
260
252
  const found = getConsequences(
@@ -14,7 +14,6 @@ export interface McEntry {
14
14
  boolVar: number;
15
15
  kind: number;
16
16
  clauses: number[];
17
- clause: number[];
18
17
  elimStacks: (number[] | undefined)[];
19
18
  }
20
19
 
@@ -26,7 +25,6 @@ const getLitValue = (lit: number, model: Int8Array) => {
26
25
  export class ModelConverter {
27
26
  entries: McEntry[] = [];
28
27
  exposedLim = 0;
29
- private mark: boolean[] = [];
30
28
  elimStack: number[] = [];
31
29
 
32
30
  private processStack(model: Int8Array, clause: number[], stack: number[]) {
@@ -74,7 +72,7 @@ export class ModelConverter {
74
72
  }
75
73
 
76
74
  mk(kind: number, boolVar: number) {
77
- const entry: McEntry = { boolVar, kind, clauses: [], clause: [], elimStacks: [] };
75
+ const entry: McEntry = { boolVar, kind, clauses: [], elimStacks: [] };
78
76
  this.entries.push(entry);
79
77
  return entry;
80
78
  }
@@ -89,10 +87,6 @@ export class ModelConverter {
89
87
  this.elimStack = [];
90
88
  }
91
89
 
92
- setClause(entry: McEntry, lits: number[]) {
93
- entry.clause.push(...lits);
94
- }
95
-
96
90
  insert(entry: McEntry, lits: number[]) {
97
91
  entry.clauses.push(...lits, NULL_LITERAL);
98
92
  this.addElimStack(entry);
@@ -105,14 +99,6 @@ export class ModelConverter {
105
99
  source.exposedLim = 0;
106
100
  }
107
101
 
108
- addClause(lits: number[]) {
109
- if (this.entries.length === 0) return;
110
- for (const lit of lits) {
111
- while (this.mark.length <= lit >> 1) this.mark.push(false);
112
- this.mark[lit >> 1] = true;
113
- }
114
- }
115
-
116
102
  private swap(boolVar: number, size: number, clause: number[]) {
117
103
  for (let index = 0; index < size; index++)
118
104
  if (clause[index] >> 1 === boolVar) {
@@ -1,11 +1,19 @@
1
1
  // Ported from Z3 (src/sat/smt/pb_solver.h, src/sat/smt/pb_solver.cpp,
2
2
  // src/sat/smt/pb_internalize.cpp), MIT license, see z3-license.txt.
3
3
  import { SmtTacticError } from "../../../../errors";
4
- import { type AstManager, OP_AT_LEAST_K, OP_AT_MOST_K, OP_PB_EQ, OP_PB_GE, OP_PB_LE } from "../ast";
4
+ import {
5
+ type AstManager,
6
+ OP_AT_LEAST_K,
7
+ OP_AT_MOST_K,
8
+ OP_PB_EQ,
9
+ OP_PB_GE,
10
+ OP_PB_LE,
11
+ SORT_BOOL,
12
+ } from "../ast";
5
13
  import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
6
- import { getPbCoeff, getPbK, hasUnitCoefficients } from "../pb-rewriter";
14
+ import { getPbCoeff, getPbK, hasUnitCoefficients, mkPbGe } from "../pb-rewriter";
7
15
  import { Rational } from "../rational";
8
- import { NULL_LITERAL } from "./clause";
16
+ import { NULL_LITERAL, UINT_MAX } from "./clause";
9
17
  import { Card, type Constraint, type ConstraintHost, Pbc } from "./pb-constraint";
10
18
  import {
11
19
  JUSTIFICATION_BINARY,
@@ -16,7 +24,6 @@ import {
16
24
  type Solver,
17
25
  } from "./solver";
18
26
 
19
- const UINT_MAX = 4294967295;
20
27
  const INT_MAX = 2147483647;
21
28
  const INT_MIN = -2147483648;
22
29
 
@@ -1005,14 +1012,6 @@ export class PbSolver implements SatExtension, ConstraintHost {
1005
1012
  this.initWatch(constraint);
1006
1013
  }
1007
1014
 
1008
- private numNonlearnedBin(lit: number) {
1009
- const wlist = this.getWlist(lit ^ 1);
1010
- let count = 0;
1011
- for (let index = 0; index < wlist.size; index++)
1012
- if (wlist.isBinary(index) && !wlist.isLearned(index)) count++;
1013
- return count;
1014
- }
1015
-
1016
1015
  private initUseLists() {
1017
1016
  const solver = this.solver;
1018
1017
  const arena = solver.arena;
@@ -1071,7 +1070,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1071
1070
  this.value(lit) !== L_UNDEF ||
1072
1071
  this.cnstrUseList[lit].length === 0 ||
1073
1072
  this.useCount(lit ^ 1) !== 0 ||
1074
- this.numNonlearnedBin(lit ^ 1) !== 0
1073
+ this.getWlist(lit).numNonlearnedBin() !== 0
1075
1074
  )
1076
1075
  return false;
1077
1076
  this.solver.assignScoped(lit);
@@ -1323,6 +1322,33 @@ export class PbSolver implements SatExtension, ConstraintHost {
1323
1322
  if (isChanged) lits.splice(0, lits.length, ...members);
1324
1323
  }
1325
1324
 
1325
+ toFormulas(lit2expr: (lit: number) => number, formulas: number[]) {
1326
+ const manager = this.manager;
1327
+ for (const constraint of this.constraints) {
1328
+ const args = constraint.lits.map(lit2expr);
1329
+ const formula =
1330
+ constraint instanceof Pbc
1331
+ ? mkPbGe(
1332
+ manager,
1333
+ constraint.coeffs.map((coeff) => Rational.fromNumber(coeff)),
1334
+ args,
1335
+ Rational.fromNumber(constraint.k),
1336
+ )
1337
+ : manager.mkApp(
1338
+ manager.mkPbDecl(
1339
+ OP_AT_LEAST_K,
1340
+ [Rational.fromNumber(constraint.k)],
1341
+ args.map(() => SORT_BOOL),
1342
+ ),
1343
+ args,
1344
+ SORT_BOOL,
1345
+ );
1346
+ formulas.push(
1347
+ constraint.lit === NULL_LITERAL ? formula : manager.mkEq(lit2expr(constraint.lit), formula),
1348
+ );
1349
+ }
1350
+ }
1351
+
1326
1352
  private active2card() {
1327
1353
  const wlits: { coeff: number; lit: number }[] = [];
1328
1354
  let sum = 0;
@@ -1450,7 +1476,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1450
1476
  this.addRootPbGe(wlits, bound, isSign);
1451
1477
  return NULL_LITERAL;
1452
1478
  }
1453
- const lit = 2 * this.solver.mkVar(true, true);
1479
+ const lit = 2 * this.solver.mkVar(true);
1454
1480
  this.addPbGe(lit, wlits, bound, false);
1455
1481
  return isSign ? lit ^ 1 : lit;
1456
1482
  }
@@ -1462,7 +1488,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1462
1488
  this.addRootPbGe(wlits, bound, isSign);
1463
1489
  return NULL_LITERAL;
1464
1490
  }
1465
- const lit = 2 * this.solver.mkVar(true, true);
1491
+ const lit = 2 * this.solver.mkVar(true);
1466
1492
  this.addPbGe(lit, wlits, bound, false);
1467
1493
  return isSign ? lit ^ 1 : lit;
1468
1494
  }
@@ -1472,8 +1498,8 @@ export class PbSolver implements SatExtension, ConstraintHost {
1472
1498
  let k = getPbK(this.manager, this.manager.decls[expr]);
1473
1499
  const wlits = this.convertPbWlits(expr);
1474
1500
  const isBaseAssert = isRoot && !isSign;
1475
- const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true, true);
1476
- const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true, true);
1501
+ const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1502
+ const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1477
1503
  this.addPbGe(lit1, wlits, Number(BigInt.asUintN(32, k.num)), false);
1478
1504
  k = k.neg();
1479
1505
  for (let index = 0; index < wlits.lits.length; index++) {
@@ -1481,7 +1507,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1481
1507
  k = k.add(Rational.of(BigInt(wlits.coeffs[index])));
1482
1508
  }
1483
1509
  if (k.isNegative()) {
1484
- const lit = 2 * solver.mkVar(false, true);
1510
+ const lit = 2 * solver.mkVar(false);
1485
1511
  solver.assignUnit(lit ^ 1);
1486
1512
  this.si.cache(expr, lit);
1487
1513
  return isSign ? lit ^ 1 : lit;
@@ -1493,7 +1519,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1493
1519
 
1494
1520
  private mkConjunction(expr: number, lit1: number, lit2: number, isSign: boolean) {
1495
1521
  const solver = this.solver;
1496
- const lit = 2 * solver.mkVar(false, true);
1522
+ const lit = 2 * solver.mkVar(false);
1497
1523
  solver.mkClause([lit ^ 1, lit1]);
1498
1524
  solver.mkClause([lit ^ 1, lit2]);
1499
1525
  solver.mkClause([lit1 ^ 1, lit2 ^ 1, lit]);
@@ -1512,7 +1538,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1512
1538
  this.addAtLeast(NULL_LITERAL, lits, bound, false);
1513
1539
  return NULL_LITERAL;
1514
1540
  }
1515
- const lit = 2 * this.solver.mkVar(true, true);
1541
+ const lit = 2 * this.solver.mkVar(true);
1516
1542
  this.addAtLeast(lit, lits, bound, false);
1517
1543
  this.si.cache(expr, lit);
1518
1544
  return isSign ? lit ^ 1 : lit;
@@ -1531,7 +1557,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1531
1557
  this.addAtLeast(NULL_LITERAL, lits, bound, false);
1532
1558
  return NULL_LITERAL;
1533
1559
  }
1534
- const lit = 2 * this.solver.mkVar(true, true);
1560
+ const lit = 2 * this.solver.mkVar(true);
1535
1561
  this.addAtLeast(lit, lits, bound, false);
1536
1562
  this.si.cache(expr, lit);
1537
1563
  return isSign ? lit ^ 1 : lit;
@@ -1541,8 +1567,8 @@ export class PbSolver implements SatExtension, ConstraintHost {
1541
1567
  const solver = this.solver;
1542
1568
  const lits = this.convertPbArgs(expr);
1543
1569
  const isBaseAssert = isRoot && !isSign;
1544
- const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true, true);
1545
- const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true, true);
1570
+ const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1571
+ const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1546
1572
  const bound = k.compare(Rational.of(BigInt(lits.length))) > 0 ? lits.length + 1 : Number(k.num);
1547
1573
  this.addAtLeast(lit1, lits, bound, false);
1548
1574
  for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
@@ -135,26 +135,30 @@ export class Probing {
135
135
  this.big.init(solver, true);
136
136
  const numVars = solver.numVars();
137
137
  this.assigned = new Uint8Array(2 * numVars);
138
- for (let index = 0; index < numVars; index++) {
139
- const boolVar = (this.stoppedAt + index) % numVars;
140
- if (this.counter < -this.limit) {
141
- this.stoppedAt = boolVar;
142
- isComplete = false;
143
- break;
144
- }
145
- if (solver.isInconsistent) break;
146
- if (solver.valueVar(boolVar) !== L_UNDEF || solver.wasEliminated(boolVar)) {
147
- if (this.isCaching) {
148
- this.resetCache(2 * boolVar);
149
- this.resetCache(2 * boolVar + 1);
138
+ try {
139
+ for (let index = 0; index < numVars; index++) {
140
+ const boolVar = (this.stoppedAt + index) % numVars;
141
+ if (this.counter < -this.limit) {
142
+ this.stoppedAt = boolVar;
143
+ isComplete = false;
144
+ break;
145
+ }
146
+ if (solver.isInconsistent) break;
147
+ if (solver.valueVar(boolVar) !== L_UNDEF || solver.wasEliminated(boolVar)) {
148
+ if (this.isCaching) {
149
+ this.resetCache(2 * boolVar);
150
+ this.resetCache(2 * boolVar + 1);
151
+ }
152
+ continue;
150
153
  }
151
- continue;
154
+ solver.checkpoint();
155
+ const oldCounter = this.counter;
156
+ const oldNumAssigned = this.numAssigned;
157
+ this.processCore(boolVar);
158
+ if (this.numAssigned > oldNumAssigned) this.counter = oldCounter;
152
159
  }
153
- solver.checkpoint();
154
- const oldCounter = this.counter;
155
- const oldNumAssigned = this.numAssigned;
156
- this.processCore(boolVar);
157
- if (this.numAssigned > oldNumAssigned) this.counter = oldCounter;
160
+ } finally {
161
+ solver.isProbing = wasProbing;
158
162
  }
159
163
  if (isComplete) this.stoppedAt = 0;
160
164
  this.counter = -this.counter;
@@ -163,7 +167,6 @@ export class Probing {
163
167
  this.assignedLits.length = 0;
164
168
  this.toAssert.length = 0;
165
169
  this.cachedBins = [];
166
- solver.isProbing = wasProbing;
167
170
  return isComplete;
168
171
  }
169
172
  }
@@ -10,6 +10,10 @@ import type { Solver } from "./solver";
10
10
  const mkNot = (manager: AstManager, expr: number) =>
11
11
  manager.isNot(expr) ? manager.getArg(expr, 0) : manager.mkNot(expr);
12
12
 
13
+ export const isLiteral = (manager: AstManager, expr: number) =>
14
+ manager.isUninterpretedConst(expr) ||
15
+ (manager.isNot(expr) && manager.isUninterpretedConst(manager.getArg(expr, 0)));
16
+
13
17
  class Sat2GoalConverter {
14
18
  readonly smc = new ModelConverter();
15
19
  var2expr: number[] = [];
@@ -17,14 +21,6 @@ class Sat2GoalConverter {
17
21
 
18
22
  constructor(private manager: AstManager) {}
19
23
 
20
- private isLiteral(expr: number) {
21
- const manager = this.manager;
22
- return (
23
- manager.isUninterpretedConst(expr) ||
24
- (manager.isNot(expr) && manager.isUninterpretedConst(manager.getArg(expr, 0)))
25
- );
26
- }
27
-
28
24
  private add(expr: number, def: number) {
29
25
  const manager = this.manager;
30
26
  manager.incRef(def);
@@ -60,7 +56,7 @@ class Sat2GoalConverter {
60
56
  def = manager.mkNot(def);
61
57
  }
62
58
  const expr = this.lit2expr(first);
63
- if (this.isLiteral(expr)) this.add(expr, def);
59
+ if (isLiteral(manager, expr)) this.add(expr, def);
64
60
  clause.length = 0;
65
61
  continue;
66
62
  }
@@ -79,7 +75,7 @@ class Sat2GoalConverter {
79
75
  root ^= 1;
80
76
  }
81
77
  const expr = this.lit2expr(first);
82
- if (this.isLiteral(expr)) this.add(expr, this.lit2expr(root));
78
+ if (isLiteral(manager, expr)) this.add(expr, this.lit2expr(root));
83
79
  index += 5;
84
80
  continue;
85
81
  }
@@ -164,5 +160,8 @@ export const sat2goal = (
164
160
  checkpoint();
165
161
  goal.assert(manager.mkOr(arena.getLits(clause).map(getExpr)));
166
162
  }
163
+ const formulas: number[] = [];
164
+ solver.ext?.toFormulas(getExpr, formulas);
165
+ for (const formula of formulas) goal.assert(formula);
167
166
  goal.addDefinitions(converter.entries);
168
167
  };