package rules
- Alphabetic
- Public
- All
Type Members
- case class AndLeftRule(subProof: LKProof, aux1: SequentIndex, aux2: SequentIndex) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a conjunction on the left:
(π) A, B, Γ :- Δ -------------- A ∧ B, Γ :- Δ
An LKProof ending with a conjunction on the left:
(π) A, B, Γ :- Δ -------------- A ∧ B, Γ :- Δ
- subProof
The subproof π.
- aux1
The index of A.
- aux2
The index of B.
- case class AndRightRule(leftSubProof: LKProof, aux1: SequentIndex, rightSubProof: LKProof, aux2: SequentIndex) extends BinaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a conjunction on the right:
(π1) (π2) Γ :- Δ, A Π :- Λ, B -------------------------- Γ, Π :- Δ, Λ, A∧B
An LKProof ending with a conjunction on the right:
(π1) (π2) Γ :- Δ, A Π :- Λ, B -------------------------- Γ, Π :- Δ, Λ, A∧B
- leftSubProof
The proof π1.
- aux1
The index of A.
- rightSubProof
The proof π2
- aux2
The index of B.
- abstract class BinaryLKProof extends LKProof
An LKProof deriving a sequent from two other sequents:
(π1) (π2) Γ :- Δ Γ' :- Δ' ------------------ Π :- Λ
- trait CommonRule extends LKProof with ContextRule[Formula, LKProof]
- case class ContractionLeftRule(subProof: LKProof, aux1: SequentIndex, aux2: SequentIndex) extends ContractionRule with Product with Serializable
An LKProof ending with a left contraction:
(π) A, A, Γ :- Δ -------------- A, Γ :- Δ
An LKProof ending with a left contraction:
(π) A, A, Γ :- Δ -------------- A, Γ :- Δ
- subProof
The subproof π.
- aux1
The index of one occurrence of A.
- aux2
The index of the other occurrence of A.
- case class ContractionRightRule(subProof: LKProof, aux1: SequentIndex, aux2: SequentIndex) extends ContractionRule with Product with Serializable
An LKProof ending with a right contraction:
(π) Γ :- Δ, A, A -------------- Γ :- Δ, A
An LKProof ending with a right contraction:
(π) Γ :- Δ, A, A -------------- Γ :- Δ, A
- subProof
The subproof π.
- aux1
The index of one occurrence of A.
- aux2
The index of the other occurrence of A.
- abstract class ContractionRule extends UnaryLKProof with CommonRule
- class ConvenienceConstructor extends AnyRef
Class for reducing boilerplate code in LK companion objects.
- case class ConversionLeftRule(subProof: LKProof, aux: SequentIndex, mainFormula: Formula) extends ConversionRule with Product with Serializable
An LKProof ending with a conversion on the left.
An LKProof ending with a conversion on the left.
(π) N, Γ :- Δ -----------d:l M, Γ :- Δ
LK proofs that contain this rule are not sound by construction, since it allows you to replace any formula by any other formula. The soundness of such proofs can only be established with respect to a context in which we have M =βδ N. Use the
check
method on gapt.proofs.context.Context to check whether the constructed proof is sound.- subProof
The proof π.
- aux
The index of N in the antecedent.
- mainFormula
The formula N.
- case class ConversionRightRule(subProof: LKProof, aux: SequentIndex, mainFormula: Formula) extends ConversionRule with Product with Serializable
An LKProof ending with a conversion on the right.
An LKProof ending with a conversion on the right.
(π) Γ :- Δ, M -----------conv:r Γ :- Δ, N
LK proofs that contain this rule are not sound by construction, since it allows you to replace any formula by any other formula. The soundness of such proofs can only be established with respect to a context in which we have M =βδ N. Use the
check
method on gapt.proofs.context.Context to check whether the constructed proof is sound.- subProof
The proof π.
- aux
The index of M in the succedent.
- mainFormula
The formula N.
- abstract class ConversionRule extends UnaryLKProof with CommonRule
- case class CutRule(leftSubProof: LKProof, aux1: SequentIndex, rightSubProof: LKProof, aux2: SequentIndex) extends BinaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a cut:
(π1) (π2) Γ :- Δ, A A, Π :- Λ ------------------------ Γ, Π :- Δ, Λ
An LKProof ending with a cut:
(π1) (π2) Γ :- Δ, A A, Π :- Λ ------------------------ Γ, Π :- Δ, Λ
- leftSubProof
The proof π1.
- aux1
The index of A in π1.
- rightSubProof
The proof π2.
- aux2
The index of A in π2.
- trait Eigenvariable extends AnyRef
Use this trait for rules that use eigenvariables.
- case class EqualityLeftRule(subProof: LKProof, eq: SequentIndex, aux: SequentIndex, replacementContext: Abs) extends EqualityRule with Product with Serializable
An LKProof ending with a left equality rule.
An LKProof ending with a left equality rule. There are two possible cases according to which direction the rule is applied in:
(π) (π) A[s], s = t, Γ :- Δ A[t], s = t, Γ :- Δ ---------------------eq:l ---------------------eq:l A[t], s = t, Γ :- Δ A[s], s = t, Γ :- Δ
- subProof
The subproof π.
- eq
The index of s = t.
- aux
The index of the formula in which the replacement is to be performed.
- replacementContext
A term λx.A[x] that designates the positions to be replaced.
- case class EqualityRightRule(subProof: LKProof, eq: SequentIndex, aux: SequentIndex, replacementContext: Abs) extends EqualityRule with Product with Serializable
An LKProof ending with a right equality rule.
An LKProof ending with a right equality rule. There are two possible cases according to which direction the rule is applied in:
(π) (π) s = t, Γ :- Δ, A[s] s = t, Γ :- Δ, A[t] ---------------------eq:r ---------------------eq:r s = t, Γ :- Δ, A[t] s = t, Γ :- Δ, A[s]
- subProof
The subproof π.
- eq
The index of s = t.
- aux
The index of the formula in which the replacement is to be performed.
- replacementContext
A term λx.A[x] that designates the positions to be replaced.
- abstract class EqualityRule extends UnaryLKProof with CommonRule
Abstract class that performs most of the construction of left and right equality rules.
- case class ExistsLeftRule(subProof: LKProof, aux: SequentIndex, eigenVariable: Var, quantifiedVariable: Var) extends UnaryLKProof with CommonRule with Eigenvariable with Product with Serializable
An LKProof ending with an existential quantifier on the left:
(π) A[x\α], Γ :- Δ ---------------∀:r ∃x.A Γ :- Δ
This rule is only applicable if the eigenvariable condition is satisfied: α must not occur freely in Γ :- Δ.An LKProof ending with an existential quantifier on the left:
(π) A[x\α], Γ :- Δ ---------------∀:r ∃x.A Γ :- Δ
This rule is only applicable if the eigenvariable condition is satisfied: α must not occur freely in Γ :- Δ.- subProof
The proof π.
- aux
The index of A[x\α].
- eigenVariable
The variable α.
- quantifiedVariable
The variable x.
- case class ExistsRightRule(subProof: LKProof, aux: SequentIndex, A: Formula, term: Expr, v: Var) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with an existential quantifier on the right:
(π) Γ :- Δ, A[x\t] ----------------∃:r Γ :- Δ, ∃x.A
An LKProof ending with an existential quantifier on the right:
(π) Γ :- Δ, A[x\t] ----------------∃:r Γ :- Δ, ∃x.A
- subProof
The proof π.
- aux
The index of A[x\t].
- A
The formula A.
- term
The term t.
- v
The variable x.
- case class ExistsSkLeftRule(subProof: LKProof, aux: SequentIndex, mainFormula: Formula, skolemTerm: Expr) extends UnaryLKProof with SkolemQuantifierRule with Product with Serializable
An LKProof ending with an existential quantifier on the left:
(π) A[x\s(...)], Γ :- Δ --------------- ∃sk:l ∃x.A Γ :- Δ
This rule requires a Skolem function s(...)An LKProof ending with an existential quantifier on the left:
(π) A[x\s(...)], Γ :- Δ --------------- ∃sk:l ∃x.A Γ :- Δ
This rule requires a Skolem function s(...)- subProof
The proof π.
- aux
The index of A[x\s(...)].
- mainFormula
The main formula A[x\s(...)]
- skolemTerm
The Skolem term s(...)
- case class ForallLeftRule(subProof: LKProof, aux: SequentIndex, A: Formula, term: Expr, v: Var) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a universal quantifier on the left:
(π) A[x\t], Γ :- Δ ----------------∀:l ∀x.A, Γ :- Δ
An LKProof ending with a universal quantifier on the left:
(π) A[x\t], Γ :- Δ ----------------∀:l ∀x.A, Γ :- Δ
- subProof
The proof π.
- aux
The index of A[x\t].
- A
The formula A.
- term
The term t.
- v
The variable x.
- case class ForallRightRule(subProof: LKProof, aux: SequentIndex, eigenVariable: Var, quantifiedVariable: Var) extends UnaryLKProof with CommonRule with Eigenvariable with Product with Serializable
An LKProof ending with a universal quantifier on the right:
(π) Γ :- Δ, A[x\α] ---------------∀:r Γ :- Δ, ∀x.A
This rule is only applicable if the eigenvariable condition is satisfied: α must not occur freely in Γ :- Δ.An LKProof ending with a universal quantifier on the right:
(π) Γ :- Δ, A[x\α] ---------------∀:r Γ :- Δ, ∀x.A
This rule is only applicable if the eigenvariable condition is satisfied: α must not occur freely in Γ :- Δ.- subProof
The proof π.
- aux
The index of A[x\α].
- eigenVariable
The variable α.
- quantifiedVariable
The variable x.
- case class ForallSkRightRule(subProof: LKProof, aux: SequentIndex, mainFormula: Formula, skolemTerm: Expr) extends UnaryLKProof with SkolemQuantifierRule with Product with Serializable
An LKProof ending with a universal quantifier on the right:
(π) Γ :- Δ, A[x\s(...)] ---------------∀:r Γ :- Δ, ∀x.A
This rule requires a Skolem function s(...)An LKProof ending with a universal quantifier on the right:
(π) Γ :- Δ, A[x\s(...)] ---------------∀:r Γ :- Δ, ∀x.A
This rule requires a Skolem function s(...)- subProof
The proof π.
- aux
The index of A[x\α].
- mainFormula
The main formula A[x\s(...)]
- skolemTerm
The Skolem term s(...)
- case class ImpLeftRule(leftSubProof: LKProof, aux1: SequentIndex, rightSubProof: LKProof, aux2: SequentIndex) extends BinaryLKProof with CommonRule with Product with Serializable
An LKProof ending with an implication on the left:
(π1) (π2) Γ :- Δ, A B, Π :- Λ -------------------------- A→B, Γ, Π :- Δ, Λ
An LKProof ending with an implication on the left:
(π1) (π2) Γ :- Δ, A B, Π :- Λ -------------------------- A→B, Γ, Π :- Δ, Λ
- leftSubProof
The proof π1.
- aux1
The index of A.
- rightSubProof
The proof π2
- aux2
The index of B.
- case class ImpRightRule(subProof: LKProof, aux1: SequentIndex, aux2: SequentIndex) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with an implication on the right:
(π) A, Γ :- Δ, B -------------- Γ :- Δ, A → B
An LKProof ending with an implication on the right:
(π) A, Γ :- Δ, B -------------- Γ :- Δ, A → B
- subProof
The subproof π.
- aux1
The index of A.
- aux2
The index of B.
- case class InductionCase(proof: LKProof, constructor: Const, hypotheses: Seq[SequentIndex], eigenVars: Seq[Var], conclusion: SequentIndex) extends Product with Serializable
Proof that a given data type constructor c preserves a formula F:
Proof that a given data type constructor c preserves a formula F:
(π) F(x,,1,,), F(x,,2,,), ..., F(x,,n,,), Γ :- Δ, F(c(x,,1,,,...,x,,n,,,y,,1,,,...,y,,n,,))
The variables xi and yi are eigenvariables; xi are the eigenvariables of the same type as the inductive data type, yi are the other arguments of the constructor c. They can come in any order in the constructor.
- proof
The LKProof ending in the sequent of this case.
- constructor
The constructor c of the inductive data type that we're considering.
- hypotheses
Indices of F(x1), ..., F(xn)
- eigenVars
The eigenvariables of this case: x1, ..., xn, y1, ..., yn (these need to correspond to the order in c)
- conclusion
Index of F(c(x1,...,xn,y1,...,yn))
- case class InductionRule(cases: Seq[InductionCase], formula: Abs, term: Expr) extends LKProof with CommonRule with Product with Serializable
An LKProof ending with an induction rule:
(π,,1,,) (π,,2,,) (π,,n,,) case 1 case 2 ... case n -------------------------------------(ind) Γ :- Δ, F(t: indTy)
An LKProof ending with an induction rule:
(π,,1,,) (π,,2,,) (π,,n,,) case 1 case 2 ... case n -------------------------------------(ind) Γ :- Δ, F(t: indTy)
This induction rule can handle inductive data types. The cases are proofs that the various type constructors preserve the formula we want to prove. They are provided via the InductionCase class.
- cases
A sequence of proofs showing that each type constructor preserves the validity of the main formula.
- formula
The formula we want to prove via induction.
- abstract class InitialSequent extends LKProof
An LKProof consisting of a single sequent:
--------ax Γ :- Δ
- case class LogicalAxiom(A: Formula) extends InitialSequent with Product with Serializable
An LKProof consisting of a logical axiom:
--------ax A :- A
with A atomic.An LKProof consisting of a logical axiom:
--------ax A :- A
with A atomic.- A
The atom A.
- case class NegLeftRule(subProof: LKProof, aux: SequentIndex) extends UnaryLKProof with CommonRule with Product with Serializable
Index of the left cut formula or the formula itself.
Index of the left cut formula or the formula itself. An LKProof ending with a negation on the left:
(π) Γ :- Δ, A -----------¬:l ¬A, Γ :- Δ
- subProof
The proof π.
- aux
The index of A in the succedent.
- case class NegRightRule(subProof: LKProof, aux: SequentIndex) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a negation on the right:Index of the left cut formula or the formula itself.
An LKProof ending with a negation on the right:Index of the left cut formula or the formula itself.
(π) A, Γ :- Δ -----------¬:r Γ :- Δ, ¬A
- subProof
The proof π.
- aux
The index of A in the antecedent.
- case class OrLeftRule(leftSubProof: LKProof, aux1: SequentIndex, rightSubProof: LKProof, aux2: SequentIndex) extends BinaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a disjunction on the left:
(π1) (π2) A, Γ :- Δ B, Π :- Λ -------------------------- A∨B, Γ, Π :- Δ, Λ
An LKProof ending with a disjunction on the left:
(π1) (π2) A, Γ :- Δ B, Π :- Λ -------------------------- A∨B, Γ, Π :- Δ, Λ
- leftSubProof
The proof π1.
- aux1
The index of A.
- rightSubProof
The proof π2
- aux2
The index of B.
- case class OrRightRule(subProof: LKProof, aux1: SequentIndex, aux2: SequentIndex) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a disjunction on the right:
(π) Γ :- Δ, A, B -------------- Γ :- Δ, A ∨ B
An LKProof ending with a disjunction on the right:
(π) Γ :- Δ, A, B -------------- Γ :- Δ, A ∨ B
- subProof
The subproof π.
- aux1
The index of A.
- aux2
The index of B.
- case class ProofLink(referencedProof: Expr, referencedSequent: Sequent[Formula]) extends InitialSequent with Product with Serializable
- case class ReflexivityAxiom(s: Expr) extends InitialSequent with Product with Serializable
An LKProof consisting of a reflexivity axiom:
------------ax :- s = s
with s a term.An LKProof consisting of a reflexivity axiom:
------------ax :- s = s
with s a term.- s
The term s.
- trait SkolemQuantifierRule extends UnaryLKProof with CommonRule
- abstract class UnaryLKProof extends LKProof
An LKProof deriving a sequent from another sequent:
(π) Γ :- Δ ---------- Γ' :- Δ'
- case class WeakeningLeftRule(subProof: LKProof, formula: Formula) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a left weakening:
(π) Γ :- Δ ---------w:l A, Γ :- Δ
An LKProof ending with a left weakening:
(π) Γ :- Δ ---------w:l A, Γ :- Δ
- subProof
The subproof π.
- formula
The formula A.
- case class WeakeningRightRule(subProof: LKProof, formula: Formula) extends UnaryLKProof with CommonRule with Product with Serializable
An LKProof ending with a right weakening:
(π) Γ :- Δ ---------w:r Γ :- Δ, A
An LKProof ending with a right weakening:
(π) Γ :- Δ ---------w:r Γ :- Δ, A
- subProof
The subproof π.
- formula
The formula A.
Value Members
- object AndLeftRule extends ConvenienceConstructor with Serializable
- object AndRightRule extends ConvenienceConstructor with Serializable
- object BinaryLKProof
- object BottomAxiom extends InitialSequent with Product with Serializable
An LKProof introducing ⊥ on the left:
--------⊥:l ⊥ :-
- object ContractionLeftRule extends ConvenienceConstructor with Serializable
- object ContractionRightRule extends ConvenienceConstructor with Serializable
- object ConversionLeftRule extends ConvenienceConstructor with Serializable
- object ConversionRightRule extends ConvenienceConstructor with Serializable
- object ConversionRule extends ConvenienceConstructor
- object CutRule extends ConvenienceConstructor with Serializable
- object EqualityLeftRule extends ConvenienceConstructor with Serializable
- object EqualityRightRule extends ConvenienceConstructor with Serializable
- object ExistsLeftRule extends ConvenienceConstructor with Serializable
- object ExistsRightRule extends ConvenienceConstructor with Serializable
- object ExistsSkLeftRule extends ConvenienceConstructor with Serializable
- object ForallLeftRule extends ConvenienceConstructor with Serializable
- object ForallRightRule extends ConvenienceConstructor with Serializable
- object ForallSkRightRule extends ConvenienceConstructor with Serializable
- object ImpLeftRule extends ConvenienceConstructor with Serializable
- object ImpRightRule extends ConvenienceConstructor with Serializable
- object InitialSequent
- object NegLeftRule extends ConvenienceConstructor with Serializable
- object NegRightRule extends ConvenienceConstructor with Serializable
- object OrLeftRule extends ConvenienceConstructor with Serializable
- object OrRightRule extends ConvenienceConstructor with Serializable
- object ProofLink extends Serializable
- object StrongQuantifierRule
- object TopAxiom extends InitialSequent with Product with Serializable
An LKProof introducing ⊤ on the right:
--------⊤:r :- ⊤
- object UnaryLKProof
- object WeakQuantifierRule
This is the API documentation for GAPT.
The main package is gapt.