Type Members
              - 
      
      
      
      
        
        class
      
      
        Elements extends AbstractIterator[A] with BufferedIterator[A] with Serializable
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        class
      
      
        WithFilter extends FilterMonadic[A, Repr]
      
      
      
        
      
    
      
     
             
        
        
              Value Members
              - 
      
      
      
      
        final 
        def
      
      
        !=(arg0: Any): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        ##(): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        ++[B >: LinearCombination, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        ++:[B >: LinearCombination, That](that: Traversable[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        ++:[B >: LinearCombination, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        +:[B >: LinearCombination, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        :+[B >: LinearCombination, That](elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        ==(arg0: Any): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        addString(b: StringBuilder): StringBuilder
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        addString(b: StringBuilder, sep: String): StringBuilder
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        aggregate[B](z: ⇒ B)(seqop: (B, LinearCombination) ⇒ B, combop: (B, B) ⇒ B): B
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        andThen[C](k: (LinearCombination) ⇒ C): PartialFunction[Int, C]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        applyOrElse[A1 <: Int, B1 >: LinearCombination](x: A1, default: (A1) ⇒ B1): B1
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        asInstanceOf[T0]: T0
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        canEqual(that: Any): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        clone(): AnyRef
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        collect[B, That](pf: PartialFunction[LinearCombination, B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        collectFirst[B](pf: PartialFunction[LinearCombination, B]): Option[B]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        combinations(n: Int): Iterator[IndexedSeq[LinearCombination]]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        companion: GenericCompanion[IndexedSeq]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        compose[A](g: (A) ⇒ Int): (A) ⇒ LinearCombination
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        lazy val
      
      
        constants: Set[ConstantTerm]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        contains[A1 >: LinearCombination](elem: A1): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        containsSlice[B](that: GenSeq[B]): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        copyToArray[B >: LinearCombination](xs: Array[B], start: Int, len: Int): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        copyToArray[B >: LinearCombination](xs: Array[B]): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        copyToArray[B >: LinearCombination](xs: Array[B], start: Int): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        copyToBuffer[B >: LinearCombination](dest: Buffer[B]): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        corresponds[B](that: GenSeq[B])(p: (LinearCombination, B) ⇒ Boolean): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        dropRight(n: Int): IndexedSeq[LinearCombination]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        endsWith[B](that: GenSeq[B]): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        eq(arg0: AnyRef): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        equals(that: Any): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        exists(p: (LinearCombination) ⇒ Boolean): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        flatMap[B, That](f: (LinearCombination) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        flatten[B](implicit asTraversable: (LinearCombination) ⇒ GenTraversableOnce[B]): IndexedSeq[B]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        fold[A1 >: LinearCombination](z: A1)(op: (A1, A1) ⇒ A1): A1
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        foldLeft[B](z: B)(op: (B, LinearCombination) ⇒ B): B
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        foldRight[B](z: B)(op: (LinearCombination, B) ⇒ B): B
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        forall(p: (LinearCombination) ⇒ Boolean): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        genericBuilder[B]: Builder[B, IndexedSeq[B]]
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        getClass(): Class[_]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        groundAtoms: Set[Atom]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        grouped(size: Int): Iterator[IndexedSeq[LinearCombination]]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        hasDefiniteSize: Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        hashCode(): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        implies(that: EquationSet): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        indexOf[B >: LinearCombination](elem: B, from: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        indexOfSlice[B >: LinearCombination](that: GenSeq[B], from: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        indexOfSlice[B >: LinearCombination](that: GenSeq[B]): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        indexWhere(p: (LinearCombination) ⇒ Boolean, from: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        indexWhere(p: (LinearCombination) ⇒ Boolean): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        indices: Range
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        isDefinedAt(idx: Int): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        isEmpty: Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        isFalse: Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        isInstanceOf[T0]: Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        isSortedBy(otherOrder: TermOrder): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        isTraversableAgain: Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        isTrue: Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        lastIndexOf[B >: LinearCombination](elem: B, end: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        lastIndexOf[B >: LinearCombination](elem: B): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        lastIndexOfSlice[B >: LinearCombination](that: GenSeq[B], end: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        lastIndexOfSlice[B >: LinearCombination](that: GenSeq[B]): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        lastIndexWhere(p: (LinearCombination) ⇒ Boolean, end: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        lastIndexWhere(p: (LinearCombination) ⇒ Boolean): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        lazy val
      
      
        leadingTermSet: Set[Term]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        length: Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        lengthCompare(len: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        map[B, That](f: (LinearCombination) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        mkString: String
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        mkString(sep: String): String
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        mkString(start: String, sep: String, end: String): String
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        ne(arg0: AnyRef): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        nonEmpty: Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        notify(): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        notifyAll(): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        orElse[A1 <: Int, B1 >: LinearCombination](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        padTo[B >: LinearCombination, That](len: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        patch[B >: LinearCombination, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        permutations: Iterator[IndexedSeq[LinearCombination]]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        predicates: Set[Predicate]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        prefixLength(p: (LinearCombination) ⇒ Boolean): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        product[B >: LinearCombination](implicit num: Numeric[B]): B
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        reduce[A1 >: LinearCombination](op: (A1, A1) ⇒ A1): A1
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        reduceOption[A1 >: LinearCombination](op: (A1, A1) ⇒ A1): Option[A1]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        val
      
      
        relationString: String
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        reverseMap[B, That](f: (LinearCombination) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        runWith[U](action: (LinearCombination) ⇒ U): (Int) ⇒ Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        sameElements[B >: LinearCombination](that: GenIterable[B]): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        scan[B >: LinearCombination, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        scanLeft[B, That](z: B)(op: (B, LinearCombination) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        scanRight[B, That](z: B)(op: (LinearCombination, B) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        segmentLength(p: (LinearCombination) ⇒ Boolean, from: Int): Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        size: Int
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        slice(from: Int, until: Int): IndexedSeq[LinearCombination]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        sliding(size: Int, step: Int): Iterator[IndexedSeq[LinearCombination]]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        sliding(size: Int): Iterator[IndexedSeq[LinearCombination]]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        startsWith[B](that: GenSeq[B], offset: Int): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        startsWith[B](that: GenSeq[B]): Boolean
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        stringPrefix: String
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        sum[B >: LinearCombination](implicit num: Numeric[B]): B
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        synchronized[T0](arg0: ⇒ T0): T0
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        takeRight(n: Int): IndexedSeq[LinearCombination]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        toArray[B >: LinearCombination](implicit arg0: ClassTag[B]): Array[B]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        toMap[T, U](implicit ev: <:<[LinearCombination, (T, U)]): Map[T, U]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        toSet: Set[LinearCombination] { ... /* 2 definitions in type refinement */ }
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        toString(): String
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        transpose[B](implicit asTraversable: (LinearCombination) ⇒ GenTraversableOnce[B]): IndexedSeq[IndexedSeq[B]]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        union[B >: LinearCombination, That](that: GenSeq[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        unzip[A1, A2](implicit asPair: (LinearCombination) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        unzip3[A1, A2, A3](implicit asTriple: (LinearCombination) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        updated[B >: LinearCombination, That](index: Int, elem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], B, That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        lazy val
      
      
        variables: Set[VariableTerm]
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        wait(arg0: Long, arg1: Int): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        wait(arg0: Long): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        final 
        def
      
      
        wait(): Unit
      
      
      
        
      
    
      
     - 
      
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        zip[A1 >: LinearCombination, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], (A1, B), That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        zipAll[B, A1 >: LinearCombination, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], (A1, B), That]): That
      
      
      
        
      
    
      
     - 
      
      
      
      
        
        def
      
      
        zipWithIndex[A1 >: LinearCombination, That](implicit bf: CanBuildFrom[IndexedSeq[LinearCombination], (A1, Int), That]): That
      
      
      
        
      
    
      
     
             
        
        
              Deprecated Value Members
              - 
      
      
      
      
        
        def
      
      
        finalize(): Unit
      
      
      
        
      
    
      
     
             
         
        
        
              
Inherited from Equals
            
              Inherited from HasNewBuilder[LinearCombination, IndexedSeq[ap.terfor.linearcombination.LinearCombination] @scala.annotation.unchecked.uncheckedVariance]
             
              
Inherited from AnyRef
            
              
Inherited from Any
            
        
         
        
       
      
      
     
      
The class for representing conjunctions of equations, i.e., of systems of equations. Systems of equations are always implicitly canonised and reduced by means of row operations, i.e., it is ensured that the leading terms of two equations are always distinct, and that no equation can be made smaller in the used
TermOrderby adding multiples of other equations. This is not a complete method for deciding the satisfiability of a system, it is also necessary to perform column operations. Column operations are not applied implicitly, however.