tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.94c3dd828
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/deciders.cjs +37 -36
- package/dist/deciders.js +55 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +3 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +146 -58
- package/dist/prove.js +142 -54
- package/dist/run.cjs +45 -43
- package/dist/run.js +47 -45
- package/dist/transfer.cjs +39 -36
- package/dist/transfer.js +23 -20
- package/dist/worker.cjs +1 -1
- package/dist/worker.js +1 -1
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/check.ts +203 -33
- package/src/cli/tlapm.ts +261 -68
- package/src/dependencies.ts +23 -2
- package/src/errors.ts +1 -1
- package/src/exit-codes.ts +1 -0
- package/src/liveness-checker.ts +530 -201
- package/src/liveness.ts +47 -32
- package/src/obligations/anonymize.ts +2 -4
- package/src/obligations/index.ts +5 -3
- package/src/obligations/pragma.ts +2 -2
- package/src/parallel.ts +2 -2
- package/src/parser.ts +151 -42
- package/src/prover/deciders.ts +1 -8
- package/src/prover/isabelle/isar/attrib.ts +86 -45
- package/src/prover/isabelle/isar/context.ts +25 -22
- package/src/prover/isabelle/isar/induct.ts +2 -5
- package/src/prover/isabelle/isar/method.ts +5 -7
- package/src/prover/isabelle/isar/proof.ts +33 -16
- package/src/prover/isabelle/isar/rule-cases.ts +6 -14
- package/src/prover/isabelle/isar/theory.ts +16 -17
- package/src/prover/isabelle/isar/toplevel.ts +46 -52
- package/src/prover/isabelle/provers/classical.ts +1 -1
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +1 -0
- package/src/prover/prep/methods.ts +50 -3
- package/src/prover/prep/normalize.ts +4 -1
- package/src/prover/prove.ts +58 -32
- package/src/prover/ptl/decide.ts +43 -63
- package/src/prover/smt/data.ts +51 -45
- package/src/prover/smt/encode.ts +1 -2
- package/src/prover/smt/rewrite.ts +1 -0
- package/src/prover/smt/solver/aig-tactic.ts +25 -15
- package/src/prover/smt/solver/arith-rewriter.ts +3 -5
- package/src/prover/smt/solver/asserted-formulas.ts +1 -1
- package/src/prover/smt/solver/ast-util.ts +3 -1
- package/src/prover/smt/solver/ast.ts +110 -152
- package/src/prover/smt/solver/bound-manager.ts +39 -28
- package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
- package/src/prover/smt/solver/bv-rewriter.ts +14 -16
- package/src/prover/smt/solver/bv1-blast.ts +1 -9
- package/src/prover/smt/solver/cg-table.ts +19 -14
- package/src/prover/smt/solver/check-logic.ts +6 -1
- package/src/prover/smt/solver/context.ts +20 -10
- package/src/prover/smt/solver/demodulator.ts +2 -2
- package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
- package/src/prover/smt/solver/distribute-forall.ts +1 -10
- package/src/prover/smt/solver/dom-simplify.ts +1 -1
- package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
- package/src/prover/smt/solver/e-matching.ts +6 -6
- package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
- package/src/prover/smt/solver/enode.ts +15 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
- package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
- package/src/prover/smt/solver/euf/egraph.ts +65 -32
- package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
- package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
- package/src/prover/smt/solver/euf/mam.ts +6 -48
- package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
- package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
- package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
- package/src/prover/smt/solver/euf/q-solver.ts +2 -0
- package/src/prover/smt/solver/euf/th-solver.ts +1 -1
- package/src/prover/smt/solver/factor.ts +1 -11
- package/src/prover/smt/solver/fd-solver.ts +1 -2
- package/src/prover/smt/solver/fm-tactic.ts +19 -13
- package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
- package/src/prover/smt/solver/internalizer.ts +41 -2
- package/src/prover/smt/solver/lia2pb.ts +18 -4
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
- package/src/prover/smt/solver/macro-finder.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +13 -13
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
- package/src/prover/smt/solver/maxcore.ts +4 -12
- package/src/prover/smt/solver/maxlex.ts +0 -7
- package/src/prover/smt/solver/maxsmt-base.ts +7 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
- package/src/prover/smt/solver/model-evaluator.ts +9 -5
- package/src/prover/smt/solver/model-macro-solver.ts +3 -3
- package/src/prover/smt/solver/muz/dl-context.ts +57 -3
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
- package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
- package/src/prover/smt/solver/muz/hnf.ts +6 -5
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
- package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
- package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
- package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
- package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
- package/src/prover/smt/solver/muz/substitution.ts +88 -37
- package/src/prover/smt/solver/nlqsat.ts +2 -2
- package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
- package/src/prover/smt/solver/nlsat/explain.ts +5 -0
- package/src/prover/smt/solver/nlsat/solver.ts +36 -25
- package/src/prover/smt/solver/opt-context.ts +9 -8
- package/src/prover/smt/solver/opt-nlsat.ts +68 -58
- package/src/prover/smt/solver/opt-solver.ts +16 -7
- package/src/prover/smt/solver/optsmt.ts +12 -9
- package/src/prover/smt/solver/pattern-inference.ts +2 -2
- package/src/prover/smt/solver/pb-rewriter.ts +13 -13
- package/src/prover/smt/solver/poly-rewriter.ts +2 -2
- package/src/prover/smt/solver/probes.ts +1 -1
- package/src/prover/smt/solver/propagate-values.ts +4 -0
- package/src/prover/smt/solver/proto-model.ts +5 -5
- package/src/prover/smt/solver/purify-arith.ts +50 -15
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
- package/src/prover/smt/solver/qe-mbp.ts +13 -23
- package/src/prover/smt/solver/qe.ts +45 -53
- package/src/prover/smt/solver/qsat.ts +70 -90
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
- package/src/prover/smt/solver/quasi-macros.ts +9 -18
- package/src/prover/smt/solver/rational.ts +17 -0
- package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
- package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
- package/src/prover/smt/solver/rewriter.ts +1 -1
- package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
- package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
- package/src/prover/smt/solver/sat/clause.ts +1 -3
- package/src/prover/smt/solver/sat/config.ts +3 -3
- package/src/prover/smt/solver/sat/consequences.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
- package/src/prover/smt/solver/sat/model-converter.ts +1 -15
- package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
- package/src/prover/smt/solver/sat/probing.ts +22 -19
- package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
- package/src/prover/smt/solver/sat/simplifier.ts +15 -56
- package/src/prover/smt/solver/sat/solver.ts +20 -19
- package/src/prover/smt/solver/sat/watch-list.ts +7 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
- package/src/prover/smt/solver/seq-derive.ts +6 -7
- package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
- package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
- package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
- package/src/prover/smt/solver/seq-re-util.ts +1 -2
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +4 -4
- package/src/prover/smt/solver/seq-rewriter.ts +1 -4
- package/src/prover/smt/solver/smt-setup.ts +15 -9
- package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
- package/src/prover/smt/solver/smtlib-script.ts +866 -728
- package/src/prover/smt/solver/tactic.ts +66 -14
- package/src/prover/smt/solver/theory-array.ts +25 -58
- package/src/prover/smt/solver/theory-bv.ts +13 -50
- package/src/prover/smt/solver/theory-fpa.ts +46 -78
- package/src/prover/smt/solver/theory-pb.ts +10 -6
- package/src/prover/smt/solver/theory-recfun.ts +2 -2
- package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
- package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
- package/src/prover/smt/solver/theory-seq-state.ts +6 -3
- package/src/prover/smt/solver/theory-seq.ts +32 -54
- package/src/prover/smt/solver/theory.ts +16 -1
- package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
- package/src/prover/smt/solver/var-subst.ts +2 -2
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/zenon/decide.ts +9 -11
- package/src/prover/zenon/node.ts +12 -11
- package/src/prover/zenon/tla/sets.ts +1 -1
- package/src/search.ts +131 -16
- package/src/successors.ts +1 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/summary.ts +29 -14
- package/src/typed-tier.ts +6535 -0
- package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
|
@@ -14,71 +14,70 @@ const MAX_UNSIGNED = 0xffffffffn;
|
|
|
14
14
|
const isUnsigned = (value: Rational) =>
|
|
15
15
|
value.isInt() && value.num >= 0n && value.num <= MAX_UNSIGNED;
|
|
16
16
|
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
17
|
+
// x != 0 => x^0 = 1
|
|
18
|
+
const xExp0 = (core: NlaCore, result: number, base: number, exponent: number) => {
|
|
19
|
+
const lemma = new LemmaBuilder(core);
|
|
20
|
+
lemma.addIneq(mkIneq(base, KIND_EQ, 0));
|
|
21
|
+
lemma.addIneq(mkIneq(exponent, KIND_NE, 0));
|
|
22
|
+
lemma.addIneq(mkIneq(result, KIND_EQ, 1));
|
|
23
|
+
return L_FALSE;
|
|
24
|
+
};
|
|
25
|
+
|
|
26
|
+
// y != 0 => 0^y = 0
|
|
27
|
+
const zeroExpY = (core: NlaCore, result: number, base: number, exponent: number) => {
|
|
28
|
+
const lemma = new LemmaBuilder(core);
|
|
29
|
+
lemma.addIneq(mkIneq(base, KIND_NE, 0));
|
|
30
|
+
lemma.addIneq(mkIneq(exponent, KIND_EQ, 0));
|
|
31
|
+
lemma.addIneq(mkIneq(result, KIND_EQ, 0));
|
|
32
|
+
return L_FALSE;
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
// x > 0 => x^y > 0
|
|
36
|
+
const xGt0 = (core: NlaCore, result: number, base: number) => {
|
|
37
|
+
const lemma = new LemmaBuilder(core);
|
|
38
|
+
lemma.addIneq(mkIneq(base, KIND_LE, 0));
|
|
39
|
+
lemma.addIneq(mkIneq(result, KIND_GT, 0));
|
|
40
|
+
return L_FALSE;
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
// x > 1, y < 0 => x^y < 1
|
|
44
|
+
const yLt1 = (core: NlaCore, result: number, base: number, exponent: number) => {
|
|
45
|
+
const lemma = new LemmaBuilder(core);
|
|
46
|
+
lemma.addIneq(mkIneq(base, KIND_LE, 1));
|
|
47
|
+
lemma.addIneq(mkIneq(exponent, KIND_GE, 0));
|
|
48
|
+
lemma.addIneq(mkIneq(result, KIND_LT, 1));
|
|
49
|
+
return L_FALSE;
|
|
50
|
+
};
|
|
51
|
+
|
|
52
|
+
// x > 1, y > 0 => x^y > 1
|
|
53
|
+
const yGt1 = (core: NlaCore, result: number, base: number, exponent: number) => {
|
|
54
|
+
const lemma = new LemmaBuilder(core);
|
|
55
|
+
lemma.addIneq(mkIneq(base, KIND_LE, 1));
|
|
56
|
+
lemma.addIneq(mkIneq(exponent, KIND_LE, 0));
|
|
57
|
+
lemma.addIneq(mkIneq(result, KIND_GT, 1));
|
|
58
|
+
return L_FALSE;
|
|
59
|
+
};
|
|
60
|
+
|
|
61
|
+
// x >= 3, y > 0 => x^y > ln(x)y + 1
|
|
62
|
+
const xGe3 = (core: NlaCore, result: number, base: number, exponent: number) => {
|
|
63
|
+
const lemma = new LemmaBuilder(core);
|
|
64
|
+
lemma.addIneq(mkIneq(base, KIND_LT, THREE));
|
|
65
|
+
lemma.addIneq(mkIneq(exponent, KIND_LE, 0));
|
|
66
|
+
lemma.addIneq(
|
|
67
|
+
mkIneq(
|
|
68
|
+
new LarTerm([
|
|
69
|
+
[result, Rational.one],
|
|
70
|
+
[exponent, Rational.minusOne],
|
|
71
|
+
]),
|
|
72
|
+
KIND_GT,
|
|
73
|
+
1,
|
|
74
|
+
),
|
|
75
|
+
);
|
|
76
|
+
return L_FALSE;
|
|
77
|
+
};
|
|
22
78
|
|
|
23
79
|
export const checkPower = (core: NlaCore, result: number, base: number, exponent: number) => {
|
|
24
80
|
if (base === NULL_LPVAR || exponent === NULL_LPVAR || result === NULL_LPVAR) return L_UNDEF;
|
|
25
|
-
const addLemma = (...ineqs: Parameters<typeof mkIneq>[]) => {
|
|
26
|
-
const lemma = new LemmaBuilder(core);
|
|
27
|
-
for (const ineq of ineqs) lemma.addIneq(mkIneq(...ineq));
|
|
28
|
-
return L_FALSE;
|
|
29
|
-
};
|
|
30
|
-
const checkAxioms = <Value>(
|
|
31
|
-
ordered: Ordered<Value>,
|
|
32
|
-
baseValue: Value,
|
|
33
|
-
exponentValue: Value,
|
|
34
|
-
resultValue: Value,
|
|
35
|
-
) => {
|
|
36
|
-
const sign = (value: Value, bound: Rational) => ordered.compare(value, ordered.of(bound));
|
|
37
|
-
if (
|
|
38
|
-
sign(baseValue, Rational.zero) !== 0 &&
|
|
39
|
-
sign(exponentValue, Rational.zero) === 0 &&
|
|
40
|
-
sign(resultValue, Rational.one) !== 0
|
|
41
|
-
)
|
|
42
|
-
return addLemma([base, KIND_EQ, 0], [exponent, KIND_NE, 0], [result, KIND_EQ, 1]);
|
|
43
|
-
if (
|
|
44
|
-
sign(baseValue, Rational.zero) === 0 &&
|
|
45
|
-
sign(exponentValue, Rational.zero) !== 0 &&
|
|
46
|
-
sign(resultValue, Rational.zero) !== 0
|
|
47
|
-
)
|
|
48
|
-
return addLemma([base, KIND_NE, 0], [exponent, KIND_EQ, 0], [result, KIND_EQ, 0]);
|
|
49
|
-
if (sign(baseValue, Rational.zero) > 0 && sign(resultValue, Rational.zero) <= 0)
|
|
50
|
-
return addLemma([base, KIND_LE, 0], [result, KIND_GT, 0]);
|
|
51
|
-
if (
|
|
52
|
-
sign(baseValue, Rational.one) > 0 &&
|
|
53
|
-
sign(exponentValue, Rational.zero) < 0 &&
|
|
54
|
-
sign(resultValue, Rational.one) >= 0
|
|
55
|
-
)
|
|
56
|
-
return addLemma([base, KIND_LE, 1], [exponent, KIND_GE, 0], [result, KIND_LT, 1]);
|
|
57
|
-
if (
|
|
58
|
-
sign(baseValue, Rational.one) > 0 &&
|
|
59
|
-
sign(exponentValue, Rational.zero) > 0 &&
|
|
60
|
-
sign(resultValue, Rational.one) <= 0
|
|
61
|
-
)
|
|
62
|
-
return addLemma([base, KIND_LE, 1], [exponent, KIND_LE, 0], [result, KIND_GT, 1]);
|
|
63
|
-
if (
|
|
64
|
-
sign(baseValue, THREE) >= 0 &&
|
|
65
|
-
sign(exponentValue, Rational.zero) > 0 &&
|
|
66
|
-
ordered.compare(resultValue, ordered.add(exponentValue, ordered.of(Rational.one))) <= 0
|
|
67
|
-
)
|
|
68
|
-
return addLemma(
|
|
69
|
-
[base, KIND_LT, THREE],
|
|
70
|
-
[exponent, KIND_LE, 0],
|
|
71
|
-
[
|
|
72
|
-
new LarTerm([
|
|
73
|
-
[result, Rational.one],
|
|
74
|
-
[exponent, Rational.minusOne],
|
|
75
|
-
]),
|
|
76
|
-
KIND_GT,
|
|
77
|
-
1,
|
|
78
|
-
],
|
|
79
|
-
);
|
|
80
|
-
return undefined;
|
|
81
|
-
};
|
|
82
81
|
const lra = core.lra;
|
|
83
82
|
const am = core.nra.am;
|
|
84
83
|
const values = core.isUsingNraModel
|
|
@@ -99,43 +98,58 @@ export const checkPower = (core: NlaCore, result: number, base: number, exponent
|
|
|
99
98
|
const baseValue = rationals[0];
|
|
100
99
|
const exponentValue = rationals[1];
|
|
101
100
|
const resultValue = rationals[2];
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
baseValue
|
|
109
|
-
exponentValue
|
|
110
|
-
resultValue
|
|
111
|
-
)
|
|
112
|
-
|
|
101
|
+
if (!baseValue.isZero() && exponentValue.isZero() && !resultValue.equals(Rational.one))
|
|
102
|
+
return xExp0(core, result, base, exponent);
|
|
103
|
+
if (baseValue.isZero() && !exponentValue.isZero() && !resultValue.isZero())
|
|
104
|
+
return zeroExpY(core, result, base, exponent);
|
|
105
|
+
if (baseValue.isPositive() && !resultValue.isPositive()) return xGt0(core, result, base);
|
|
106
|
+
if (
|
|
107
|
+
baseValue.compare(Rational.one) > 0 &&
|
|
108
|
+
exponentValue.isNegative() &&
|
|
109
|
+
resultValue.compare(Rational.one) >= 0
|
|
110
|
+
)
|
|
111
|
+
return yLt1(core, result, base, exponent);
|
|
112
|
+
if (
|
|
113
|
+
baseValue.compare(Rational.one) > 0 &&
|
|
114
|
+
exponentValue.isPositive() &&
|
|
115
|
+
resultValue.compare(Rational.one) <= 0
|
|
116
|
+
)
|
|
117
|
+
return yGt1(core, result, base, exponent);
|
|
118
|
+
if (
|
|
119
|
+
baseValue.compare(THREE) >= 0 &&
|
|
120
|
+
exponentValue.isPositive() &&
|
|
121
|
+
resultValue.compare(exponentValue.add(Rational.one)) <= 0
|
|
122
|
+
)
|
|
123
|
+
return xGe3(core, result, base, exponent);
|
|
113
124
|
if (baseValue.isPositive() && isUnsigned(exponentValue)) {
|
|
114
125
|
const powerValue = baseValue.pow(Number(exponentValue.num));
|
|
115
126
|
const comparison = resultValue.compare(powerValue);
|
|
116
127
|
if (comparison === 0) return L_TRUE;
|
|
117
|
-
if (core.random() % 2 === 0)
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
128
|
+
if (core.random() % 2 === 0) {
|
|
129
|
+
const lemma = new LemmaBuilder(core);
|
|
130
|
+
lemma.addIneq(mkIneq(base, KIND_NE, baseValue));
|
|
131
|
+
lemma.addIneq(mkIneq(exponent, KIND_NE, exponentValue));
|
|
132
|
+
lemma.addIneq(mkIneq(result, KIND_EQ, powerValue));
|
|
133
|
+
return L_FALSE;
|
|
134
|
+
}
|
|
123
135
|
const isIncreasing = baseValue.compare(Rational.one) >= 0;
|
|
124
|
-
if (exponentValue.isPositive() && comparison < 0)
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
);
|
|
136
|
+
if (exponentValue.isPositive() && comparison < 0) {
|
|
137
|
+
const lemma = new LemmaBuilder(core);
|
|
138
|
+
lemma.addIneq(mkIneq(base, KIND_LT, baseValue));
|
|
139
|
+
lemma.addIneq(mkIneq(exponent, isIncreasing ? KIND_LT : KIND_GT, exponentValue));
|
|
140
|
+
if (!isIncreasing) lemma.addIneq(mkIneq(exponent, KIND_LT, 0));
|
|
141
|
+
lemma.addIneq(mkIneq(result, KIND_GE, powerValue));
|
|
142
|
+
return L_FALSE;
|
|
143
|
+
}
|
|
144
|
+
if (comparison > 0) {
|
|
145
|
+
const lemma = new LemmaBuilder(core);
|
|
146
|
+
lemma.addIneq(mkIneq(base, KIND_LE, 0));
|
|
147
|
+
lemma.addIneq(mkIneq(base, KIND_GT, baseValue));
|
|
148
|
+
lemma.addIneq(mkIneq(exponent, isIncreasing ? KIND_GT : KIND_LT, exponentValue));
|
|
149
|
+
if (isIncreasing) lemma.addIneq(mkIneq(exponent, KIND_LT, 0));
|
|
150
|
+
lemma.addIneq(mkIneq(result, KIND_LE, powerValue));
|
|
151
|
+
return L_FALSE;
|
|
152
|
+
}
|
|
139
153
|
}
|
|
140
154
|
if (baseValue.isPositive() && exponentValue.isPositive() && !exponentValue.isInt()) {
|
|
141
155
|
const num = exponentValue.num;
|
|
@@ -153,20 +167,43 @@ export const checkPower = (core: NlaCore, result: number, base: number, exponent
|
|
|
153
167
|
const baseValue = values[0];
|
|
154
168
|
const exponentValue = values[1];
|
|
155
169
|
const resultValue = values[2];
|
|
156
|
-
const
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
170
|
+
const zero = new Anum(Rational.zero);
|
|
171
|
+
const one = new Anum(Rational.one);
|
|
172
|
+
if (
|
|
173
|
+
am.compare(baseValue, zero) !== 0 &&
|
|
174
|
+
am.compare(exponentValue, zero) === 0 &&
|
|
175
|
+
am.compare(resultValue, one) !== 0
|
|
176
|
+
)
|
|
177
|
+
return xExp0(core, result, base, exponent);
|
|
178
|
+
if (
|
|
179
|
+
am.compare(baseValue, zero) === 0 &&
|
|
180
|
+
am.compare(exponentValue, zero) !== 0 &&
|
|
181
|
+
am.compare(resultValue, zero) !== 0
|
|
182
|
+
)
|
|
183
|
+
return zeroExpY(core, result, base, exponent);
|
|
184
|
+
if (am.compare(baseValue, zero) > 0 && am.compare(resultValue, zero) <= 0)
|
|
185
|
+
return xGt0(core, result, base);
|
|
186
|
+
if (
|
|
187
|
+
am.compare(baseValue, one) > 0 &&
|
|
188
|
+
am.compare(exponentValue, zero) < 0 &&
|
|
189
|
+
am.compare(resultValue, one) >= 0
|
|
190
|
+
)
|
|
191
|
+
return yLt1(core, result, base, exponent);
|
|
192
|
+
if (
|
|
193
|
+
am.compare(baseValue, one) > 0 &&
|
|
194
|
+
am.compare(exponentValue, zero) > 0 &&
|
|
195
|
+
am.compare(resultValue, one) <= 0
|
|
196
|
+
)
|
|
197
|
+
return yGt1(core, result, base, exponent);
|
|
198
|
+
if (
|
|
199
|
+
am.compare(baseValue, new Anum(THREE)) >= 0 &&
|
|
200
|
+
am.compare(exponentValue, zero) > 0 &&
|
|
201
|
+
am.compare(resultValue, am.add(exponentValue, one)) <= 0
|
|
202
|
+
)
|
|
203
|
+
return xGe3(core, result, base, exponent);
|
|
167
204
|
if (
|
|
168
|
-
am.compare(baseValue,
|
|
169
|
-
am.compare(exponentValue,
|
|
205
|
+
am.compare(baseValue, zero) > 0 &&
|
|
206
|
+
am.compare(exponentValue, zero) > 0 &&
|
|
170
207
|
am.isRational(exponentValue)
|
|
171
208
|
) {
|
|
172
209
|
const exponentRational = am.toRational(exponentValue);
|
|
@@ -189,27 +189,60 @@ export class NlaTranscendentals {
|
|
|
189
189
|
return true;
|
|
190
190
|
}
|
|
191
191
|
|
|
192
|
-
//
|
|
193
|
-
private
|
|
194
|
-
if (app.op !== "exp"
|
|
192
|
+
// x1 < x2 implies exp(x1) < exp(x2).
|
|
193
|
+
private checkExpMonotonicity(app: TranscendentalApp) {
|
|
194
|
+
if (app.op !== "exp") return false;
|
|
195
195
|
const core = this.core;
|
|
196
196
|
const arg = core.val(app.arg);
|
|
197
|
-
if (app.op === "log" && !arg.isPositive()) return false;
|
|
198
197
|
const val = core.val(app.val);
|
|
199
198
|
for (const other of this.apps) {
|
|
200
|
-
if (other.op !==
|
|
199
|
+
if (other.op !== "exp" || other.arg === app.arg) continue;
|
|
201
200
|
const otherArg = core.val(other.arg);
|
|
202
|
-
if (app.op === "log" && !otherArg.isPositive()) continue;
|
|
203
201
|
const otherVal = core.val(other.val);
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
202
|
+
if (arg.compare(otherArg) < 0 && val.compare(otherVal) >= 0) {
|
|
203
|
+
new LemmaBuilder(core)
|
|
204
|
+
.addIneq(mkIneq(mkTerm(app.arg, 1, other.arg, -1), KIND_GE, 0))
|
|
205
|
+
.addIneq(mkIneq(mkTerm(app.val, 1, other.val, -1), KIND_LT, 0));
|
|
206
|
+
return true;
|
|
207
|
+
}
|
|
208
|
+
if (arg.compare(otherArg) > 0 && val.compare(otherVal) <= 0) {
|
|
209
|
+
new LemmaBuilder(core)
|
|
210
|
+
.addIneq(mkIneq(mkTerm(app.arg, 1, other.arg, -1), KIND_LE, 0))
|
|
211
|
+
.addIneq(mkIneq(mkTerm(app.val, 1, other.val, -1), KIND_GT, 0));
|
|
212
|
+
return true;
|
|
213
|
+
}
|
|
214
|
+
}
|
|
215
|
+
return false;
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
// 0 < x1 < x2 implies log(x1) < log(x2).
|
|
219
|
+
private checkLogMonotonicity(app: TranscendentalApp) {
|
|
220
|
+
if (app.op !== "log") return false;
|
|
221
|
+
const core = this.core;
|
|
222
|
+
const arg = core.val(app.arg);
|
|
223
|
+
if (!arg.isPositive()) return false;
|
|
224
|
+
const val = core.val(app.val);
|
|
225
|
+
for (const other of this.apps) {
|
|
226
|
+
if (other.op !== "log" || other.arg === app.arg) continue;
|
|
227
|
+
const otherArg = core.val(other.arg);
|
|
228
|
+
if (!otherArg.isPositive()) continue;
|
|
229
|
+
const otherVal = core.val(other.val);
|
|
230
|
+
if (arg.compare(otherArg) < 0 && val.compare(otherVal) >= 0) {
|
|
231
|
+
new LemmaBuilder(core)
|
|
232
|
+
.addIneq(mkIneq(app.arg, KIND_LE, 0))
|
|
233
|
+
.addIneq(mkIneq(other.arg, KIND_LE, 0))
|
|
234
|
+
.addIneq(mkIneq(mkTerm(app.arg, 1, other.arg, -1), KIND_GE, 0))
|
|
235
|
+
.addIneq(mkIneq(mkTerm(app.val, 1, other.val, -1), KIND_LT, 0));
|
|
236
|
+
return true;
|
|
237
|
+
}
|
|
238
|
+
if (arg.compare(otherArg) > 0 && val.compare(otherVal) <= 0) {
|
|
239
|
+
new LemmaBuilder(core)
|
|
240
|
+
.addIneq(mkIneq(app.arg, KIND_LE, 0))
|
|
241
|
+
.addIneq(mkIneq(other.arg, KIND_LE, 0))
|
|
242
|
+
.addIneq(mkIneq(mkTerm(app.arg, 1, other.arg, -1), KIND_LE, 0))
|
|
243
|
+
.addIneq(mkIneq(mkTerm(app.val, 1, other.val, -1), KIND_GT, 0));
|
|
244
|
+
return true;
|
|
245
|
+
}
|
|
213
246
|
}
|
|
214
247
|
return false;
|
|
215
248
|
}
|
|
@@ -221,9 +254,9 @@ export class NlaTranscendentals {
|
|
|
221
254
|
this.checkLinearMajorant(app) ||
|
|
222
255
|
this.checkSignOnPiRange(app) ||
|
|
223
256
|
this.checkExpLowerBound(app) ||
|
|
224
|
-
|
|
257
|
+
this.checkExpMonotonicity(app) ||
|
|
225
258
|
this.checkLogUpperBound(app) ||
|
|
226
|
-
|
|
259
|
+
this.checkLogMonotonicity(app)
|
|
227
260
|
)
|
|
228
261
|
return true;
|
|
229
262
|
const arg = this.core.val(app.arg).toDouble();
|
|
@@ -465,7 +465,7 @@ export class MacroManager {
|
|
|
465
465
|
if (!isAppOf(manager, expr, OP_EQ)) return undefined;
|
|
466
466
|
const lhs = manager.getArg(expr, 0);
|
|
467
467
|
const rhs = manager.getArg(expr, 1);
|
|
468
|
-
if (!manager.
|
|
468
|
+
if (!manager.isGroundApp(lhs) && !manager.isGroundApp(rhs)) return undefined;
|
|
469
469
|
const sort = manager.sorts[lhs];
|
|
470
470
|
if (manager.isUninterpretedSort(sort) || manager.getSortSize(sort) === 1n) return undefined;
|
|
471
471
|
if (isMacroHead(manager, lhs, numDecls)) return { head: lhs, value: rhs };
|
|
@@ -258,7 +258,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
258
258
|
let numUnboundVars = 0;
|
|
259
259
|
const visit = (term: number) => {
|
|
260
260
|
size++;
|
|
261
|
-
if (manager.
|
|
261
|
+
if (manager.isGroundApp(term)) return;
|
|
262
262
|
for (let index = 0; index < manager.getNumArgs(term); index++) {
|
|
263
263
|
const arg = manager.getArg(term, index);
|
|
264
264
|
if (manager.kinds[arg] === KIND_VAR) {
|
|
@@ -287,7 +287,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
287
287
|
else this.vars[varIndex] = reg;
|
|
288
288
|
continue;
|
|
289
289
|
}
|
|
290
|
-
if (manager.
|
|
290
|
+
if (manager.isGroundApp(pattern)) {
|
|
291
291
|
this.seq.push(mkCheck(reg, hasher.getGroundEnode(pattern, this.quantifier)));
|
|
292
292
|
this.setMark(reg, NOT_CHECKED);
|
|
293
293
|
continue;
|
|
@@ -364,7 +364,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
364
364
|
let count = 0;
|
|
365
365
|
let hasUnboundVars = false;
|
|
366
366
|
const visit = (term: number) => {
|
|
367
|
-
if (manager.
|
|
367
|
+
if (manager.isGroundApp(term)) return;
|
|
368
368
|
for (let index = 0; index < manager.getNumArgs(term); index++) {
|
|
369
369
|
const arg = manager.getArg(term, index);
|
|
370
370
|
if (manager.kinds[arg] !== KIND_VAR) visit(arg);
|
|
@@ -378,7 +378,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
378
378
|
|
|
379
379
|
private genMpFilter(expr: number): number {
|
|
380
380
|
const manager = this.manager;
|
|
381
|
-
if (manager.
|
|
381
|
+
if (manager.isGroundApp(expr)) {
|
|
382
382
|
const oreg = this.tree.numRegs;
|
|
383
383
|
this.tree.numRegs += 1;
|
|
384
384
|
const instr = mkInstruction<E>(OP_GET_ENODE);
|
|
@@ -441,7 +441,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
441
441
|
this.todo.push(oreg + index);
|
|
442
442
|
if (
|
|
443
443
|
(manager.kinds[arg] === KIND_VAR && this.vars[manager.values[arg]] >= 0) ||
|
|
444
|
-
|
|
444
|
+
manager.isGroundApp(arg)
|
|
445
445
|
)
|
|
446
446
|
hasDepth1Joint = true;
|
|
447
447
|
}
|
|
@@ -451,7 +451,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
451
451
|
const reg = this.vars[manager.values[arg]];
|
|
452
452
|
return reg >= 0 ? { ...mkNullJoint<E>(), kind: JOINT_VAR, reg } : mkNullJoint<E>();
|
|
453
453
|
}
|
|
454
|
-
if (manager.
|
|
454
|
+
if (manager.isGroundApp(arg))
|
|
455
455
|
return {
|
|
456
456
|
...mkNullJoint<E>(),
|
|
457
457
|
kind: JOINT_GROUND,
|
|
@@ -543,7 +543,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
543
543
|
const expr = this.getRegister(instr.reg);
|
|
544
544
|
return (
|
|
545
545
|
this.isApp(expr) &&
|
|
546
|
-
!manager.
|
|
546
|
+
!manager.isGroundApp(expr) &&
|
|
547
547
|
manager.decls[expr] === instr.label &&
|
|
548
548
|
manager.getNumArgs(expr) === instr.numArgs
|
|
549
549
|
);
|
|
@@ -556,14 +556,14 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
556
556
|
|
|
557
557
|
private isCheckCompatible(instr: Instruction<E>) {
|
|
558
558
|
const expr = this.getRegister(instr.reg);
|
|
559
|
-
if (!this.
|
|
559
|
+
if (!this.manager.isGroundApp(expr)) return false;
|
|
560
560
|
const node = this.hasher.getGroundEnode(expr, this.quantifier);
|
|
561
561
|
return instr.enode !== null && node !== null && instr.enode.root === node.root;
|
|
562
562
|
}
|
|
563
563
|
|
|
564
564
|
private getPatLblHash(reg: number) {
|
|
565
565
|
const expr = this.registers[reg];
|
|
566
|
-
if (this.manager.
|
|
566
|
+
if (this.manager.isGroundApp(expr)) {
|
|
567
567
|
const node = this.hasher.getGroundEnode(expr, this.quantifier);
|
|
568
568
|
return node === null ? -1 : this.hasher.getLblHash(node);
|
|
569
569
|
}
|
|
@@ -576,7 +576,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
576
576
|
return (
|
|
577
577
|
expr !== -1 &&
|
|
578
578
|
this.getMark(instr.reg) === NOT_CHECKED &&
|
|
579
|
-
this.manager.
|
|
579
|
+
this.manager.isGroundApp(expr) &&
|
|
580
580
|
instr.enode !== null &&
|
|
581
581
|
this.getPatLblHash(instr.reg) === instr.enode.lblHash
|
|
582
582
|
);
|
|
@@ -586,7 +586,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
586
586
|
const expr = this.getRegister(instr.reg);
|
|
587
587
|
return (
|
|
588
588
|
this.isApp(expr) &&
|
|
589
|
-
!this.manager.
|
|
589
|
+
!this.manager.isGroundApp(expr) &&
|
|
590
590
|
hasHash(instr.lblLow, instr.lblHigh, this.getPatLblHash(instr.reg))
|
|
591
591
|
);
|
|
592
592
|
}
|
|
@@ -595,7 +595,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
595
595
|
const expr = this.getRegister(instr.reg);
|
|
596
596
|
return (
|
|
597
597
|
expr !== -1 &&
|
|
598
|
-
this.manager.
|
|
598
|
+
this.manager.isGroundApp(expr) &&
|
|
599
599
|
hasHash(instr.lblLow, instr.lblHigh, this.getPatLblHash(instr.reg))
|
|
600
600
|
);
|
|
601
601
|
}
|
|
@@ -603,7 +603,7 @@ export class Compiler<E extends MamEnode<E> = Enode> {
|
|
|
603
603
|
private isFilterSemiCompatible(instr: Instruction<E>) {
|
|
604
604
|
const expr = this.getRegister(instr.reg);
|
|
605
605
|
return (
|
|
606
|
-
this.getMark(instr.reg) === NOT_CHECKED && this.isApp(expr) && !this.manager.
|
|
606
|
+
this.getMark(instr.reg) === NOT_CHECKED && this.isApp(expr) && !this.manager.isGroundApp(expr)
|
|
607
607
|
);
|
|
608
608
|
}
|
|
609
609
|
|
|
@@ -11,17 +11,7 @@ export const runMaxBvSharing = (manager: AstManager) => (goal: Goal) => {
|
|
|
11
11
|
runSimplifier(goal, false, (state) => {
|
|
12
12
|
const rewriter = new MaxBvSharing(manager);
|
|
13
13
|
return {
|
|
14
|
-
reduce: () =>
|
|
15
|
-
let rewritten = -1;
|
|
16
|
-
state.forEachIndex((index) => {
|
|
17
|
-
const form = state.get(index);
|
|
18
|
-
const next = rewriter.rewrite(form);
|
|
19
|
-
if (rewritten !== -1) manager.decRef(rewritten);
|
|
20
|
-
rewritten = next;
|
|
21
|
-
if (rewritten !== form) goal.update(index, rewritten);
|
|
22
|
-
});
|
|
23
|
-
if (rewritten !== -1) manager.decRef(rewritten);
|
|
24
|
-
},
|
|
14
|
+
reduce: () => state.rewriteEach((form) => rewriter.rewrite(form)),
|
|
25
15
|
release: () => rewriter.release(),
|
|
26
16
|
};
|
|
27
17
|
});
|
|
@@ -67,13 +67,6 @@ export class Maxcore extends MaxsmtSolverBase {
|
|
|
67
67
|
this.trail.push(expr);
|
|
68
68
|
}
|
|
69
69
|
|
|
70
|
-
private isTrueIn(model: ProtoModel, expr: number) {
|
|
71
|
-
const value = model.eval(expr, true);
|
|
72
|
-
const isTrue = value === this.manager.trueExpr;
|
|
73
|
-
this.manager.decRef(value);
|
|
74
|
-
return isTrue;
|
|
75
|
-
}
|
|
76
|
-
|
|
77
70
|
private isFalseIn(model: ProtoModel, expr: number) {
|
|
78
71
|
const value = model.eval(expr, true);
|
|
79
72
|
const isFalse = value === this.manager.falseExpr;
|
|
@@ -171,9 +164,10 @@ export class Maxcore extends MaxsmtSolverBase {
|
|
|
171
164
|
this.lower = this.upper;
|
|
172
165
|
return L_TRUE;
|
|
173
166
|
}
|
|
174
|
-
|
|
167
|
+
const weight = this.getCoreWeight(items);
|
|
168
|
+
cores.push({ core: items, weight });
|
|
175
169
|
this.removeSoft(items);
|
|
176
|
-
this.splitCore(items);
|
|
170
|
+
this.splitCore(items, weight);
|
|
177
171
|
if (items.length >= this.context.params.maxCoreSize) break;
|
|
178
172
|
status = this.checkSatHillClimb(this.asms.items);
|
|
179
173
|
}
|
|
@@ -211,13 +205,11 @@ export class Maxcore extends MaxsmtSolverBase {
|
|
|
211
205
|
.reduce((minimum, weight) => (weight.compare(minimum) < 0 ? weight : minimum));
|
|
212
206
|
}
|
|
213
207
|
|
|
214
|
-
private splitCore(core: readonly number[]) {
|
|
215
|
-
const weight = this.getCoreWeight(core);
|
|
208
|
+
private splitCore(core: readonly number[], weight: Rational) {
|
|
216
209
|
for (const expr of core) {
|
|
217
210
|
const other = this.getWeight(expr);
|
|
218
211
|
if (other.compare(weight) > 0) this.newAssumption(expr, other.sub(weight));
|
|
219
212
|
}
|
|
220
|
-
return weight;
|
|
221
213
|
}
|
|
222
214
|
|
|
223
215
|
private updateModel(def: number, value: number) {
|
|
@@ -24,13 +24,6 @@ export class Maxlex extends MaxsmtSolverBase {
|
|
|
24
24
|
);
|
|
25
25
|
}
|
|
26
26
|
|
|
27
|
-
private isTrueIn(model: ProtoModel, expr: number) {
|
|
28
|
-
const value = model.eval(expr, true);
|
|
29
|
-
const isTrue = value === this.manager.trueExpr;
|
|
30
|
-
this.manager.decRef(value);
|
|
31
|
-
return isTrue;
|
|
32
|
-
}
|
|
33
|
-
|
|
34
27
|
private assertValue(soft: Soft) {
|
|
35
28
|
if (soft.value === L_TRUE) this.solver.assertExpr(soft.expr);
|
|
36
29
|
else if (soft.value === L_FALSE) {
|
|
@@ -65,6 +65,13 @@ export abstract class MaxsmtSolverBase {
|
|
|
65
65
|
return this.context.getSolver();
|
|
66
66
|
}
|
|
67
67
|
|
|
68
|
+
protected isTrueIn(model: ProtoModel, expr: number) {
|
|
69
|
+
const value = model.eval(expr, true);
|
|
70
|
+
const isTrue = value === this.manager.trueExpr;
|
|
71
|
+
this.manager.decRef(value);
|
|
72
|
+
return isTrue;
|
|
73
|
+
}
|
|
74
|
+
|
|
68
75
|
protected init() {
|
|
69
76
|
this.lower = Rational.zero;
|
|
70
77
|
this.upper = Rational.zero;
|
|
@@ -15,7 +15,6 @@ import {
|
|
|
15
15
|
OP_LT,
|
|
16
16
|
OP_MOD,
|
|
17
17
|
OP_MUL,
|
|
18
|
-
OP_NUM,
|
|
19
18
|
OP_OR,
|
|
20
19
|
OP_SUB,
|
|
21
20
|
OP_UMINUS,
|
|
@@ -23,7 +22,7 @@ import {
|
|
|
23
22
|
SORT_INT,
|
|
24
23
|
SORT_REAL,
|
|
25
24
|
} from "../ast";
|
|
26
|
-
import { getExtendedNumeral,
|
|
25
|
+
import { getExtendedNumeral, mkNot } from "../ast-util";
|
|
27
26
|
import { ExprSafeReplace } from "../expr-safe-replace";
|
|
28
27
|
import { ObjMap } from "../hashtable";
|
|
29
28
|
import {
|
|
@@ -44,19 +43,11 @@ import {
|
|
|
44
43
|
} from "../model-based-opt";
|
|
45
44
|
import { getEuclideanDiv, getEuclideanMod, Rational } from "../rational";
|
|
46
45
|
import type { RefVector } from "../ref-vector";
|
|
47
|
-
import { markRec, type MbpContext } from "./mbp-plugin";
|
|
46
|
+
import { getBinaryArgs, getNumeral, markRec, type MbpContext } from "./mbp-plugin";
|
|
48
47
|
|
|
49
48
|
const isArith = (manager: AstManager, expr: number) =>
|
|
50
49
|
manager.sorts[expr] === SORT_INT || manager.sorts[expr] === SORT_REAL;
|
|
51
50
|
|
|
52
|
-
const getBinaryArgs = (manager: AstManager, expr: number, op: number) =>
|
|
53
|
-
isAppOf(manager, expr, op) && manager.getNumArgs(expr) === 2
|
|
54
|
-
? [manager.getArg(expr, 0), manager.getArg(expr, 1)]
|
|
55
|
-
: undefined;
|
|
56
|
-
|
|
57
|
-
const getNumeral = (manager: AstManager, expr: number) =>
|
|
58
|
-
isAppOf(manager, expr, OP_NUM) ? manager.getRationalValue(expr) : undefined;
|
|
59
|
-
|
|
60
51
|
const insertMul = (terms: ObjMap<Rational>, expr: number, value: Rational) =>
|
|
61
52
|
terms.set(expr, (terms.get(expr) ?? Rational.zero).add(value));
|
|
62
53
|
|
|
@@ -10,6 +10,7 @@ import {
|
|
|
10
10
|
OP_EQ,
|
|
11
11
|
OP_IMPLIES,
|
|
12
12
|
OP_ITE,
|
|
13
|
+
OP_NUM,
|
|
13
14
|
OP_OR,
|
|
14
15
|
OP_XOR,
|
|
15
16
|
SORT_BOOL,
|
|
@@ -59,6 +60,14 @@ export class MbpContext {
|
|
|
59
60
|
const isIff = (manager: AstManager, expr: number) =>
|
|
60
61
|
isAppOf(manager, expr, OP_EQ) && manager.sorts[manager.getArg(expr, 0)] === SORT_BOOL;
|
|
61
62
|
|
|
63
|
+
export const getBinaryArgs = (manager: AstManager, expr: number, op: number) =>
|
|
64
|
+
isAppOf(manager, expr, op) && manager.getNumArgs(expr) === 2
|
|
65
|
+
? [manager.getArg(expr, 0), manager.getArg(expr, 1)]
|
|
66
|
+
: undefined;
|
|
67
|
+
|
|
68
|
+
export const getNumeral = (manager: AstManager, expr: number) =>
|
|
69
|
+
isAppOf(manager, expr, OP_NUM) ? manager.getRationalValue(expr) : undefined;
|
|
70
|
+
|
|
62
71
|
export const markRec = (manager: AstManager, visited: Set<number>, expr: number) => {
|
|
63
72
|
const todo = [expr];
|
|
64
73
|
for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
|