tla-ts 0.0.10-dev.1ebc153bd → 0.0.10-dev.22f7435d3

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 (108) hide show
  1. package/dist/deciders.cjs +31 -31
  2. package/dist/deciders.js +30 -30
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +6 -2
  5. package/dist/index.d.ts +6 -2
  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 +68 -68
  10. package/dist/prove.js +61 -61
  11. package/dist/run.cjs +42 -42
  12. package/dist/run.js +44 -44
  13. package/dist/transfer.cjs +38 -38
  14. package/dist/transfer.js +29 -29
  15. package/dist/worker.cjs +7 -7
  16. package/dist/worker.js +7 -7
  17. package/package.json +1 -1
  18. package/src/bags.ts +5 -2
  19. package/src/builtins.ts +4 -3
  20. package/src/check-failure.ts +9 -6
  21. package/src/check-trace.ts +116 -64
  22. package/src/check.ts +343 -166
  23. package/src/cli/tlc-output.ts +1 -0
  24. package/src/cli/tlc.ts +3 -2
  25. package/src/codegen.ts +23 -8
  26. package/src/dependencies.ts +5 -4
  27. package/src/dfid.ts +13 -8
  28. package/src/environment.ts +1 -0
  29. package/src/evaluate.ts +58 -23
  30. package/src/exit-codes.ts +27 -13
  31. package/src/java-hash.ts +14 -0
  32. package/src/liveness-checker.ts +131 -81
  33. package/src/liveness.ts +48 -10
  34. package/src/parser.ts +6 -1
  35. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  36. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  37. package/src/prover/smt/solver/asserted-formulas.ts +109 -63
  38. package/src/prover/smt/solver/ast.ts +5 -3
  39. package/src/prover/smt/solver/auf-solver.ts +23 -12
  40. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  41. package/src/prover/smt/solver/bound-simplifier.ts +10 -11
  42. package/src/prover/smt/solver/card2bv.ts +34 -15
  43. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -23
  44. package/src/prover/smt/solver/context.ts +44 -11
  45. package/src/prover/smt/solver/dependent-expr-state.ts +19 -13
  46. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  47. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  48. package/src/prover/smt/solver/elim-uncnstr.ts +1 -1
  49. package/src/prover/smt/solver/fd-solver.ts +146 -39
  50. package/src/prover/smt/solver/internalizer.ts +1 -1
  51. package/src/prover/smt/solver/lp/lp-settings.ts +4 -0
  52. package/src/prover/smt/solver/maxcore.ts +2 -1
  53. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  54. package/src/prover/smt/solver/model-checker.ts +1 -1
  55. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  56. package/src/prover/smt/solver/model-generator.ts +82 -42
  57. package/src/prover/smt/solver/muz/dl-context.ts +12 -40
  58. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  59. package/src/prover/smt/solver/muz/dl-rule.ts +6 -7
  60. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  61. package/src/prover/smt/solver/muz/horn-tactic.ts +14 -1
  62. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  63. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  64. package/src/prover/smt/solver/opt-context.ts +12 -4
  65. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  66. package/src/prover/smt/solver/opt-solver.ts +4 -3
  67. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  68. package/src/prover/smt/solver/poly-rewriter.ts +1 -0
  69. package/src/prover/smt/solver/proto-model.ts +4 -2
  70. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  71. package/src/prover/smt/solver/qsat.ts +23 -8
  72. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  73. package/src/prover/smt/solver/rewriter.ts +31 -25
  74. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  75. package/src/prover/smt/solver/sat/inc-sat-solver.ts +56 -28
  76. package/src/prover/smt/solver/sat/sat-tactic.ts +13 -4
  77. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  78. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  79. package/src/prover/smt/solver/smt-kernel.ts +39 -4
  80. package/src/prover/smt/solver/smt-setup.ts +28 -4
  81. package/src/prover/smt/solver/smtlib-parser.ts +31 -4
  82. package/src/prover/smt/solver/smtlib-script.ts +219 -82
  83. package/src/prover/smt/solver/solve-eqs.ts +24 -17
  84. package/src/prover/smt/solver/solver.ts +18 -3
  85. package/src/prover/smt/solver/tactic.ts +132 -78
  86. package/src/prover/smt/solver/theory-bv.ts +11 -1
  87. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  88. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  89. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
  90. package/src/prover/smt/solver/theory-lra-propagate.ts +7 -1
  91. package/src/prover/smt/solver/theory-lra.ts +1 -0
  92. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  93. package/src/resolve.ts +446 -167
  94. package/src/runtime.ts +4 -0
  95. package/src/search.ts +161 -92
  96. package/src/simulate.ts +165 -102
  97. package/src/spec-description.ts +3 -4
  98. package/src/standard-modules.ts +56 -22
  99. package/src/subexpressions.ts +168 -49
  100. package/src/successors.ts +6 -3
  101. package/src/symmetry.ts +1 -0
  102. package/src/tlc/random.ts +2 -1
  103. package/src/tlc/replay.ts +22 -14
  104. package/src/tlc/tlc-operators.ts +7 -7
  105. package/src/tlc/tlcext-operators.ts +26 -10
  106. package/src/tlc/trace-spec.ts +6 -20
  107. package/src/typed-tier.ts +9 -4
  108. package/src/values.ts +95 -57
@@ -1,3 +1,4 @@
1
+ import { SmtInvariantError } from "../../../errors";
1
2
  import type { AssertedFormulas } from "./asserted-formulas";
2
3
  import {
3
4
  AstManager,
@@ -154,6 +155,7 @@ export interface SmtParams {
154
155
  isMbqi: boolean;
155
156
  mbqiMaxIterations: number;
156
157
  relevancyLevel: 0 | 2;
158
+ randomSeed?: number;
157
159
  // The model checker's auxiliary context pretends every array operation is supported.
158
160
  isArrayFakeSupport?: boolean;
159
161
  }
@@ -172,6 +174,7 @@ export class Context extends Internalizer {
172
174
  private scopeAuxClauseLimits: number[] = [];
173
175
  private scopeTrailLimits: number[] = [];
174
176
  private baseScopeLemmaLimits: number[] = [];
177
+ private isBaseScopeInconsistent: boolean[] = [];
175
178
  private atomPropagationQueue: Literal[] = [];
176
179
  private thEqQueue: number[] = [];
177
180
  private thDiseqQueue: number[] = [];
@@ -210,15 +213,17 @@ export class Context extends Internalizer {
210
213
  this.qmanager = new DefaultQuantifierManager(this);
211
214
  }
212
215
 
213
- // As in Z3, rereading the parameters drops the setup's tuning but for eliminate_term_ite and relevancy.
216
+ // As in Z3, rereading the parameters drops the setup's tuning but for eliminate_term_ite, eliminate_bounds and relevancy.
214
217
  updateParams(params: KernelParams) {
215
218
  this.params.isMbqi = params.isMbqi;
216
219
  this.params.mbqiMaxIterations = params.mbqiMaxIterations;
220
+ this.params.randomSeed = params.randomSeed;
217
221
  this.config = {
218
222
  ...DEFAULT_CONFIG,
219
223
  theories: this.config.theories,
220
224
  isFindingMacros: params.isFindingMacros,
221
225
  isEliminatingTermIte: this.config.isEliminatingTermIte,
226
+ isEliminatingBounds: this.config.isEliminatingBounds,
222
227
  };
223
228
  this.qmanager.updateParams();
224
229
  }
@@ -239,6 +244,7 @@ export class Context extends Internalizer {
239
244
  );
240
245
  this.setup = setup;
241
246
  this.config = config;
247
+ this.randomSeed = this.params.randomSeed ?? 0;
242
248
  if (config.relevancyLevel !== undefined) this.relevancy.isEnabled = config.relevancyLevel > 0;
243
249
  for (const family of config.theories)
244
250
  if (family !== FAMILY_POLY || this.manager.hasTypeVars) this.registerFamily(family);
@@ -982,11 +988,12 @@ export class Context extends Internalizer {
982
988
  this.cacheGeneration(newLevel, visited);
983
989
  this.qmanager.pop(numScopes);
984
990
  this.fingerprints.pop(numScopes);
991
+ if (newLevel >= this.baseLevel || !this.isBaseScopeInconsistent[newLevel]) this.conflict = null;
985
992
  if (newLevel < this.baseLevel) {
986
993
  this.deleteClauses(this.lemmas, this.baseScopeLemmaLimits[newLevel]);
987
994
  shrink(this.baseScopeLemmaLimits, newLevel);
995
+ shrink(this.isBaseScopeInconsistent, newLevel);
988
996
  }
989
- this.conflict = null;
990
997
  this.deleteClauses(this.auxClauses, this.scopeAuxClauseLimits[newLevel]);
991
998
  this.relevancy.pop(numScopes);
992
999
  this.unassignVars(this.scopeAssignedLimits[newLevel]);
@@ -1280,6 +1287,9 @@ export class Context extends Internalizer {
1280
1287
  }
1281
1288
 
1282
1289
  private mkProtoModel() {
1290
+ const failure = this.lastSearchFailure;
1291
+ if (this.hasCaseSplits() || failure === FAILURE_CANCELED || failure === FAILURE_NUM_CONFLICTS)
1292
+ return undefined;
1283
1293
  if (this.modelState.kind !== "none") this.modelState.generated.model.decRef();
1284
1294
  const generated = mkModel(this);
1285
1295
  generated.model.incRef();
@@ -1322,9 +1332,11 @@ export class Context extends Internalizer {
1322
1332
  }
1323
1333
 
1324
1334
  getModel() {
1335
+ if (this.isInconsistent()) return undefined;
1325
1336
  if (this.modelState.kind === "final") return this.modelState.model;
1326
1337
  const generated =
1327
1338
  this.modelState.kind === "proto" ? this.modelState.generated : this.mkProtoModel();
1339
+ if (generated === undefined) return undefined;
1328
1340
  const model = generated.model.mkModel();
1329
1341
  model.addRecFuns();
1330
1342
  model.incRef();
@@ -1332,6 +1344,12 @@ export class Context extends Internalizer {
1332
1344
  return model;
1333
1345
  }
1334
1346
 
1347
+ getSatModel() {
1348
+ const model = this.getModel();
1349
+ if (model === undefined) throw new SmtInvariantError("a sat answer without a model");
1350
+ return model;
1351
+ }
1352
+
1335
1353
  validateModel(model: ProtoModel) {
1336
1354
  const manager = this.manager;
1337
1355
  for (const literal of this.assignedLiterals) {
@@ -1361,7 +1379,10 @@ export class Context extends Internalizer {
1361
1379
  )
1362
1380
  return status;
1363
1381
  const generated = this.mkProtoModel();
1364
- if (qmanager.checkModel(generated.model, generated.root2value) !== CHECK_MODEL_RESTART)
1382
+ if (
1383
+ generated === undefined ||
1384
+ qmanager.checkModel(generated.model, generated.root2value) !== CHECK_MODEL_RESTART
1385
+ )
1365
1386
  return status;
1366
1387
  this.lastSearchFailure = FAILURE_OK;
1367
1388
  status = L_UNDEF;
@@ -1371,9 +1392,10 @@ export class Context extends Internalizer {
1371
1392
  if (status === L_TRUE && qmanager.quantifiers.length === 0) return L_TRUE;
1372
1393
  if (status === L_TRUE) {
1373
1394
  const generated = this.mkProtoModel();
1374
- const result = qmanager.isModelBased()
1375
- ? qmanager.checkModel(generated.model, generated.root2value)
1376
- : CHECK_MODEL_UNKNOWN;
1395
+ const result =
1396
+ generated !== undefined && qmanager.isModelBased()
1397
+ ? qmanager.checkModel(generated.model, generated.root2value)
1398
+ : CHECK_MODEL_UNKNOWN;
1377
1399
  if (result === CHECK_MODEL_SAT) return L_TRUE;
1378
1400
  if (result === CHECK_MODEL_UNKNOWN) {
1379
1401
  this.lastSearchFailure = FAILURE_QUANTIFIERS;
@@ -1469,6 +1491,7 @@ export class Context extends Internalizer {
1469
1491
  this.popToBaseLevel();
1470
1492
  this.pushScope();
1471
1493
  this.baseScopeLemmaLimits.push(this.lemmas.length);
1494
+ this.isBaseScopeInconsistent.push(this.isInconsistent());
1472
1495
  this.baseLevel++;
1473
1496
  this.searchLevel++;
1474
1497
  }
@@ -1502,15 +1525,23 @@ export class Context extends Internalizer {
1502
1525
  this.asserted = asserted;
1503
1526
  this.macros = asserted.macros;
1504
1527
  this.hasQuantifiers = asserted.hasQuantifiers;
1505
- const formulas = asserted.reduce();
1528
+ if (this.checkCanceled()) return;
1529
+ asserted.reduce();
1530
+ if (this.checkCanceled()) return;
1506
1531
  if (asserted.isInconsistent) {
1507
1532
  this.setConflict("axiom", null);
1508
1533
  return;
1509
1534
  }
1510
- for (const formula of formulas) {
1511
- if (this.isInconsistent()) break;
1512
- this.internalizeAssertion(formula, 0);
1535
+ const formulas = asserted.getFormulas();
1536
+ const size = asserted.getNumFormulas();
1537
+ for (let qhead = asserted.getQhead(); qhead < size && !this.isInconsistent(); qhead++) {
1538
+ if (this.checkCanceled()) {
1539
+ asserted.commit(qhead);
1540
+ return;
1541
+ }
1542
+ this.internalizeAssertion(formulas[qhead], 0);
1513
1543
  }
1544
+ asserted.commit();
1514
1545
  }
1515
1546
 
1516
1547
  initAssumptions(assumptions: number[], asserted: AssertedFormulas) {
@@ -1519,7 +1550,7 @@ export class Context extends Internalizer {
1519
1550
  this.unsatCore = [];
1520
1551
  if (assumptions.length > 0) {
1521
1552
  this.propagate();
1522
- if (this.isInconsistent()) return;
1553
+ if (this.isInconsistent() || this.checkCanceled()) return;
1523
1554
  this.delInactiveLemmas();
1524
1555
  this.pushScope();
1525
1556
  const manager = this.manager;
@@ -1619,10 +1650,12 @@ export class Context extends Internalizer {
1619
1650
  }
1620
1651
 
1621
1652
  search() {
1653
+ if (this.asserted?.isInconsistent && !this.isInconsistent()) this.setConflict("axiom", null);
1622
1654
  if (this.isInconsistent()) {
1623
1655
  this.resolveConflict();
1624
1656
  return L_FALSE;
1625
1657
  }
1658
+ if (this.checkCanceled()) return L_UNDEF;
1626
1659
  this.resetModel();
1627
1660
  for (const theory of this.theories) theory.initSearchEh();
1628
1661
  this.qmanager.initSearchEh();
@@ -36,15 +36,18 @@ export class DependentExprState {
36
36
  const manager = this.manager;
37
37
  const goal = this.goal;
38
38
  let rewritten = -1;
39
- this.forEachIndex((index) => {
40
- const form = this.get(index);
41
- const next = rewrite(form);
42
- if (next === -1) return;
39
+ try {
40
+ this.forEachIndex((index) => {
41
+ const form = this.get(index);
42
+ const next = rewrite(form);
43
+ if (next === -1) return;
44
+ if (rewritten !== -1) manager.decRef(rewritten);
45
+ rewritten = next;
46
+ if (rewritten !== form) goal.update(index, rewritten, goal.getDependency(index));
47
+ });
48
+ } finally {
43
49
  if (rewritten !== -1) manager.decRef(rewritten);
44
- rewritten = next;
45
- if (rewritten !== form) goal.update(index, rewritten, goal.getDependency(index));
46
- });
47
- if (rewritten !== -1) manager.decRef(rewritten);
50
+ }
48
51
  }
49
52
 
50
53
  hasQuantifiers() {
@@ -64,7 +67,7 @@ export const finishSimplifier = (goal: Goal, definitions: Definition[] = []) =>
64
67
  goal.elimTrue();
65
68
  goal.elimRedundancies();
66
69
  goal.depth++;
67
- if (definitions.length > 0 || goal.isModelsEnabled) goal.addDefinitions(definitions);
70
+ if (goal.isModelsEnabled) goal.addDefinitions(definitions);
68
71
  };
69
72
 
70
73
  interface Simplifier {
@@ -79,8 +82,11 @@ export const runSimplifier = (
79
82
  ) => {
80
83
  const state = new DependentExprState(goal.manager, goal);
81
84
  const simplifier = create(state);
82
- if (!goal.isProofsEnabled || isSupportingProofs) simplifier.reduce();
83
- finishSimplifier(goal);
84
- simplifier.release();
85
- state.release();
85
+ try {
86
+ if (!goal.isProofsEnabled || isSupportingProofs) simplifier.reduce();
87
+ finishSimplifier(goal);
88
+ } finally {
89
+ simplifier.release();
90
+ state.release();
91
+ }
86
92
  };
@@ -228,33 +228,49 @@ export const createDt2BvTactic = (manager: AstManager) => {
228
228
  else argsCannotBeFd(expr);
229
229
  }
230
230
  for (const sort of nonFdSorts) fdSorts.delete(sort);
231
- if (fdSorts.size > 0) runEnum2Bv(manager, goal, fdSorts);
231
+ if (fdSorts.size > 0)
232
+ runEnum2Bv(
233
+ manager,
234
+ goal,
235
+ (visit) => {
236
+ const size = goal.forms.size;
237
+ for (let index = 0; index < size && !goal.isInconsistent; index++) visit(index);
238
+ },
239
+ fdSorts,
240
+ );
232
241
  goal.depth++;
233
242
  return [goal];
234
243
  };
235
244
  };
236
245
 
237
- export const runEnum2Bv = (manager: AstManager, goal: Goal, fdSorts?: Set<number>) => {
246
+ export const runEnum2Bv = (
247
+ manager: AstManager,
248
+ goal: Goal,
249
+ forEachIndex: (visit: (index: number) => void) => void,
250
+ fdSorts?: Set<number>,
251
+ ) => {
238
252
  const rewriter = new Enum2BvRewriter(manager, fdSorts);
239
253
  let rewritten = -1;
240
- const size = goal.forms.size;
241
- for (let index = 0; index < size && !goal.isInconsistent; index++) {
242
- const next = rewriter.rewrite(goal.forms.items[index]);
254
+ try {
255
+ forEachIndex((index) => {
256
+ const next = rewriter.rewrite(goal.forms.items[index]);
257
+ release(manager, rewritten);
258
+ rewritten = next;
259
+ goal.update(index, rewritten);
260
+ });
261
+ const bounds = new RefVector(manager);
262
+ for (const bound of rewriter.bounds.items) bounds.push(bound);
263
+ rewriter.bounds.reset();
264
+ for (const bound of bounds.items) goal.assert(bound);
265
+ const definitions: Definition[] = [];
266
+ for (const entry of rewriter.enumIndexes)
267
+ definitions.push({ decl: rewriter.enumBvs[entry[1]], def: -1 });
268
+ for (const entry of rewriter.enumIndexes)
269
+ definitions.push({ decl: entry[0], def: rewriter.enumDefs.items[entry[1]] });
270
+ if (definitions.length > 0) goal.addDefinitions(definitions);
271
+ bounds.reset();
272
+ } finally {
243
273
  release(manager, rewritten);
244
- rewritten = next;
245
- goal.update(index, rewritten);
274
+ rewriter.release();
246
275
  }
247
- const bounds = new RefVector(manager);
248
- for (const bound of rewriter.bounds.items) bounds.push(bound);
249
- rewriter.bounds.reset();
250
- for (const bound of bounds.items) goal.assert(bound);
251
- const definitions: Definition[] = [];
252
- for (const entry of rewriter.enumIndexes)
253
- definitions.push({ decl: rewriter.enumBvs[entry[1]], def: -1 });
254
- for (const entry of rewriter.enumIndexes)
255
- definitions.push({ decl: entry[0], def: rewriter.enumDefs.items[entry[1]] });
256
- if (definitions.length > 0) goal.addDefinitions(definitions);
257
- bounds.reset();
258
- release(manager, rewritten);
259
- rewriter.release();
260
276
  };
@@ -0,0 +1,89 @@
1
+ import {
2
+ type AstManager,
3
+ KIND_VAR,
4
+ OP_ADD,
5
+ OP_GE,
6
+ OP_LE,
7
+ OP_MUL,
8
+ OP_NOT,
9
+ OP_OR,
10
+ QUANTIFIER_FORALL,
11
+ } from "./ast";
12
+ import { Rational } from "./rational";
13
+ import { RewriterTpl } from "./rewriter-tpl";
14
+ import { collectUsedVars, elimUnusedVars } from "./var-subst";
15
+
16
+ interface Bound {
17
+ lower: number;
18
+ upper: number;
19
+ }
20
+
21
+ const getBound = (manager: AstManager, atom: number): Bound | undefined => {
22
+ const isNegated = manager.getOp(atom) === OP_NOT;
23
+ const inequality = isNegated ? manager.getArg(atom, 0) : atom;
24
+ const op = manager.getOp(inequality);
25
+ if ((op !== OP_LE && op !== OP_GE) || !manager.isNumeral(manager.getArg(inequality, 1)))
26
+ return undefined;
27
+ const isLe = (op === OP_LE) !== isNegated;
28
+ const term = manager.getArg(inequality, 0);
29
+ const bound = { lower: -1, upper: -1 };
30
+ if (manager.kinds[term] === KIND_VAR) bound.upper = term;
31
+ else if (manager.getOp(term) === OP_ADD && manager.getNumArgs(term) === 2) {
32
+ const first = manager.getArg(term, 0);
33
+ if (manager.kinds[first] === KIND_VAR) bound.upper = first;
34
+ else if (!manager.isGroundApp(first)) return undefined;
35
+ const second = manager.getArg(term, 1);
36
+ if (
37
+ manager.getOp(second) !== OP_MUL ||
38
+ !manager.isNumeral(manager.getArg(second, 0)) ||
39
+ !manager.getRationalValue(manager.getArg(second, 0)).equals(Rational.minusOne)
40
+ )
41
+ return undefined;
42
+ const negated = manager.getArg(second, 1);
43
+ if (manager.kinds[negated] === KIND_VAR) bound.lower = negated;
44
+ else if (!manager.isGroundApp(negated)) return undefined;
45
+ } else return undefined;
46
+ return isLe ? bound : { lower: bound.upper, upper: bound.lower };
47
+ };
48
+
49
+ export class ElimBoundsRw extends RewriterTpl {
50
+ reduceQuantifier(expr: number, body: number) {
51
+ const manager = this.manager;
52
+ const data = manager.getQuantifier(expr);
53
+ if (data.kind !== QUANTIFIER_FORALL) return -1;
54
+ const numVars = data.sorts.length;
55
+ const atoms = manager.getOp(body) === OP_OR ? manager.getArgs(body) : [body];
56
+ const isUsed = Array.from({ length: numVars }, () => false);
57
+ for (const atom of atoms)
58
+ if (getBound(manager, atom) === undefined)
59
+ for (const [index, isVarUsed] of collectUsedVars(manager, atom, numVars).entries())
60
+ if (isVarUsed) isUsed[index] = true;
61
+ if (isUsed.every((isVarUsed) => isVarUsed)) return -1;
62
+ const isCandidate = (variable: number) =>
63
+ variable !== -1 && manager.values[variable] < numVars && !isUsed[manager.values[variable]];
64
+ const lowers = new Set<number>();
65
+ const uppers = new Set<number>();
66
+ for (const atom of atoms) {
67
+ const bound = getBound(manager, atom);
68
+ if (bound === undefined) continue;
69
+ if (isCandidate(bound.lower)) lowers.add(bound.lower);
70
+ if (isCandidate(bound.upper)) uppers.add(bound.upper);
71
+ }
72
+ const candidates = new Set(
73
+ [...lowers, ...uppers].filter((variable) => !lowers.has(variable) || !uppers.has(variable)),
74
+ );
75
+ if (candidates.size === 0) return -1;
76
+ const kept = atoms.filter((atom) => {
77
+ const bound = getBound(manager, atom);
78
+ return bound === undefined || (!candidates.has(bound.lower) && !candidates.has(bound.upper));
79
+ });
80
+ if (kept.length === atoms.length) return -1;
81
+ if (kept.length === 0) {
82
+ manager.incRef(manager.falseExpr);
83
+ return manager.falseExpr;
84
+ }
85
+ return manager.withTemporaries(() =>
86
+ elimUnusedVars(manager, manager.mkQuantifier({ ...data, body: manager.mkOr(kept) })),
87
+ );
88
+ }
89
+ }
@@ -522,7 +522,7 @@ export const elimUncnstr = (manager: AstManager, goal: Goal, bodies: RefVector)
522
522
  const rewritten = rewriter.rewrite(form);
523
523
  if (rewritten !== form) {
524
524
  isModified = true;
525
- goal.update(index, rewritten);
525
+ goal.update(index, rewritten, goal.dependencies[index]);
526
526
  }
527
527
  manager.decRef(rewritten);
528
528
  }
@@ -1,4 +1,4 @@
1
- import { SmtCanceledError } from "../../../errors";
1
+ import { SmtCanceledError, SmtTacticError } from "../../../errors";
2
2
  import {
3
3
  type AstManager,
4
4
  KIND_APP,
@@ -7,27 +7,29 @@ import {
7
7
  OP_AND,
8
8
  OP_EQ,
9
9
  OP_IMPLIES,
10
+ OP_OR,
10
11
  OP_UBV2INT,
11
12
  OP_ULEQ,
12
13
  SORT_BOOL,
13
14
  SORT_INT,
14
15
  } from "./ast";
16
+ import { mkNot } from "./ast-util";
15
17
  import { BoundManager } from "./bound-manager";
16
18
  import { mkBvApp } from "./bv-decl-plugin";
17
19
  import { Bv2IntContext, Bv2IntRewriter } from "./bv2int-rewriter";
18
- import { card2bv } from "./card2bv";
20
+ import { createCard2Bv } from "./card2bv";
21
+ import { DependentExprState } from "./dependent-expr-state";
19
22
  import { runEnum2Bv } from "./dt2bv-tactic";
23
+ import { release } from "./expr-ref";
20
24
  import { ExprSafeReplace } from "./expr-safe-replace";
21
25
  import { type Definition, Goal } from "./goal";
22
- import { ObjMap } from "./hashtable";
23
- import { L_FALSE, L_TRUE } from "./lbool";
26
+ import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
24
27
  import { RefVector } from "./ref-vector";
25
28
  import { Rewriter } from "./rewriter";
26
29
  import { convertModel, getRewriterOptions } from "./tactic";
27
30
  import { UINT_MAX } from "./sat/clause";
28
31
  import type { SatParams } from "./sat/config";
29
32
  import { IncSatSolver } from "./sat/inc-sat-solver";
30
- import { SubstReplacer } from "./solve-eqs";
31
33
 
32
34
  const getNumBits = (value: bigint) => {
33
35
  let bound = 1n;
@@ -50,9 +52,10 @@ const collectBounds = (manager: AstManager, bounds: BoundManager, form: number)
50
52
  // bounded_int2bv_simplifier: an integer constant between two bounds becomes an unsigned
51
53
  // bit-vector plus the lower bound.
52
54
  const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
55
+ const state = new DependentExprState(manager, goal);
53
56
  const bounds = new BoundManager(manager);
54
- for (const form of goal.forms.items) collectBounds(manager, bounds, form);
55
- const substitution = new ObjMap<number>((expr) => manager.hashes[expr]);
57
+ state.forEachIndex((index) => collectBounds(manager, bounds, goal.forms.items[index]));
58
+ const substitution = new ExprSafeReplace(manager);
56
59
  const trail = new RefVector(manager);
57
60
  const sideConditions = new RefVector(manager);
58
61
  const definitions: Definition[] = [];
@@ -77,7 +80,6 @@ const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
77
80
  const replacement = offset.isZero()
78
81
  ? unsigned
79
82
  : manager.mkApp(OP_ADD, [unsigned, manager.mkNumeral(offset.num)], SORT_INT);
80
- trail.push(replacement);
81
83
  definitions.push(
82
84
  { decl: manager.decls[bits], def: -1 },
83
85
  { decl: manager.decls[expr], def: replacement },
@@ -86,36 +88,118 @@ const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
86
88
  sideConditions.push(
87
89
  mkBvApp(manager, OP_ULEQ, [bits, manager.mkBvNumeral(domainSize - 1n, numBits)]),
88
90
  );
89
- substitution.set(expr, replacement);
91
+ substitution.insert(expr, replacement);
90
92
  }
91
- if (substitution.size > 0) {
92
- const replacer = new SubstReplacer(manager, substitution);
93
- const context = new Bv2IntContext(manager, UINT_MAX);
94
- const rewriter = new Bv2IntRewriter(manager, context);
95
- for (let index = 0; index < goal.forms.size; index++) {
96
- const form = goal.forms.items[index];
97
- const replaced = replacer.rewrite(form);
98
- const result = rewriter.rewrite(replaced);
99
- manager.decRef(replaced);
100
- if (result !== form) goal.update(index, result);
101
- manager.decRef(result);
93
+ try {
94
+ if (substitution.sources.size > 0) {
95
+ const context = new Bv2IntContext(manager, UINT_MAX);
96
+ const rewriter = new Bv2IntRewriter(manager, context);
97
+ let replaced = -1;
98
+ let result = -1;
99
+ try {
100
+ state.forEachIndex((index) => {
101
+ const form = goal.forms.items[index];
102
+ const nextReplaced = substitution.apply(form);
103
+ release(manager, replaced);
104
+ replaced = nextReplaced;
105
+ const nextResult = rewriter.rewrite(replaced);
106
+ release(manager, result);
107
+ result = nextResult;
108
+ if (result !== form) goal.update(index, result);
109
+ });
110
+ } finally {
111
+ release(manager, result);
112
+ release(manager, replaced);
113
+ rewriter.release();
114
+ context.release();
115
+ }
102
116
  }
103
- rewriter.release();
104
- context.release();
105
- replacer.release();
117
+ for (const condition of sideConditions.items) goal.assert(condition);
118
+ if (definitions.length > 0) goal.addDefinitions(definitions);
119
+ } finally {
120
+ substitution.release();
121
+ sideConditions.reset();
122
+ trail.reset();
106
123
  }
107
- for (const condition of sideConditions.items) goal.assert(condition);
108
- if (definitions.length > 0) goal.addDefinitions(definitions);
109
- sideConditions.reset();
110
- trail.reset();
111
124
  };
112
125
 
126
+ class SolverFormulas extends Goal {
127
+ override assert(form: number) {
128
+ if (this.manager.isFalse(form)) this.isInconsistent = true;
129
+ this.forms.push(form);
130
+ }
131
+
132
+ override update(index: number, form: number) {
133
+ if (this.manager.isFalse(form)) this.isInconsistent = true;
134
+ this.forms.set(index, form);
135
+ }
136
+
137
+ flattenSuffix() {
138
+ const manager = this.manager;
139
+ const forms = this.forms;
140
+ const seen = new Set<number>();
141
+ const pinned = new RefVector(manager);
142
+ let kept = 0;
143
+ for (let index = 0; index < forms.size; index++) {
144
+ const form = forms.items[index];
145
+ pinned.push(form);
146
+ if (seen.has(form)) continue;
147
+ seen.add(form);
148
+ if (manager.isTrue(form)) continue;
149
+ if (manager.getOp(form) === OP_AND) {
150
+ const numArgs = manager.getNumArgs(form);
151
+ for (let argIndex = 0; argIndex < numArgs; argIndex++)
152
+ this.assert(manager.getArg(form, argIndex));
153
+ continue;
154
+ }
155
+ if (manager.isNot(form) && manager.getOp(manager.getArg(form, 0)) === OP_OR) {
156
+ const disjunction = manager.getArg(form, 0);
157
+ const numArgs = manager.getNumArgs(disjunction);
158
+ for (let argIndex = 0; argIndex < numArgs; argIndex++)
159
+ this.assert(mkNot(manager, manager.getArg(disjunction, argIndex)));
160
+ continue;
161
+ }
162
+ if (index !== kept) forms.set(kept, form);
163
+ kept++;
164
+ }
165
+ while (forms.size > kept) forms.pop();
166
+ pinned.reset();
167
+ }
168
+ }
169
+
113
170
  const runFdSimplifier = (manager: AstManager, forms: readonly number[]) => {
114
- const fmls = new Goal(manager);
171
+ const fmls = new SolverFormulas(manager);
115
172
  for (const form of forms) fmls.assert(form);
116
- runBoundedInt2Bv(manager, fmls);
117
- card2bv(manager, fmls, getRewriterOptions(manager, new Map()));
118
- runEnum2Bv(manager, fmls);
173
+ if (fmls.forms.size === 0) return fmls;
174
+ const state = new DependentExprState(manager, fmls);
175
+ const simplifiers = [
176
+ () => runBoundedInt2Bv(manager, fmls),
177
+ () => {
178
+ const simplifier = createCard2Bv(manager, getRewriterOptions(manager, new Map()))(state);
179
+ try {
180
+ simplifier.reduce();
181
+ } finally {
182
+ simplifier.release();
183
+ }
184
+ },
185
+ () => runEnum2Bv(manager, fmls, (visit) => state.forEachIndex(visit)),
186
+ ];
187
+ try {
188
+ if (!fmls.isInconsistent && manager.limit.inc())
189
+ for (const simplify of simplifiers) {
190
+ if (fmls.isInconsistent || !manager.limit.inc()) break;
191
+ try {
192
+ simplify();
193
+ } catch (error) {
194
+ if (!(error instanceof SmtCanceledError)) throw error;
195
+ break;
196
+ }
197
+ fmls.flattenSuffix();
198
+ }
199
+ } finally {
200
+ state.release();
201
+ }
202
+ if (!manager.limit.inc()) fmls.reset();
119
203
  return fmls;
120
204
  };
121
205
 
@@ -176,7 +260,6 @@ export const getFdConsequences = (
176
260
  const solver = new IncSatSolver(manager, params);
177
261
  try {
178
262
  for (const form of fmls.forms.items) solver.assertExpr(form);
179
- if (fmls.isInconsistent) solver.assertExpr(manager.falseExpr);
180
263
  const found = solver.getConsequences(asms1, queryVars);
181
264
  const coreReplace = new ExprSafeReplace(manager);
182
265
  asms1.forEach((assumption, index) => coreReplace.insert(assumption, assumptions[index]));
@@ -244,18 +327,16 @@ export const createFdTactic = (manager: AstManager, params: SatParams) => (goal:
244
327
  const solver = new IncSatSolver(manager, params, false);
245
328
  try {
246
329
  for (const form of fmls.forms.items) solver.assertExpr(form);
247
- const result = fmls.isInconsistent ? L_FALSE : solver.check();
330
+ const result = solver.check();
248
331
  goal.reset();
249
332
  if (result === L_TRUE) {
250
333
  const model = solver.getModel();
251
- model?.incRef();
252
- if (model !== null) {
253
- goal.converters = [...goal.converters, ...fmls.converters];
254
- goal.model = model;
255
- }
334
+ const converted = model === null ? null : convertModel(fmls, model);
335
+ converted?.incRef();
336
+ if (converted !== null) goal.model = converted;
256
337
  } else if (result === L_FALSE) goal.assert(manager.falseExpr);
257
338
  else {
258
- if (!manager.limit.inc()) throw new SmtCanceledError();
339
+ if (!manager.limit.inc()) throw new SmtTacticError("canceled");
259
340
  for (const form of solver.getAssertions()) goal.assert(form);
260
341
  goal.converters = [...goal.converters, ...fmls.converters, ...solver.getConverters()];
261
342
  }
@@ -265,3 +346,29 @@ export const createFdTactic = (manager: AstManager, params: SatParams) => (goal:
265
346
  solver.release();
266
347
  }
267
348
  };
349
+
350
+ export const checkFdSolver = (manager: AstManager, params: SatParams, forms: readonly number[]) => {
351
+ const fmls = runFdSimplifier(manager, forms);
352
+ const solver = new IncSatSolver(manager, params);
353
+ const limit = manager.limit;
354
+ const wasSuspended = limit.isSuspended;
355
+ try {
356
+ for (const form of fmls.forms.items) solver.assertExpr(form);
357
+ const result = (() => {
358
+ try {
359
+ return solver.check();
360
+ } catch (error) {
361
+ if (!(error instanceof SmtCanceledError)) throw error;
362
+ return L_UNDEF;
363
+ }
364
+ })();
365
+ const model = result === L_TRUE ? solver.getModel() : null;
366
+ limit.isSuspended = true;
367
+ const converted = model === null ? undefined : convertModel(fmls, model);
368
+ converted?.incRef();
369
+ return { result, model: converted, reasonUnknown: solver.reasonUnknown };
370
+ } finally {
371
+ limit.isSuspended = wasSuspended;
372
+ solver.release();
373
+ }
374
+ };
@@ -172,7 +172,7 @@ export abstract class Internalizer {
172
172
  falseEnode: Enode;
173
173
  protected generation = 0;
174
174
  protected cachedGeneration = new Map<number, number>();
175
- private randomSeed = 0;
175
+ protected randomSeed = 0;
176
176
  isSearching = false;
177
177
  config = DEFAULT_CONFIG;
178
178
 
@@ -70,6 +70,10 @@ export class LpSettings {
70
70
 
71
71
  constructor(readonly isCanceled: () => boolean) {}
72
72
 
73
+ setRandomSeed(seed: number) {
74
+ this.random = new RandomGen(seed);
75
+ }
76
+
73
77
  getRandomNext(bound?: number) {
74
78
  const value = this.random.next();
75
79
  return bound === undefined ? value : value % bound;