File: Mathlib/Algebra/Group/Int.lean

full_name: Int.instCommMonoid
code: instance instCommMonoid : CommMonoid ℤ 
goal: CommMonoid ℤ

full_name: Int.instAddCommGroup
code: instance instAddCommGroup : AddCommGroup ℤ 
goal: AddCommGroup ℤ

full_name: Int.instAddCommMonoid
code: instance instAddCommMonoid    : AddCommMonoid ℤ    
goal: AddCommMonoid ℤ

full_name: Int.instAddMonoid
code: instance instAddMonoid        : AddMonoid ℤ        
goal: AddMonoid ℤ

full_name: Int.instMonoid
code: instance instMonoid           : Monoid ℤ           
goal: Monoid ℤ

full_name: Int.instCommSemigroup
code: instance instCommSemigroup    : CommSemigroup ℤ    
goal: CommSemigroup ℤ

full_name: Int.instSemigroup
code: instance instSemigroup        : Semigroup ℤ        
goal: Semigroup ℤ

full_name: Int.instAddGroup
code: instance instAddGroup         : AddGroup ℤ         
goal: AddGroup ℤ

full_name: Int.instAddCommSemigroup
code: instance instAddCommSemigroup : AddCommSemigroup ℤ 
goal: AddCommSemigroup ℤ

full_name: Int.instAddSemigroup
code: instance instAddSemigroup     : AddSemigroup ℤ     
goal: AddSemigroup ℤ

full_name: Int.toAdd_pow
code: lemma toAdd_pow (a : Multiplicative ℤ) (b : ℕ) : toAdd (a ^ b) = toAdd a * b 
goal: Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * ↑b

full_name: Int.toAdd_zpow
code: lemma toAdd_zpow (a : Multiplicative ℤ) (b : ℤ) : toAdd (a ^ b) = toAdd a * b 
goal: Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * b

full_name: Int.ofAdd_mul
code: @[simp] lemma ofAdd_mul (a b : ℤ) : ofAdd (a * b) = ofAdd a ^ b 
goal: Multiplicative.ofAdd (a * b) = Multiplicative.ofAdd a ^ b

full_name: Int.units_natAbs
code: lemma units_natAbs (u : ℤˣ) : natAbs u = 1 
goal: (↑u).natAbs = 1

full_name: Int.natAbs_of_isUnit
code: @[simp] lemma natAbs_of_isUnit (hu : IsUnit u) : natAbs u = 1 
goal: u.natAbs = 1

full_name: Int.isUnit_eq_one_or
code: lemma isUnit_eq_one_or (hu : IsUnit u) : u = 1 ∨ u = -1 
goal: u = 1 ∨ u = -1

full_name: Int.isUnit_ne_iff_eq_neg
code: lemma isUnit_ne_iff_eq_neg (hu : IsUnit u) (hv : IsUnit v) : u ≠ v ↔ u = -v 
goal: u ≠ v ↔ u = -v

full_name: Int.isUnit_eq_or_eq_neg
code: lemma isUnit_eq_or_eq_neg (hu : IsUnit u) (hv : IsUnit v) : u = v ∨ u = -v 
goal: u = v ∨ u = -v

full_name: Int.isUnit_iff
code: lemma isUnit_iff : IsUnit u ↔ u = 1 ∨ u = -1 
goal: IsUnit u ↔ u = 1 ∨ u = -1

full_name: Int.eq_one_or_neg_one_of_mul_eq_one
code: lemma eq_one_or_neg_one_of_mul_eq_one (h : u * v = 1) : u = 1 ∨ u = -1 
goal: u = 1 ∨ u = -1

full_name: Int.eq_one_or_neg_one_of_mul_eq_one'
code: lemma eq_one_or_neg_one_of_mul_eq_one' (h : u * v = 1) : u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1 
goal: u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1

full_name: Int.eq_of_mul_eq_one
code: lemma eq_of_mul_eq_one (h : u * v = 1) : u = v 
goal: u = v

full_name: Int.mul_eq_one_iff_eq_one_or_neg_one
code: lemma mul_eq_one_iff_eq_one_or_neg_one : u * v = 1 ↔ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1 
goal: u * v = 1 ↔ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1

full_name: Int.eq_one_or_neg_one_of_mul_eq_neg_one'
code: lemma eq_one_or_neg_one_of_mul_eq_neg_one' (h : u * v = -1) : u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1 
goal: u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1

full_name: Int.mul_eq_neg_one_iff_eq_one_or_neg_one
code: lemma mul_eq_neg_one_iff_eq_one_or_neg_one : u * v = -1 ↔ u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1 
goal: u * v = -1 ↔ u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1

full_name: Int.isUnit_iff_natAbs_eq
code: lemma isUnit_iff_natAbs_eq : IsUnit u ↔ u.natAbs = 1 
goal: IsUnit u ↔ u.natAbs = 1

full_name: Int.ofNat_isUnit
code: @[norm_cast]
lemma ofNat_isUnit {n : ℕ} : IsUnit (n : ℤ) ↔ IsUnit n 
goal: IsUnit ↑n ↔ IsUnit n

full_name: Int.isUnit_mul_self
code: lemma isUnit_mul_self (hu : IsUnit u) : u * u = 1 
goal: u * u = 1

full_name: Int.isUnit_add_isUnit_eq_isUnit_add_isUnit
code: lemma 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 
goal: a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c

full_name: Int.eq_one_or_neg_one_of_mul_eq_neg_one
code: lemma eq_one_or_neg_one_of_mul_eq_neg_one (h : u * v = -1) : u = 1 ∨ u = -1 
goal: u = 1 ∨ u = -1

full_name: Int.emod_two_ne_one
code: @[simp] lemma emod_two_ne_one : ¬n % 2 = 1 ↔ n % 2 = 0 
goal: ¬n % 2 = 1 ↔ n % 2 = 0

full_name: Int.one_emod_two
code: @[simp] lemma one_emod_two : (1 : Int) % 2 = 1 
goal: 1 % 2 = 1

full_name: Int.emod_two_ne_zero
code: @[local simp] lemma emod_two_ne_zero : ¬n % 2 = 0 ↔ n % 2 = 1 
goal: ¬n % 2 = 0 ↔ n % 2 = 1

full_name: Int.even_iff
code: lemma even_iff : Even n ↔ n % 2 = 0 
goal: Even n ↔ n % 2 = 0

full_name: Int.not_even_iff
code: lemma not_even_iff : ¬Even n ↔ n % 2 = 1 
goal: ¬Even n ↔ n % 2 = 1

full_name: Int.two_dvd_ne_zero
code: @[simp] lemma two_dvd_ne_zero : ¬2 ∣ n ↔ n % 2 = 1 
goal: ¬2 ∣ n ↔ n % 2 = 1

full_name: Int.instDecidablePredEven
code: instance : DecidablePred (Even : ℤ → Prop) 
goal: DecidablePred Even

full_name: Int.instDecidablePredIsSquare
code: /-- `IsSquare` can be decided on `ℤ` by checking against the square root. -/
instance : DecidablePred (IsSquare : ℤ → Prop) 
goal: DecidablePred IsSquare

full_name: Int.not_even_one
code: @[simp] lemma not_even_one : ¬Even (1 : ℤ) 
goal: ¬Even 1

full_name: Int.even_add
code: @[parity_simps] lemma even_add : Even (m + n) ↔ (Even m ↔ Even n) 
goal: Even (m + n) ↔ (Even m ↔ Even n)

full_name: Int.two_not_dvd_two_mul_add_one
code: lemma two_not_dvd_two_mul_add_one (n : ℤ) : ¬2 ∣ 2 * n + 1 
goal: ¬2 ∣ 2 * n + 1

full_name: Int.even_sub
code: @[parity_simps]
lemma even_sub : Even (m - n) ↔ (Even m ↔ Even n) 
goal: Even (m - n) ↔ (Even m ↔ Even n)

full_name: Int.even_add_one
code: @[parity_simps] lemma even_add_one : Even (n + 1) ↔ ¬Even n 
goal: Even (n + 1) ↔ ¬Even n

full_name: Int.even_sub_one
code: @[parity_simps] lemma even_sub_one : Even (n - 1) ↔ ¬Even n 
goal: Even (n - 1) ↔ ¬Even n

full_name: Int.even_mul
code: @[parity_simps] lemma even_mul : Even (m * n) ↔ Even m ∨ Even n 
goal: Even (m * n) ↔ Even m ∨ Even n

full_name: Int.even_pow
code: @[parity_simps] lemma even_pow {n : ℕ} : Even (m ^ n) ↔ Even m ∧ n ≠ 0 
goal: Even (m ^ n) ↔ Even m ∧ n ≠ 0

full_name: Int.even_pow'
code: lemma even_pow' {n : ℕ} (h : n ≠ 0) : Even (m ^ n) ↔ Even m 
goal: Even (m ^ n) ↔ Even m

full_name: Int.even_coe_nat
code: @[simp, norm_cast] lemma even_coe_nat (n : ℕ) : Even (n : ℤ) ↔ Even n 
goal: Even ↑n ↔ Even n

full_name: Int.two_mul_ediv_two_of_even
code: lemma two_mul_ediv_two_of_even : Even n → 2 * (n / 2) = n 
goal: Even n → 2 * (n / 2) = n

full_name: Int.ediv_two_mul_two_of_even
code: lemma ediv_two_mul_two_of_even : Even n → n / 2 * 2 = n 
goal: Even n → n / 2 * 2 = n

full_name: zsmul_int_int
code: lemma zsmul_int_int (a b : ℤ) : a • b = a * b 
goal: a • b = a * b

full_name: zsmul_int_one
code: lemma zsmul_int_one (n : ℤ) : n • (1 : ℤ) = n 
goal: n • 1 = n