tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.94c3dd828

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (196) hide show
  1. package/dist/deciders.cjs +37 -36
  2. package/dist/deciders.js +55 -54
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +3 -0
  5. package/dist/index.d.ts +3 -0
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove.cjs +146 -58
  10. package/dist/prove.js +142 -54
  11. package/dist/run.cjs +45 -43
  12. package/dist/run.js +47 -45
  13. package/dist/transfer.cjs +39 -36
  14. package/dist/transfer.js +23 -20
  15. package/dist/worker.cjs +1 -1
  16. package/dist/worker.js +1 -1
  17. package/package.json +1 -1
  18. package/src/ast.ts +3 -3
  19. package/src/check.ts +203 -33
  20. package/src/cli/tlapm.ts +261 -68
  21. package/src/dependencies.ts +23 -2
  22. package/src/errors.ts +1 -1
  23. package/src/exit-codes.ts +1 -0
  24. package/src/liveness-checker.ts +530 -201
  25. package/src/liveness.ts +47 -32
  26. package/src/obligations/anonymize.ts +2 -4
  27. package/src/obligations/index.ts +5 -3
  28. package/src/obligations/pragma.ts +2 -2
  29. package/src/parallel.ts +2 -2
  30. package/src/parser.ts +151 -42
  31. package/src/prover/deciders.ts +1 -8
  32. package/src/prover/isabelle/isar/attrib.ts +86 -45
  33. package/src/prover/isabelle/isar/context.ts +25 -22
  34. package/src/prover/isabelle/isar/induct.ts +2 -5
  35. package/src/prover/isabelle/isar/method.ts +5 -7
  36. package/src/prover/isabelle/isar/proof.ts +33 -16
  37. package/src/prover/isabelle/isar/rule-cases.ts +6 -14
  38. package/src/prover/isabelle/isar/theory.ts +16 -17
  39. package/src/prover/isabelle/isar/toplevel.ts +46 -52
  40. package/src/prover/isabelle/provers/classical.ts +1 -1
  41. package/src/prover/ocaml.ts +4 -1
  42. package/src/prover/prep/action.ts +1 -0
  43. package/src/prover/prep/methods.ts +50 -3
  44. package/src/prover/prep/normalize.ts +4 -1
  45. package/src/prover/prove.ts +58 -32
  46. package/src/prover/ptl/decide.ts +43 -63
  47. package/src/prover/smt/data.ts +51 -45
  48. package/src/prover/smt/encode.ts +1 -2
  49. package/src/prover/smt/rewrite.ts +1 -0
  50. package/src/prover/smt/solver/aig-tactic.ts +25 -15
  51. package/src/prover/smt/solver/arith-rewriter.ts +3 -5
  52. package/src/prover/smt/solver/asserted-formulas.ts +1 -1
  53. package/src/prover/smt/solver/ast-util.ts +3 -1
  54. package/src/prover/smt/solver/ast.ts +110 -152
  55. package/src/prover/smt/solver/bound-manager.ts +39 -28
  56. package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
  57. package/src/prover/smt/solver/bv-rewriter.ts +14 -16
  58. package/src/prover/smt/solver/bv1-blast.ts +1 -9
  59. package/src/prover/smt/solver/cg-table.ts +19 -14
  60. package/src/prover/smt/solver/check-logic.ts +6 -1
  61. package/src/prover/smt/solver/context.ts +20 -10
  62. package/src/prover/smt/solver/demodulator.ts +2 -2
  63. package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
  64. package/src/prover/smt/solver/distribute-forall.ts +1 -10
  65. package/src/prover/smt/solver/dom-simplify.ts +1 -1
  66. package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
  67. package/src/prover/smt/solver/e-matching.ts +6 -6
  68. package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
  69. package/src/prover/smt/solver/enode.ts +15 -1
  70. package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
  71. package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
  72. package/src/prover/smt/solver/euf/egraph.ts +65 -32
  73. package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
  74. package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
  75. package/src/prover/smt/solver/euf/mam.ts +6 -48
  76. package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
  77. package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
  78. package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
  79. package/src/prover/smt/solver/euf/q-solver.ts +2 -0
  80. package/src/prover/smt/solver/euf/th-solver.ts +1 -1
  81. package/src/prover/smt/solver/factor.ts +1 -11
  82. package/src/prover/smt/solver/fd-solver.ts +1 -2
  83. package/src/prover/smt/solver/fm-tactic.ts +19 -13
  84. package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
  85. package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
  86. package/src/prover/smt/solver/internalizer.ts +41 -2
  87. package/src/prover/smt/solver/lia2pb.ts +18 -4
  88. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  89. package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
  90. package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
  91. package/src/prover/smt/solver/macro-finder.ts +1 -1
  92. package/src/prover/smt/solver/mam-compiler.ts +13 -13
  93. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
  94. package/src/prover/smt/solver/maxcore.ts +4 -12
  95. package/src/prover/smt/solver/maxlex.ts +0 -7
  96. package/src/prover/smt/solver/maxsmt-base.ts +7 -0
  97. package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
  98. package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
  99. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
  100. package/src/prover/smt/solver/model-evaluator.ts +9 -5
  101. package/src/prover/smt/solver/model-macro-solver.ts +3 -3
  102. package/src/prover/smt/solver/muz/dl-context.ts +57 -3
  103. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
  104. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
  105. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
  106. package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
  107. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
  108. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
  109. package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
  110. package/src/prover/smt/solver/muz/hnf.ts +6 -5
  111. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
  112. package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
  113. package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
  114. package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
  115. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
  116. package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
  117. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
  118. package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
  119. package/src/prover/smt/solver/muz/substitution.ts +88 -37
  120. package/src/prover/smt/solver/nlqsat.ts +2 -2
  121. package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
  122. package/src/prover/smt/solver/nlsat/explain.ts +5 -0
  123. package/src/prover/smt/solver/nlsat/solver.ts +36 -25
  124. package/src/prover/smt/solver/opt-context.ts +9 -8
  125. package/src/prover/smt/solver/opt-nlsat.ts +68 -58
  126. package/src/prover/smt/solver/opt-solver.ts +16 -7
  127. package/src/prover/smt/solver/optsmt.ts +12 -9
  128. package/src/prover/smt/solver/pattern-inference.ts +2 -2
  129. package/src/prover/smt/solver/pb-rewriter.ts +13 -13
  130. package/src/prover/smt/solver/poly-rewriter.ts +2 -2
  131. package/src/prover/smt/solver/probes.ts +1 -1
  132. package/src/prover/smt/solver/propagate-values.ts +4 -0
  133. package/src/prover/smt/solver/proto-model.ts +5 -5
  134. package/src/prover/smt/solver/purify-arith.ts +50 -15
  135. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
  136. package/src/prover/smt/solver/qe-mbp.ts +13 -23
  137. package/src/prover/smt/solver/qe.ts +45 -53
  138. package/src/prover/smt/solver/qsat.ts +70 -90
  139. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
  140. package/src/prover/smt/solver/quasi-macros.ts +9 -18
  141. package/src/prover/smt/solver/rational.ts +17 -0
  142. package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
  143. package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
  144. package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
  145. package/src/prover/smt/solver/rewriter.ts +1 -1
  146. package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
  147. package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
  148. package/src/prover/smt/solver/sat/clause.ts +1 -3
  149. package/src/prover/smt/solver/sat/config.ts +3 -3
  150. package/src/prover/smt/solver/sat/consequences.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -15
  154. package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
  155. package/src/prover/smt/solver/sat/probing.ts +22 -19
  156. package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
  157. package/src/prover/smt/solver/sat/simplifier.ts +15 -56
  158. package/src/prover/smt/solver/sat/solver.ts +20 -19
  159. package/src/prover/smt/solver/sat/watch-list.ts +7 -0
  160. package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
  161. package/src/prover/smt/solver/seq-derive.ts +6 -7
  162. package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
  163. package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
  164. package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
  165. package/src/prover/smt/solver/seq-re-util.ts +1 -2
  166. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-live.ts +4 -4
  168. package/src/prover/smt/solver/seq-rewriter.ts +1 -4
  169. package/src/prover/smt/solver/smt-setup.ts +15 -9
  170. package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
  171. package/src/prover/smt/solver/smtlib-script.ts +866 -728
  172. package/src/prover/smt/solver/tactic.ts +66 -14
  173. package/src/prover/smt/solver/theory-array.ts +25 -58
  174. package/src/prover/smt/solver/theory-bv.ts +13 -50
  175. package/src/prover/smt/solver/theory-fpa.ts +46 -78
  176. package/src/prover/smt/solver/theory-pb.ts +10 -6
  177. package/src/prover/smt/solver/theory-recfun.ts +2 -2
  178. package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
  179. package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
  180. package/src/prover/smt/solver/theory-seq-state.ts +6 -3
  181. package/src/prover/smt/solver/theory-seq.ts +32 -54
  182. package/src/prover/smt/solver/theory.ts +16 -1
  183. package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
  184. package/src/prover/smt/solver/var-subst.ts +2 -2
  185. package/src/prover/smt/table.ts +3 -2
  186. package/src/prover/zenon/decide.ts +9 -11
  187. package/src/prover/zenon/node.ts +12 -11
  188. package/src/prover/zenon/tla/sets.ts +1 -1
  189. package/src/search.ts +131 -16
  190. package/src/successors.ts +1 -1
  191. package/src/symmetry.ts +2 -2
  192. package/src/tableau.ts +2 -2
  193. package/src/tlc/fingerprint.ts +81 -9
  194. package/src/tlc/summary.ts +29 -14
  195. package/src/typed-tier.ts +6535 -0
  196. package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
@@ -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
- interface Ordered<Value> {
18
- compare(first: Value, second: Value): number;
19
- of(value: Rational): Value;
20
- add(first: Value, second: Value): Value;
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
- const axiom = checkAxioms(
103
- {
104
- compare: (first: Rational, second: Rational) => first.compare(second),
105
- of: (value) => value,
106
- add: (first, second) => first.add(second),
107
- },
108
- baseValue,
109
- exponentValue,
110
- resultValue,
111
- );
112
- if (axiom !== undefined) return axiom;
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
- return addLemma(
119
- [base, KIND_NE, baseValue],
120
- [exponent, KIND_NE, exponentValue],
121
- [result, KIND_EQ, powerValue],
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
- return addLemma(
126
- [base, KIND_LT, baseValue],
127
- [exponent, isIncreasing ? KIND_LT : KIND_GT, exponentValue],
128
- ...(isIncreasing ? [] : [[exponent, KIND_LT, 0] as Parameters<typeof mkIneq>]),
129
- [result, KIND_GE, powerValue],
130
- );
131
- if (comparison > 0)
132
- return addLemma(
133
- [base, KIND_LE, 0],
134
- [base, KIND_GT, baseValue],
135
- [exponent, isIncreasing ? KIND_GT : KIND_LT, exponentValue],
136
- ...(isIncreasing ? [[exponent, KIND_LT, 0] as Parameters<typeof mkIneq>] : []),
137
- [result, KIND_LE, powerValue],
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 axiom = checkAxioms(
157
- {
158
- compare: (first: Anum, second: Anum) => am.compare(first, second),
159
- of: (value) => new Anum(value),
160
- add: (first, second) => am.add(first, second),
161
- },
162
- baseValue,
163
- exponentValue,
164
- resultValue,
165
- );
166
- if (axiom !== undefined) return axiom;
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, new Anum(Rational.zero)) > 0 &&
169
- am.compare(exponentValue, new Anum(Rational.zero)) > 0 &&
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
- // exp is increasing, and so is log on positive arguments.
193
- private checkMonotonicity(app: TranscendentalApp) {
194
- if (app.op !== "exp" && app.op !== "log") return false;
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 !== app.op || other.arg === app.arg) continue;
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
- const isLess = arg.compare(otherArg) < 0 && val.compare(otherVal) >= 0;
205
- if (!isLess && !(arg.compare(otherArg) > 0 && val.compare(otherVal) <= 0)) continue;
206
- const lemma = new LemmaBuilder(core);
207
- if (app.op === "log")
208
- lemma.addIneq(mkIneq(app.arg, KIND_LE, 0)).addIneq(mkIneq(other.arg, KIND_LE, 0));
209
- lemma
210
- .addIneq(mkIneq(mkTerm(app.arg, 1, other.arg, -1), isLess ? KIND_GE : KIND_LE, 0))
211
- .addIneq(mkIneq(mkTerm(app.val, 1, other.val, -1), isLess ? KIND_LT : KIND_GT, 0));
212
- return true;
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
- (app.op === "exp" && this.checkMonotonicity(app)) ||
257
+ this.checkExpMonotonicity(app) ||
225
258
  this.checkLogUpperBound(app) ||
226
- (app.op === "log" && this.checkMonotonicity(app))
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.isGround(lhs) && !manager.isGround(rhs)) return undefined;
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.isGround(term)) return;
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.isGround(pattern)) {
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.isGround(term)) return;
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.isGround(expr)) {
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
- (manager.kinds[arg] !== KIND_VAR && manager.isGround(arg))
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.isGround(arg))
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.isGround(expr) &&
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.isApp(expr) || !this.manager.isGround(expr)) return false;
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.isGround(expr)) {
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.isGround(expr) &&
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.isGround(expr) &&
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.isGround(expr) &&
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.isGround(expr)
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
- cores.push({ core: items, weight: this.getCoreWeight(items) });
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, isAppOf, mkNot } from "../ast-util";
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()) {