PredConj

final def !=(arg0: Any): Boolean

final def ##(): Int

def --(that: PredConj): PredConj

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

lazy val constants: Set[ConstantTerm]

def diff(oldConj: PredConj)(implicit fullOrder: TermOrder): (PredConj, PredConj)

Find the subset of literals in this conjunction that also occur in oldConj, as well as the subset of literals that do not occur in oldConj.

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def filter(pred: (Atom) ⇒ Boolean): PredConj

final def getClass(): Class[_]

lazy val groundAtoms: Set[Atom]

def hashCode(): Int

def implies(that: PredConj): Boolean

def isFalse: Boolean

Return true if this formula is obviously always false.

final def isInstanceOf[T0]: Boolean

def isLiteral: Boolean

def isSortedBy(otherOrder: TermOrder): Boolean

def isTrue: Boolean

Return true if this formula is obviously always true

def iterator: Iterator[PredConj]

def lookupFunctionResult(atom: Atom): Option[LinearCombination]

Check whether there is a positive literal with the given predicate, and starting with the given arguments, and return the last argument.

def lookupFunctionResult(pred: Predicate, arguments: Seq[LinearCombination]): Option[LinearCombination]

Check whether there is a positive literal with the given predicate, and starting with the given arguments, and return the last argument.

final def ne(arg0: AnyRef): Boolean

def negate: PredConj

Create the negation of exactly one literal

val negativeLits: IndexedSeq[Atom]

lazy val negativeLitsAsSet: Set[Atom]

def negativeLitsWithPred(pred: Predicate): IndexedSeq[Atom]

final def notify(): Unit

final def notifyAll(): Unit

val order: TermOrder

def partition(pred: (Atom) ⇒ Boolean): (PredConj, PredConj)

val positiveLits: IndexedSeq[Atom]

lazy val positiveLitsAsSet: Set[Atom]

def positiveLitsWithPred(pred: Predicate): IndexedSeq[Atom]

lazy val predicates: Set[Predicate]

def size: Int

def sortBy(newOrder: TermOrder): PredConj

Re-sort an object with a new TermOrder.

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def unary_!: PredConj

def updateLits(newPosLits: IndexedSeq[Atom], newNegLits: IndexedSeq[Atom])(implicit newOrder: TermOrder): PredConj

def updateLits(newPosLits: IndexedSeq[Atom], newNegLits: IndexedSeq[Atom], logger: ComputationLogger)(implicit newOrder: TermOrder): PredConj

Update the literals of this conjunction; if nothing has changed, the old object is returned

def updateLitsSubset(newPosLits: IndexedSeq[Atom], newNegLits: IndexedSeq[Atom], newOrder: TermOrder): PredConj

Update the atoms of this conjunction under the assumption that the new atoms form a subset of the old atoms

lazy val variables: Set[VariableTerm]

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit