bool LogicInfo::isDifferenceLogic() const {
PrettyCheckArgument(d_locked, *this,
"This LogicInfo isn't locked yet, and cannot be queried");
PrettyCheckArgument(
isTheoryEnabled(theory::THEORY_ARITH), *this,
"Arithmetic not used in this LogicInfo; cannot ask whether it's difference logic");
return d_differenceLogic;
}
bool LogicInfo::areRealsUsed() const {
PrettyCheckArgument(d_locked, *this,
"This LogicInfo isn't locked yet, and cannot be queried");
PrettyCheckArgument(
isTheoryEnabled(theory::THEORY_ARITH), *this,
"Arithmetic not used in this LogicInfo; cannot ask whether reals are used");
return d_reals;
}
bool LogicInfo::isPure(theory::TheoryId theory) const {
PrettyCheckArgument(d_locked, *this,
"This LogicInfo isn't locked yet, and cannot be queried");
// the third and fourth conjucts are really just to rule out the misleading
// case where you ask isPure(THEORY_BOOL) and get true even in e.g. QF_LIA
return isTheoryEnabled(theory) && !isSharingEnabled() &&
( !isTrueTheory(theory) || d_sharingTheories == 1 ) &&
( isTrueTheory(theory) || d_sharingTheories == 0 );
}
bool LogicInfo::operator>=(const LogicInfo& other) const {
PrettyCheckArgument(isLocked() && other.isLocked(), *this,
"This LogicInfo isn't locked yet, and cannot be queried");
for(theory::TheoryId id = theory::THEORY_FIRST; id < theory::THEORY_LAST; ++id) {
if(!d_theories[id] && other.d_theories[id]) {
return false;
}
}
PrettyCheckArgument(d_sharingTheories >= other.d_sharingTheories, *this,
"LogicInfo internal inconsistency");
if(isTheoryEnabled(theory::THEORY_ARITH) && other.isTheoryEnabled(theory::THEORY_ARITH)) {
return (d_integers || !other.d_integers) && (d_reals || !other.d_reals)
&& (d_transcendentals || !other.d_transcendentals)
&& (!d_linear || other.d_linear)
&& (!d_differenceLogic || other.d_differenceLogic);
} else {
return true;
}
}
bool LogicInfo::operator==(const LogicInfo& other) const {
PrettyCheckArgument(isLocked() && other.isLocked(), *this,
"This LogicInfo isn't locked yet, and cannot be queried");
for(theory::TheoryId id = theory::THEORY_FIRST; id < theory::THEORY_LAST; ++id) {
if(d_theories[id] != other.d_theories[id]) {
return false;
}
}
PrettyCheckArgument(d_sharingTheories == other.d_sharingTheories, *this,
"LogicInfo internal inconsistency");
if(isTheoryEnabled(theory::THEORY_ARITH)) {
return
d_integers == other.d_integers &&
d_reals == other.d_reals &&
d_linear == other.d_linear &&
d_differenceLogic == other.d_differenceLogic;
} else {
return true;
}
}
/** Is this a quantified logic? */
bool LogicInfo::isQuantified() const {
PrettyCheckArgument(d_locked, *this,
"This LogicInfo isn't locked yet, and cannot be queried");
return isTheoryEnabled(theory::THEORY_QUANTIFIERS);
}
