Class/Object

at.logic.gapt.proofs

Sequent

Related Docs: object Sequent | package proofs

Permalink

case class Sequent[+A](antecedent: Seq[A], succedent: Seq[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
Linear Supertypes
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Sequent
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. AnyRef
  7. Any
Implicitly
  1. by RichFormulaSequent
  2. by RichFOLSequent
  3. by RichClause
  4. by any2stringadd
  5. by StringFormat
  6. by Ensuring
  7. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Sequent(antecedent: Seq[A], succedent: Seq[A])

    Permalink

    antecedent

    The first list.

    succedent

    The second list.

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from Sequent[A] to any2stringadd[Sequent[A]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ++[B >: A](that: Sequent[B]): Sequent[B]

    Permalink
  5. def ++:[B >: A](es: GenTraversable[B]): Sequent[B]

    Permalink

    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.

  6. def +:[B >: A](e: B): Sequent[B]

    Permalink

    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

  7. def ->[B](y: B): (Sequent[A], B)

    Permalink
    Implicit information
    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()
  8. def :+[B >: A](e: B): Sequent[B]

    Permalink

    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

  9. def :++[B >: A](es: GenTraversable[B]): Sequent[B]

    Permalink

    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.

  10. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  11. val antecedent: Seq[A]

    Permalink

    The first list.

  12. def apply(is: Seq[SequentIndex]): Seq[A]

    Permalink
  13. def apply(i: SequentIndex): A

    Permalink

    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.

  14. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  15. val clause: Clause[A]

    Permalink
    Implicit information
    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
  16. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  17. def collect[B](f: PartialFunction[A, B]): Sequent[B]

    Permalink
  18. def contains[B](el: B, isSuc: Boolean): Boolean

    Permalink
  19. def contains[B](el: B): Boolean

    Permalink

    Returns true iff the sequent contains some element in either cedent.

  20. def delete(is: Seq[SequentIndex])(implicit dummyImplicit: DummyImplicit): Sequent[A]

    Permalink
  21. def delete(is: SequentIndex*): Sequent[A]

    Permalink
  22. def delete(i: SequentIndex): Sequent[A]

    Permalink
  23. def diff[B >: A](other: Sequent[B]): Sequent[A]

    Permalink

    Takes the multiset difference between two sequents, i.e.

    Takes the multiset difference between two sequents, i.e. each side separately.

  24. def distinct: Sequent[A]

    Permalink

    Removes duplicate formulas from both cedents.

  25. def elements: Seq[A]

    Permalink

    Sequence of elements of the sequent.

    Sequence of elements of the sequent.

    returns

    Antecedent concatenated with succedent.

  26. def ensuring(cond: (Sequent[A]) ⇒ Boolean, msg: ⇒ Any): Sequent[A]

    Permalink
    Implicit information
    This member is added by an implicit conversion from Sequent[A] to Ensuring[Sequent[A]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  27. def ensuring(cond: (Sequent[A]) ⇒ Boolean): Sequent[A]

    Permalink
    Implicit information
    This member is added by an implicit conversion from Sequent[A] to Ensuring[Sequent[A]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  28. def ensuring(cond: Boolean, msg: ⇒ Any): Sequent[A]

    Permalink
    Implicit information
    This member is added by an implicit conversion from Sequent[A] to Ensuring[Sequent[A]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  29. def ensuring(cond: Boolean): Sequent[A]

    Permalink
    Implicit information
    This member is added by an implicit conversion from Sequent[A] to Ensuring[Sequent[A]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  30. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  31. def exists(p: (A) ⇒ Boolean): Boolean

    Permalink
  32. def filter(p: (A) ⇒ Boolean): Sequent[A]

    Permalink

    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.

  33. def filterNot(p: (A) ⇒ Boolean): Sequent[A]

    Permalink

    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.

  34. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  35. def find(pred: (A) ⇒ Boolean): Option[SequentIndex]

    Permalink
  36. def flatMap[B](f: (A) ⇒ TraversableOnce[B], g: (A) ⇒ TraversableOnce[B]): Sequent[B]

    Permalink
  37. def flatMap[B](f: (A) ⇒ TraversableOnce[B]): Sequent[B]

    Permalink
  38. def focus(i: SequentIndex): (A, Sequent[A])

    Permalink

    "Focuses on one element of the seuqent, i.e.

    "Focuses on one element of the seuqent, 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.

  39. def forall(p: (A) ⇒ Boolean): Boolean

    Permalink
  40. def foreach[U](f: (A) ⇒ U): Unit

    Permalink
  41. def formatted(fmtstr: String): String

    Permalink
    Implicit information
    This member is added by an implicit conversion from Sequent[A] to StringFormat[Sequent[A]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  42. def formulas: Seq[HOLFormula]

    Permalink
    Implicit information
    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 HOLFormula (A <: HOLFormula).
    Definition Classes
    RichFormulaSequent
  43. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  44. def groupBy[B](f: (A) ⇒ B): Sequent[(B, Seq[A])]

    Permalink
  45. def indexOf[B >: A](elem: B): SequentIndex

    Permalink
  46. def indexOfInAnt[B >: A](elem: B): SequentIndex

    Permalink
  47. def indexOfInSuc[B >: A](elem: B): SequentIndex

    Permalink
  48. def indexOfOption[B >: A](elem: B): Option[SequentIndex]

    Permalink
  49. def indexOfPol[B >: A](elem: B, inSuc: Boolean): SequentIndex

    Permalink
  50. def indices: Seq[SequentIndex]

    Permalink

    Returns the range of indices of the sequent as a sequence.

  51. def indicesSequent: Sequent[SequentIndex]

    Permalink

    Returns the range of indices of the sequent as a sequent.

  52. def indicesWhere(p: (A) ⇒ Boolean): Seq[SequentIndex]

    Permalink

    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.

  53. def indicesWherePol(p: (A) ⇒ Boolean, pol: Boolean): Seq[SequentIndex]

    Permalink
  54. def insertAt[B >: A](i: SequentIndex, el: B): Sequent[B]

    Permalink
  55. def intersect[B >: A](other: Sequent[B]): Sequent[A]

    Permalink

    Computes the intersection of two sequents.

  56. def isDefinedAt(i: SequentIndex): Boolean

    Permalink

    Tests whether the sequent is defined at the supplied SequentIndex.

  57. def isEmpty: Boolean

    Permalink

    Returns true iff both cedents are empty.

  58. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  59. def isSubMultisetOf[B >: A](other: Sequent[B]): Boolean

    Permalink
  60. def isSubsetOf[B >: A](other: Sequent[B]): Boolean

    Permalink

    other

    Another Sequent.

    returns

    True iff other contains this pair of sets.

  61. def isTaut: Boolean

    Permalink
  62. def length: Int

    Permalink

    The number of elements in the sequent.

  63. def lengths: (Int, Int)

    Permalink

    A pair consisting of the lengths of the cedents.

  64. def map[B](f: (A) ⇒ B, g: (A) ⇒ B): Sequent[B]

    Permalink

    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.

  65. def map[B](f: (A) ⇒ B): Sequent[B]

    Permalink

    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.

  66. def multiSetEquals[B](other: Sequent[B]): Boolean

    Permalink

    Equality treating each side of the sequent as a multiset.

  67. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  68. def negative: Seq[A]

    Permalink
    Implicit information
    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
  69. def nonEmpty: Boolean

    Permalink
  70. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  71. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  72. def polarizedElements: Seq[(A, Boolean)]

    Permalink

    Sequence of elements together with polarities of type Boolean signifying whether an element is in the antecedent or succedent.

  73. def positive: Seq[A]

    Permalink
    Implicit information
    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
  74. def removeFromAntecedent[B](e: B): Sequent[A]

    Permalink
  75. def removeFromSuccedent[B](e: B): Sequent[A]

    Permalink
  76. def replaceAt[B >: A](i: SequentIndex, el: B): Sequent[B]

    Permalink
  77. val sequent: Sequent[HOLFormula]

    Permalink
    Implicit information
    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 HOLFormula (A <: HOLFormula).
    Definition Classes
    RichFormulaSequent
  78. def setEquals[B](other: Sequent[B]): Boolean

    Permalink

    Equality treating each side of the sequent as a set.

  79. def size: Int

    Permalink

    Synonym for length.

  80. def sizes: (Int, Int)

    Permalink

    Synonym for lengths.

  81. def sortBy[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): Sequent[A]

    Permalink
  82. def sorted[B >: A](implicit ordering: Ordering[B]): Sequent[A]

    Permalink
  83. val succedent: Seq[A]

    Permalink

    The second list.

  84. def swapped: Sequent[A]

    Permalink
  85. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  86. def toNegConjunction: HOLFormula

    Permalink
    Implicit information
    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 HOLFormula (A <: HOLFormula).
    Definition Classes
    RichFormulaSequent
  87. def toString(): String

    Permalink
    Definition Classes
    Sequent → AnyRef → Any
  88. def toTuple: (Seq[A], Seq[A])

    Permalink

    returns

    The sequent in tuple form.

  89. def updated[B >: A](index: SequentIndex, elem: B): Sequent[B]

    Permalink
  90. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  91. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  92. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  93. def withFilter(p: (A) ⇒ Boolean): Sequent[A]

    Permalink
  94. def zip[B](that: Sequent[B]): Sequent[(A, B)]

    Permalink
  95. def zipWithIndex: Sequent[(A, SequentIndex)]

    Permalink
  96. def [B](y: B): (Sequent[A], B)

    Permalink
    Implicit information
    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

  1. def toDisjunction: HOLFormula

    Permalink
    Implicit information
    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 HOLFormula (A <: HOLFormula).
    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
  2. def toDisjunction: FOLFormula

    Permalink
    Implicit information
    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
  3. def toImplication: HOLFormula

    Permalink
    Implicit information
    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 HOLFormula (A <: HOLFormula).
    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
  4. def toImplication: FOLFormula

    Permalink
    Implicit information
    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

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion RichFormulaSequent from Sequent[A] to RichFormulaSequent

Inherited by implicit conversion RichFOLSequent from Sequent[A] to RichFOLSequent

Inherited by implicit conversion RichClause from Sequent[A] to RichClause[A]

Inherited by implicit conversion any2stringadd from Sequent[A] to any2stringadd[Sequent[A]]

Inherited by implicit conversion StringFormat from Sequent[A] to StringFormat[Sequent[A]]

Inherited by implicit conversion Ensuring from Sequent[A] to Ensuring[Sequent[A]]

Inherited by implicit conversion ArrowAssoc from Sequent[A] to ArrowAssoc[Sequent[A]]

Ungrouped