Datasets:
File size: 5,111 Bytes
d03762b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | import Library.Theory.ModEq.Defs
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Linarith
open Lean hiding Rat mkRat
open Lean.Meta Qq Lean.Elab Term
open Lean.Parser.Tactic Mathlib.Meta.NormNum
namespace Mathlib.Meta.NormNum
theorem isInt_ModEq_true : {a b a' b' n : ℤ} → IsInt a a' → IsInt b b' → decide (a' = b') = true →
Int.ModEq n a b
| _, _, a', b', n, ⟨rfl⟩, ⟨rfl⟩, hab =>
by
dsimp
replace hab := of_decide_eq_true hab
rw [hab]
use 0
ring
theorem isInt_ModEq_false : {a b a' b' n : ℤ} → IsInt a a' → IsInt b b' → decide (0 < n) = true →
decide (a' < n) = true → decide (b' < n) = true → decide (0 ≤ a') = true →
decide (0 ≤ b') = true → decide (a' ≠ b') = true → ¬ Int.ModEq n a b
| _, _, a', b', n, ⟨rfl⟩, ⟨rfl⟩, hn, han, hbn, ha, hb, hab =>
by
dsimp
change ¬ n ∣ _
replace hn := of_decide_eq_true hn
replace han := of_decide_eq_true han
replace hbn := of_decide_eq_true hbn
replace ha := of_decide_eq_true ha
replace hb := of_decide_eq_true hb
replace hab := of_decide_eq_true hab
rw [← Int.exists_lt_and_lt_iff_not_dvd _ hn]
cases' lt_or_gt_of_ne hab with hab hab
· exact ⟨-1, by linarith, by linarith⟩
· exact ⟨0, by linarith, by linarith⟩
end Mathlib.Meta.NormNum
/-- The `norm_num` extension which identifies expressions of the form `a ≡ b [ZMOD n]`,
such that `norm_num` successfully recognises both `a` and `b` and they are small compared to `n`. -/
@[norm_num Int.ModEq _ _ _] def evalModEq : NormNumExt where eval (e : Q(Prop)) := do
let .app (.app (.app f (n : Q(ℤ))) (a : Q(ℤ))) (b : Q(ℤ)) ← whnfR e | failure
guard <|← withNewMCtxDepth <| isDefEq f q(Int.ModEq)
let ra : Result a ← derive a
let rb : Result b ← derive b
let rn : Result q($n) ← derive n
let i : Q(Ring ℤ) := q(Int.instRingInt)
let ⟨za, na, pa⟩ ← ra.toInt
let ⟨zb, nb, pb⟩ ← rb.toInt
let ⟨zn, _, _⟩ ← rn.toInt i
if za = zb then
-- reduce `a ≡ b [ZMOD n]` to `true` if `a` and `b` reduce to the same integer
let pab : Q(decide ($na = $nb) = true) := (q(Eq.refl true) : Expr)
let r : Q(Int.ModEq $n $a $b) := q(isInt_ModEq_true $pa $pb $pab)
return (.isTrue r : Result q(Int.ModEq $n $a $b))
else
-- reduce `a ≡ b [ZMOD n]` to `false` if `0 < n`, `a` reduces to `a'` with `0 ≤ a' < n`,
-- and `b` reduces to `b'` with `0 ≤ b' < n`
let pab : Q(decide ($na ≠ $nb) = true) := (q(Eq.refl true) : Expr)
if zn = 0 then failure
let pn : Q(decide (0 < $n) = true) := (q(Eq.refl true) : Expr)
if zn ≤ za then failure
let pan : Q(decide ($na < $n) = true) := (q(Eq.refl true) : Expr)
if zn ≤ zb then failure
let pbn : Q(decide ($nb < $n) = true) := (q(Eq.refl true) : Expr)
if za < 0 then failure
let pa0 : Q(decide (0 ≤ $na) = true) := (q(Eq.refl true) : Expr)
if zb < 0 then failure
let pb0 : Q(decide (0 ≤ $nb) = true) := (q(Eq.refl true) : Expr)
let r : Q(¬Int.ModEq $n $a $b) := q(isInt_ModEq_false $pa $pb $pn $pan $pbn $pa0 $pb0 $pab)
return (.isFalse r : Result q(¬Int.ModEq $n $a $b))
/--
Normalize numerical expressions. Supports the operations `+` `-` `*` `/` `⁻¹` and `^`
over numerical types such as `ℕ`, `ℤ`, `ℚ`, `ℝ`, `ℂ` and some general algebraic types,
and can prove goals of the form `A = B`, `A ≠ B`, `A < B` and `A ≤ B`, where `A` and `B` are
numerical expressions.
-/
elab (name := numbers) "numbers" loc:(location ?) : tactic =>
elabNormNum mkNullNode loc (simpOnly := true) (useSimp := false)
theorem Prod.ne_left {a1 a2 : A} {b1 b2 : B} : a1 ≠ a2 → (a1, b1) ≠ (a2, b2) := mt <| by
rw [Prod.mk.inj_iff]
exact And.left
theorem Prod.ne_right {a1 a2 : A} {b1 b2 : B} : b1 ≠ b2 → (a1, b1) ≠ (a2, b2) := mt <| by
rw [Prod.mk.inj_iff]
exact And.right
theorem Prod.ne_left_right {a1 a2 : A} {b1 b2 : B} {c1 c2 : C} (h : b1 ≠ b2) :
(a1, b1, c1) ≠ (a2, b2, c2) :=
Prod.ne_right <| Prod.ne_left h
theorem Prod.ne_right_right {a1 a2 : A} {b1 b2 : B} {c1 c2 : C} (h : c1 ≠ c2) :
(a1, b1, c1) ≠ (a2, b2, c2) :=
Prod.ne_right <| Prod.ne_right h
macro_rules | `(tactic| numbers) => `(tactic| apply Prod.ext <;> numbers)
macro_rules | `(tactic| numbers) => `(tactic| apply Prod.ne_left ; numbers)
macro_rules | `(tactic| numbers) => `(tactic| apply Prod.ne_right ; numbers)
macro_rules | `(tactic| numbers) => `(tactic| apply Prod.ne_left_right ; numbers)
macro_rules | `(tactic| numbers) => `(tactic| apply Prod.ne_right_right ; numbers)
macro (name := normNumCmd) "#numbers" ppSpace e:term : command =>
`(command| #conv norm_num1 => $e)
open Tactic
@[inherit_doc numbers] syntax (name := numbersConv) "numbers" : conv
/-- Elaborator for `numbers` conv tactic. -/
@[tactic numbersConv] def elabNormNum1Conv : Tactic := fun _ ↦ withMainContext do
let ctx ← getSimpContext mkNullNode true
Conv.applySimpResult (← deriveSimp ctx (← instantiateMVars (← Conv.getLhs)) (useSimp := false))
|