13 1.4 Lemma Statements 16 1.5 Summary of New Lean Constructs 18 2 Backward Proofs 21 2.1 Tactic Mode 22 2.2 Basic Tactics 23 2.3 Reasoning about Connectives and Quantifiers 26 2.4 Reasoning Equality 29 2.5 Rewriting Tactics 30 2.6 Proofs by Mathematical Induction 31 2.7 Induction Tactic 33 2.8 Cleanup Tactics 33 2.9 Summary of New Lean Constructs 34 3 Forward Proofs 35 3.1 Structured Introductory Examples 75 5.2 Logical Symbols 81 5.3 Rule Induction 82 5.4 Linear Arithmetic Tactic 85 5.5 Elimination 85 5.6 Further Examples 87 5.7 Summary of New Lean Constructs 91 6

The IO monad 29 4.5 Related type classes 29 5 Writing Tactics 31 5.1 A First Look at the Tactic Monad 31 5.2 Names and Expressions 34 5.3 Examples 39 5.4 Reduction 40 5.5 Metavariables a_{0} $ , and b otherwise. ## WRITING TACTICS ### 5.1 A First Look at the Tactic Monad The canonical way to invoke a tactic in Lean is to use the by keyword within a Lean expression. Suppose we write \rightarrow $ a $ \land $ b := by _ Lean expects something of type tactic unit to fill the underscore, where tactic refers to the tactic monad. When the elaborator processes this definition, it elaborates

Tactics .45 6.1 Tactic Mode .45 6.2 Basic Tactics .46 6.3 Equality and Other Relations .49 6.4 Structured Tactic Proofs .49 6.5 Inductive Types .50 6.6 Tactic Combinators .53 up a message window which shows you error messages, warnings, output, and goal information when in tactic mode. Typing an underscore in an expression asks Lean to infer a suitable value for the expression 25 or later, you can then press M-, to go back to the original location. In tactic mode, if you put your cursor on a tactic (or the keyword begin or end) and type C-c C-g, Emacs will show you the goal

Proof Language 4.6 Exercises 5 Tactics 5.1 Entering Tactic Mode 5.2 Basic Tactics 5.3 More Tactics 5.4 Structuring Tactic Proofs 5.5 Tactic Combinators ..... 68 5.6 Rewriting ..... 70 5.7 Using variables that only appear in a tactic command or block are not automatically added to the context. The include command takes care of that. Essentially, the rewrite tactic uses a given equality (which can complex term) to "rewrite" the goal. If doing so reduces the goal to an identity t = t, the tactic applies reflexivity to prove it. Rewrites can be applied sequentially, so that the proof above can

definition when fully applied recursor : user-defined precursor/eliminator, used for the induction tactic recursor : user-defined non-dependent precursor/eliminator where is the position of the hidden name. ## Tactic Mode At any point in a proof or definition you can switch to tactic mode and apply tactics to finish that part of the proof or definition. begin ... end : enter tactic mode, and blocking blocking mechanism within tactic mode { ... } : blocking mechanism within tactic mode by ... : enter tactic mode, can only execute a single tactic begin+; by+ : same as =begin= and =by=, but make local

instructions, or procedures, that tell Lean how to construct the requisite expression. Here is a tactic-style proof of the theorem above: theorem even_add : ∀ m n, even m → even n → even (n + m) := begin that will assist in the verification of programs and the construction of proofs as well. It is the tactic framework that serves as a gateway to the use of automation. Lean provides means of implementing searches through two lists of expressions, assumed to be hypotheses available in the context of a tactic proof, in search of a pair of the form $ h_{1}:p $ and $ h_{2}:p $ . When it finds such a pair

the rewrite: sym : l = r -> r = l sym Refl = Refl We can complete this proof using the trivial tactic, which finds value in the premises. The proof of the second lemma proceeds in exactly the same way is: views.parity_lemma_2 = proof { intro; intro; exact believe_me value; } The exact tactic allows us to provide an exact value for the proof. In this case, we assert that the value we gave to direct the construction of the proof. In this case, we can normalise the goal with the compute tactic: -plusredZ_Z> compute (plusredZ_Z) ----- {hole0} : Z = Z Now we have to prove that Z equals

of the rewrite: sym : l = r -> r = l sym Refl = Refl We can complete this proof using the trivial tactic, which finds value in the premises. The proof of the second lemma proceeds in exactly the same way parity_lemma_1 using this is: views.parity_lemma_2 = proof { intro; intro; exact believe_me value; } The exact tactic allows us to provide an exact value for the proof. In this case, we assert that the value we gave to direct the construction of the proof. In this case, we can normalise the goal with the compute tactic: -plusredZ_Z> compute ---------------------------------- (plusredZ_Z) -------- {hole0} : Z = Z Now

the rewrite: sym : l = r -> r = l sym Refl = Refl We can complete this proof using the trivial tactic, which finds value in the premises. The proof of the second lemma proceeds in exactly the same way is: views.parity_lemma_2 = proof { intro; intro; exact believe_me value; } The exact tactic allows us to provide an exact value for the proof. In this case, we assert that the value we gave to direct the construction of the proof. In this case, we can normalise the goal with the compute tactic: -plusredZ_Z> compute (plusredZ_Z) {hole0} : Z = Z Now we have to prove that Z equals Z, which

the rewrite: sym : l = r -> r = l sym Refl = Refl We can complete this proof using the trivial tactic, which finds value in the premises. The proof of the second lemma proceeds in exactly the same way is: views.parity_lemma_2 = proof { intro; intro; exact believe_me value; } The exact tactic allows us to provide an exact value for the proof. In this case, we assert that the value we gave to direct the construction of the proof. In this case, we can normalise the goal with the compute tactic: -plusredZ_Z> compute (plusredZ_Z) ----- {hole0} : Z = Z Now we have to prove that Z equals