GroebnerMultiplication

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val AC: AC_NIA.type

val DISCRETE_SPLITTING_LIMIT: Int

val PROPAGATION_UPDATE_LIMIT: Int

def RANDOMISE_CASES(goal: Goal): Boolean

val RANDOMISE_VARIABLE_ORDER: Boolean

val SMALL_INTERVAL_BOUND: Int

val SPLITTER_BASE_PRIORITY: Int

def VALUE_ENUMERATOR(goal: Goal): Boolean

val _mul: Predicate

final def asInstanceOf[T0]: T0

val axioms: Conjunction

Axioms defining the theory; such axioms are simply added as formulae to the problem to be proven, and thus handled using the standard reasoning techniques (including e-matching).

def clone(): AnyRef

def convert(expr: IFormula): IFormula

Convert the given expression to this multiplication theory

def convert(expr: ITerm): ITerm

Convert the given expression to this multiplication theory

def convert(expr: IExpression): IExpression

Convert the given expression to this multiplication theory

implicit def convert2RichMulTerm(term: ITerm): RichMulTerm

val debug: Boolean

val dependencies: List[IntValueEnumTheory]

Optionally, other theories that this theory depends on.

def eDiv(numTerm: ITerm, denomTerm: ITerm): ITerm

Euclidian division

def eDivWithSpecialZero(num: ITerm, denom: ITerm): ITerm

Euclidian division, assuming the SMT-LIB semantics for division by zero.

def eMod(numTerm: ITerm, denomTerm: ITerm): ITerm

Euclidian remainder

def eModWithSpecialZero(num: ITerm, denom: ITerm): ITerm

Euclidian remaining, assuming the SMT-LIB semantics for remainder by zero.

def eagerActions(goal: Goal, gbCache: GBCache): Seq[Action]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evalFun(f: IFunApp): Option[ITerm]

Optionally, a function evaluating theory functions applied to concrete arguments, represented as constructor terms.

def evalPred(p: IAtom): Option[Boolean]

Optionally, a function evaluating theory predicates applied to concrete arguments, represented as constructor terms.

def evaluatingSimplifier(t: IExpression): IExpression

A simplification function that applies the methods evalFun and evalPred to some given expression (but not recursively).

def extend(order: TermOrder): TermOrder

Add the symbols defined by this theory to the order

def fDiv(numTerm: ITerm, denomTerm: ITerm): ITerm

Floor division

def fMod(numTerm: ITerm, denomTerm: ITerm): ITerm

Floor remainder

def filterActions(actions: Seq[Action], order: TermOrder): Seq[Action]

val functionPredicateMapping: List[(IFunction, Predicate)]

Mapping of interpreted functions to interpreted predicates, used translating input ASTs to internal ASTs (the latter only containing predicates).

val functionalPredicates: Set[Predicate]

Information which of the predicates satisfy the functionality axiom; at some internal points, such predicates can be handled more efficiently

val functions: List[IFunction]

Interpreted functions of the theory

def generateDecoderData(model: Conjunction): Option[TheoryDecoderData]

If this theory defines any Theory.Decoder, which can translate model data into some theory-specific representation, this function can be overridden to pre-compute required data from a model.

final def getClass(): Class[_]

def hashCode(): Int

def iPostprocess(f: IFormula, signature: Signature): IFormula

Optionally, a post-processor that is applied to formulas output by the prover, for instance to interpolants or the result of quantifier elimination.

def iPreprocess(f: IFormula, signature: Signature): (IFormula, Signature)

Optionally, a pre-processor that is applied to formulas over this theory, prior to sending the formula to a prover.

def intervals2Actions(intervalSet: IntervalSet, predicates: IndexedSeq[Atom], goal: Goal, label2Assumptions: (BitSet) ⇒ Seq[Formula]): Seq[Action]

def intervals2Formula(intervalSet: IntervalSet, predicates: IndexedSeq[Atom], goal: Goal): Conjunction

final def isInstanceOf[T0]: Boolean

def isSoundForSat(theories: Seq[Theory], config: Theory.SatSoundnessConfig.Value): Boolean

Check whether we can tell that the given combination of theories is sound for checking satisfiability of a problem, i.e., if proof construction ends up in a dead end, can it be concluded that a problem is satisfiable.

val modelGenPredicates: Set[Predicate]

Optionally, a set of predicates used by the theory to tell the PresburgerModelFinder about terms that will be handled exclusively by this theory.

val mul: IFunction

Symbol representing proper (non-linear) multiplication

def mult(t1: ITerm, t2: ITerm): ITerm

Multiply two terms, using the mul function if necessary; if any of the two terms is constant, normal Presburger multiplication will be used.

def multSimplify(t1: ITerm, t2: ITerm): ITerm

Multiply two terms, using the mul function if necessary; if any of the two terms is constant, normal Presburger multiplication will be used, and simple terms will directly be simplified.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def plugin: Some[Plugin]

Optionally, a plug-in implementing reasoning in this theory

def postSimplifiers: Seq[(IExpression) ⇒ IExpression]

Optionally, simplifiers that are applied to formulas output by the prover, for instance to interpolants or the result of quantifier.

def postprocess(f: Conjunction, signature: Signature): Conjunction

Optionally, a post-processor that is applied to formulas output by the prover, for instance to interpolants or the result of quantifier elimination.

def pow(basis: ITerm, expTerm: ITerm): ITerm

Exponentiation, with non-negative exponent

val predicateMatchConfig: PredicateMatchConfig

Information how interpreted predicates should be handled for e-matching.

val predicates: List[Predicate]

Interpreted predicates of the theory

def preprocess(f: Conjunction, signature: Signature): Conjunction

Optionally, a pre-processor that is applied to formulas over this theory, prior to sending the formula to a prover.

def printActions(t: String, actions: Seq[Action]): Unit

def printNIAgoal(t: String, goal: Goal): Unit

val reducerPlugin: ReducerPluginFactory

Optionally, a plugin for the reducer applied to formulas both before and during proving.

def simpleLinearizers(goal: Goal): Set[ConstantTerm]

Find a set of constants that are sufficient to make all product constraints linear: assigning concrete values to the constants will make products become linear.

val singleInstantiationPredicates: Set[Predicate]

When instantiating existentially quantifier formulas, EX phi, at most one instantiation is necessary provided that all predicates in phi are contained in this set.

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

def tDiv(numTerm: ITerm, denomTerm: ITerm): ITerm

Truncation division

def tMod(numTerm: ITerm, denomTerm: ITerm): ITerm

Truncation remainder

def toString(): String

val totalityAxioms: Conjunction

Additional axioms that are included if the option +genTotalityAxioms is given to Princess.

lazy val transitiveDependencies: Iterable[Theory]

Dependencies closed under transitivity, i.e., also including the dependencies of dependencies.

val triggerRelevantFunctions: Set[IFunction]

A list of functions that should be considered in automatic trigger generation

val valueEnumerator: IntValueEnumTheory

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit