case class Sequent[+A](antecedent: Vector[A], succedent: Vector[A]) extends Product with Serializable
A sequent is a pair of sequences of elements of type A, typically written as a1,…,am :- b1,…,bn.
- A
The type of the elements of the sequent.
- antecedent
The first list.
- succedent
The second list.
- Source
- sequents.scala
- Alphabetic
- By Inheritance
- Sequent
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- by RichFormulaSequent
- by RichFOLSequent
- by RichClause
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
Sequent(antecedent: Vector[A], succedent: Vector[A])
- antecedent
The first list.
- succedent
The second list.
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ++[B >: A](that: Sequent[B]): Sequent[B]
-
def
++:[B >: A](es: Traversable[B]): Sequent[B]
Adds a sequent of elements to the antecedent.
Adds a sequent of elements to the antecedent. New elements are always outermost, i.e. on the very left.
- es
A collection of elements of type B > A.
- returns
The sequent with es added to the antecedent.
-
def
+:[B >: A](e: B): Sequent[B]
Adds an element to the antecedent.
Adds an element to the antecedent. New elements are always outermost, i.e. on the very left.
- e
An element of type B > A
- returns
The sequent with e added to the antecedent
-
def
->[B](y: B): (Sequent[A], B)
- Implicit
- This member is added by an implicit conversion from Sequent[A] to ArrowAssoc[Sequent[A]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
-
def
:+[B >: A](e: B): Sequent[B]
Adds an element to the succedent.
Adds an element to the succedent. New elements are always outermost, i.e. on the very right.
- e
An element of type B > A
- returns
The sequent with e added to the succedent
-
def
:++[B >: A](es: Traversable[B]): Sequent[B]
Adds a sequence of elements to the succedent.
Adds a sequence of elements to the succedent. New elements are always outermost, i.e. on the very right.
- es
A collection of elements of type B > A.
- returns
The sequent with es added to the succedent.
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- val antecedent: Vector[A]
- def apply(is: Seq[SequentIndex]): Seq[A]
-
def
apply(i: SequentIndex): A
Returns the element at some SequentIndex.
Returns the element at some SequentIndex.
- i
A SequentIndex, i.e. Ant(k) or Suc(k)
- returns
The k-th element of the antecedent or succedent, depending on the type of i.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cedent(polarity: Polarity): Vector[A]
-
val
clause: Clause[A]
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichClause[A] performed by method RichClause in at.logic.gapt.proofs.
- Definition Classes
- RichClause
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- def collect[B](f: PartialFunction[A, B]): Sequent[B]
- def contains[B](el: B, polarity: Polarity): Boolean
-
def
contains[B](el: B): Boolean
Returns true iff the sequent contains some element in either cedent.
- def delete(is: SequentIndex*)(implicit d: DummyImplicit): Sequent[A]
- def delete(is: Seq[SequentIndex]): Sequent[A]
- def delete(i: SequentIndex): Sequent[A]
-
def
diff[B >: A](other: Sequent[B]): Sequent[A]
Takes the multiset difference between two sequents, i.e.
Takes the multiset difference between two sequents, i.e. each side separately.
-
def
distinct: Sequent[A]
Removes duplicate formulas from both cedents.
-
def
elements: Vector[A]
Sequence of elements of the sequent.
Sequence of elements of the sequent.
- returns
Antecedent concatenated with succedent.
- def ensuring(cond: (Sequent[A]) ⇒ Boolean, msg: ⇒ Any): Sequent[A]
- def ensuring(cond: (Sequent[A]) ⇒ Boolean): Sequent[A]
- def ensuring(cond: Boolean, msg: ⇒ Any): Sequent[A]
- def ensuring(cond: Boolean): Sequent[A]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def exists(p: (A) ⇒ Boolean): Boolean
-
def
filter(p: (A) ⇒ Boolean): Sequent[A]
The sub-sequent of elements satisfying some predicate.
The sub-sequent of elements satisfying some predicate.
- p
A function of type A => Boolean.
- returns
The sequent consisting of only those elements satisfying p.
-
def
filterNot(p: (A) ⇒ Boolean): Sequent[A]
The sub-sequent of elements not satisfying some predicate.
The sub-sequent of elements not satisfying some predicate.
- p
A function of type A => Boolean.
- returns
The sequent consisting of only those elements not satisfying p.
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def find(pred: (A) ⇒ Boolean): Option[SequentIndex]
- def flatMap[B](f: (A) ⇒ TraversableOnce[B], g: (A) ⇒ TraversableOnce[B]): Sequent[B]
- def flatMap[B](f: (A) ⇒ TraversableOnce[B]): Sequent[B]
-
def
focus(i: SequentIndex): (A, Sequent[A])
Focuses on one element of the sequent, i.e.
Focuses on one element of the sequent, i.e. returns element at index and the rest of the sequent.
- i
A SequentIndex.
- returns
A pair consisting of this(i) and the rest of this.
- def forall(p: (A) ⇒ Boolean): Boolean
- def foreach[U](f: (A) ⇒ U): Unit
- def formatted(fmtstr: String): String
-
def
formulas: Vector[Formula]
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFormulaSequent performed by method RichFormulaSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of Formula (A <: Formula).
- Definition Classes
- RichFormulaSequent
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def groupBy[B](f: (A) ⇒ B): Sequent[(B, Vector[A])]
- def indexOf[B >: A](elem: B, polarity: Polarity): SequentIndex
- def indexOf[B >: A](elem: B): SequentIndex
- def indexOfInAnt[B >: A](elem: B): SequentIndex
- def indexOfInSuc[B >: A](elem: B): SequentIndex
- def indexOfOption[B >: A](elem: B, pol: Polarity): Option[SequentIndex]
- def indexOfOption[B >: A](elem: B): Option[SequentIndex]
-
def
indices: Vector[SequentIndex]
Returns the range of indices of the sequent as a sequence.
-
def
indicesSequent: Sequent[SequentIndex]
Returns the range of indices of the sequent as a sequent.
-
def
indicesWhere(p: (A) ⇒ Boolean): Vector[SequentIndex]
Returns the list of indices of elements satisfying some predicate.
Returns the list of indices of elements satisfying some predicate.
- p
A function of type A => Boolean.
- def indicesWherePol(p: (A) ⇒ Boolean, pol: Polarity): Vector[SequentIndex]
- def insertAt[B >: A](i: SequentIndex, el: B): Sequent[B]
-
def
intersect[B >: A](other: Sequent[B]): Sequent[A]
Computes the intersection of two sequents.
-
def
isDefinedAt(i: SequentIndex): Boolean
Tests whether the sequent is defined at the supplied SequentIndex.
-
def
isEmpty: Boolean
Returns true iff both cedents are empty.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isSubMultisetOf[B >: A](other: Sequent[B]): Boolean
-
def
isSubsetOf[B >: A](other: Sequent[B]): Boolean
- other
Another Sequent.
- returns
True iff other contains this pair of sets.
- def isTaut: Boolean
-
def
length: Int
The number of elements in the sequent.
-
def
lengths: (Int, Int)
A pair consisting of the lengths of the cedents.
-
def
map[B](f: (A) ⇒ B, g: (A) ⇒ B): Sequent[B]
Maps two functions over the antecedent and succedent, respectively.
Maps two functions over the antecedent and succedent, respectively.
- B
The return type of f and g.
- f
The function to map over the antecedent.
- g
The function to map over the succedent.
- returns
The sequent of type B that results from mapping f and g over the antecedent and succedent, respectively.
-
def
map[B](f: (A) ⇒ B): Sequent[B]
Maps a function over both cedents
Maps a function over both cedents
- B
The return type of f
- f
A function of type A => B
- returns
The sequent of type B that results from mapping f over both cedents.
-
def
multiSetEquals[B](other: Sequent[B]): Boolean
Equality treating each side of the sequent as a multiset.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
negative: Vector[A]
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichClause[A] performed by method RichClause in at.logic.gapt.proofs.
- Definition Classes
- RichClause
- def nonEmpty: Boolean
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
polarizedElements: Vector[(A, Polarity)]
Sequence of elements together with polarities of type Boolean signifying whether an element is in the antecedent or succedent.
-
def
positive: Vector[A]
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichClause[A] performed by method RichClause in at.logic.gapt.proofs.
- Definition Classes
- RichClause
- def removeFromAntecedent[B](e: B): Sequent[A]
- def removeFromSuccedent[B](e: B): Sequent[A]
- def replaceAt[B >: A](i: SequentIndex, el: B): Sequent[B]
-
def
setEquals[B](other: Sequent[B]): Boolean
Equality treating each side of the sequent as a set.
-
def
size: Int
Synonym for length.
-
def
sizes: (Int, Int)
Synonym for lengths.
- def sortBy[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): Sequent[A]
- def sorted[B >: A](implicit ordering: Ordering[B]): Sequent[A]
- val succedent: Vector[A]
- def swapped: Sequent[A]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def toSigRelativeString(implicit sig: BabelSignature): String
-
def
toString(): String
- Definition Classes
- Sequent → AnyRef → Any
-
def
toTuple: (Vector[A], Vector[A])
- returns
The sequent in tuple form.
- def updated[B >: A](index: SequentIndex, elem: B): Sequent[B]
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- def withFilter(p: (A) ⇒ Boolean): Sequent[A]
- def zip[B](that: Sequent[B]): Sequent[(A, B)]
- def zipWithIndex: Sequent[(A, SequentIndex)]
-
def
→[B](y: B): (Sequent[A], B)
- Implicit
- This member is added by an implicit conversion from Sequent[A] to ArrowAssoc[Sequent[A]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Definition Classes
- ArrowAssoc
Shadowed Implicit Value Members
-
val
sequent: HOLSequent
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFormulaSequent performed by method RichFormulaSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of Formula (A <: Formula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFormulaSequent).sequent
- Definition Classes
- RichFormulaSequent
-
val
sequent: FOLSequent
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFOLSequent performed by method RichFOLSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFOLSequent).sequent
- Definition Classes
- RichFOLSequent
-
def
toConjunction: Formula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFormulaSequent performed by method RichFormulaSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of Formula (A <: Formula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFormulaSequent).toConjunction
- Definition Classes
- RichFormulaSequent
-
def
toConjunction: FOLFormula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFOLSequent performed by method RichFOLSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFOLSequent).toConjunction
- Definition Classes
- RichFOLSequent
-
def
toDisjunction: Formula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFormulaSequent performed by method RichFormulaSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of Formula (A <: Formula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFormulaSequent).toDisjunction
- Definition Classes
- RichFormulaSequent
-
def
toDisjunction: FOLFormula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFOLSequent performed by method RichFOLSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFOLSequent).toDisjunction
- Definition Classes
- RichFOLSequent
-
def
toFormula: Formula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFormulaSequent performed by method RichFormulaSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of Formula (A <: Formula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFormulaSequent).toFormula
- Definition Classes
- RichFormulaSequent
-
def
toFormula: FOLFormula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFOLSequent performed by method RichFOLSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFOLSequent).toFormula
- Definition Classes
- RichFOLSequent
-
def
toImplication: Formula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFormulaSequent performed by method RichFormulaSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of Formula (A <: Formula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFormulaSequent).toImplication
- Definition Classes
- RichFormulaSequent
-
def
toImplication: FOLFormula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFOLSequent performed by method RichFOLSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFOLSequent).toImplication
- Definition Classes
- RichFOLSequent
-
def
toNegConjunction: Formula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFormulaSequent performed by method RichFormulaSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of Formula (A <: Formula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFormulaSequent).toNegConjunction
- Definition Classes
- RichFormulaSequent
-
def
toNegConjunction: FOLFormula
- Implicit
- This member is added by an implicit conversion from Sequent[A] to RichFOLSequent performed by method RichFOLSequent in at.logic.gapt.proofs. This conversion will take place only if A is a subclass of FOLFormula (A <: FOLFormula).
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(sequent: RichFOLSequent).toNegConjunction
- Definition Classes
- RichFOLSequent
Deprecated Value Members
-
def
indexOfPol[B >: A](elem: B, polarity: Polarity): SequentIndex
- Annotations
- @deprecated
- Deprecated
(Since version 2.9) Use indexOf instead.
-
def
indexOfPolOption[B >: A](elem: B, pol: Polarity): Option[SequentIndex]
- Annotations
- @deprecated
- Deprecated
(Since version 2.9) Use indexOfOption instead.
This is the API documentation for GAPT.
The main package is at.logic.gapt.