package lk
- Source
- package.scala
- Alphabetic
- By Inheritance
- lk
- AnyRef
- Any
- Hide All
- Show All
- 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.
- case class Attributes(attrs: Map[String, Set[String]]) extends Product with Serializable
-
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
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.
-
case class
DefinitionLeftRule(subProof: LKProof, aux: SequentIndex, mainFormula: Formula) extends DefinitionRule with Product with Serializable
An LKProof ending with a definition on the left.
An LKProof ending with a definition on the left.
Introducing the definition c := φ on the left means replacing some occurrences of the expression φ by c in a formula in the antecedent:
(π) A[φ], Γ :- Δ -----------d:l A[c], Γ :- Δ
NB: 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. Use the
check
method on Context to check whether the constructed proof is sound.- subProof
The proof π.
- aux
The index of A in the antecedent.
- mainFormula
The formula
-
case class
DefinitionRightRule(subProof: LKProof, aux: SequentIndex, mainFormula: Formula) extends DefinitionRule with Product with Serializable
An LKProof ending with a definition on the right.
An LKProof ending with a definition on the right.
Introducing the definition c := φ on the right means replacing some occurrences of the expression φ by c in a formula in the succedent:
(π) Γ :- Δ, A[φ] -----------d:r Γ :- Δ, A[c]
NB: 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. Use the
check
method on Context to check whether the constructed proof is sound.- subProof
The proof π.
- aux
The index of A in the succedent.
- mainFormula
The formula
- abstract class DefinitionRule extends UnaryLKProof with CommonRule
-
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 Γ :- Δ
- class InterpolationException extends Exception
-
class
IterativeParallelStrategy extends ReductionStrategy
Applies the given reduction exhaustively to lowermost redexes.
- class IterativeSelectiveStrategy extends ReductionStrategy
- abstract class LKProof extends SequentProof[Formula, LKProof]
- class LKProofReplacer extends LKVisitor[Unit]
-
class
LKProofSubstitutable extends Substitutable[Substitution, LKProof, LKProof]
Class that describes how LKProofs can be substituted.
- class LKRuleCreationException extends Exception
- class LKToNDTranslationException extends Exception
-
trait
LKVisitor[T] extends AnyRef
Implementation of the visitor pattern for gapt.proofs.lk.LKProof.
Implementation of the visitor pattern for gapt.proofs.lk.LKProof. Proof transformations can implement this trait to reduce boilerplate code.
- T
Type of additional arguments that may be used in the transformation.
- class LeftRankInductionUnfoldingReduction extends CutReduction
-
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.
-
class
LowerMostRedexReducer extends LKVisitor[Unit] with RedexReducer
Applies a given reduction to the lowermost redexes.
-
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.
- class ParallelAtDepthStrategy extends ReductionStrategy
- case class ProofLink(referencedProof: Expr, referencedSequent: Sequent[Formula]) extends InitialSequent with Product with Serializable
-
trait
RedexReducer extends AnyRef
Describes objects that can apply a reduction to redexes.
- trait ReductionStrategy extends AnyRef
-
class
ReductiveCutNormalization extends AnyRef
This class implements a version of Gentzen's cut-reduction procedure for our sequent calculus LK.
-
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 Selector extends AnyRef
- trait SkolemQuantifierRule extends UnaryLKProof with CommonRule
- trait SolveUtils extends AnyRef
-
abstract
class
UnaryLKProof extends LKProof
An LKProof deriving a sequent from another sequent:
(π) Γ :- Δ ---------- Γ' :- Δ'
- class UnfoldInductions extends AnyRef
-
class
UppermostFirstStrategy extends ReductionStrategy
Applies the given reduction exhaustively to uppermost redexes.
-
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.
-
class
eliminateDefinitions extends Function[Expr, Expr]
Implements definition elimination.
- class regularize extends LKVisitor[Unit]
- class solvePropositional extends SolveUtils
- class unfoldInduction extends AnyRef
Value Members
- object AndLeftMacroRule extends ConvenienceConstructor
- object AndLeftRule extends ConvenienceConstructor with Serializable
- object AndRightRule extends ConvenienceConstructor with Serializable
- object ArithmeticInductionToSchema
- object AtomicExpansion
- object Attributes extends Serializable
- object BinaryLKProof
-
object
BottomAxiom extends InitialSequent with Product with Serializable
An LKProof introducing ⊥ on the left:
--------⊥:l ⊥ :-
-
object
ContractionLeftMacroRule
This macro rule simulates a series of contractions in the antecedent.
- object ContractionLeftRule extends ConvenienceConstructor with Serializable
-
object
ContractionMacroRule extends ConvenienceConstructor
This macro rule simulates a series of contractions in both cedents.
-
object
ContractionRightMacroRule
This macro rule simulates a series of contractions in the succedent.
- object ContractionRightRule extends ConvenienceConstructor with Serializable
- object CreateASchemaVersion extends LKVisitor[MutableContext]
- object CutRule extends ConvenienceConstructor with Serializable
- object DefinitionLeftRule extends ConvenienceConstructor with Serializable
- object DefinitionRightRule extends ConvenienceConstructor with Serializable
- object DefinitionRule extends ConvenienceConstructor
- object EigenVariablesLK
- object EqualityLeftMacroRule extends ConvenienceConstructor
- object EqualityLeftRule extends ConvenienceConstructor with Serializable
- object EqualityRightMacroRule extends ConvenienceConstructor
- object EqualityRightRule extends ConvenienceConstructor with Serializable
- object EquationalLKProver extends OneShotProver
-
object
ExchangeLeftMacroRule
Move a formula to the beginning of the antecedent, where the main formula is customarily placed.
Move a formula to the beginning of the antecedent, where the main formula is customarily placed.
(π) Γ, A, Γ' :- Δ -------------- A, Γ, Γ' :- Δ
-
object
ExchangeRightMacroRule
Move a formula to the end of the succedent, where the main formula is customarily placed.
Move a formula to the end of the succedent, where the main formula is customarily placed.
(π) Γ :- Δ, A, Δ' -------------- Γ :- Δ, Δ', A
- object ExistsLeftBlock
- object ExistsLeftRule extends ConvenienceConstructor with Serializable
- object ExistsRightBlock
- object ExistsRightRule extends ConvenienceConstructor with Serializable
- object ExistsSkLeftRule extends ConvenienceConstructor with Serializable
- object ExtractInterpolant
- object FOTheoryMacroRule
- object ForallLeftBlock
- object ForallLeftRule extends ConvenienceConstructor with Serializable
- object ForallRightBlock
- object ForallRightRule extends ConvenienceConstructor with Serializable
- object ForallSkRightRule extends ConvenienceConstructor with Serializable
- object ImpLeftRule extends ConvenienceConstructor with Serializable
- object ImpRightMacroRule extends ConvenienceConstructor
- object ImpRightRule extends ConvenienceConstructor with Serializable
- object InitialSequent
- object Interpolate
- object IsKSimple
- implicit object LKProofSubstitutableDefault extends LKProofSubstitutable
- object LKProver extends OneShotProver
- object LKToExpansionProof
- object LKToND
- object MG3iToLJ
- object NaturalNumberInductionRule extends ConvenienceConstructor
- object NegLeftRule extends ConvenienceConstructor with Serializable
- object NegRightRule extends ConvenienceConstructor with Serializable
- object OrLeftRule extends ConvenienceConstructor with Serializable
- object OrRightMacroRule extends ConvenienceConstructor
- object OrRightRule extends ConvenienceConstructor with Serializable
- object ParamodulationLeftRule extends ConvenienceConstructor
- object ParamodulationRightRule extends ConvenienceConstructor
- object ProofLink extends Serializable
- object StrongQuantifierRule
- object StuckCutReduction
-
object
TopAxiom extends InitialSequent with Product with Serializable
An LKProof introducing ⊤ on the right:
--------⊤:r :- ⊤
- object TransRule
- object UnaryLKProof
- object WeakQuantifierBlock
- object WeakQuantifierRule
-
object
WeakeningContractionMacroRule extends ConvenienceConstructor
This macro rule simulates multiple weakenings and contractions in both cedents.
-
object
WeakeningLeftMacroRule
This macro rule simulates a series of weakenings in the antecedent.
-
object
WeakeningMacroRule extends ConvenienceConstructor
This macro rule simulates a series of weakenings in both cedents.
-
object
WeakeningRightMacroRule
This macro rule simulates a series of weakenings in the succedent.
- object acnf
- object acnfTop
-
object
cleanCuts extends LKVisitor[Unit]
Algorithm that removes some unnecessary cuts.
Algorithm that removes some unnecessary cuts. At the moment it only removes cuts where one of the premises is a logical axiom.
- object cleanStructuralRules
- object consoleString
- object containsDefinitionRules
- object containsEqualityReasoning
- object cutFormulas
- object cutNormal
- object cutsNumber
-
object
eliminateDefinitions
Eliminates definitions from a lambda expression, HOL formula, or LK proof.
- object equalityLeftReduction
- object equalityRightReduction
- object extractInductionAxioms
- object extractInductionGrammar
- object extractRecSchem
- object folSkolemize
- object freeVariablesLK
- object groundFreeVarsLK
- object inductionEigenvariables
- object inductionNormalForm
- object inductionsNumber
- object instanceProof
- object instantiateProof
- object introOrCut
- object isAcnf
- object isAcnfTop
- object isAtomicCut
- object isCutFree
- object isInductionFree
-
object
isMaeharaMG3i
Checks whether a given proof in LK is in the calculus L'J introduced in [Maehara 1954].
Checks whether a given proof in LK is in the calculus L'J introduced in [Maehara 1954]. In [Troelstra et al. 2000] this calculus is referred to as m-G3i.
[Maehara 1954] Maehara Shoji, Eine Darstellung der intuitionistischen Logik in der klassischen, 1954. [Troelstra et al. 2000] Troelstra, Schwichtenberg, Basic Proof Theory, 2000.
- object isRegular
- implicit object lkProofReplaceable extends ClosedUnderReplacement[LKProof]
- object logicalComplexity
- object makeInductionExplicit extends LKVisitor[Unit]
-
object
makeTheoryAxiomsExplicit extends LKVisitor[Seq[Formula]]
Given a list of formulas Π, this transforms a proof π of Σ :- Δ into a proof π' of Π, Σ :- Δ.
Given a list of formulas Π, this transforms a proof π of Σ :- Δ into a proof π' of Π, Σ :- Δ.
It replaces theory axioms on sequents S that are subsumed by Π with propositional proofs of Π, S.
-
object
moveStrongQuantifierRulesDown
Modifies an LK proof to introduce strong quantifiers as soon as possible.
- object normalizeLKt extends normalize
- object printProofStats
-
object
proofFromInstances
Computes a proof of F from a proof of some instances of F
- object pushAllWeakeningsToLeaves
- object pushEqualityInferencesToLeaves
- object pushSingleWeakeningToLeaves
- object quantRulesNumber
-
object
regularize
Proof regularization
- object rulesNumber
- object skolemizeLK
- object solvePropositional extends solvePropositional
- object solveQuasiPropositional extends solvePropositional
- object strongQuantRulesNumber
- object unfoldInduction
- object weakQuantRulesNumber
- object weakeningOnlySubTree
This is the API documentation for GAPT.
The main package is gapt.