The integers form a group

This file contains the additive group and multiplicative monoid instances on the integers.

See note [foundational algebra order theory].

Instances

instance Int.instCommMonoid : CommMonoid ℤ

Equations

• Int.instCommMonoid = CommMonoid.mk Int.mul_comm

instance Int.instAddCommGroup : AddCommGroup ℤ

Equations

• Int.instAddCommGroup = AddCommGroup.mk Int.add_comm

Extra instances to short-circuit type class resolution

These also prevent non-computable instances like Int.normedCommRing being used to construct these instances non-computably.

instance Int.instAddCommMonoid : AddCommMonoid ℤ

Equations

• Int.instAddCommMonoid = inferInstance

instance Int.instAddMonoid : AddMonoid ℤ

Equations

• Int.instAddMonoid = inferInstance

instance Int.instMonoid : Monoid ℤ

Equations

• Int.instMonoid = inferInstance

instance Int.instCommSemigroup : CommSemigroup ℤ

Equations

• Int.instCommSemigroup = inferInstance

instance Int.instSemigroup : Semigroup ℤ

Equations

• Int.instSemigroup = inferInstance

instance Int.instAddGroup : AddGroup ℤ

Equations

• Int.instAddGroup = inferInstance

instance Int.instAddCommSemigroup : AddCommSemigroup ℤ

Equations

• Int.instAddCommSemigroup = inferInstance

instance Int.instAddSemigroup : AddSemigroup ℤ

Equations

• Int.instAddSemigroup = inferInstance

Miscellaneous lemmas

theorem Int.natAbs_pow (n : ℤ) (k : ℕ) : (n ^ k).natAbs = n.natAbs ^ k

theorem Int.coe_nat_strictMono : StrictMono fun (x : ℕ) => ↑x

theorem Int.toAdd_pow (a : Multiplicative ℤ) (b : ℕ) : Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * ↑b

theorem Int.toAdd_zpow (a : Multiplicative ℤ) (b : ℤ) : Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * b

@[simp]

theorem Int.ofAdd_mul (a : ℤ) (b : ℤ) : Multiplicative.ofAdd (a * b) = Multiplicative.ofAdd a ^ b

Units

theorem Int.units_natAbs (u : ℤˣ) : (↑u).natAbs = 1

@[simp]

theorem Int.natAbs_of_isUnit {u : ℤ} (hu : IsUnit u) : u.natAbs = 1

theorem Int.isUnit_eq_one_or {u : ℤ} (hu : IsUnit u) : u = 1 ∨ u = -1

theorem Int.isUnit_ne_iff_eq_neg {u : ℤ} {v : ℤ} (hu : IsUnit u) (hv : IsUnit v) : u ≠ v ↔ u = -v

theorem Int.isUnit_eq_or_eq_neg {u : ℤ} {v : ℤ} (hu : IsUnit u) (hv : IsUnit v) : u = v ∨ u = -v

theorem Int.isUnit_iff {u : ℤ} : IsUnit u ↔ u = 1 ∨ u = -1

theorem Int.eq_one_or_neg_one_of_mul_eq_one {u : ℤ} {v : ℤ} (h : u * v = 1) : u = 1 ∨ u = -1

theorem Int.eq_one_or_neg_one_of_mul_eq_one' {u : ℤ} {v : ℤ} (h : u * v = 1) : u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1

theorem Int.eq_of_mul_eq_one {u : ℤ} {v : ℤ} (h : u * v = 1) : u = v

theorem Int.mul_eq_one_iff_eq_one_or_neg_one {u : ℤ} {v : ℤ} : u * v = 1 ↔ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1

theorem Int.eq_one_or_neg_one_of_mul_eq_neg_one' {u : ℤ} {v : ℤ} (h : u * v = -1) : u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1

theorem Int.mul_eq_neg_one_iff_eq_one_or_neg_one {u : ℤ} {v : ℤ} : u * v = -1 ↔ u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1

theorem Int.isUnit_iff_natAbs_eq {u : ℤ} : IsUnit u ↔ u.natAbs = 1

theorem Int.IsUnit.natAbs_eq {u : ℤ} : IsUnit u → u.natAbs = 1

Alias of the forward direction of Int.isUnit_iff_natAbs_eq.

theorem Int.ofNat_isUnit {n : ℕ} : IsUnit ↑n ↔ IsUnit n

theorem Int.isUnit_mul_self {u : ℤ} (hu : IsUnit u) : u * u = 1

theorem Int.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

theorem Int.eq_one_or_neg_one_of_mul_eq_neg_one {u : ℤ} {v : ℤ} (h : u * v = -1) : u = 1 ∨ u = -1

theorem zsmul_int_int (a : ℤ) (b : ℤ) : a • b = a * b

theorem zsmul_int_one (n : ℤ) : n • 1 = n