PR contents

(last sync)

feat(data/int/units): If z * w = 1, then z = w (#18499)

This PR adds a lemma stating that if z * w = 1, then z = w.

mathlib4 PR: https://github.com/leanprover-community/mathlib4/pull/2497

Diff

@@ -57,6 +57,9 @@ begin
   tauto,
 end
 
+theorem eq_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = w :=
+(eq_one_or_neg_one_of_mul_eq_one' h).elim (λ h, h.1.trans h.2.symm) (λ h, h.1.trans h.2.symm)
+
 lemma mul_eq_one_iff_eq_one_or_neg_one {z w : ℤ} :
   z * w = 1 ↔ z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 :=
 begin

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-25-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

ad7a2212

Diff

@@ -59,7 +59,7 @@ theorem isUnit_eq_or_eq_neg {a b : ℤ} (ha : IsUnit a) (hb : IsUnit b) : a = b
   by
   rcases is_unit_eq_one_or hb with (rfl | rfl)
   · exact is_unit_eq_one_or ha
-  · rwa [or_comm', neg_neg, ← is_unit_iff]
+  · rwa [or_comm, neg_neg, ← is_unit_iff]
 #align int.is_unit_eq_or_eq_neg Int.isUnit_eq_or_eq_neg
 -/

bump to nightly-2024-04-09-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

659ec6f7

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad
 -/
 import Data.Nat.Units
-import Data.Int.Basic
+import Algebra.Group.Int
 import Algebra.Ring.Units
 
 #align_import data.int.units from "leanprover-community/mathlib"@"45a1ada01ed893722d0f8d15b9e44270996515d5"

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -141,7 +141,7 @@ theorem isUnit_mul_self {a : ℤ} (ha : IsUnit a) : a * a = 1 :=
 theorem isUnit_add_isUnit_eq_isUnit_add_isUnit {a b c d : ℤ} (ha : IsUnit a) (hb : IsUnit b)
     (hc : IsUnit c) (hd : IsUnit d) : a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c :=
   by
-  rw [is_unit_iff] at ha hb hc hd 
+  rw [is_unit_iff] at ha hb hc hd
   cases ha <;> cases hb <;> cases hc <;> cases hd <;> subst ha <;> subst hb <;> subst hc <;>
       subst hd <;>
     tidy

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad
 -/
-import Mathbin.Data.Nat.Units
-import Mathbin.Data.Int.Basic
-import Mathbin.Algebra.Ring.Units
+import Data.Nat.Units
+import Data.Int.Basic
+import Algebra.Ring.Units
 
 #align_import data.int.units from "leanprover-community/mathlib"@"45a1ada01ed893722d0f8d15b9e44270996515d5"

bump to nightly-2023-08-23-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

f612b9e0

Diff

@@ -121,7 +121,7 @@ theorem isUnit_iff_natAbs_eq {n : ℤ} : IsUnit n ↔ n.natAbs = 1 := by
 #align int.is_unit_iff_nat_abs_eq Int.isUnit_iff_natAbs_eq
 -/
 
-alias is_unit_iff_nat_abs_eq ↔ is_unit.nat_abs_eq _
+alias ⟨is_unit.nat_abs_eq, _⟩ := is_unit_iff_nat_abs_eq
 #align int.is_unit.nat_abs_eq Int.IsUnit.natAbs_eq
 
 #print Int.ofNat_isUnit /-

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad
-
-! This file was ported from Lean 3 source module data.int.units
-! leanprover-community/mathlib commit 45a1ada01ed893722d0f8d15b9e44270996515d5
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Nat.Units
 import Mathbin.Data.Int.Basic
 import Mathbin.Algebra.Ring.Units
 
+#align_import data.int.units from "leanprover-community/mathlib"@"45a1ada01ed893722d0f8d15b9e44270996515d5"
+
 /-!
 # Lemmas about units in `ℤ`.

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -25,6 +25,7 @@ namespace Int
 /-! ### units -/
 
 
+#print Int.units_natAbs /-
 @[simp]
 theorem units_natAbs (u : ℤˣ) : natAbs u = 1 :=
   Units.ext_iff.1 <|
@@ -32,15 +33,21 @@ theorem units_natAbs (u : ℤˣ) : natAbs u = 1 :=
       ⟨natAbs u, natAbs ↑u⁻¹, by rw [← nat_abs_mul, Units.mul_inv] <;> rfl, by
         rw [← nat_abs_mul, Units.inv_mul] <;> rfl⟩
 #align int.units_nat_abs Int.units_natAbs
+-/
 
+#print Int.units_eq_one_or /-
 theorem units_eq_one_or (u : ℤˣ) : u = 1 ∨ u = -1 := by
   simpa only [Units.ext_iff, units_nat_abs] using nat_abs_eq u
 #align int.units_eq_one_or Int.units_eq_one_or
+-/
 
+#print Int.isUnit_eq_one_or /-
 theorem isUnit_eq_one_or {a : ℤ} : IsUnit a → a = 1 ∨ a = -1
   | ⟨x, hx⟩ => hx ▸ (units_eq_one_or _).imp (congr_arg coe) (congr_arg coe)
 #align int.is_unit_eq_one_or Int.isUnit_eq_one_or
+-/
 
+#print Int.isUnit_iff /-
 theorem isUnit_iff {a : ℤ} : IsUnit a ↔ a = 1 ∨ a = -1 :=
   by
   refine' ⟨fun h => is_unit_eq_one_or h, fun h => _⟩
@@ -48,13 +55,16 @@ theorem isUnit_iff {a : ℤ} : IsUnit a ↔ a = 1 ∨ a = -1 :=
   · exact isUnit_one
   · exact is_unit_one.neg
 #align int.is_unit_iff Int.isUnit_iff
+-/
 
+#print Int.isUnit_eq_or_eq_neg /-
 theorem isUnit_eq_or_eq_neg {a b : ℤ} (ha : IsUnit a) (hb : IsUnit b) : a = b ∨ a = -b :=
   by
   rcases is_unit_eq_one_or hb with (rfl | rfl)
   · exact is_unit_eq_one_or ha
   · rwa [or_comm', neg_neg, ← is_unit_iff]
 #align int.is_unit_eq_or_eq_neg Int.isUnit_eq_or_eq_neg
+-/
 
 #print Int.eq_one_or_neg_one_of_mul_eq_one /-
 theorem eq_one_or_neg_one_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = 1 ∨ z = -1 :=
@@ -108,22 +118,29 @@ theorem mul_eq_neg_one_iff_eq_one_or_neg_one {z w : ℤ} :
 #align int.mul_eq_neg_one_iff_eq_one_or_neg_one Int.mul_eq_neg_one_iff_eq_one_or_neg_one
 -/
 
+#print Int.isUnit_iff_natAbs_eq /-
 theorem isUnit_iff_natAbs_eq {n : ℤ} : IsUnit n ↔ n.natAbs = 1 := by
   simp [nat_abs_eq_iff, is_unit_iff, Nat.cast_zero]
 #align int.is_unit_iff_nat_abs_eq Int.isUnit_iff_natAbs_eq
+-/
 
 alias is_unit_iff_nat_abs_eq ↔ is_unit.nat_abs_eq _
 #align int.is_unit.nat_abs_eq Int.IsUnit.natAbs_eq
 
+#print Int.ofNat_isUnit /-
 @[norm_cast]
 theorem ofNat_isUnit {n : ℕ} : IsUnit (n : ℤ) ↔ IsUnit n := by
   rw [Nat.isUnit_iff, is_unit_iff_nat_abs_eq, nat_abs_of_nat]
 #align int.of_nat_is_unit Int.ofNat_isUnit
+-/
 
+#print Int.isUnit_mul_self /-
 theorem isUnit_mul_self {a : ℤ} (ha : IsUnit a) : a * a = 1 :=
   (isUnit_eq_one_or ha).elim (fun h => h.symm ▸ rfl) fun h => h.symm ▸ rfl
 #align int.is_unit_mul_self Int.isUnit_mul_self
+-/
 
+#print Int.isUnit_add_isUnit_eq_isUnit_add_isUnit /-
 theorem isUnit_add_isUnit_eq_isUnit_add_isUnit {a b c d : ℤ} (ha : IsUnit a) (hb : IsUnit b)
     (hc : IsUnit c) (hd : IsUnit d) : a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c :=
   by
@@ -132,6 +149,7 @@ theorem isUnit_add_isUnit_eq_isUnit_add_isUnit {a b c d : ℤ} (ha : IsUnit a) (
       subst hd <;>
     tidy
 #align int.is_unit_add_is_unit_eq_is_unit_add_is_unit Int.isUnit_add_isUnit_eq_isUnit_add_isUnit
+-/
 
 #print Int.eq_one_or_neg_one_of_mul_eq_neg_one /-
 theorem eq_one_or_neg_one_of_mul_eq_neg_one {z w : ℤ} (h : z * w = -1) : z = 1 ∨ z = -1 :=

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -127,7 +127,7 @@ theorem isUnit_mul_self {a : ℤ} (ha : IsUnit a) : a * a = 1 :=
 theorem isUnit_add_isUnit_eq_isUnit_add_isUnit {a b c d : ℤ} (ha : IsUnit a) (hb : IsUnit b)
     (hc : IsUnit c) (hd : IsUnit d) : a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c :=
   by
-  rw [is_unit_iff] at ha hb hc hd
+  rw [is_unit_iff] at ha hb hc hd 
   cases ha <;> cases hb <;> cases hc <;> cases hd <;> subst ha <;> subst hb <;> subst hc <;>
       subst hd <;>
     tidy

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -25,12 +25,6 @@ namespace Int
 /-! ### units -/
 
 
-/- warning: int.units_nat_abs -> Int.units_natAbs is a dubious translation:
-lean 3 declaration is
-  forall (u : Units.{0} Int Int.monoid), Eq.{1} Nat (Int.natAbs ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Units.{0} Int Int.monoid) Int (HasLiftT.mk.{1, 1} (Units.{0} Int Int.monoid) Int (CoeTCₓ.coe.{1, 1} (Units.{0} Int Int.monoid) Int (coeBase.{1, 1} (Units.{0} Int Int.monoid) Int (Units.hasCoe.{0} Int Int.monoid)))) u)) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))
-but is expected to have type
-  forall (u : Units.{0} Int Int.instMonoidInt), Eq.{1} Nat (Int.natAbs (Units.val.{0} Int Int.instMonoidInt u)) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))
-Case conversion may be inaccurate. Consider using '#align int.units_nat_abs Int.units_natAbsₓ'. -/
 @[simp]
 theorem units_natAbs (u : ℤˣ) : natAbs u = 1 :=
   Units.ext_iff.1 <|
@@ -39,32 +33,14 @@ theorem units_natAbs (u : ℤˣ) : natAbs u = 1 :=
         rw [← nat_abs_mul, Units.inv_mul] <;> rfl⟩
 #align int.units_nat_abs Int.units_natAbs
 
-/- warning: int.units_eq_one_or -> Int.units_eq_one_or is a dubious translation:
-lean 3 declaration is
-  forall (u : Units.{0} Int Int.monoid), Or (Eq.{1} (Units.{0} Int Int.monoid) u (OfNat.ofNat.{0} (Units.{0} Int Int.monoid) 1 (OfNat.mk.{0} (Units.{0} Int Int.monoid) 1 (One.one.{0} (Units.{0} Int Int.monoid) (MulOneClass.toHasOne.{0} (Units.{0} Int Int.monoid) (Units.mulOneClass.{0} Int Int.monoid)))))) (Eq.{1} (Units.{0} Int Int.monoid) u (Neg.neg.{0} (Units.{0} Int Int.monoid) (Units.hasNeg.{0} Int Int.monoid (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring)))) (OfNat.ofNat.{0} (Units.{0} Int Int.monoid) 1 (OfNat.mk.{0} (Units.{0} Int Int.monoid) 1 (One.one.{0} (Units.{0} Int Int.monoid) (MulOneClass.toHasOne.{0} (Units.{0} Int Int.monoid) (Units.mulOneClass.{0} Int Int.monoid)))))))
-but is expected to have type
-  forall (u : Units.{0} Int Int.instMonoidInt), Or (Eq.{1} (Units.{0} Int Int.instMonoidInt) u (OfNat.ofNat.{0} (Units.{0} Int Int.instMonoidInt) 1 (One.toOfNat1.{0} (Units.{0} Int Int.instMonoidInt) (InvOneClass.toOne.{0} (Units.{0} Int Int.instMonoidInt) (DivInvOneMonoid.toInvOneClass.{0} (Units.{0} Int Int.instMonoidInt) (DivisionMonoid.toDivInvOneMonoid.{0} (Units.{0} Int Int.instMonoidInt) (DivisionCommMonoid.toDivisionMonoid.{0} (Units.{0} Int Int.instMonoidInt) (CommGroup.toDivisionCommMonoid.{0} (Units.{0} Int Int.instMonoidInt) (Units.instCommGroupUnitsToMonoid.{0} Int Int.instCommMonoidInt))))))))) (Eq.{1} (Units.{0} Int Int.instMonoidInt) u (Neg.neg.{0} (Units.{0} Int Int.instMonoidInt) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (OfNat.ofNat.{0} (Units.{0} Int Int.instMonoidInt) 1 (One.toOfNat1.{0} (Units.{0} Int Int.instMonoidInt) (InvOneClass.toOne.{0} (Units.{0} Int Int.instMonoidInt) (DivInvOneMonoid.toInvOneClass.{0} (Units.{0} Int Int.instMonoidInt) (DivisionMonoid.toDivInvOneMonoid.{0} (Units.{0} Int Int.instMonoidInt) (DivisionCommMonoid.toDivisionMonoid.{0} (Units.{0} Int Int.instMonoidInt) (CommGroup.toDivisionCommMonoid.{0} (Units.{0} Int Int.instMonoidInt) (Units.instCommGroupUnitsToMonoid.{0} Int Int.instCommMonoidInt))))))))))
-Case conversion may be inaccurate. Consider using '#align int.units_eq_one_or Int.units_eq_one_orₓ'. -/
 theorem units_eq_one_or (u : ℤˣ) : u = 1 ∨ u = -1 := by
   simpa only [Units.ext_iff, units_nat_abs] using nat_abs_eq u
 #align int.units_eq_one_or Int.units_eq_one_or
 
-/- warning: int.is_unit_eq_one_or -> Int.isUnit_eq_one_or is a dubious translation:
-lean 3 declaration is
-  forall {a : Int}, (IsUnit.{0} Int Int.monoid a) -> (Or (Eq.{1} Int a (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))) (Eq.{1} Int a (Neg.neg.{0} Int Int.hasNeg (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))))
-but is expected to have type
-  forall {a : Int}, (IsUnit.{0} Int Int.instMonoidInt a) -> (Or (Eq.{1} Int a (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (Eq.{1} Int a (Neg.neg.{0} Int Int.instNegInt (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))))
-Case conversion may be inaccurate. Consider using '#align int.is_unit_eq_one_or Int.isUnit_eq_one_orₓ'. -/
 theorem isUnit_eq_one_or {a : ℤ} : IsUnit a → a = 1 ∨ a = -1
   | ⟨x, hx⟩ => hx ▸ (units_eq_one_or _).imp (congr_arg coe) (congr_arg coe)
 #align int.is_unit_eq_one_or Int.isUnit_eq_one_or
 
-/- warning: int.is_unit_iff -> Int.isUnit_iff is a dubious translation:
-lean 3 declaration is
-  forall {a : Int}, Iff (IsUnit.{0} Int Int.monoid a) (Or (Eq.{1} Int a (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))) (Eq.{1} Int a (Neg.neg.{0} Int Int.hasNeg (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))))
-but is expected to have type
-  forall {a : Int}, Iff (IsUnit.{0} Int Int.instMonoidInt a) (Or (Eq.{1} Int a (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (Eq.{1} Int a (Neg.neg.{0} Int Int.instNegInt (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))))
-Case conversion may be inaccurate. Consider using '#align int.is_unit_iff Int.isUnit_iffₓ'. -/
 theorem isUnit_iff {a : ℤ} : IsUnit a ↔ a = 1 ∨ a = -1 :=
   by
   refine' ⟨fun h => is_unit_eq_one_or h, fun h => _⟩
@@ -73,12 +49,6 @@ theorem isUnit_iff {a : ℤ} : IsUnit a ↔ a = 1 ∨ a = -1 :=
   · exact is_unit_one.neg
 #align int.is_unit_iff Int.isUnit_iff
 
-/- warning: int.is_unit_eq_or_eq_neg -> Int.isUnit_eq_or_eq_neg is a dubious translation:
-lean 3 declaration is
-  forall {a : Int} {b : Int}, (IsUnit.{0} Int Int.monoid a) -> (IsUnit.{0} Int Int.monoid b) -> (Or (Eq.{1} Int a b) (Eq.{1} Int a (Neg.neg.{0} Int Int.hasNeg b)))
-but is expected to have type
-  forall {a : Int} {b : Int}, (IsUnit.{0} Int Int.instMonoidInt a) -> (IsUnit.{0} Int Int.instMonoidInt b) -> (Or (Eq.{1} Int a b) (Eq.{1} Int a (Neg.neg.{0} Int Int.instNegInt b)))
-Case conversion may be inaccurate. Consider using '#align int.is_unit_eq_or_eq_neg Int.isUnit_eq_or_eq_negₓ'. -/
 theorem isUnit_eq_or_eq_neg {a b : ℤ} (ha : IsUnit a) (hb : IsUnit b) : a = b ∨ a = -b :=
   by
   rcases is_unit_eq_one_or hb with (rfl | rfl)
@@ -138,52 +108,22 @@ theorem mul_eq_neg_one_iff_eq_one_or_neg_one {z w : ℤ} :
 #align int.mul_eq_neg_one_iff_eq_one_or_neg_one Int.mul_eq_neg_one_iff_eq_one_or_neg_one
 -/
 
-/- warning: int.is_unit_iff_nat_abs_eq -> Int.isUnit_iff_natAbs_eq is a dubious translation:
-lean 3 declaration is
-  forall {n : Int}, Iff (IsUnit.{0} Int Int.monoid n) (Eq.{1} Nat (Int.natAbs n) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))
-but is expected to have type
-  forall {n : Int}, Iff (IsUnit.{0} Int Int.instMonoidInt n) (Eq.{1} Nat (Int.natAbs n) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))
-Case conversion may be inaccurate. Consider using '#align int.is_unit_iff_nat_abs_eq Int.isUnit_iff_natAbs_eqₓ'. -/
 theorem isUnit_iff_natAbs_eq {n : ℤ} : IsUnit n ↔ n.natAbs = 1 := by
   simp [nat_abs_eq_iff, is_unit_iff, Nat.cast_zero]
 #align int.is_unit_iff_nat_abs_eq Int.isUnit_iff_natAbs_eq
 
-/- warning: int.is_unit.nat_abs_eq -> Int.IsUnit.natAbs_eq is a dubious translation:
-lean 3 declaration is
-  forall {n : Int}, (IsUnit.{0} Int Int.monoid n) -> (Eq.{1} Nat (Int.natAbs n) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))
-but is expected to have type
-  forall {n : Int}, (IsUnit.{0} Int Int.instMonoidInt n) -> (Eq.{1} Nat (Int.natAbs n) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))
-Case conversion may be inaccurate. Consider using '#align int.is_unit.nat_abs_eq Int.IsUnit.natAbs_eqₓ'. -/
 alias is_unit_iff_nat_abs_eq ↔ is_unit.nat_abs_eq _
 #align int.is_unit.nat_abs_eq Int.IsUnit.natAbs_eq
 
-/- warning: int.of_nat_is_unit -> Int.ofNat_isUnit is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat}, Iff (IsUnit.{0} Int Int.monoid ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)) (IsUnit.{0} Nat Nat.monoid n)
-but is expected to have type
-  forall {n : Nat}, Iff (IsUnit.{0} Int Int.instMonoidInt (Nat.cast.{0} Int instNatCastInt n)) (IsUnit.{0} Nat Nat.monoid n)
-Case conversion may be inaccurate. Consider using '#align int.of_nat_is_unit Int.ofNat_isUnitₓ'. -/
 @[norm_cast]
 theorem ofNat_isUnit {n : ℕ} : IsUnit (n : ℤ) ↔ IsUnit n := by
   rw [Nat.isUnit_iff, is_unit_iff_nat_abs_eq, nat_abs_of_nat]
 #align int.of_nat_is_unit Int.ofNat_isUnit
 
-/- warning: int.is_unit_mul_self -> Int.isUnit_mul_self is a dubious translation:
-lean 3 declaration is
-  forall {a : Int}, (IsUnit.{0} Int Int.monoid a) -> (Eq.{1} Int (HMul.hMul.{0, 0, 0} Int Int Int (instHMul.{0} Int Int.hasMul) a a) (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))
-but is expected to have type
-  forall {a : Int}, (IsUnit.{0} Int Int.instMonoidInt a) -> (Eq.{1} Int (HMul.hMul.{0, 0, 0} Int Int Int (instHMul.{0} Int Int.instMulInt) a a) (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))
-Case conversion may be inaccurate. Consider using '#align int.is_unit_mul_self Int.isUnit_mul_selfₓ'. -/
 theorem isUnit_mul_self {a : ℤ} (ha : IsUnit a) : a * a = 1 :=
   (isUnit_eq_one_or ha).elim (fun h => h.symm ▸ rfl) fun h => h.symm ▸ rfl
 #align int.is_unit_mul_self Int.isUnit_mul_self
 
-/- warning: int.is_unit_add_is_unit_eq_is_unit_add_is_unit -> Int.isUnit_add_isUnit_eq_isUnit_add_isUnit is a dubious translation:
-lean 3 declaration is
-  forall {a : Int} {b : Int} {c : Int} {d : Int}, (IsUnit.{0} Int Int.monoid a) -> (IsUnit.{0} Int Int.monoid b) -> (IsUnit.{0} Int Int.monoid c) -> (IsUnit.{0} Int Int.monoid d) -> (Iff (Eq.{1} Int (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) a b) (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) c d)) (Or (And (Eq.{1} Int a c) (Eq.{1} Int b d)) (And (Eq.{1} Int a d) (Eq.{1} Int b c))))
-but is expected to have type
-  forall {a : Int} {b : Int} {c : Int} {d : Int}, (IsUnit.{0} Int Int.instMonoidInt a) -> (IsUnit.{0} Int Int.instMonoidInt b) -> (IsUnit.{0} Int Int.instMonoidInt c) -> (IsUnit.{0} Int Int.instMonoidInt d) -> (Iff (Eq.{1} Int (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) a b) (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) c d)) (Or (And (Eq.{1} Int a c) (Eq.{1} Int b d)) (And (Eq.{1} Int a d) (Eq.{1} Int b c))))
-Case conversion may be inaccurate. Consider using '#align int.is_unit_add_is_unit_eq_is_unit_add_is_unit Int.isUnit_add_isUnit_eq_isUnit_add_isUnitₓ'. -/
 theorem isUnit_add_isUnit_eq_isUnit_add_isUnit {a b c d : ℤ} (ha : IsUnit a) (hb : IsUnit b)
     (hc : IsUnit c) (hd : IsUnit d) : a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c :=
   by

bump to nightly-2023-03-17-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/da3fc4a33ff6bc75f077f691dc94c217b8d41559

11391fe2

Diff

@@ -161,7 +161,7 @@ alias is_unit_iff_nat_abs_eq ↔ is_unit.nat_abs_eq _
 lean 3 declaration is
   forall {n : Nat}, Iff (IsUnit.{0} Int Int.monoid ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)) (IsUnit.{0} Nat Nat.monoid n)
 but is expected to have type
-  forall {n : Nat}, Iff (IsUnit.{0} Int Int.instMonoidInt (Nat.cast.{0} Int Int.instNatCastInt n)) (IsUnit.{0} Nat Nat.monoid n)
+  forall {n : Nat}, Iff (IsUnit.{0} Int Int.instMonoidInt (Nat.cast.{0} Int instNatCastInt n)) (IsUnit.{0} Nat Nat.monoid n)
 Case conversion may be inaccurate. Consider using '#align int.of_nat_is_unit Int.ofNat_isUnitₓ'. -/
 @[norm_cast]
 theorem ofNat_isUnit {n : ℕ} : IsUnit (n : ℤ) ↔ IsUnit n := by

bump to nightly-2023-03-07-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

e067364a

Diff

@@ -103,10 +103,12 @@ theorem eq_one_or_neg_one_of_mul_eq_one' {z w : ℤ} (h : z * w = 1) :
 #align int.eq_one_or_neg_one_of_mul_eq_one' Int.eq_one_or_neg_one_of_mul_eq_one'
 -/
 
+#print Int.eq_of_mul_eq_one /-
 theorem eq_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = w :=
   (eq_one_or_neg_one_of_mul_eq_one' h).elim (fun h => h.1.trans h.2.symm) fun h =>
     h.1.trans h.2.symm
 #align int.eq_of_mul_eq_one Int.eq_of_mul_eq_one
+-/
 
 #print Int.mul_eq_one_iff_eq_one_or_neg_one /-
 theorem mul_eq_one_iff_eq_one_or_neg_one {z w : ℤ} : z * w = 1 ↔ z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 :=

bump to nightly-2023-02-28-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/9da1b3534b65d9661eb8f42443598a92bbb49211

ead5cda8

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad
 
 ! This file was ported from Lean 3 source module data.int.units
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit 45a1ada01ed893722d0f8d15b9e44270996515d5
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -103,6 +103,11 @@ theorem eq_one_or_neg_one_of_mul_eq_one' {z w : ℤ} (h : z * w = 1) :
 #align int.eq_one_or_neg_one_of_mul_eq_one' Int.eq_one_or_neg_one_of_mul_eq_one'
 -/
 
+theorem eq_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = w :=
+  (eq_one_or_neg_one_of_mul_eq_one' h).elim (fun h => h.1.trans h.2.symm) fun h =>
+    h.1.trans h.2.symm
+#align int.eq_of_mul_eq_one Int.eq_of_mul_eq_one
+
 #print Int.mul_eq_one_iff_eq_one_or_neg_one /-
 theorem mul_eq_one_iff_eq_one_or_neg_one {z w : ℤ} : z * w = 1 ↔ z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 :=
   by

448144f7

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: Split Data.{Nat,Int}{.Order}.Basic in group vs ring instances (#11924)

Scatter the content of Data.Nat.Basic across:

Data.Nat.Defs for the lemmas having no dependencies
Algebra.Group.Nat for the monoid instances and the few miscellaneous lemmas needing them.
Algebra.Ring.Nat for the semiring instance and the few miscellaneous lemmas following it.

Similarly, scatter

Data.Int.Basic across Data.Int.Defs, Algebra.Group.Int, Algebra.Ring.Int
Data.Nat.Order.Basic across Data.Nat.Defs, Algebra.Order.Group.Nat, Algebra.Order.Ring.Nat
Data.Int.Order.Basic across Data.Int.Defs, Algebra.Order.Group.Int, Algebra.Order.Ring.Int

Also move a few lemmas from Data.Nat.Order.Lemmas to Data.Nat.Defs.

Before pre_11924

After post_11924

47062a71

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad
 -/
 import Mathlib.Data.Nat.Units
-import Mathlib.Data.Int.Basic
+import Mathlib.Algebra.Ring.Int
 import Mathlib.Algebra.Ring.Units
 import Mathlib.Tactic.Common

fix: improvements I noticed when teaching (#8420)

Rename (and generalize and move)

Int.units_ne_neg_self -> units_ne_neg_self
Int.neg_units_ne_self -> neg_units_ne_self

Change the simps config for Closeds
Add some gcongr-lemmas (currently is a bit picky about the exact statement of lemmas tagged with gcongr, so I had to add some variants that I could tag).

8e0aa131

Diff

@@ -31,13 +31,6 @@ theorem units_eq_one_or (u : ℤˣ) : u = 1 ∨ u = -1 := by
   simpa only [Units.ext_iff, units_natAbs] using natAbs_eq u
 #align int.units_eq_one_or Int.units_eq_one_or
 
-@[simp]
-theorem units_ne_neg_self (u : ℤˣ) : u ≠ -u := by
-  rcases units_eq_one_or u with rfl | rfl <;> decide
-
-@[simp]
-theorem neg_units_ne_self (u : ℤˣ) : -u ≠ u := (units_ne_neg_self u).symm
-
 theorem units_ne_iff_eq_neg {u u' : ℤˣ} : u ≠ u' ↔ u = -u' := by
   rcases units_eq_one_or u with rfl | rfl <;>
   rcases units_eq_one_or u' with rfl | rfl <;>

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -122,7 +122,7 @@ theorem isUnit_add_isUnit_eq_isUnit_add_isUnit {a b c d : ℤ} (ha : IsUnit a) (
   rw [isUnit_iff] at ha hb hc hd
   cases ha <;> cases hb <;> cases hc <;> cases hd <;>
       subst a <;> subst b <;> subst c <;> subst d <;>
-    simp
+    simp (config := {decide := true})
 #align int.is_unit_add_is_unit_eq_is_unit_add_is_unit Int.isUnit_add_isUnit_eq_isUnit_add_isUnit
 
 theorem eq_one_or_neg_one_of_mul_eq_neg_one {z w : ℤ} (h : z * w = -1) : z = 1 ∨ z = -1 :=

chore: delay import of Tactic.Common (#7000)

I know that this is contrary to what we've done previously, but:

I'm trying to upstream a great many tactics from Mathlib to Std (essentially, everything that non-mathematicians want too).
This makes it much easier for me to see what is going on, and understand the import requirements (particularly for the "big" tactics norm_num / ring / linarith)
It's actually not as bad as it looks here, because as these tactics move up to Std they will start disappearing again from explicit imports, but Mathlib can happily import all of Std.

(Oh

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

4f3418a7

Diff

@@ -6,6 +6,7 @@ Authors: Jeremy Avigad
 import Mathlib.Data.Nat.Units
 import Mathlib.Data.Int.Basic
 import Mathlib.Algebra.Ring.Units
+import Mathlib.Tactic.Common
 
 #align_import data.int.units from "leanprover-community/mathlib"@"641b6a82006416ec431b2987b354af9311fed4f2"

refactor(Data/Int/Units): golf isUnit_eq_or_eq_neg (#6952)

This PR adds an IsUnit version of units_ne_iff_eq_neg and uses it to golf isUnit_eq_or_eq_neg.

ab52fda3

Diff

@@ -42,6 +42,9 @@ theorem units_ne_iff_eq_neg {u u' : ℤˣ} : u ≠ u' ↔ u = -u' := by
   rcases units_eq_one_or u' with rfl | rfl <;>
   decide
 
+theorem isUnit_ne_iff_eq_neg {u u' : ℤ} (hu : IsUnit u) (hu' : IsUnit u') : u ≠ u' ↔ u = -u' := by
+  simpa only [Ne, Units.ext_iff] using units_ne_iff_eq_neg (u := hu.unit) (u' := hu'.unit)
+
 theorem isUnit_eq_one_or {a : ℤ} : IsUnit a → a = 1 ∨ a = -1
   | ⟨_, hx⟩ => hx ▸ (units_eq_one_or _).imp (congr_arg Units.val) (congr_arg Units.val)
 #align int.is_unit_eq_one_or Int.isUnit_eq_one_or
@@ -53,10 +56,8 @@ theorem isUnit_iff {a : ℤ} : IsUnit a ↔ a = 1 ∨ a = -1 := by
   · exact isUnit_one.neg
 #align int.is_unit_iff Int.isUnit_iff
 
-theorem isUnit_eq_or_eq_neg {a b : ℤ} (ha : IsUnit a) (hb : IsUnit b) : a = b ∨ a = -b := by
-  rcases isUnit_eq_one_or hb with (rfl | rfl)
-  · exact isUnit_eq_one_or ha
-  · rwa [or_comm, neg_neg, ← isUnit_iff]
+theorem isUnit_eq_or_eq_neg {a b : ℤ} (ha : IsUnit a) (hb : IsUnit b) : a = b ∨ a = -b :=
+  or_iff_not_imp_left.mpr (isUnit_ne_iff_eq_neg ha hb).mp
 #align int.is_unit_eq_or_eq_neg Int.isUnit_eq_or_eq_neg
 
 theorem eq_one_or_neg_one_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = 1 ∨ z = -1 :=

feat(Int/Units): a few lemmas about ℤˣ (#6933)

fa813a8e

Diff

@@ -30,6 +30,18 @@ theorem units_eq_one_or (u : ℤˣ) : u = 1 ∨ u = -1 := by
   simpa only [Units.ext_iff, units_natAbs] using natAbs_eq u
 #align int.units_eq_one_or Int.units_eq_one_or
 
+@[simp]
+theorem units_ne_neg_self (u : ℤˣ) : u ≠ -u := by
+  rcases units_eq_one_or u with rfl | rfl <;> decide
+
+@[simp]
+theorem neg_units_ne_self (u : ℤˣ) : -u ≠ u := (units_ne_neg_self u).symm
+
+theorem units_ne_iff_eq_neg {u u' : ℤˣ} : u ≠ u' ↔ u = -u' := by
+  rcases units_eq_one_or u with rfl | rfl <;>
+  rcases units_eq_one_or u' with rfl | rfl <;>
+  decide
+
 theorem isUnit_eq_one_or {a : ℤ} : IsUnit a → a = 1 ∨ a = -1
   | ⟨_, hx⟩ => hx ▸ (units_eq_one_or _).imp (congr_arg Units.val) (congr_arg Units.val)
 #align int.is_unit_eq_one_or Int.isUnit_eq_one_or

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -88,7 +88,7 @@ theorem isUnit_iff_natAbs_eq {n : ℤ} : IsUnit n ↔ n.natAbs = 1 := by
   simp [natAbs_eq_iff, isUnit_iff, Nat.cast_zero]
 #align int.is_unit_iff_nat_abs_eq Int.isUnit_iff_natAbs_eq
 
-alias isUnit_iff_natAbs_eq ↔ IsUnit.natAbs_eq _
+alias ⟨IsUnit.natAbs_eq, _⟩ := isUnit_iff_natAbs_eq
 #align int.is_unit.nat_abs_eq Int.IsUnit.natAbs_eq
 
 -- Porting note: `rw` didn't work on `natAbs_ofNat`, so had to change to `simp`,

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad
-
-! This file was ported from Lean 3 source module data.int.units
-! leanprover-community/mathlib commit 641b6a82006416ec431b2987b354af9311fed4f2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Nat.Units
 import Mathlib.Data.Int.Basic
 import Mathlib.Algebra.Ring.Units
 
+#align_import data.int.units from "leanprover-community/mathlib"@"641b6a82006416ec431b2987b354af9311fed4f2"
+
 /-!
 # Lemmas about units in `ℤ`.
 -/

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

a4eaf1c4

Diff

@@ -11,7 +11,6 @@ Authors: Jeremy Avigad
 import Mathlib.Data.Nat.Units
 import Mathlib.Data.Int.Basic
 import Mathlib.Algebra.Ring.Units
-import Mathlib.Tactic.Tauto
 
 /-!
 # Lemmas about units in `ℤ`.

chore: strip trailing spaces in lean files (#2828)

vscode is already configured by .vscode/settings.json to trim these on save. It's not clear how they've managed to stick around.

By doing this all in one PR now, it avoids getting random whitespace diffs in PRs later.

This was done with a regex search in vscode,

6ceb5945

Diff

@@ -63,7 +63,7 @@ theorem eq_one_or_neg_one_of_mul_eq_one' {z w : ℤ} (h : z * w = 1) :
 #align int.eq_one_or_neg_one_of_mul_eq_one' Int.eq_one_or_neg_one_of_mul_eq_one'
 
 theorem eq_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = w :=
-  (eq_one_or_neg_one_of_mul_eq_one' h).elim 
+  (eq_one_or_neg_one_of_mul_eq_one' h).elim
     (and_imp.2 (·.trans ·.symm)) (and_imp.2 (·.trans ·.symm))
 #align int.eq_of_mul_eq_one Int.eq_of_mul_eq_one

feat(Data/Int/Units): If z * w = 1, then z = w (#2497)

This PR adds a lemma stating that if z * w = 1, then z = w.

mathlib PR: https://github.com/leanprover-community/mathlib/pull/18499

Co-authored-by: Chris Hughes <33847686+ChrisHughes24@users.noreply.github.com>

0ecf8c35

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad
 
 ! This file was ported from Lean 3 source module data.int.units
-! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! leanprover-community/mathlib commit 641b6a82006416ec431b2987b354af9311fed4f2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -62,6 +62,11 @@ theorem eq_one_or_neg_one_of_mul_eq_one' {z w : ℤ} (h : z * w = 1) :
       rcases eq_one_or_neg_one_of_mul_eq_one h' with (rfl | rfl) <;> tauto
 #align int.eq_one_or_neg_one_of_mul_eq_one' Int.eq_one_or_neg_one_of_mul_eq_one'
 
+theorem eq_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = w :=
+  (eq_one_or_neg_one_of_mul_eq_one' h).elim 
+    (and_imp.2 (·.trans ·.symm)) (and_imp.2 (·.trans ·.symm))
+#align int.eq_of_mul_eq_one Int.eq_of_mul_eq_one
+
 theorem mul_eq_one_iff_eq_one_or_neg_one {z w : ℤ} :
     z * w = 1 ↔ z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 := by
   refine' ⟨eq_one_or_neg_one_of_mul_eq_one', fun h => Or.elim h (fun H => _) fun H => _⟩ <;>

chore: format by line breaks with long lines (#1529)

This was done semi-automatically with some regular expressions in vim in contrast to the fully automatic https://github.com/leanprover-community/mathlib4/pull/1523.

Co-authored-by: Moritz Firsching <firsching@google.com>

1050066f

Diff

@@ -62,8 +62,8 @@ theorem eq_one_or_neg_one_of_mul_eq_one' {z w : ℤ} (h : z * w = 1) :
       rcases eq_one_or_neg_one_of_mul_eq_one h' with (rfl | rfl) <;> tauto
 #align int.eq_one_or_neg_one_of_mul_eq_one' Int.eq_one_or_neg_one_of_mul_eq_one'
 
-theorem mul_eq_one_iff_eq_one_or_neg_one {z w : ℤ} : z * w = 1 ↔ z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 :=
-  by
+theorem mul_eq_one_iff_eq_one_or_neg_one {z w : ℤ} :
+    z * w = 1 ↔ z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 := by
   refine' ⟨eq_one_or_neg_one_of_mul_eq_one', fun h => Or.elim h (fun H => _) fun H => _⟩ <;>
       rcases H with ⟨rfl, rfl⟩ <;>
     rfl

chore: tidy after data.int.units port (#1199)

Co-authored-by: Reid Barton <rwbarton@gmail.com>

ea82bbc6

Diff

@@ -87,7 +87,8 @@ theorem isUnit_iff_natAbs_eq {n : ℤ} : IsUnit n ↔ n.natAbs = 1 := by
   simp [natAbs_eq_iff, isUnit_iff, Nat.cast_zero]
 #align int.is_unit_iff_nat_abs_eq Int.isUnit_iff_natAbs_eq
 
-alias isUnit_iff_natAbs_eq ↔ isUnit.natAbs_eq _
+alias isUnit_iff_natAbs_eq ↔ IsUnit.natAbs_eq _
+#align int.is_unit.nat_abs_eq Int.IsUnit.natAbs_eq
 
 -- Porting note: `rw` didn't work on `natAbs_ofNat`, so had to change to `simp`,
 -- presumably because `(n : ℤ)` is `Nat.cast` and not just `ofNat`

feat: implement basic version of tauto tactic (#1081)

Adds a basic version of the tauto tactic, mostly a line-by-line translation of the Lean 3 version.

As per this zulip discussion, makes tauto always-classical and eliminates tauto!.
Does not yet add any symmetry-based logic or the fancy union-find datastructure from https://github.com/leanprover-community/mathlib/pull/180.
Adds a andThenOnSubgoals tactic combinator in Mathlib.Tactic.Basic.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

3f9ce172

Diff

@@ -11,6 +11,7 @@ Authors: Jeremy Avigad
 import Mathlib.Data.Nat.Units
 import Mathlib.Data.Int.Basic
 import Mathlib.Algebra.Ring.Units
+import Mathlib.Tactic.Tauto
 
 /-!
 # Lemmas about units in `ℤ`.
@@ -54,15 +55,11 @@ theorem eq_one_or_neg_one_of_mul_eq_one {z w : ℤ} (h : z * w = 1) : z = 1 ∨
   isUnit_iff.mp (isUnit_of_mul_eq_one z w h)
 #align int.eq_one_or_neg_one_of_mul_eq_one Int.eq_one_or_neg_one_of_mul_eq_one
 
--- Porting note: this was proven in mathlib3 with `tauto` which hasn't been ported yet
 theorem eq_one_or_neg_one_of_mul_eq_one' {z w : ℤ} (h : z * w = 1) :
     z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 := by
   have h' : w * z = 1 := mul_comm z w ▸ h
   rcases eq_one_or_neg_one_of_mul_eq_one h with (rfl | rfl) <;>
-      rcases eq_one_or_neg_one_of_mul_eq_one h' with (rfl | rfl) <;>
-    try cases h
-  · exact Or.inl ⟨rfl, rfl⟩
-  · exact Or.inr ⟨rfl, rfl⟩
+      rcases eq_one_or_neg_one_of_mul_eq_one h' with (rfl | rfl) <;> tauto
 #align int.eq_one_or_neg_one_of_mul_eq_one' Int.eq_one_or_neg_one_of_mul_eq_one'
 
 theorem mul_eq_one_iff_eq_one_or_neg_one {z w : ℤ} : z * w = 1 ↔ z = 1 ∧ w = 1 ∨ z = -1 ∧ w = -1 :=