trait TacticCommands extends AnyRef
- Alphabetic
- By Inheritance
- TacticCommands
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
+(other: String): String
- Implicit
- This member is added by an implicit conversion from TacticCommands to any2stringadd[TacticCommands] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
-
def
->[B](y: B): (TacticCommands, B)
- Implicit
- This member is added by an implicit conversion from TacticCommands to ArrowAssoc[TacticCommands] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
allL(terms: Expr*): ForallLeftTactic
Applies the
ForallLeft
tactic to the current subgoal: The goalApplies the
ForallLeft
tactic to the current subgoal: The goal∀x1,...,∀xn.A, Γ :- Δ
is reduced to
A[x1\t1,...,xn\tn], ∀x1,...,∀xn.A, Γ :- Δ.
This will only work if there is exactly one universal formula in the antecedent!
- terms
The terms
t1,...,tn
.
-
def
allL(applyToLabel: String, terms: Expr*): ForallLeftTactic
Applies the
ForallLeft
tactic to the current subgoal: The goalApplies the
ForallLeft
tactic to the current subgoal: The goal∀x1,...,∀xn.A, Γ :- Δ
is reduced to
A[x1\t1,...,xn\tn], ∀x1,...,∀xn.A, Γ :- Δ
.- applyToLabel
The label of the formula
∀x1,...,∀xn.A
.- terms
The terms
t1,...,tn
.
-
def
allR: ForallRightTactic
Applies the
ForallRight
tactic to the current subgoal: The goalApplies the
ForallRight
tactic to the current subgoal: The goalΓ :- Δ, ∀x.A
is reduced to
Γ :- Δ, A
.This will only work if there is exactly one universal formula in the succedent!
-
def
allR(applyToLabel: String): ForallRightTactic
Applies the
ForallRight
tactic to the current subgoal: The goalApplies the
ForallRight
tactic to the current subgoal: The goalΓ :- Δ, ∀x.A
is reduced to
Γ :- Δ, A
.- applyToLabel
The label of the formula
∀x.A
.
-
def
allR(eigenVariable: Var): ForallRightTactic
Applies the
ForallRight
tactic to the current subgoal: The goalApplies the
ForallRight
tactic to the current subgoal: The goalΓ :- Δ, ∀x.A
is reduced to
Γ :- Δ, A[x\α]
.This will only work if there is exactly one universal formula in the succedent!
- eigenVariable
The variable
α
.
-
def
allR(applyToLabel: String, eigenVariable: Var): ForallRightTactic
Applies the
ForallRight
tactic to the current subgoal: The goalApplies the
ForallRight
tactic to the current subgoal: The goalΓ :- Δ, ∀x.A
is reduced to
Γ :- Δ, A[x\α]
.- applyToLabel
The label of the formula
∀x.A
.- eigenVariable
The variable
α
.
- def anaInd(implicit ctx: Context): Tactic[Unit]
- def anaIndG(implicit ctx: Context): Tactic[Unit]
- def analyticInduction(implicit ctx: MutableContext): AnalyticInductionTactic
-
def
andL: AndLeftTactic
Applies the
AndLeft
tactic to the current subgoal: The goalApplies the
AndLeft
tactic to the current subgoal: The goalA ∧ B, Γ :- Δ
is reduced to
A, B, Γ :- Δ
.This will only work if there is exactly one conjunctive formula in the antecedent!
-
def
andL(applyToLabel: String): AndLeftTactic
Applies the
AndLeft
tactic to the current subgoal: The goalApplies the
AndLeft
tactic to the current subgoal: The goalA ∧ B, Γ :- Δ
is reduced to
A, B, Γ :- Δ
.- applyToLabel
The label of the formula
A ∧ B
.
-
def
andR: AndRightTactic
Applies the
AndRight
tactic to the current subgoal: The goalApplies the
AndRight
tactic to the current subgoal: The goalΓ :- Δ, A ∧ B
is reduced to
Γ :- Δ, A
andΓ :- Δ, B
.This will only work if there is exactly one conjunctive formula in the succedent!
-
def
andR(applyToLabel: String): AndRightTactic
Applies the
AndRight
tactic to the current subgoal: The goalApplies the
AndRight
tactic to the current subgoal: The goalΓ :- Δ, A ∧ B
is reduced to
Γ :- Δ, A
andΓ :- Δ, B
.- applyToLabel
The label of the formula
A ∧ B
.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
axiomBot: BottomAxiomTactic.type
Applies the
BottomAxiom
tactic to the current subgoal: A subgoal of the form⊥, Γ :- Δ
will be closed. -
def
axiomLog: LogicalAxiomTactic.type
Applies the
LogicalAxiom
tactic to the current subgoal: A subgoal of the formA, Γ :- Δ, A
will be closed. -
def
axiomRefl: ReflexivityAxiomTactic.type
Applies the
ReflexivityAxiom
tactic to the current subgoal: A subgoal of the formΓ :- Δ, s = s
will be closed. -
def
axiomTop: TopAxiomTactic.type
Applies the
TopAxiom
tactic to the current subgoal: A subgoal of the formΓ :- Δ, ⊤
will be closed. -
def
by: TacticBlockArgument[Tactic[Unit]]
by { tac1; tac2; ...; tacn }
solves the first goal using the provided tactic block, and fails otherwise - def cases(lemma: String, terms: Expr*)(implicit ctx: Context): Tactic[Unit]
- def casesW(label: String, lemma: String, terms: Expr*)(implicit ctx: Context): Tactic[Unit]
- def chain(h: String): ChainTactic
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
cut(label: String, cutFormula: Formula): CutTactic
Applies the
Cut
tactic to the current subgoal: The goalApplies the
Cut
tactic to the current subgoal: The goalΓ :- Δ
is reduced to
Γ :- Δ, C
andC, Γ :- Δ
.- label
The label of
C
.- cutFormula
The formula
C
.
-
def
decompose: Tactic[Unit]
Decomposes the current subgoal by applying all "simple" rules as often as possible.
Decomposes the current subgoal by applying all "simple" rules as often as possible. These rules are: -
¬:l
and¬:r
-∧:l
-∨:r
-→:r
-∀:r
-∃:l
- def destruct(label: String): Tactic[Any]
-
def
ensuring(cond: (TacticCommands) ⇒ Boolean, msg: ⇒ Any): TacticCommands
- Implicit
- This member is added by an implicit conversion from TacticCommands to Ensuring[TacticCommands] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: (TacticCommands) ⇒ Boolean): TacticCommands
- Implicit
- This member is added by an implicit conversion from TacticCommands to Ensuring[TacticCommands] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean, msg: ⇒ Any): TacticCommands
- Implicit
- This member is added by an implicit conversion from TacticCommands to Ensuring[TacticCommands] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean): TacticCommands
- Implicit
- This member is added by an implicit conversion from TacticCommands to Ensuring[TacticCommands] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
eql(eq: String, fm: String): EqualityTactic
Applies the
Equality
tactic to the current subgoal: Given an equations = t
and a formulaA
, some occurrences ofs
in A are replaced byt
or vice versa.Applies the
Equality
tactic to the current subgoal: Given an equations = t
and a formulaA
, some occurrences ofs
in A are replaced byt
or vice versa. The exact behavior can be controlled with additional commands:-
fromLeftToRight
: Occurrences ofs
will be replaced byt
. -fromRightToLeft
: Occurrences oft
will be replaced bys
. -yielding(f)
: The tactic will attempt to replace occurences in such a way that the end result isf
.If neither
fromLeftToRight
norfromRightToLeft
is used, the direction of replacement needs to be unambiguous, i.e.s
andt
may not both occur inA
.- eq
The label of
s = t
.- fm
The label of
A
.
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
escargot(implicit ctx: MutableContext): ResolutionProverTactic
Calls
escargot
on the current subgoal. - def escrgt(implicit ctx: Context): Tactic[Unit]
-
def
exL: ExistsLeftTactic
Applies the
ExistsLeft
tactic to the current subgoal: The goalApplies the
ExistsLeft
tactic to the current subgoal: The goal∃x.A, Γ :- Δ
is reduced to
A, Γ :- Δ
.This will only work if there is exactly one existential formula in the antecedent!
-
def
exL(applyToLabel: String): ExistsLeftTactic
Applies the
ExistsLeft
tactic to the current subgoal: The goalApplies the
ExistsLeft
tactic to the current subgoal: The goal∃x.A, Γ :- Δ
is reduced to
A, Γ :- Δ
.- applyToLabel
The label of the formula
∃x.A
.
-
def
exL(eigenVariable: Var): ExistsLeftTactic
Applies the
ExistsLeft
tactic to the current subgoal: The goalApplies the
ExistsLeft
tactic to the current subgoal: The goal∃x.A, Γ :- Δ
is reduced to
A[x\α], Γ :- Δ
.This will only work if there is exactly one existential formula in the antecedent!
- eigenVariable
The variable
α
.
-
def
exL(applyToLabel: String, eigenVariable: Var): ExistsLeftTactic
Applies the
ExistsLeft
tactic to the current subgoal: The goalApplies the
ExistsLeft
tactic to the current subgoal: The goal∃x.A, Γ :- Δ
is reduced to
A[x\α], Γ :- Δ
.- applyToLabel
The label of the formula
∃x.A
.- eigenVariable
The variable
α
.
-
def
exR(terms: Expr*): ExistsRightTactic
Applies the
ExistsRight
tactic to the current subgoal: The goalApplies the
ExistsRight
tactic to the current subgoal: The goalΓ :- Δ, ∃x1...∃xn.A
is reduced to
Γ :- Δ, ∃x1...∃xn.A, A[x1\t1,...,xn\tn]
.This will only work if there is exactly one existential formula in the succedent!
- terms
The terms
t1,...,tn
.
-
def
exR(applyToLabel: String, terms: Expr*): ExistsRightTactic
Applies the
ExistsRight
tactic to the current subgoal: The goalApplies the
ExistsRight
tactic to the current subgoal: The goalΓ :- Δ, ∃x1...∃xn.A
is reduced to
Γ :- Δ, ∃x1...∃xn.A, A[x1\t1,...,xn\tn]
.- applyToLabel
The label of the formula
∃x1...∃xn.A
.- terms
The terms
t1,...,tn
.
-
def
fail: Tactic[Nothing] { def apply(proofState: gapt.proofs.gaptic.ProofState): scala.util.Left[gapt.proofs.gaptic.TacticFailure,Nothing] }
Tactic that immediately fails.
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
foTheory(implicit ctx: Context): Tactic[Unit]
Solves the current subgoal as a first-order consequence of the background theory.
Solves the current subgoal as a first-order consequence of the background theory. This closes the goal.
- ctx
A Context. The current subgoal must be contained in its background theory.
-
def
focus(indexOfSubGoal: OpenAssumptionIndex): FocusTactic
Moves the specified goal to the front of the goal list.
Moves the specified goal to the front of the goal list.
- indexOfSubGoal
The index of the goal.
-
def
focus(indexOfSubGoal: Int): FocusTactic
Moves the specified goal to the front of the goal list.
Moves the specified goal to the front of the goal list.
- indexOfSubGoal
The index of the goal.
- def forget(pred: (String, Formula) ⇒ Boolean): Tactic[Unit]
-
def
forget(ls: String*): Tactic[Unit]
Lets you "forget" a sequence of formulas, i.e.
Lets you "forget" a sequence of formulas, i.e. the tactics version of the weakening rule. The formulas with labels
L1,...,Ln
will be removed from the current goal.- ls
The labels
L1
,...,Ln
.
-
def
formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from TacticCommands to StringFormat[TacticCommands] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
- def generalize(vs: Var*): Tactic[Unit]
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
haveInstance(formula: Formula, polarity: Polarity): Tactic[String]
Instantiates prenex quantifiers to obtain a formula in a given polarity.
- def haveInstances(sequent: HOLSequent): Tactic[Sequent[String]]
-
def
impL: ImpLeftTactic
Applies the
ImpLeft
tactic to the current subgoal: The goalApplies the
ImpLeft
tactic to the current subgoal: The goalA → B, Γ :- Δ
is reduced to
Γ :- Δ, A
andB, Γ :- Δ
.This will only work if there is exactly one implicative formula in the antecedent!
-
def
impL(applyToLabel: String): ImpLeftTactic
Applies the
ImpLeft
tactic to the current subgoal: The goalApplies the
ImpLeft
tactic to the current subgoal: The goalA → B, Γ :- Δ
is reduced to
Γ :- Δ, A
andB, Γ :- Δ
.- applyToLabel
The label of the formula
A → B
.
-
def
impR: ImpRightTactic
Applies the
ImpRight
tactic to the current subgoal: The goalApplies the
ImpRight
tactic to the current subgoal: The goalΓ :- Δ, A → B
is reduced to
A, Γ :- Δ, B
.This will only work if there is exactly one implicative formula in the succedent!
-
def
impR(applyToLabel: String): ImpRightTactic
Applies the
ImpRight
tactic to the current subgoal: The goalApplies the
ImpRight
tactic to the current subgoal: The goalΓ :- Δ, A → B
is reduced to
A, Γ :- Δ, B
.- applyToLabel
The label of the formula
A → B
.
- def include(labels: String*)(implicit ctx: Context, dummyImplicit: DummyImplicit): Tactic[Unit]
- def include(names: Expr*)(implicit ctx: Context): Tactic[Unit]
-
def
include(label: String, proof: LKProof): Tactic[Unit]
Uses an LKProof as a lemma.
Uses an LKProof as a lemma.
If
proof
ends inΓ :- φ
, then the current goalΓ, Π :- Λ
is reduced to
Γ, Π, φ :- Λ
- label
the label for φ in the subgoal
- proof
The proof to insert as a lemma by a cut.
-
def
induction(on: Var, label: String)(implicit ctx: Context): InductionTactic
Applies the
Induction
tactic to the current subgoal: The goalApplies the
Induction
tactic to the current subgoal: The goalΓ, :- Δ, ∀x.A
is reduced to
n
new subgoals, wheren
is the number of constructors of the type ofx
.- label
The label of the formula
∀x.A
.- ctx
A Context. It must contain an inductive definition of the type of
x
.
-
def
induction(on: Var)(implicit ctx: Context): InductionTactic
Applies the
Induction
tactic to the current subgoal: The goalApplies the
Induction
tactic to the current subgoal: The goalΓ, :- Δ, ∀x.A
is reduced to
n
new subgoals, wheren
is the number of constructors of the type ofx
.This will only work if there is exactly one universal formula in the succedent!
- ctx
A Context. It must contain an inductive definition of the type of
x
.
-
def
insert(proof: LKProof): InsertTactic
Inserts an LKProof for the current subgoal.
Inserts an LKProof for the current subgoal.
- proof
The proof to be inserted. Its end-sequent must subsume the current goal.
- def introUnivsExcept(i: Int): Tactic[Unit]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
negL: NegLeftTactic
Applies the
NegLeft
tactic to the current subgoal: The goalApplies the
NegLeft
tactic to the current subgoal: The goal¬A, Γ :- Δ
is reduced to
Γ :- Δ, A
.This will only work if there is exactly one negated formula in the antecedent!
-
def
negL(applyToLabel: String): NegLeftTactic
Applies the
NegLeft
tactic to the current subgoal: The goalApplies the
NegLeft
tactic to the current subgoal: The goal¬A, Γ :- Δ
is reduced to
Γ :- Δ, A
.- applyToLabel
The label of the formula
¬A
.
-
def
negR: NegRightTactic
Applies the
NegRight
tactic to the current subgoal: The goalApplies the
NegRight
tactic to the current subgoal: The goalΓ :- Δ, A
is reduced to
A, Γ :- Δ
.This will only work if there is exactly one negated formula in the succedent!
-
def
negR(applyToLabel: String): NegRightTactic
Applies the
NegRight
tactic to the current subgoal: The goalApplies the
NegRight
tactic to the current subgoal: The goalΓ :- Δ, ¬A
is reduced to
A, Γ :- Δ
.- applyToLabel
The label of the formula
¬A
.
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def now: Tactic[Unit]
-
def
orL: OrLeftTactic
Applies the
OrLeft
tactic to the current subgoal: The goalApplies the
OrLeft
tactic to the current subgoal: The goalA ∨ B, Γ :- Δ
is reduced to
A, Γ :- Δ
andB, Γ :- Δ
.This will only work if there is exactly one disjunctive formula in the antecedent!
-
def
orL(applyToLabel: String): OrLeftTactic
Applies the
OrLeft
tactic to the current subgoal: The goalApplies the
OrLeft
tactic to the current subgoal: The goalA ∨ B, Γ :- Δ
is reduced to
A, Γ :- Δ
andB, Γ :- Δ
.- applyToLabel
The label of the formula
A ∨ B
.
-
def
orR: OrRightTactic
Applies the
OrRight
tactic to the current subgoal: The goalApplies the
OrRight
tactic to the current subgoal: The goalΓ :- Δ, A ∨ B
is reduced to
Γ :- Δ, A, B
.This will only work if there is exactly one disjunctive formula in the succedent!
-
def
orR(applyToLabel: String): OrRightTactic
Applies the
OrRight
tactic to the current subgoal: The goalApplies the
OrRight
tactic to the current subgoal: The goalΓ :- Δ, A ∨ B
is reduced to
Γ :- Δ, A, B
.- applyToLabel
The label of the formula
A ∨ B
.
-
def
prop: Tactic[Unit]
Calls the builtin tableau prover on the current subgoal.
Calls the builtin tableau prover on the current subgoal. If the goal is a tautology, a proof will automatically be found and inserted.
-
def
prover9(implicit ctx: MutableContext): ResolutionProverTactic
Calls
prover9
on the current subgoal. - def quasiprop: Tactic[Unit]
-
def
ref(proofName: String)(implicit ctx: Context): ProofLinkTactic
Applies the
LogicalAxiom
tactic to the current subgoal: A subgoal of the formA, Γ :- Δ, A
will be closed. -
def
refl: ReflexivityAxiomTactic.type
Synonym for axiomRefl.
-
def
renameLabel(oldLabel: String): RenameTactic
Changes the provided label.
Changes the provided label. Syntax:
renameLabel("foo") to "bar"
- oldLabel
The label to be renamed.
-
def
repeat[T](t: Tactic[T]): RepeatTactic[T]
Repeats a tactical until it fails.
Repeats a tactical until it fails.
- t
A tactical.
- def resolutionProver(prover: Prover)(implicit ctx: MutableContext): ResolutionProverTactic
- def revert(hyps: String*): Tactic[Unit]
-
def
rewrite: RewriteTactic
Rewrites the formula specified by target using (possibly universally quantified) equations.
Rewrites the formula specified by target using (possibly universally quantified) equations.
rewrite.many ltr "equation1" in "target" rewrite.many ltr ("equation1", "eq2") rtl ("eq3", "eq4") in "target" subst (hov"x" -> le"f(f(c))")
ltr
: rewrite left-to-right using this equationrtl
: rewrite right-to-left using this equationmany
: rewrite as long as possible (default is to only rewrite once) - def simp(implicit ctx: Context): SimpTactic
-
def
skip: Tactic[Unit]
Does nothing.
- def subst(hyps: String*): Tactic[Unit]
- def subst1(hyp: String): SubstTactic
- def subst1: SubstTactic
- def substAll: Tactic[Unit]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
theory(implicit ctx: Context): Tactic[Unit]
Declares the current subgoal as a theory axiom, i.e.
Declares the current subgoal as a theory axiom, i.e. a sequent that is contained in the background theory. This closes the goal.
- ctx
A Context. The current subgoal must be contained in its background theory.
-
def
toString(): String
- Definition Classes
- AnyRef → Any
- def trace(implicit sig: BabelSignature): Tactic[Unit]
- def treeGrammarInduction(implicit ctx: Context): TreeGrammarInductionTactic
-
def
trivial: Tactic[Unit]
Attempts to apply the tactics
axiomTop
,axiomBot
,axiomRefl
, andaxiomLog
. -
def
unfold(definitions: String*)(implicit ctx: Context): UnfoldTacticHelper
Replaces a defined constant with its definition.
Replaces a defined constant with its definition. Syntax:
unfold("def1", "def2",...,"defn") in ("label1", "label2",...,"labelk")
NB: This will only replace the first definition it finds in each supplied formula. If you want to unfold all definitions, use
repeat
.- definitions
The definitions
def1
,...,defn
.- ctx
A Context. The definitions you want to unfold need to be present in
ctx
.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
→[B](y: B): (TacticCommands, B)
- Implicit
- This member is added by an implicit conversion from TacticCommands to ArrowAssoc[TacticCommands] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
-
object
currentGoal extends Tactical1[OpenAssumption] with Product with Serializable
Retrieves the current subgoal.
This is the API documentation for GAPT.
The main package is gapt.