package proofs
- Source
- package.scala
- Alphabetic
- By Inheritance
- proofs
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- case class Ant(k: Int) extends SequentIndex with Product with Serializable
- trait Checkable[-T] extends AnyRef
- type Clause[+A] = Sequent[A]
- trait ContextRule[Formula, This <: SequentProof[Formula, This]] extends SequentProof[Formula, This]
- class ContextSection extends AnyRef
-
trait
DagProof[Proof <: DagProof[Proof]] extends Product
DAG-like proof.
DAG-like proof.
Proofs are recursive structures that are represented as case classes. Equality is standard case class equality (but implemented in such a way that it is efficient on DAGs).
- Proof
The type of proof, e.g. gapt.proofs.lk.LKProof.
- type FOLClause = Sequent[FOLAtom]
- type FOLSequent = Sequent[FOLFormula]
- type HOLClause = Sequent[Atom]
- type HOLSequent = Sequent[Formula]
- sealed trait IndexOrFormula extends AnyRef
-
case class
NDSequent[+A](assumptions: Seq[A], conclusion: A) extends Product with Serializable
Sequents for natural deduction.
Sequents for natural deduction.
They have the form A1,...,Am :- B (there is always exactly one element in the succedent).
- A
The type of elements in the sequent.
- assumptions
The elements A1,...,Am.
- conclusion
The element B.
-
class
ProofBuilder[+Proof] extends AnyRef
Class for convenient construction of proofs.
Class for convenient construction of proofs. Allows you to write proofs post-order style (à la Bussproofs). Example:
(ProofBuilder c LogicalAxiom(A) c LogicalAxiom(B) u (WeakeningLeftRule(_, C)) b (AndRightRule(_,_, And(A, B)) qed)
The constructor is private, so the only way to instantiate this class is by using the ProofBuilder object. This means that the stack will always be empty in the beginning. - implicit final class RichClause[+A] extends AnyVal
- implicit final class RichFOLSequent extends AnyVal
- implicit final class RichFormulaSequent extends AnyVal
- implicit final class SeqWrapper[+A] extends AnyVal
-
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 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.
-
case class
SequentConnector(lowerSizes: (Int, Int), upperSizes: (Int, Int), parentsSequent: Sequent[Seq[SequentIndex]]) extends Product with Serializable
This class models the connection of formula occurrences between two sequents in a proof.
This class models the connection of formula occurrences between two sequents in a proof.
The most basic use case is that of connecting the conclusion of an LK inference with one of the premises. This is the origin of the names "lowerSizes" and "upperSizes".
- lowerSizes
The dimensions of the first ("lower") of the two connected sequents.
- upperSizes
The dimensions of the second ("upper") of the two connected sequents.
- parentsSequent
A sequent of lists of indices such that for each index i of lowerSequent, parentsSequent(i) is the list of indices of the parents of i in upperSequent.
- implicit final class SequentFlatMapOp[A] extends AnyVal
- implicit final class SequentFlattenOp[A] extends AnyVal
-
sealed abstract
class
SequentIndex extends Ordered[SequentIndex]
Represents an index of an element in a sequent.
Represents an index of an element in a sequent.
In a sequent, the elements have the following indices: Ant(0), Ant(1), ..., Ant(m) :- Suc(0), Suc(1), ..., Suc(n)
- trait SequentProof[+Formula, This <: SequentProof[Formula, This]] extends DagProof[This]
-
case class
SetSequent[+A](sequent: Sequent[A]) extends Product with Serializable
Used for clause set extraction
Used for clause set extraction
- sequent
A sequent.
- case class Suc(k: Int) extends SequentIndex with Product with Serializable
Value Members
- val Clause: Sequent.type
- val FOLClause: Sequent.type
- val HOLClause: Sequent.type
- val HOLSequent: Sequent.type
- object Checkable
- object DagProof
- object IndexOrFormula
- object NDSequent extends Serializable
- object ProofBuilder extends ProofBuilder[Nothing]
- object Sequent extends Serializable
- object SequentConnector extends Serializable
- object SequentIndex
- object guessPermutation
- object loadExpansionProof
- object withSection
This is the API documentation for GAPT.
The main package is gapt.