package lk
- 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.
-
abstract
class
BinaryLKProof
extends LKProof
An LKProof deriving a sequent from two other sequents:
(π1) (π2) Γ :- Δ Γ' :- Δ' ------------------ Π :- Λ
An LKProof deriving a sequent from two other sequents:
(π1) (π2) Γ :- Δ Γ' :- Δ' ------------------ Π :- Λ
- trait CommonRule extends LKProof with ContextRule[HOLFormula, 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, definition: Definition, replacementContext: Abs) extends DefinitionRule with Product with Serializable
An LKProof ending with a definition on the left:
An LKProof ending with a definition on the left:
(π) A[φ], Γ :- Δ -----------d:l A[c], Γ :- Δ
- subProof
The proof π.
- aux
The index of A in the antecedent.
- definition
The definition c := φ.
- replacementContext
A term λx.A[x] that designates the positions for the definition.
-
case class
DefinitionRightRule
(subProof: LKProof, aux: SequentIndex, definition: Definition, replacementContext: Abs) extends DefinitionRule with Product with Serializable
An LKProof ending with a definition on the right:
An LKProof ending with a definition on the right:
(π) Γ :- Δ, A[φ] -----------d:l Γ :- Δ, A[c]
- subProof
The proof π.
- aux
The index of A in the succedent.
- definition
The definition c := φ.
- replacementContext
A term λx.A[x] that designates the positions for the definition.
- 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, Γ :- Δ
In either case, the rule only replaces term occurrences at parallel positions. These positions are given by the positions argument.
- 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]
In either case, the rule only replaces term occurrences at parallel positions. These positions are given by the positions argument.
- 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: HOLFormula, term: LambdaExpression, 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: HOLFormula, skolemTerm: LambdaExpression, skolemDef: LambdaExpression) 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(...)
- skolemDef
The Skolem definition, see at.logic.gapt.expr.hol.SkolemFunctions
-
case class
ForallLeftRule
(subProof: LKProof, aux: SequentIndex, A: HOLFormula, term: LambdaExpression, 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: HOLFormula, skolemTerm: LambdaExpression, skolemDef: LambdaExpression) 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(...)
- skolemDef
The Skolem definition, see at.logic.gapt.expr.hol.SkolemFunctions
-
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: LambdaExpression) 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 Γ :- Δ
An LKProof consisting of a single sequent:
--------ax Γ :- Δ
- class InterpolationException extends Exception
- abstract class LKProof extends SequentProof[HOLFormula, 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
-
trait
LKVisitor
[T] extends AnyRef
Implementation of the visitor pattern for at.logic.gapt.proofs.lk.LKProof.
Implementation of the visitor pattern for at.logic.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.
-
case class
LogicalAxiom
(A: HOLFormula) 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.
-
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. - class ReductiveCutElimination extends AnyRef
-
case class
ReflexivityAxiom
(s: LambdaExpression) 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
- trait SolveUtils extends AnyRef
- case class TheoryAxiom (conclusion: Sequent[HOLAtom]) extends InitialSequent with Product with Serializable
-
abstract
class
UnaryLKProof
extends LKProof
An LKProof deriving a sequent from another sequent:
(π) Γ :- Δ ---------- Γ' :- Δ'
An LKProof deriving a sequent from another sequent:
(π) Γ :- Δ ---------- Γ' :- Δ'
-
case class
WeakeningLeftRule
(subProof: LKProof, formula: HOLFormula) 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: HOLFormula) 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[LambdaExpression, LambdaExpression]
Implements definition elimination.
- class regularize extends LKVisitor[Unit]
- class solvePropositional extends SolveUtils
Value Members
- implicit def LeftSequentIndex(i: SequentIndex): Either[SequentIndex, HOLFormula]
- implicit def RightFormula(f: HOLFormula): Either[SequentIndex, HOLFormula]
- object AndLeftMacroRule extends ConvenienceConstructor
- object AndLeftRule extends ConvenienceConstructor with Serializable
- object AndRightRule extends ConvenienceConstructor with Serializable
- object AtomicExpansion
-
object
Axiom
Convenience object for constructing Axioms.
- object BinaryLKProof
-
object
BottomAxiom
extends InitialSequent with Product with Serializable
An LKProof introducing ⊥ on the left:
--------⊥:l ⊥ :-
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 CutRule extends ConvenienceConstructor with Serializable
- object DefinitionLeftRule extends ConvenienceConstructor with Serializable
- object DefinitionRightRule extends ConvenienceConstructor with Serializable
- object DefinitionRule
- object Eigenvariable
- 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
- implicit object LKProofSubstitutableDefault extends LKProofSubstitutable
- object LKProver extends OneShotProver
- object LKToExpansionProof
- 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 ProofBuilder extends ProofBuilder[LKProof]
-
object
ReductiveCutElimination
This object implements a version of Gentzen's cut-elimination proof for our sequent calculus LK.
This object implements a version of Gentzen's cut-elimination proof for our sequent calculus LK. For details, please refer to the documentation of the apply methods.
- object ResolutionProofBuilder extends ProofBuilder[ResolutionProof]
- object StrongQuantifierRule
-
object
TopAxiom
extends InitialSequent with Product with Serializable
An LKProof introducing ⊤ on the right:
--------⊤:r :- ⊤
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
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 containsEqualityReasoning
- object cutFormulas
- object cutsNumber
-
object
eliminateDefinitions
Eliminates definitions from a lambda expression, HOL formula, or LK proof.
- object extractRecSchem
- object freeVariablesLK
- object groundFreeVarsLK
- object inductionsNumber
- object isRegular
- implicit object lkProofReplaceable extends ClosedUnderReplacement[LKProof]
- object makeInductionExplicit extends LKVisitor[Unit]
-
object
makeTheoryAxiomsExplicit
extends LKVisitor[Seq[HOLFormula]]
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 printProofStats
-
object
proofFromInstances
Computes a proof of F from a proof of some instances of F
- object quantRulesNumber
-
object
regularize
Proof regularization
- object rulesNumber
- object skolemize
- object skolemizeInferences
- object solvePropositional extends solvePropositional
- object solveQuasiPropositional extends solvePropositional
- object strongQuantRulesNumber
- object weakQuantRulesNumber