class DLBelleParser extends DLTacticParser
Bellerophon tactic parser for Differential Dynamic Logic reads input strings in the concrete syntax of
Bellerophon tactics for KeYmaera X. It uses tacticProvider
to map names and inputs to concrete tactic expressions.
- See also
- Alphabetic
- By Inheritance
- DLBelleParser
- DLTacticParser
- TacticParser
- Function1
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new DLBelleParser(printer: (BelleExpr) ⇒ String, tacticProvider: (String, List[Either[Seq[Any], PositionLocator]], Declaration) ⇒ BelleExpr)
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
andThen[A](g: (BelleExpr) ⇒ A): (String) ⇒ A
- Definition Classes
- Function1
- Annotations
- @unspecialized()
-
def
apply(input: String, defs: Declaration): BelleExpr
Parse the input string in the concrete syntax of Bellerophon tactics.
Parse the input string in the concrete syntax of Bellerophon tactics.
- input
the string to parse as a Bellerophon tactic.
- defs
the definitions to elaborate variables/functions/predicates to their expected type.
- Definition Classes
- DLBelleParser → TacticParser
-
final
def
apply(input: String): BelleExpr
Parse the input string in the concrete syntax of Bellerophon tactics.
Parse the input string in the concrete syntax of Bellerophon tactics.
- input
the string to parse as a Bellerophon tactic.
- Definition Classes
- TacticParser → Function1
- Exceptions thrown
ParseException
ifinput
is not a well-formed Bellerophon tactic.
- def argList[_, A](p: ⇒ P[A])(implicit arg0: P[Any]): P[List[A]]
- def argument[_](argInfo: ArgInfo)(implicit arg0: P[Any]): P[Seq[Any]]
- def argumentInterior[_](argInfo: ArgInfo)(implicit arg0: P[Any]): P[Seq[Any]]
- def argumentList[_](isStart: Boolean, args: List[ArgInfo], numPosArgs: Int)(implicit arg0: P[Any]): P[(List[Seq[Any]], List[PositionLocator])]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def at[_](implicit arg0: P[Any]): P[BelleExpr]
- def atomicTactic[_](implicit arg0: P[Any]): P[BelleExpr]
- def baseTac[_](implicit arg0: P[Any]): P[BelleExpr]
- def baseVariable[_](implicit arg0: P[Any]): P[BaseVariable]
-
val
belleParser: (String) ⇒ BelleExpr
Parse the input string in the concrete syntax as a differential dynamic logic expression
-
def
blank[_](implicit arg0: P[Any]): P[Unit]
Explicit nonempty whitespace terminal from expParser.
- def branchTac[_](implicit arg0: P[Any]): P[BelleExpr]
- def builtinTactic[_](implicit arg0: P[Any]): P[BelleExpr]
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
compose[A](g: (A) ⇒ String): (A) ⇒ BelleExpr
- Definition Classes
- Function1
- Annotations
- @unspecialized()
- def eitherTac[_](implicit arg0: P[Any]): P[BelleExpr]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def escapedPositionExpression[_](implicit arg0: P[Any]): P[(Expression, PosInExpr)]
- def escapedString[_](implicit arg0: P[Any]): P[String]
-
def
expression[_](implicit arg0: P[Any]): P[Expression]
expression: Parses a dL expression from expParser.
-
val
expressionParser: Parser
The expression parser for differential dynamic logic
The expression parser for differential dynamic logic
- Definition Classes
- DLBelleParser → TacticParser
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
formula[_](implicit arg0: P[Any]): P[Formula]
formula: Parses a dL formula from expParser.
- def fullTactic[_](implicit arg0: P[Any]): P[BelleExpr]
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
ident[_](implicit arg0: P[Any]): P[(String, Option[Int])]
parse an identifier from expParser
- def integer[_](implicit arg0: P[Any]): P[Int]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def locator[_](implicit arg0: P[Any]): P[PositionLocator]
- def natural[_](implicit arg0: P[Any]): P[Int]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
number[_](implicit arg0: P[Any]): P[Number]
parse a number literal from expParser
- def optionTac[_](implicit arg0: P[Any]): P[BelleExpr]
- def parenTac[_](implicit arg0: P[Any]): P[BelleExpr]
- def partialTac[_](implicit arg0: P[Any]): P[BelleExpr]
- def posInExpr[_](implicit arg0: P[Any]): P[PosInExpr]
- def position[_](implicit arg0: P[Any]): P[Position]
- def positionLocator[_](implicit arg0: P[Any]): P[PositionLocator]
-
val
printer: (BelleExpr) ⇒ String
A pretty-printer that can write the output that this parser reads
A pretty-printer that can write the output that this parser reads
- Definition Classes
- DLBelleParser → TacticParser
-
def
program[_](implicit arg0: P[Any]): P[Program]
program: Parses a dL program from expParser.
- def repTac[_](implicit arg0: P[Any]): P[BelleExpr]
- def searchLocator[_](implicit arg0: P[Any]): P[PositionLocator]
- def seqTac[_](implicit arg0: P[Any]): P[BelleExpr]
-
def
setDefTactics(defs: Map[String, DefTactic]): Unit
Sets the defined tactics to be used during parsing.
Sets the defined tactics to be used during parsing.
- Definition Classes
- DLBelleParser → DLTacticParser
-
def
setDefs(defs: Declaration): Unit
Sets the definitions to be used when parsing tactic expressions.
Sets the definitions to be used when parsing tactic expressions. Expected to be set before apply or tactic are used.
- Definition Classes
- DLBelleParser → DLTacticParser
- def shape[_](implicit arg0: P[Any]): P[(String, (Expression, PosInExpr))]
- def string[_](implicit arg0: P[Any]): P[String]
- def substPair[_](implicit arg0: P[Any]): P[SubstitutionPair]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tactic[_](implicit arg0: P[Any]): P[BelleExpr]
tactic: Parses a dL Bellerophon tactic.
tactic: Parses a dL Bellerophon tactic.
- Definition Classes
- DLBelleParser → DLTacticParser
-
val
tacticParser: (String) ⇒ BelleExpr
Parse the input string in the concrete syntax as a Bellerophon tactic
Parse the input string in the concrete syntax as a Bellerophon tactic
- Definition Classes
- DLBelleParser → TacticParser
- def tacticSymbol[_](implicit arg0: P[Any]): P[String]
-
def
term[_](doAmbigCuts: Boolean)(implicit arg0: P[Any]): P[Term]
term: Parses a dL term from expParser.
-
def
toString(): String
- Definition Classes
- Function1 → AnyRef → Any
- def usingTac[_](implicit arg0: P[Any]): P[BelleExpr]
-
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( ... )
KeYmaera X: An aXiomatic Tactical Theorem Prover
KeYmaera X is a theorem prover for differential dynamic logic (dL), a logic for specifying and verifying properties of hybrid systems with mixed discrete and continuous dynamics. Reasoning about complicated hybrid systems requires support for sophisticated proof techniques, efficient computation, and a user interface that crystallizes salient properties of the system. KeYmaera X allows users to specify custom proof search techniques as tactics, execute tactics in parallel, and interface with partial proofs via an extensible user interface.
http://keymaeraX.org/
Concrete syntax for input language Differential Dynamic Logic
Package Structure
Main documentation entry points for KeYmaera X API:
edu.cmu.cs.ls.keymaerax.core
- KeYmaera X kernel, proof certificates, main data structuresExpression
- Differential dynamic logic expressions:Term
,Formula
,Program
Sequent
- Sequents of formulasProvable
- Proof certificates transformed by rules/axiomsRule
- Proof rules as well asUSubstOne
for (one-pass) uniform substitutions and renaming.StaticSemantics
- Static semantics with free and bound variable analysisKeYmaeraXParser
.edu.cmu.cs.ls.keymaerax.parser
- Parser and pretty printer with concrete syntax and notation for differential dynamic logic.KeYmaeraXPrettyPrinter
- Pretty printer producing concrete KeYmaera X syntaxKeYmaeraXParser
- Parser reading concrete KeYmaera X syntaxKeYmaeraXArchiveParser
- Parser reading KeYmaera X model and proof archive.kyx
filesDLParser
- Combinator parser reading concrete KeYmaera X syntaxDLArchiveParser
- Combinator parser reading KeYmaera X model and proof archive.kyx
filesedu.cmu.cs.ls.keymaerax.infrastruct
- Prover infrastructure outside the kernelUnificationMatch
- Unification algorithmRenUSubst
- Renaming Uniform Substitution quickly combining kernel's renaming and substitution.Context
- Representation for contexts of formulas in which they occur.Augmentors
- Augmenting formula and expression data structures with additional functionalityExpressionTraversal
- Generic traversal functionality for expressionsedu.cmu.cs.ls.keymaerax.bellerophon
- Bellerophon tactic language and tactic interpreterBelleExpr
- Tactic language expressionsSequentialInterpreter
- Sequential tactic interpreter for Bellerophon tacticsedu.cmu.cs.ls.keymaerax.btactics
- Bellerophon tactic library for conducting proofs.TactixLibrary
- Main KeYmaera X tactic library including many proof tactics.HilbertCalculus
- Hilbert Calculus for differential dynamic logicSequentCalculus
- Sequent Calculus for propositional and first-order logicHybridProgramCalculus
- Hybrid Program Calculus for differential dynamic logicDifferentialEquationCalculus
- Differential Equation Calculus for differential dynamic logicUnifyUSCalculus
- Unification-based uniform substitution calculus underlying the other calculi[edu.cmu.cs.ls.keymaerax.btactics.UnifyUSCalculus.ForwardTactic ForwardTactic]
- Forward tactic framework for conducting proofs from premises to conclusionsedu.cmu.cs.ls.keymaerax.lemma
- Lemma mechanismLemma
- Lemmas are Provables stored under a name, e.g., in files.LemmaDB
- Lemma database stored in files or database etc.edu.cmu.cs.ls.keymaerax.tools.qe
- Real arithmetic back-end solversMathematicaQETool
- Mathematica interface for real arithmetic.Z3QETool
- Z3 interface for real arithmetic.edu.cmu.cs.ls.keymaerax.tools.ext
- Extended back-ends for noncritical ODE solving, counterexamples, algebra, simplifiers, etc.Mathematica
- Mathematica interface for ODE solving, algebra, simplification, invariant generation, etc.Z3
- Z3 interface for real arithmetic including simplifiers.Entry Points
Additional entry points and usage points for KeYmaera X API:
edu.cmu.cs.ls.keymaerax.launcher.KeYmaeraX
- Command-line launcher for KeYmaera X supports command-line argument-help
to obtain usage informationedu.cmu.cs.ls.keymaerax.btactics.AxIndex
- Axiom indexing data structures with keys and recursors for canonical proof strategies.edu.cmu.cs.ls.keymaerax.btactics.DerivationInfo
- Meta-information on all derivation steps (axioms, derived axioms, proof rules, tactics) with user-interface info.edu.cmu.cs.ls.keymaerax.bellerophon.UIIndex
- Index determining which canonical reasoning steps to display on the KeYmaera X User Interface.edu.cmu.cs.ls.keymaerax.btactics.Ax
- Registry for derived axioms and axiomatic proof rules that are proved from the core.References
Full references on KeYmaera X are provided at http://keymaeraX.org/. The main references are the following:
1. André Platzer. A complete uniform substitution calculus for differential dynamic logic. Journal of Automated Reasoning, 59(2), pp. 219-265, 2017.
2. Nathan Fulton, Stefan Mitsch, Jan-David Quesel, Marcus Völp and André Platzer. KeYmaera X: An axiomatic tactical theorem prover for hybrid systems. In Amy P. Felty and Aart Middeldorp, editors, International Conference on Automated Deduction, CADE'15, Berlin, Germany, Proceedings, volume 9195 of LNCS, pp. 527-538. Springer, 2015.
3. André Platzer. Logical Foundations of Cyber-Physical Systems. Springer, 2018. Videos