Packages

p

at.logic.gapt

proofs

package proofs

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. proofs
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. case class Ant (k: Int) extends SequentIndex with Product with Serializable
  2. trait Checkable [-T] extends AnyRef
  3. type Clause[+A] = Sequent[A]
  4. class Context extends BabelSignature

    Captures constants, types, definitions, and background theory used in a proof.

    Captures constants, types, definitions, and background theory used in a proof.

    Each of these different kinds of information is stored in a separate Facet of the context. Each modification or addition to the context is recorded as an Update. Adding information is only possible by adding it as an Update. (Basically a Context is an extensible LCF-style kernel.)

    There are several inferences in our LK proofs for which it is not enough that are syntactically valid: An induction inference might follow the syntactical scheme of an induction inference and satisfy the eigenvariable criterion, however if it excludes a constructor of the inductive type, then it still allows us to prove non-theorems. The same is also true for definition rules and theory axioms.

    Hence we store all information necessary to validate these inferences inside a Context object. For completeness, it also includes the collection of constant symbols.

    Having this information available is also important for a second reason: it allows us make decisions based on the current context:

    • The induction tactic uses the information about inductive types to create the necessary subgoals.
    • The Babel parser uses the information about constants to decide whether a free identifier is a variable or a constant, and if it is a constant, what type it should have.
    • The unfold tactic uses the information about definitions to unfold them.
    • The inductive prover can automatically generate random instances for base types.
    • at.logic.gapt.proofs.expansion.ExpansionProofToLK uses the information about the background theory to produce LK proofs modulo the background theory.
  5. trait ContextRule [Formula, This <: SequentProof[Formula, This]] extends SequentProof[Formula, This]
  6. 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. at.logic.gapt.proofs.lk.LKProof.

  7. type FOLClause = Sequent[FOLAtom]
  8. type FOLSequent = Sequent[FOLFormula]
  9. type HOLClause = Sequent[HOLAtom]
  10. type HOLSequent = Sequent[HOLFormula]
  11. case class NJSequent [+A](assumptions: Seq[A], conclusion: A) extends Product with Serializable

    Sequents for the intuitionistic calculus NJ, i.e.

    Sequents for the intuitionistic calculus NJ, i.e. natural deduction with sequents.

    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.

  12. implicit class RichClause [+A] extends AnyRef
  13. implicit final class RichFOLSequent extends AnyVal
  14. implicit final class RichFormulaSequent extends AnyVal
  15. implicit final class SeqWrapper [+A] extends AnyVal
  16. 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.

  17. 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.

  18. implicit final class SequentFlatMapOp [A] extends AnyVal
  19. implicit final class SequentFlattenOp [A] extends AnyVal
  20. 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)

  21. trait SequentProof [+Formula, This <: SequentProof[Formula, This]] extends DagProof[This]
  22. case class Suc (k: Int) extends SequentIndex with Product with Serializable

Value Members

  1. val Clause: Sequent.type
  2. val FOLClause: Sequent.type
  3. val HOLClause: Sequent.type
  4. val HOLSequent: Sequent.type
  5. object Checkable
  6. object Context
  7. object DagProof
  8. object NJSequent extends Serializable
  9. object Sequent extends Serializable
  10. object SequentConnector extends Serializable
  11. object SequentIndex
  12. object loadExpansionProof

Inherited from AnyRef

Inherited from Any

Ungrouped