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.
- package/dist/deciders.cjs +31 -31
- package/dist/deciders.js +30 -30
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +6 -2
- package/dist/index.d.ts +6 -2
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +68 -68
- package/dist/prove.js +61 -61
- package/dist/run.cjs +42 -42
- package/dist/run.js +44 -44
- package/dist/transfer.cjs +38 -38
- package/dist/transfer.js +29 -29
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/bags.ts +5 -2
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +9 -6
- package/src/check-trace.ts +116 -64
- package/src/check.ts +343 -166
- package/src/cli/tlc-output.ts +1 -0
- package/src/cli/tlc.ts +3 -2
- package/src/codegen.ts +23 -8
- package/src/dependencies.ts +5 -4
- package/src/dfid.ts +13 -8
- package/src/environment.ts +1 -0
- package/src/evaluate.ts +58 -23
- package/src/exit-codes.ts +27 -13
- package/src/java-hash.ts +14 -0
- package/src/liveness-checker.ts +131 -81
- package/src/liveness.ts +48 -10
- package/src/parser.ts +6 -1
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +109 -63
- package/src/prover/smt/solver/ast.ts +5 -3
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
- package/src/prover/smt/solver/bound-simplifier.ts +10 -11
- package/src/prover/smt/solver/card2bv.ts +34 -15
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -23
- package/src/prover/smt/solver/context.ts +44 -11
- package/src/prover/smt/solver/dependent-expr-state.ts +19 -13
- package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +1 -1
- package/src/prover/smt/solver/fd-solver.ts +146 -39
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +4 -0
- package/src/prover/smt/solver/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +82 -42
- package/src/prover/smt/solver/muz/dl-context.ts +12 -40
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-rule.ts +6 -7
- package/src/prover/smt/solver/muz/hnf.ts +2 -2
- package/src/prover/smt/solver/muz/horn-tactic.ts +14 -1
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
- package/src/prover/smt/solver/opt-context.ts +12 -4
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-solver.ts +4 -3
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/poly-rewriter.ts +1 -0
- package/src/prover/smt/solver/proto-model.ts +4 -2
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qsat.ts +23 -8
- package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +56 -28
- package/src/prover/smt/solver/sat/sat-tactic.ts +13 -4
- package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
- package/src/prover/smt/solver/smt-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +39 -4
- package/src/prover/smt/solver/smt-setup.ts +28 -4
- package/src/prover/smt/solver/smtlib-parser.ts +31 -4
- package/src/prover/smt/solver/smtlib-script.ts +219 -82
- package/src/prover/smt/solver/solve-eqs.ts +24 -17
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +132 -78
- package/src/prover/smt/solver/theory-bv.ts +11 -1
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +7 -1
- package/src/prover/smt/solver/theory-lra.ts +1 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
- package/src/resolve.ts +446 -167
- package/src/runtime.ts +4 -0
- package/src/search.ts +161 -92
- package/src/simulate.ts +165 -102
- package/src/spec-description.ts +3 -4
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +168 -49
- package/src/successors.ts +6 -3
- package/src/symmetry.ts +1 -0
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +22 -14
- package/src/tlc/tlc-operators.ts +7 -7
- package/src/tlc/tlcext-operators.ts +26 -10
- package/src/tlc/trace-spec.ts +6 -20
- package/src/typed-tier.ts +9 -4
- 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 (
|
|
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 =
|
|
1375
|
-
|
|
1376
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1511
|
-
|
|
1512
|
-
|
|
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
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
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
|
-
|
|
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 (
|
|
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
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
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)
|
|
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 = (
|
|
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
|
-
|
|
241
|
-
|
|
242
|
-
|
|
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
|
-
|
|
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 {
|
|
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 {
|
|
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
|
-
|
|
55
|
-
const substitution = new
|
|
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.
|
|
91
|
+
substitution.insert(expr, replacement);
|
|
90
92
|
}
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
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
|
-
|
|
104
|
-
|
|
105
|
-
|
|
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
|
|
171
|
+
const fmls = new SolverFormulas(manager);
|
|
115
172
|
for (const form of forms) fmls.assert(form);
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
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 =
|
|
330
|
+
const result = solver.check();
|
|
248
331
|
goal.reset();
|
|
249
332
|
if (result === L_TRUE) {
|
|
250
333
|
const model = solver.getModel();
|
|
251
|
-
model
|
|
252
|
-
|
|
253
|
-
|
|
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
|
|
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
|
-
|
|
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;
|