| /- |
| Copyright (c) 2022 Mario Carneiro. All rights reserved. |
| Released under Apache 2.0 license as described in the file LICENSE. |
| Authors: Mario Carneiro, Heather Macbeth |
| -/ |
| import Library.Theory.ModEq.Lemmas |
|
|
| /-! # `mod_cases` tactic |
|
|
| The `mod_cases` tactic does case disjunction on `e % n`, where `e : ℤ`, to yield a number of |
| subgoals in which `e ≡ 0 [ZMOD n]`, ..., `e ≡ n-1 [ZMOD n]` are assumed. |
| -/ |
|
|
| namespace Mathlib.Tactic.ModCases |
| open Lean Meta Elab Tactic Term Qq Int |
|
|
| / |
| `OnModCases n a lb p` represents a partial proof by cases that |
| there exists `0 ≤ z < n` such that `a ≡ z (mod n)`. |
| It asserts that if `∃ z, lb ≤ z < n ∧ a ≡ z (mod n)` holds, then `p` |
| (where `p` is the current goal). |
| -/ |
| def OnModCases (n : ℕ) (a : ℤ) (lb : ℕ) (p : Sort _) := |
| ∀ z, lb ≤ z ∧ z < n ∧ a ≡ ↑z [ZMOD ↑n] → p |
|
|
| / |
| The first theorem we apply says that `∃ z, 0 ≤ z < n ∧ a ≡ z (mod n)`. |
| The actual mathematical content of the proof is here. |
| -/ |
| @[inline] def onModCases_start (p : Sort _) (a : ℤ) (n : ℕ) (hn : Nat.ble 1 n = true) |
| (H : OnModCases n a (nat_lit 0) p) : p := by |
| refine H (a % ↑n).toNat ?_ |
| have := ofNat_pos.2 <| Nat.le_of_ble_eq_true hn |
| have nonneg := emod_nonneg a <| Int.ne_of_gt this |
| refine ⟨Nat.zero_le _, ?_, ?_⟩ |
| · rw [Int.toNat_lt nonneg]; exact Int.emod_lt_of_pos _ this |
| · rw [Int.ModEq, Int.toNat_of_nonneg nonneg] |
| exact ⟨a / n, by linear_combination - a.emod_add_ediv n⟩ |
|
|
| / |
| The end point is that once we have reduced to `∃ z, n ≤ z < n ∧ a ≡ z (mod n)` |
| there are no more cases to consider. |
| -/ |
| @[inline] def onModCases_stop (p : Sort _) (n : ℕ) (a : ℤ) : OnModCases n a n p := |
| fun _ h => (Nat.not_lt.2 h.1 h.2.1).elim |
|
|
| / |
| The successor case decomposes `∃ z, b ≤ z < n ∧ a ≡ z (mod n)` into |
| `a ≡ b (mod n) ∨ ∃ z, b+1 ≤ z < n ∧ a ≡ z (mod n)`, |
| and the `a ≡ b (mod n) → p` case becomes a subgoal. |
| -/ |
| @[inline] def onModCases_succ {p : Sort _} {n : ℕ} {a : ℤ} (b : ℕ) |
| (h : a ≡ OfNat.ofNat b [ZMOD OfNat.ofNat n] → p) (H : OnModCases n a (Nat.add b 1) p) : |
| OnModCases n a b p := |
| fun z ⟨h₁, h₂⟩ => if e : b = z then h (e ▸ h₂.2) else H _ ⟨Nat.lt_of_le_of_ne h₁ e, h₂⟩ |
|
|
| / |
| Proves an expression of the form `OnModCases n a b p` where `n` and `b` are raw nat literals |
| and `b ≤ n`. Returns the list of subgoals `?gi : a ≡ i [ZMOD n] → p`. |
| -/ |
| partial def proveOnModCases (n : Q(ℕ)) (a : Q(ℤ)) (b : Q(ℕ)) (p : Q(Sort u)) : |
| MetaM (Q(OnModCases $n $a $b $p) × List MVarId) := do |
| if n.natLit! ≤ b.natLit! then |
| pure ((q(onModCases_stop $p $n $a) : Expr), []) |
| else |
| let ty := q($a ≡ OfNat.ofNat $b [ZMOD OfNat.ofNat $n] → $p) |
| let g : QQ ty ← mkFreshExprMVar ty |
| let ((pr : Q(OnModCases $n $a (Nat.add $b 1) $p)), acc) ← |
| proveOnModCases n a (mkRawNatLit (b.natLit! + 1)) p |
| pure ((q(onModCases_succ $b $g $pr) : Expr), g.mvarId! :: acc) |
|
|
| / |
| * The tactic `mod_cases h : e % 3` will perform a case disjunction on `e : ℤ` and yield subgoals |
| containing the assumptions `h : e ≡ 0 [ZMOD 3]`, `h : e ≡ 1 [ZMOD 3]`, `h : e ≡ 2 [ZMOD 3]` |
| respectively. |
| * In general, `mod_cases h : e % n` works |
| when `n` is a positive numeral and `e` is an expression of type `ℤ`. |
| * If `h` is omitted as in `mod_cases e % n`, it will be default-named `H`. |
| -/ |
| syntax "mod_cases " (atomic(binderIdent ":"))? term:71 " % " num : tactic |
|
|
| elab_rules : tactic |
| | `(tactic| mod_cases $[$h :]? $e % $n) => do |
| let n := n.getNat |
| if n == 0 then Elab.throwUnsupportedSyntax |
| let g ← getMainGoal |
| g.withContext do |
| let ⟨u, p, g⟩ ← inferTypeQ (.mvar g) |
| let e : Q(ℤ) ← Tactic.elabTermEnsuringType e q(ℤ) |
| let h := h.getD (← `(binderIdent| _)) |
| have lit : Q(ℕ) := mkRawNatLit n |
| let p₁ : Q(Nat.ble 1 $lit = true) := (q(Eq.refl true) : Expr) |
| let (p₂, gs) ← proveOnModCases lit e (mkRawNatLit 0) p |
| let gs ← gs.mapM fun g => do |
| let (fvar, g) ← match h with |
| | `(binderIdent| $n:ident) => g.intro n.getId |
| | _ => g.intro `H |
| g.withContext <| (Expr.fvar fvar).addLocalVarInfoForBinderIdent h |
| pure g |
| g.mvarId!.assign q(onModCases_start $p $e $lit $p₁ $p₂) |
| replaceMainGoal gs |
|
|
