michael/lean2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(doc/lean): include lean documentation scripts in the test set

Browse source 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura 2014-01-05 13:16:47 -08:00
parent 4ba097a141
commit 9d6bd7501c
3 changed files with 51 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
doc/lean/calc.md
View file

@ -25,13 +25,13 @@ in `<expr>_{i-1}`.
Here is an example Here is an example
```lean ```lean
Variables a b c d e : Nat. variables a b c d e : Nat.
Axiom Ax1 : a = b. axiom Ax1 : a = b.
Axiom Ax2 : b = c + 1. axiom Ax2 : b = c + 1.
Axiom Ax3 : c = d. axiom Ax3 : c = d.
Axiom Ax4 : e = 1 + d. axiom Ax4 : e = 1 + d.
Theorem T : a = e theorem T : a = e
:= calc a = b : Ax1 := calc a = b : Ax1
... = c + 1 : Ax2 ... = c + 1 : Ax2
... = d + 1 : { Ax3 } ... = d + 1 : { Ax3 }
@ -49,7 +49,7 @@ gaps in our calculational proofs. In the previous examples, we can use `_` as ar
Here is the same example using placeholders. Here is the same example using placeholders.
```lean ```lean
Theorem T' : a = e theorem T' : a = e
:= calc a = b : Ax1 := calc a = b : Ax1
... = c + 1 : Ax2 ... = c + 1 : Ax2
... = d + 1 : { Ax3 } ... = d + 1 : { Ax3 }
@ -61,7 +61,7 @@ We can also use the operators `=>`, `⇒`, `<=>`, `⇔` and `≠` in calculation
Here is an example. Here is an example.
```lean ```lean
Theorem T2 (a b c : Nat) (H1 : a = b) (H2 : b = c + 1) : a ≠ 0 theorem T2 (a b c : Nat) (H1 : a = b) (H2 : b = c + 1) : a ≠ 0
:= calc a = b : H1 := calc a = b : H1
... = c + 1 : H2 ... = c + 1 : H2
... ≠ 0 : Nat::SuccNeZero _. ... ≠ 0 : Nat::SuccNeZero _.
@ -70,11 +70,11 @@ Here is an example.
The Lean `let` construct can also be used to build calculational-like proofs. The Lean `let` construct can also be used to build calculational-like proofs.
```lean ```lean
Variable P : Nat → Nat → Bool. variable P : Nat → Nat → Bool.
Variable f : Nat → Nat. variable f : Nat → Nat.
Axiom Axf (a : Nat) : f (f a) = a. axiom Axf (a : Nat) : f (f a) = a.
Theorem T3 (a b : Nat) (H : P (f (f (f (f a)))) (f (f b))) : P a b theorem T3 (a b : Nat) (H : P (f (f (f (f a)))) (f (f b))) : P a b
:= let s1 : P (f (f a)) (f (f b)) := Subst H (Axf a), := let s1 : P (f (f a)) (f (f b)) := Subst H (Axf a),
s2 : P a (f (f b)) := Subst s1 (Axf a), s2 : P a (f (f b)) := Subst s1 (Axf a),
s3 : P a b := Subst s2 (Axf b) s3 : P a b := Subst s2 (Axf b)

69
doc/lean/expr.md
View file

@ -13,56 +13,47 @@ and _Types_.
## Constants ## Constants
Constants are essentially references to variable declarations, definitions, axioms and theorems in the Constants are essentially references to variable declarations, definitions, axioms and theorems in the
environment. In the following example, we use the command `Variables` to declare `x` and `y` as integers. environment. In the following example, we use the command `variables` to declare `x` and `y` as integers.
The `Check` command displays the type of the given expression. The `x` and `y` in the `Check` command The `check` command displays the type of the given expression. The `x` and `y` in the `check` command
are constants. They reference the objects declared using the command `Variables`. are constants. They reference the objects declared using the command `variables`.
```lean ```lean
Variables x y : Int. variables x y : Nat
Check x + y. check x + y
``` ```
In the following example, we define the constant `s` as the sum of `x` and `y` using the `Definition` command. In the following example, we define the constant `s` as the sum of `x` and `y` using the `definition` command.
The `Eval` command evaluates (normalizes) the expression `s + 1`. In this example, `Eval` will just expand The `eval` command evaluates (normalizes) the expression `s + 1`. In this example, `eval` will just expand
the definition of `s`, and return `x + y + 1`. the definition of `s`, and return `x + y + 1`.
```lean ```lean
Definition s := x + y. definition s := x + y
Eval s + 1. eval s + 1
``` ```
## Function applications ## Function applications
In Lean, the expression `f t` is a function application, where `f` is a function that is applied to `t`. In Lean, the expression `f t` is a function application, where `f` is a function that is applied to `t`.
In the following example, we define the function `max`. The `Eval` command evaluates the application `max 1 2`, In the following example, we define the function `max`. The `eval` command evaluates the application `max 1 2`,
and returns the value `2`. Note that, the expression `if (x >= y) x y` is also a function application. and returns the value `2`. Note that, the expression `if (x >= y) x y` is also a function application.
```lean ```lean
Definition max (x y : Int) : Int := if (x >= y) x y. definition max (x y : Nat) : Nat := if (x >= y) x y
Eval max 1 2. eval max 1 2
``` ```
The expression `max 1` is also a valid expression in Lean, and it has type `Int -> Int`. The expression `max 1` is also a valid expression in Lean, and it has type `Nat -> Nat`.
```lean ```lean
Check max 1. check max 1
```
Remark: we can make the expression `if (x >= y) x y` more "user-friendly" by using custom "Notation".
The following `Notation` command defines the usual `if-then-else` expression. The value `40` is the precedence
of the new notation.
```lean
Notation 40 if _ then _ else _ : if
Check if x >= y then x else y.
``` ```
In the following command, we define the function `inc`, and evaluate some expressions using `inc` and `max`. In the following command, we define the function `inc`, and evaluate some expressions using `inc` and `max`.
```lean ```lean
Definition inc (x : Int) : Int := x + 1. definition inc (x : Nat) : Nat := x + 1
Eval inc (inc (inc 2)). eval inc (inc (inc 2))
Eval max (inc 2) 2 = 3. eval max (inc 2) 2 = 3
``` ```
## Heterogeneous equality ## Heterogeneous equality
@ -74,14 +65,14 @@ The expression `t == s` is a heterogenous equality that is true iff `t` and `s`
In the following example, we evaluate the expressions `1 == 2` and `2 == 2`. The first evaluates to `false` and the second to `true`. In the following example, we evaluate the expressions `1 == 2` and `2 == 2`. The first evaluates to `false` and the second to `true`.
```lean ```lean
Eval 1 == 2. eval 1 == 2
Eval 2 == 2. eval 2 == 2
``` ```
Since we can compare elements of different types, the following expression is type correct and evaluates to `false`. Since we can compare elements of different types, the following expression is type correct and evaluates to `false`.
```lean ```lean
Eval 1 == true. eval 1 == true
``` ```
This is consistent with the set theoretic semantics used in Lean, where the interpretation of all expressions are sets. This is consistent with the set theoretic semantics used in Lean, where the interpretation of all expressions are sets.
@ -93,21 +84,21 @@ It expects `t` and `s` to have the same type. Thus, the expression `1 = true` is
The symbol `=` is just notation. Internally, homogeneous equality is defined as: The symbol `=` is just notation. Internally, homogeneous equality is defined as:
``` ```
Definition eq {A : (Type U)} (x y : A) : Bool := x == y. definition eq {A : (Type U)} (x y : A) : Bool := x == y
Infix 50 = : eq. infix 50 = : eq
``` ```
The curly braces indicate that the first argument of `eq` is implicit. The symbol `=` is just a syntax sugar for `eq`. The curly braces indicate that the first argument of `eq` is implicit. The symbol `=` is just a syntax sugar for `eq`.
In the following example, we use the `SetOption` command to force Lean to display implicit arguments and In the following example, we use the `setoption` command to force Lean to display implicit arguments and
disable notation when pretty printing expressions. disable notation when pretty printing expressions.
```lean ```lean
SetOption pp::implicit true. setoption pp::implicit true
SetOption pp::notation false. setoption pp::notation false
Check 1 = 2. check 1 = 2
(* restore default configuration *) -- restore default configuration
SetOption pp::implicit false. setoption pp::implicit false
SetOption pp::notation true. setoption pp::notation true
Check 1 = 2. check 1 = 2
``` ```

9
src/shell/CMakeLists.txt
View file

@ -76,6 +76,15 @@ FOREACH(T ${LEANLUATESTS})
COMMAND "./test_single.sh" "${CMAKE_CURRENT_BINARY_DIR}/lean" ${T}) COMMAND "./test_single.sh" "${CMAKE_CURRENT_BINARY_DIR}/lean" ${T})
ENDFOREACH(T) ENDFOREACH(T)
# LEAN DOCS
file(GLOB LEANDOCS "${LEAN_SOURCE_DIR}/../doc/lean/*.md")
FOREACH(T ${LEANDOCS})
GET_FILENAME_COMPONENT(T_NAME ${T} NAME)
add_test(NAME "leandoc_${T_NAME}"
WORKING_DIRECTORY "${LEAN_SOURCE_DIR}/../doc/lean"
COMMAND "./test_single.sh" "${CMAKE_CURRENT_BINARY_DIR}/lean" ${T})
ENDFOREACH(T)
# LEAN LUA DOCS # LEAN LUA DOCS
file(GLOB LEANLUADOCS "${LEAN_SOURCE_DIR}/../doc/lua/*.md") file(GLOB LEANLUADOCS "${LEAN_SOURCE_DIR}/../doc/lua/*.md")
FOREACH(T ${LEANLUADOCS}) FOREACH(T ${LEANLUADOCS})