tla-ts 0.0.10-dev.37a75eb5b → 0.0.10-dev.45c0eaef5

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 (229) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +33 -33
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +17 -3
  7. package/dist/index.d.ts +17 -3
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +55 -55
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -42
  16. package/dist/run.js +42 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +96 -91
  20. package/dist/transfer.js +95 -90
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +31 -3
  25. package/src/bags.ts +12 -10
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -93
  29. package/src/check.ts +418 -246
  30. package/src/cli/tlc-output.ts +17 -2
  31. package/src/cli/tlc.ts +5 -4
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +23 -10
  34. package/src/coverage.ts +255 -18
  35. package/src/dependencies.ts +68 -15
  36. package/src/dfid.ts +93 -35
  37. package/src/environment.ts +106 -39
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +415 -132
  40. package/src/exit-codes.ts +28 -15
  41. package/src/instances.ts +135 -11
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +674 -236
  45. package/src/lexer.ts +12 -2
  46. package/src/liveness-checker.ts +161 -60
  47. package/src/liveness.ts +55 -10
  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/obligations/source.ts +2 -0
  52. package/src/parser.ts +110 -111
  53. package/src/prover/isabelle/isar/attrib.ts +4 -4
  54. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  55. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  56. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  57. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  58. package/src/prover/isabelle/pure/term.ts +3 -3
  59. package/src/prover/prep/md5.ts +26 -29
  60. package/src/prover/smt/rewrite.ts +2 -7
  61. package/src/prover/smt/simplify.ts +1 -1
  62. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  63. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  64. package/src/prover/smt/solver/asserted-formulas.ts +164 -58
  65. package/src/prover/smt/solver/ast-lt.ts +1 -1
  66. package/src/prover/smt/solver/ast.ts +65 -13
  67. package/src/prover/smt/solver/auf-solver.ts +23 -12
  68. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  69. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  70. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  71. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  72. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  73. package/src/prover/smt/solver/card2bv.ts +35 -18
  74. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  75. package/src/prover/smt/solver/context.ts +65 -14
  76. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  77. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  78. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  79. package/src/prover/smt/solver/diff-neq.ts +1 -2
  80. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  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 +3 -9
  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/fd-solver.ts +608 -141
  93. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  94. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  95. package/src/prover/smt/solver/goal.ts +4 -3
  96. package/src/prover/smt/solver/hashtable.ts +4 -0
  97. package/src/prover/smt/solver/internalizer.ts +1 -1
  98. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  99. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  100. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  101. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  102. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  103. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  104. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  105. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  106. package/src/prover/smt/solver/maxcore.ts +2 -1
  107. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  108. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  109. package/src/prover/smt/solver/model-checker.ts +1 -1
  110. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  111. package/src/prover/smt/solver/model-generator.ts +85 -43
  112. package/src/prover/smt/solver/mpf.ts +2 -4
  113. package/src/prover/smt/solver/mus.ts +2 -3
  114. package/src/prover/smt/solver/muz/dl-context.ts +14 -42
  115. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  116. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  117. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  118. package/src/prover/smt/solver/muz/hnf.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 +15 -2
  121. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  122. package/src/prover/smt/solver/muz/spacer-context.ts +1 -4
  123. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  124. package/src/prover/smt/solver/nlqsat.ts +1 -1
  125. package/src/prover/smt/solver/nlsat/algebraic.ts +4 -5
  126. package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
  127. package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
  128. package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
  129. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  130. package/src/prover/smt/solver/nnf.ts +6 -2
  131. package/src/prover/smt/solver/opt-context.ts +16 -7
  132. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  133. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  134. package/src/prover/smt/solver/opt-solver.ts +4 -3
  135. package/src/prover/smt/solver/optsmt.ts +1 -1
  136. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  137. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  138. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  139. package/src/prover/smt/solver/probes.ts +88 -23
  140. package/src/prover/smt/solver/proto-model.ts +8 -8
  141. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  142. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  143. package/src/prover/smt/solver/qe-lite.ts +2 -2
  144. package/src/prover/smt/solver/qe.ts +3 -2
  145. package/src/prover/smt/solver/qsat.ts +23 -8
  146. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  147. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  148. package/src/prover/smt/solver/rewriter.ts +31 -25
  149. package/src/prover/smt/solver/rlimit.ts +7 -3
  150. package/src/prover/smt/solver/sat/config.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  154. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  155. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  156. package/src/prover/smt/solver/sat/sat-tactic.ts +15 -6
  157. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  158. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  159. package/src/prover/smt/solver/sat/solver.ts +27 -47
  160. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  161. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  162. package/src/prover/smt/solver/seq-derive.ts +1 -1
  163. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  164. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  165. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  166. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  168. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  169. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  170. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  171. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  172. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  173. package/src/prover/smt/solver/smt-kernel.ts +40 -6
  174. package/src/prover/smt/solver/smt-setup.ts +106 -13
  175. package/src/prover/smt/solver/smtlib-parser.ts +579 -214
  176. package/src/prover/smt/solver/smtlib-script.ts +600 -170
  177. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  178. package/src/prover/smt/solver/solver.ts +18 -3
  179. package/src/prover/smt/solver/tactic.ts +342 -196
  180. package/src/prover/smt/solver/theory-bv.ts +13 -3
  181. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  182. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  183. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  184. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  185. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  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/theory-without-terms.ts +24 -0
  191. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  192. package/src/prover/tlapm/cache.ts +8 -8
  193. package/src/prover/zenon/index-table.ts +5 -2
  194. package/src/prover/zenon/isar-case.ts +1 -1
  195. package/src/prover/zenon/isar.ts +2 -2
  196. package/src/prover/zenon/phrase.ts +1 -1
  197. package/src/resolve.ts +1226 -246
  198. package/src/runtime.ts +19 -2
  199. package/src/sany/builtins.ts +10 -10
  200. package/src/sany/generation.ts +4 -2
  201. package/src/sany/generator-def-entries.ts +123 -36
  202. package/src/sany/generator-definitions.ts +4 -2
  203. package/src/sany/generator-expressions.ts +51 -20
  204. package/src/sany/generator-proofs.ts +17 -11
  205. package/src/sany/generator.ts +11 -5
  206. package/src/sany/lexer.ts +15 -7
  207. package/src/sany/modules.ts +4 -2
  208. package/src/sany/nodes.ts +1 -1
  209. package/src/sany/selectors.ts +11 -6
  210. package/src/sany/xml.ts +2 -3
  211. package/src/search.ts +283 -126
  212. package/src/simulate.ts +247 -185
  213. package/src/spec-description.ts +15 -7
  214. package/src/standard-definitions.ts +1 -0
  215. package/src/standard-modules.ts +56 -22
  216. package/src/subexpressions.ts +563 -139
  217. package/src/successors.ts +50 -20
  218. package/src/symmetry.ts +2 -1
  219. package/src/tlc/jar-data.ts +1 -3
  220. package/src/tlc/messages.ts +3 -3
  221. package/src/tlc/random.ts +2 -1
  222. package/src/tlc/replay.ts +147 -46
  223. package/src/tlc/tlc-operators.ts +10 -8
  224. package/src/tlc/tlcext-operators.ts +26 -10
  225. package/src/tlc/trace-spec.ts +9 -22
  226. package/src/trace-liveness.ts +529 -0
  227. package/src/typed-tier.ts +52 -31
  228. package/src/typescript/types.ts +2 -2
  229. package/src/values.ts +150 -79
@@ -33,6 +33,13 @@ export abstract class Constraint {
33
33
  return this.lits.length;
34
34
  }
35
35
 
36
+ getMaxVar() {
37
+ let maxVar = this.lit === NULL_LITERAL ? 0 : this.lit >> 1;
38
+ for (let index = 0; index < this.lits.length; index++)
39
+ maxVar = Math.max(maxVar, this.lits[index] >> 1);
40
+ return maxVar;
41
+ }
42
+
36
43
  getCoeff(_index: number) {
37
44
  return 1;
38
45
  }
@@ -832,6 +832,24 @@ export class PbSolver implements SatExtension, ConstraintHost {
832
832
  this.numPropagationsSincePop = 0;
833
833
  }
834
834
 
835
+ gcVars(numVars: number) {
836
+ this.gcConstraintVars(numVars, this.constraints);
837
+ this.gcConstraintVars(numVars, this.learned);
838
+ }
839
+
840
+ private gcConstraintVars(numVars: number, constraints: Constraint[]) {
841
+ let next = 0;
842
+ for (let index = 0; index < constraints.length; index++) {
843
+ const constraint = constraints[index];
844
+ if (constraint.getMaxVar() >= numVars) {
845
+ constraint.clearWatch(this);
846
+ constraint.nullifyTrackingLiteral(this);
847
+ this.deallocate(constraint);
848
+ } else constraints[next++] = constraint;
849
+ }
850
+ constraints.length = next;
851
+ }
852
+
835
853
  popReinit() {
836
854
  const toReinit = this.constraintToReinit;
837
855
  let size = this.constraintToReinitLastSize;
@@ -1443,7 +1461,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1443
1461
  private convertPbWlits(expr: number): WLits {
1444
1462
  const manager = this.manager;
1445
1463
  const lits = this.convertPbArgs(expr);
1446
- const coeffs = lits.map((_, index) =>
1464
+ const coeffs = lits.map((_value, index) =>
1447
1465
  this.checkUnsigned(getPbCoeff(manager, manager.decls[expr], index)),
1448
1466
  );
1449
1467
  return { coeffs, lits };
@@ -1470,7 +1488,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1470
1488
  k = k.add(Rational.of(BigInt(wlits.coeffs[index])));
1471
1489
  }
1472
1490
  const bound = this.checkUnsigned(k);
1473
- if (isRoot) {
1491
+ if (isRoot && this.solver.numUserScopes === 0) {
1474
1492
  this.addRootPbGe(wlits, bound, isSign);
1475
1493
  return NULL_LITERAL;
1476
1494
  }
@@ -1482,7 +1500,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1482
1500
  private convertPbGe(expr: number, isRoot: boolean, isSign: boolean) {
1483
1501
  const bound = this.checkUnsigned(getPbK(this.manager, this.manager.decls[expr]));
1484
1502
  const wlits = this.convertPbWlits(expr);
1485
- if (isRoot) {
1503
+ if (isRoot && this.solver.numUserScopes === 0) {
1486
1504
  this.addRootPbGe(wlits, bound, isSign);
1487
1505
  return NULL_LITERAL;
1488
1506
  }
@@ -1495,7 +1513,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1495
1513
  const solver = this.solver;
1496
1514
  let k = getPbK(this.manager, this.manager.decls[expr]);
1497
1515
  const wlits = this.convertPbWlits(expr);
1498
- const isBaseAssert = isRoot && !isSign;
1516
+ const isBaseAssert = isRoot && !isSign && solver.numUserScopes === 0;
1499
1517
  const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1500
1518
  const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1501
1519
  this.addPbGe(lit1, wlits, Number(BigInt.asUintN(32, k.num)), false);
@@ -1528,7 +1546,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1528
1546
  private convertAtLeastK(expr: number, k: Rational, isRoot: boolean, isSign: boolean) {
1529
1547
  const lits = this.convertPbArgs(expr);
1530
1548
  let bound = k.compare(Rational.of(BigInt(lits.length))) > 0 ? lits.length + 1 : Number(k.num);
1531
- if (isRoot) {
1549
+ if (isRoot && this.solver.numUserScopes === 0) {
1532
1550
  if (isSign) {
1533
1551
  for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
1534
1552
  bound = lits.length + 1 - bound;
@@ -1547,7 +1565,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
1547
1565
  for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
1548
1566
  const bound1 = k.compare(Rational.of(BigInt(lits.length))) >= 0 ? lits.length : Number(k.num);
1549
1567
  let bound = lits.length - bound1;
1550
- if (isRoot) {
1568
+ if (isRoot && this.solver.numUserScopes === 0) {
1551
1569
  if (isSign) {
1552
1570
  for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
1553
1571
  bound = lits.length + 1 - bound;
@@ -1564,7 +1582,8 @@ export class PbSolver implements SatExtension, ConstraintHost {
1564
1582
  private convertEqK(expr: number, k: Rational, isRoot: boolean, isSign: boolean) {
1565
1583
  const solver = this.solver;
1566
1584
  const lits = this.convertPbArgs(expr);
1567
- const isBaseAssert = isRoot && !isSign;
1585
+ // Deviation from Z3: convert_eq_k asserts at the base level in a user scope too, so the constraint outlives the pop.
1586
+ const isBaseAssert = isRoot && !isSign && solver.numUserScopes === 0;
1568
1587
  const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1569
1588
  const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
1570
1589
  const bound = k.compare(Rational.of(BigInt(lits.length))) > 0 ? lits.length + 1 : Number(k.num);
@@ -1,4 +1,4 @@
1
- import { SmtTacticError } from "../../../../errors";
1
+ import { SmtCanceledError, SmtTacticError } from "../../../../errors";
2
2
  import type { AstManager } from "../ast";
3
3
  import type { ThSolverFactory } from "../euf/euf-solver";
4
4
  import { OVER, type Goal } from "../goal";
@@ -6,7 +6,7 @@ import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
6
6
  import { ProtoModel } from "../proto-model";
7
7
  import type { SatParams } from "./config";
8
8
  import { Goal2Sat } from "./goal2sat";
9
- import { sat2goal } from "./sat2goal";
9
+ import { Sat2GoalConverter, sat2goal } from "./sat2goal";
10
10
  import { Solver } from "./solver";
11
11
 
12
12
  // With a theory factory, the sat solver runs the euf solver of sat.euf as its extension.
@@ -19,12 +19,19 @@ export const createSatTactic =
19
19
  const goal2sat = new Goal2Sat(manager, solver, params.get("ite_extra") !== false, mkThSolver);
20
20
  goal2sat.run(goal.forms.items);
21
21
  goal.reset();
22
- const result = solver.check();
22
+ const result = (() => {
23
+ try {
24
+ return solver.check();
25
+ } catch (error) {
26
+ if (error instanceof SmtCanceledError) throw new SmtTacticError("canceled");
27
+ throw error;
28
+ }
29
+ })();
23
30
  if (result === L_UNDEF) goal.reasonUnknown = solver.reasonUnknown;
24
31
  const unhandledFuns = goal2sat.euf?.unhandledFunctions ?? goal2sat.unhandledFuns;
25
32
  if (result === L_FALSE) goal.assert(manager.falseExpr);
26
33
  else if (result === L_TRUE && unhandledFuns.length === 0) {
27
- const model = new ProtoModel(manager);
34
+ const model = new ProtoModel(manager).mkModel();
28
35
  for (const [expr, boolVar] of goal2sat.atoms) {
29
36
  if (!manager.isUninterpretedConst(expr)) continue;
30
37
  const value = solver.model[boolVar];
@@ -32,11 +39,13 @@ export const createSatTactic =
32
39
  else if (value === L_FALSE) model.registerConst(manager.decls[expr], manager.falseExpr);
33
40
  }
34
41
  const euf = goal2sat.euf;
35
- goal.model = (euf?.updateModel(model) ?? model).mkModel();
42
+ goal.model = euf?.updateModel(model) ?? model;
36
43
  euf?.validateModel(goal.model);
37
44
  } else {
38
45
  solver.popToBaseLevel();
39
- sat2goal(manager, solver, goal2sat.atoms, goal);
46
+ const converter = new Sat2GoalConverter(manager);
47
+ sat2goal(manager, solver, goal2sat.atoms, goal, converter);
48
+ goal.addDefinitions(converter.entries);
40
49
  if (unhandledFuns.length > 0) goal.updatePrecision(OVER);
41
50
  }
42
51
  goal.depth++;
@@ -1,6 +1,7 @@
1
1
  import { SmtCanceledError } from "../../../../errors";
2
2
  import { type AstManager, SORT_BOOL } from "../ast";
3
3
  import type { Definition, Goal } from "../goal";
4
+ import { RefVector } from "../ref-vector";
4
5
  import { NULL_LITERAL } from "./clause";
5
6
  import { ModelConverter } from "./model-converter";
6
7
  import type { Solver } from "./solver";
@@ -12,28 +13,32 @@ export const isLiteral = (manager: AstManager, expr: number) =>
12
13
  manager.isUninterpretedConst(expr) ||
13
14
  (manager.isNot(expr) && manager.isUninterpretedConst(manager.getArg(expr, 0)));
14
15
 
15
- class Sat2GoalConverter {
16
+ export class Sat2GoalConverter {
16
17
  readonly smc = new ModelConverter();
17
- var2expr: number[] = [];
18
- readonly entries: Definition[] = [];
18
+ readonly var2expr: RefVector;
19
+ entries: Definition[] = [];
19
20
 
20
- constructor(private manager: AstManager) {}
21
+ constructor(private manager: AstManager) {
22
+ this.var2expr = new RefVector(manager);
23
+ }
21
24
 
22
25
  private add(expr: number, def: number) {
23
26
  const manager = this.manager;
24
27
  manager.incRef(def);
28
+ manager.incDeclRef(manager.decls[expr]);
25
29
  this.entries.push({ decl: manager.decls[expr], def });
26
30
  }
27
31
 
28
32
  hide(expr: number) {
29
- this.entries.push({ decl: this.manager.decls[expr], def: -1 });
33
+ const manager = this.manager;
34
+ manager.incDeclRef(manager.decls[expr]);
35
+ this.entries.push({ decl: manager.decls[expr], def: -1 });
30
36
  }
31
37
 
32
38
  flushSmc(solver: Solver, atoms: Map<number, number>) {
33
39
  this.smc.flush(solver.mc);
34
- this.var2expr.length = solver.numVars();
35
- this.var2expr.fill(-1);
36
- for (const [expr, boolVar] of atoms) this.var2expr[boolVar] = expr;
40
+ this.var2expr.resize(solver.numVars());
41
+ for (const [expr, boolVar] of atoms) this.var2expr.set(boolVar, expr);
37
42
  this.flushGmc();
38
43
  }
39
44
 
@@ -82,21 +87,39 @@ class Sat2GoalConverter {
82
87
  }
83
88
 
84
89
  insert(boolVar: number, atom: number) {
85
- while (this.var2expr.length <= boolVar) this.var2expr.push(-1);
86
- this.var2expr[boolVar] = atom;
90
+ if (this.var2expr.size <= boolVar) this.var2expr.resize(boolVar + 1);
91
+ this.var2expr.set(boolVar, atom);
87
92
  if (this.manager.isUninterpretedConst(atom)) this.hide(atom);
88
93
  }
89
94
 
95
+ copyEntries() {
96
+ const manager = this.manager;
97
+ for (const entry of this.entries) {
98
+ manager.incDeclRef(entry.decl);
99
+ if (entry.def !== -1) manager.incRef(entry.def);
100
+ }
101
+ return [...this.entries];
102
+ }
103
+
104
+ release() {
105
+ const manager = this.manager;
106
+ this.var2expr.reset();
107
+ for (const entry of this.entries) {
108
+ if (entry.def !== -1) manager.decRef(entry.def);
109
+ manager.decDeclRef(entry.decl);
110
+ }
111
+ this.entries = [];
112
+ }
113
+
90
114
  private lit2expr(lit: number) {
91
115
  const manager = this.manager;
92
116
  const boolVar = lit >> 1;
93
- if (this.var2expr[boolVar] === -1) {
117
+ if (this.var2expr.items[boolVar] === -1) {
94
118
  const aux = manager.mkFreshConst(null, SORT_BOOL);
95
- manager.incRef(aux);
96
- this.var2expr[boolVar] = aux;
119
+ this.var2expr.set(boolVar, aux);
97
120
  this.hide(aux);
98
121
  }
99
- const expr = this.var2expr[boolVar];
122
+ const expr = this.var2expr.items[boolVar];
100
123
  return (lit & 1) === 1 ? manager.mkNot(expr) : expr;
101
124
  }
102
125
  }
@@ -106,60 +129,61 @@ export const sat2goal = (
106
129
  solver: Solver,
107
130
  atoms: Map<number, number>,
108
131
  goal: Goal,
132
+ converter: Sat2GoalConverter,
109
133
  ) => {
110
134
  if (solver.atBaseLvl() && solver.isInconsistent) {
111
135
  goal.assert(manager.falseExpr);
112
136
  return;
113
137
  }
114
- const converter = new Sat2GoalConverter(manager);
115
138
  converter.flushSmc(solver, atoms);
116
- const lit2expr = new Int32Array(2 * solver.numVars()).fill(-1);
139
+ const lit2expr = new RefVector(manager);
140
+ lit2expr.resize(2 * solver.numVars());
117
141
  for (const [expr, boolVar] of atoms) {
118
- lit2expr[2 * boolVar] = expr;
119
- lit2expr[2 * boolVar + 1] = mkNot(manager, expr);
120
- manager.incRef(lit2expr[2 * boolVar + 1]);
142
+ lit2expr.set(2 * boolVar, expr);
143
+ lit2expr.set(2 * boolVar + 1, mkNot(manager, expr));
121
144
  }
122
145
  const getExpr = (lit: number) => {
123
- if (lit2expr[lit] === -1) {
146
+ if (lit2expr.items[lit] === -1) {
124
147
  const boolVar = lit >> 1;
125
- let aux = converter.var2expr[boolVar] ?? -1;
148
+ let aux = converter.var2expr.items[boolVar] ?? -1;
126
149
  if (aux === -1) {
127
150
  aux = manager.mkFreshConst(null, SORT_BOOL);
128
- manager.incRef(aux);
129
151
  converter.insert(boolVar, aux);
130
152
  }
131
- lit2expr[2 * boolVar] = aux;
132
- lit2expr[2 * boolVar + 1] = mkNot(manager, aux);
133
- manager.incRef(lit2expr[2 * boolVar + 1]);
153
+ lit2expr.set(2 * boolVar, aux);
154
+ lit2expr.set(2 * boolVar + 1, mkNot(manager, aux));
134
155
  }
135
- return lit2expr[lit];
156
+ return lit2expr.items[lit];
136
157
  };
137
158
  const checkpoint = () => {
138
159
  if (!manager.limit.inc()) throw new SmtCanceledError();
139
160
  };
140
- const trailSize = solver.initTrailSize();
141
- for (let index = 0; index < trailSize; index++) {
142
- checkpoint();
143
- goal.assert(getExpr(solver.trail[index]));
144
- }
145
- for (let index = 0; index < solver.watches.length; index++) {
146
- const first = index ^ 1;
147
- const wlist = solver.watches[index];
148
- for (let position = 0; position < wlist.size; position++) {
149
- if (!wlist.isBinary(position) || wlist.isLearned(position)) continue;
150
- const second = wlist.getLiteral(position);
151
- if (first > second) continue;
161
+ try {
162
+ const trailSize = solver.initTrailSize();
163
+ for (let index = 0; index < trailSize; index++) {
152
164
  checkpoint();
153
- goal.assert(manager.mkOr([getExpr(first), getExpr(second)]));
165
+ goal.assert(getExpr(solver.trail[index]));
154
166
  }
167
+ for (let index = 0; index < solver.watches.length; index++) {
168
+ const first = index ^ 1;
169
+ const wlist = solver.watches[index];
170
+ for (let position = 0; position < wlist.size; position++) {
171
+ if (!wlist.isBinary(position) || wlist.isLearned(position)) continue;
172
+ const second = wlist.getLiteral(position);
173
+ if (first > second) continue;
174
+ checkpoint();
175
+ goal.assert(manager.mkOr([getExpr(first), getExpr(second)]));
176
+ }
177
+ }
178
+ const arena = solver.arena;
179
+ for (const clause of solver.clauses) {
180
+ checkpoint();
181
+ goal.assert(manager.mkOr(arena.getLits(clause).map(getExpr)));
182
+ }
183
+ const formulas: number[] = [];
184
+ solver.ext?.toFormulas(getExpr, formulas);
185
+ for (const formula of formulas) goal.assert(formula);
186
+ } finally {
187
+ lit2expr.reset();
155
188
  }
156
- const arena = solver.arena;
157
- for (const clause of solver.clauses) {
158
- checkpoint();
159
- goal.assert(manager.mkOr(arena.getLits(clause).map(getExpr)));
160
- }
161
- const formulas: number[] = [];
162
- solver.ext?.toFormulas(getExpr, formulas);
163
- for (const formula of formulas) goal.assert(formula);
164
- goal.addDefinitions(converter.entries);
165
189
  };
@@ -1270,7 +1270,7 @@ export class Simplifier {
1270
1270
  for (const wlist of solver.watches) {
1271
1271
  solver.checkpoint();
1272
1272
  const size = wlist.size;
1273
- const order = Array.from({ length: size }, (_, index) => index);
1273
+ const order = Array.from({ length: size }, (_value, index) => index);
1274
1274
  const getRank = (index: number) =>
1275
1275
  wlist.isBinary(index)
1276
1276
  ? 2 * wlist.getLiteral(index) + (wlist.isLearned(index) ? 1 : 0)
@@ -59,6 +59,7 @@ export interface SatExtension {
59
59
  pop(numScopes: number): void;
60
60
  userPush?(): void;
61
61
  userPop?(numScopes: number): void;
62
+ gcVars?(numVars: number): void;
62
63
  popReinit(): void;
63
64
  simplify(): void;
64
65
  gc(): void;
@@ -74,7 +75,7 @@ const RANDOM_MAX_VALUE = 0x7fff;
74
75
  const S_SAT = 0;
75
76
  const S_UNSAT = 1;
76
77
 
77
- export class Ema {
78
+ class Ema {
78
79
  private beta = 1;
79
80
  value = 0;
80
81
  private period = 0;
@@ -139,7 +140,6 @@ export class Solver {
139
140
  model = new Int8Array(0);
140
141
  isModelCurrent = false;
141
142
  isInconsistent = false;
142
- isSearching = false;
143
143
  conflictJustLevel = 0;
144
144
  conflictLevel = 0;
145
145
  conflictVal = 0;
@@ -147,7 +147,6 @@ export class Solver {
147
147
  notL = NULL_LITERAL;
148
148
  clauses: number[] = [];
149
149
  learned: number[] = [];
150
- numFrozen = 0;
151
150
  watches: WatchList[] = [];
152
151
  assignment = new Int8Array(16);
153
152
  justLevel = new Uint32Array(8);
@@ -196,7 +195,6 @@ export class Solver {
196
195
  scopes: Scope[] = [];
197
196
  core: number[] = [];
198
197
  conflicts = 0;
199
- decisions = 0;
200
198
  conflictsSinceInit = 0;
201
199
  restarts = 0;
202
200
  conflictsSinceRestart = 0;
@@ -392,7 +390,6 @@ export class Solver {
392
390
  }
393
391
 
394
392
  delClause(clause: number) {
395
- if (this.arena.isFrozen(clause)) this.numFrozen--;
396
393
  this.arena.delClause(clause);
397
394
  }
398
395
 
@@ -879,38 +876,33 @@ export class Solver {
879
876
  check(assumptions: readonly number[] = []) {
880
877
  this.reasonUnknown = "no reason given";
881
878
  this.popToBaseLevel();
882
- this.isSearching = true;
883
879
  this.isGivenUp = false;
884
- try {
885
- this.initSearch();
886
- if (this.checkInconsistent()) return L_FALSE;
887
- this.propagate(false);
888
- if (this.checkInconsistent()) return L_FALSE;
889
- this.initAssumptions(assumptions);
890
- this.propagate(false);
880
+ this.initSearch();
881
+ if (this.checkInconsistent()) return L_FALSE;
882
+ this.propagate(false);
883
+ if (this.checkInconsistent()) return L_FALSE;
884
+ this.initAssumptions(assumptions);
885
+ this.propagate(false);
886
+ if (this.checkInconsistent()) return L_FALSE;
887
+ if (this.config.isForcingCleanup) this.doCleanup(true);
888
+ if (this.config.isGcBurst) {
889
+ this.conflictsSinceGc = this.gcThreshold + 1;
890
+ this.doGc();
891
+ }
892
+ if (this.config.isEnablingPreSimplify) {
893
+ this.doSimplify();
891
894
  if (this.checkInconsistent()) return L_FALSE;
892
- if (this.config.isForcingCleanup) this.doCleanup(true);
893
- if (this.config.isGcBurst) {
894
- this.conflictsSinceGc = this.gcThreshold + 1;
895
- this.doGc();
896
- }
897
- if (this.config.isEnablingPreSimplify) {
898
- this.doSimplify();
899
- if (this.checkInconsistent()) return L_FALSE;
900
- }
901
- if (this.config.maxConflicts === 0) return L_UNDEF;
902
- if (this.config.maxConflicts > 0 && this.config.burstSearch > 0) {
903
- this.restartThreshold = this.config.burstSearch;
904
- const result = this.boundedSearch();
905
- if (result !== L_UNDEF || this.isGivenUp) return result;
906
- this.popReinit(this.scopeLvl);
907
- this.conflictsSinceRestart = 0;
908
- this.restartThreshold = this.config.restartInitial;
909
- }
910
- return this.basicSearch();
911
- } finally {
912
- this.isSearching = false;
913
895
  }
896
+ if (this.config.maxConflicts === 0) return L_UNDEF;
897
+ if (this.config.maxConflicts > 0 && this.config.burstSearch > 0) {
898
+ this.restartThreshold = this.config.burstSearch;
899
+ const result = this.boundedSearch();
900
+ if (result !== L_UNDEF || this.isGivenUp) return result;
901
+ this.popReinit(this.scopeLvl);
902
+ this.conflictsSinceRestart = 0;
903
+ this.restartThreshold = this.config.restartInitial;
904
+ }
905
+ return this.basicSearch();
914
906
  }
915
907
 
916
908
  checkInconsistent() {
@@ -1126,7 +1118,6 @@ export class Solver {
1126
1118
  const next = this.nextVar();
1127
1119
  if (next === -1) return false;
1128
1120
  this.push();
1129
- this.decisions++;
1130
1121
  this.assignScoped(2 * next + (this.guess(next) ? 0 : 1));
1131
1122
  return true;
1132
1123
  }
@@ -1885,6 +1876,7 @@ export class Solver {
1885
1876
  };
1886
1877
  gcClauses(this.learned);
1887
1878
  gcClauses(this.clauses);
1879
+ this.ext?.gcVars?.(maxVar);
1888
1880
  let next = 0;
1889
1881
  for (const lit of this.trail) if (lit >> 1 < maxVar) this.trail[next++] = lit;
1890
1882
  this.trail.length = next;
@@ -1932,16 +1924,6 @@ export class Solver {
1932
1924
  this.activityInc >>>= 14;
1933
1925
  }
1934
1926
 
1935
- numClauses() {
1936
- let numClauses = this.trail.length;
1937
- for (let lit = 0; lit < this.watches.length; lit++) {
1938
- const wlist = this.watches[lit];
1939
- for (let index = 0; index < wlist.size; index++)
1940
- if (wlist.isBinary(index) && (lit ^ 1) < wlist.getLiteral(index)) numClauses++;
1941
- }
1942
- return numClauses + this.clauses.length + this.learned.length;
1943
- }
1944
-
1945
1927
  doCleanup(isForced: boolean) {
1946
1928
  if (this.conflictsSinceInit === 0 && !isForced) return false;
1947
1929
  return this.atBaseLvl() && !this.isInconsistent && this.cleaner.run(isForced);
@@ -2063,12 +2045,10 @@ export class Solver {
2063
2045
  this.detachClause(clause);
2064
2046
  arena.inactRounds[clause] = 0;
2065
2047
  arena.setFrozen(clause, true);
2066
- this.numFrozen++;
2067
2048
  }
2068
2049
  }
2069
2050
  } else if (this.psm(clause) <= Math.trunc(arena.size[clause] * this.minDTk)) {
2070
2051
  arena.setFrozen(clause, false);
2071
- this.numFrozen--;
2072
2052
  if (!this.activateFrozenClause(clause)) {
2073
2053
  this.delClause(clause);
2074
2054
  continue;
@@ -1,4 +1,3 @@
1
- import { SmtUnsupportedError } from "../../../errors";
2
1
  import {
3
2
  type AstManager,
4
3
  FAMILY_ARITH,
@@ -24,7 +23,6 @@ import {
24
23
  OP_SEQ_PREFIX,
25
24
  OP_SEQ_UNIT,
26
25
  OP_STRING_FROM_CODE,
27
- OP_STRING_ITOS,
28
26
  OP_STRING_LT,
29
27
  OP_STRING_STOI,
30
28
  OP_STRING_TO_CODE,
@@ -36,7 +34,7 @@ import { FALSE_LITERAL, type Literal, TRUE_LITERAL, negate } from "./literal";
36
34
  import { isBinaryApp, isEmptySeq, mkConcatOf, mkEmptySeq, mkSeqApp } from "./seq-decl-plugin";
37
35
  import { SeqSkolem } from "./seq-skolem";
38
36
 
39
- export interface SeqAxiomsHost {
37
+ interface SeqAxiomsHost {
40
38
  rewrite(expr: number): number;
41
39
  mkEqLiteral(first: number, second: number): Literal;
42
40
  ensureEnode(expr: number): void;
@@ -62,7 +60,7 @@ export const getMinLengthOf = (manager: AstManager, seq: number): number => {
62
60
 
63
61
  const UINT_MAX = 0xffffffff;
64
62
 
65
- export const getMaxLengthOf = (manager: AstManager, seq: number): number => {
63
+ const getMaxLengthOf = (manager: AstManager, seq: number): number => {
66
64
  const getLength = (expr: number) => {
67
65
  if (isEmptySeq(manager, expr)) return 0;
68
66
  const op = manager.getOp(expr);
@@ -180,13 +178,8 @@ export class SeqAxioms {
180
178
  return result;
181
179
  }
182
180
 
183
- mkLen(seq: number) {
184
- return this.host.rewrite(this.mkSeq(OP_SEQ_LENGTH, [seq]));
185
- }
186
-
187
- private purify(expr: number | undefined) {
181
+ private purify(expr: number) {
188
182
  const manager = this.manager;
189
- if (expr === undefined) return undefined;
190
183
  if (manager.depths[expr] === 1 || manager.isValue(expr)) return expr;
191
184
  if (this.host.rewrite(expr) === expr) return expr;
192
185
  let result = this.purified.get(expr);
@@ -256,9 +249,9 @@ export class SeqAxioms {
256
249
  extractAxiom(expr: number) {
257
250
  const manager = this.manager;
258
251
  const [seqArg, indexArg, lengthArg] = manager.getArgs(expr);
259
- const seq = this.purify(seqArg)!;
260
- const index = this.purify(indexArg)!;
261
- const length = this.purify(lengthArg)!;
252
+ const seq = this.purify(seqArg);
253
+ const index = this.purify(indexArg);
254
+ const length = this.purify(lengthArg);
262
255
  if (this.smallSegmentAxiom(expr, seqArg, indexArg, lengthArg)) return;
263
256
  if (this.isTail(seq, indexArg, lengthArg)) {
264
257
  this.tailAxiom(expr, seq);
@@ -436,9 +429,9 @@ export class SeqAxioms {
436
429
  const args = manager.getArgs(index);
437
430
  const minusOne = this.mkInt(-1);
438
431
  const zero = this.mkInt(0);
439
- const offset = this.purify(args[2]);
440
- const pattern = this.purify(args[1])!;
441
- const text = this.purify(args[0])!;
432
+ const offset = args.length > 2 ? this.purify(args[2]) : undefined;
433
+ const pattern = this.purify(args[1]);
434
+ const text = this.purify(args[0]);
442
435
  const contains = this.mkSeq(OP_SEQ_CONTAINS, [text, pattern]);
443
436
  const isMinusOne = this.mkEq(index, minusOne);
444
437
  const isZero = this.mkEq(index, zero);
@@ -511,8 +504,8 @@ export class SeqAxioms {
511
504
  lastIndexofAxiom(index: number) {
512
505
  const manager = this.manager;
513
506
  const [textArg, patternArg] = manager.getArgs(index);
514
- const text = this.purify(textArg)!;
515
- const pattern = this.purify(patternArg)!;
507
+ const text = this.purify(textArg);
508
+ const pattern = this.purify(patternArg);
516
509
  const minusOne = this.mkInt(-1);
517
510
  const zero = this.mkInt(0);
518
511
  const skolem = this.skolem;
@@ -539,9 +532,9 @@ export class SeqAxioms {
539
532
  replaceAxiom(replace: number) {
540
533
  const manager = this.manager;
541
534
  const [source, patternArg, targetArg] = manager.getArgs(replace);
542
- const text = this.purify(source)!;
543
- const pattern = this.purify(patternArg)!;
544
- const target = this.purify(targetArg)!;
535
+ const text = this.purify(source);
536
+ const pattern = this.purify(patternArg);
537
+ const target = this.purify(targetArg);
545
538
  const skolem = this.skolem;
546
539
  const left = skolem.mkIndexofLeft(text, pattern);
547
540
  const right = skolem.mkIndexofRight(text, pattern);
@@ -565,8 +558,8 @@ export class SeqAxioms {
565
558
  atAxiom(expr: number) {
566
559
  const manager = this.manager;
567
560
  const [seqArg, indexArg] = manager.getArgs(expr);
568
- const seq = this.purify(seqArg)!;
569
- const index = this.purify(indexArg)!;
561
+ const seq = this.purify(seqArg);
562
+ const index = this.purify(indexArg);
570
563
  this.mkInt(0);
571
564
  const one = this.mkInt(1);
572
565
  const empty = this.mkEmpty(manager.sorts[expr]);
@@ -747,8 +740,8 @@ export class SeqAxioms {
747
740
  ltAxiom(expr: number) {
748
741
  const manager = this.manager;
749
742
  const [firstArg, secondArg] = manager.getArgs(expr);
750
- const first = this.purify(firstArg)!;
751
- const second = this.purify(secondArg)!;
743
+ const first = this.purify(firstArg);
744
+ const second = this.purify(secondArg);
752
745
  const charSort = manager.getSeqElementSort(manager.sorts[first]);
753
746
  const lt = expr;
754
747
  const gt = this.mkSeq(OP_STRING_LT, [second, first]);
@@ -895,8 +888,8 @@ export class SeqAxioms {
895
888
  private affixAxiom(expr: number, name: string, isPrefix: boolean) {
896
889
  const manager = this.manager;
897
890
  const [firstArg, secondArg] = manager.getArgs(expr);
898
- const first = this.purify(firstArg)!;
899
- const second = this.purify(secondArg)!;
891
+ const first = this.purify(firstArg);
892
+ const second = this.purify(secondArg);
900
893
  const firstLength = this.mkLenAxiom(first);
901
894
  const secondLength = this.mkLenAxiom(second);
902
895
  const isLonger = this.mkGe(this.mkSub(firstLength, secondLength), 1);
@@ -999,12 +992,4 @@ export class SeqAxioms {
999
992
  this.addClause([this.mkNot(tracker), this.mkLe(this.mkLenAxiom(target), limit)]);
1000
993
  return tracker;
1001
994
  }
1002
-
1003
- ubvAxiom(): never {
1004
- throw new SmtUnsupportedError("str.from_ubv in the theory of sequences");
1005
- }
1006
-
1007
- isItos(expr: number) {
1008
- return this.manager.getOp(expr) === OP_STRING_ITOS;
1009
- }
1010
995
  }
@@ -271,7 +271,7 @@ const SEQ_VARIANTS = new Map([
271
271
  [OP_INTERNAL_STRING_SUBSTR, OP_SEQ_EXTRACT],
272
272
  ]);
273
273
 
274
- const STRING_VARIANTS = new Map([...SEQ_VARIANTS].map(([variant, op]) => [op, variant]));
274
+ const STRING_VARIANTS = new Map([...SEQ_VARIANTS].map((entry) => [entry[1], entry[0]]));
275
275
 
276
276
  const getPsig = (op: number) => {
277
277
  const sig = SIGS.get(op);
@@ -63,7 +63,7 @@ import {
63
63
  import { type ReRewriter, getResultExpr } from "./seq-re-rewriter";
64
64
 
65
65
  export const DERIVATIVE_ANTIMIROV = 0;
66
- export const DERIVATIVE_BRZOZOWSKI = 1;
66
+ const DERIVATIVE_BRZOZOWSKI = 1;
67
67
  export const TRANSITION_BRZOZOWSKI = 0;
68
68
  export const TRANSITION_LIGHT_ANTIMIROV = 1;
69
69