File: Mathlib/Algebra/GCDMonoid/Nat.lean

full_name: instGCDMonoidNat
code: /-- `ℕ` is a gcd_monoid. -/
instance : GCDMonoid ℕ 
goal: GCDMonoid ℕ

full_name: gcd_eq_nat_gcd
code: theorem gcd_eq_nat_gcd (m n : ℕ) : gcd m n = Nat.gcd m n 
goal: gcd m n = m.gcd n

full_name: lcm_eq_nat_lcm
code: theorem lcm_eq_nat_lcm (m n : ℕ) : lcm m n = Nat.lcm m n 
goal: lcm m n = m.lcm n

full_name: instNormalizedGCDMonoidNat
code: instance : NormalizedGCDMonoid ℕ 
goal: NormalizedGCDMonoid ℕ

full_name: Int.normalizationMonoid
code: instance normalizationMonoid : NormalizationMonoid ℤ 
goal: NormalizationMonoid ℤ

full_name: Int.normUnit_eq
code: theorem normUnit_eq (z : ℤ) : normUnit z = if 0 ≤ z then 1 else -1 
goal: normUnit z = if 0 ≤ z then 1 else -1

full_name: Int.normalize_of_nonneg
code: theorem normalize_of_nonneg {z : ℤ} (h : 0 ≤ z) : normalize z = z 
goal: normalize z = z

full_name: Int.normalize_of_nonpos
code: theorem normalize_of_nonpos {z : ℤ} (h : z ≤ 0) : normalize z = -z 
goal: normalize z = -z

full_name: Int.normalize_coe_nat
code: theorem normalize_coe_nat (n : ℕ) : normalize (n : ℤ) = n 
goal: normalize ↑n = ↑n

full_name: Int.abs_eq_normalize
code: theorem abs_eq_normalize (z : ℤ) : |z| = normalize z 
goal: |z| = normalize z

full_name: Int.nonneg_of_normalize_eq_self
code: theorem nonneg_of_normalize_eq_self {z : ℤ} (hz : normalize z = z) : 0 ≤ z 
goal: 0 ≤ z

full_name: Int.nonneg_iff_normalize_eq_self
code: theorem nonneg_iff_normalize_eq_self (z : ℤ) : normalize z = z ↔ 0 ≤ z 
goal: normalize z = z ↔ 0 ≤ z

full_name: Int.eq_of_associated_of_nonneg
code: theorem eq_of_associated_of_nonneg {a b : ℤ} (h : Associated a b) (ha : 0 ≤ a) (hb : 0 ≤ b) :
    a = b 
goal: a = b

full_name: Int.instGCDMonoid
code: instance : GCDMonoid ℤ 
goal: GCDMonoid ℤ

full_name: Int.instNormalizedGCDMonoid
code: instance : NormalizedGCDMonoid ℤ 
goal: NormalizedGCDMonoid ℤ

full_name: Int.coe_gcd
code: theorem coe_gcd (i j : ℤ) : ↑(Int.gcd i j) = GCDMonoid.gcd i j 
goal: ↑(i.gcd j) = gcd i j

full_name: Int.coe_lcm
code: theorem coe_lcm (i j : ℤ) : ↑(Int.lcm i j) = GCDMonoid.lcm i j 
goal: ↑(i.lcm j) = lcm i j

full_name: Int.natAbs_gcd
code: theorem natAbs_gcd (i j : ℤ) : natAbs (GCDMonoid.gcd i j) = Int.gcd i j 
goal: (gcd i j).natAbs = i.gcd j

full_name: Int.natAbs_lcm
code: theorem natAbs_lcm (i j : ℤ) : natAbs (GCDMonoid.lcm i j) = Int.lcm i j 
goal: (lcm i j).natAbs = i.lcm j

full_name: Int.exists_unit_of_abs
code: theorem exists_unit_of_abs (a : ℤ) : ∃ (u : ℤ) (_ : IsUnit u), (Int.natAbs a : ℤ) = u * a 
goal: ∃ u, ∃ (_ : IsUnit u), ↑a.natAbs = u * a

full_name: Int.gcd_eq_natAbs
code: theorem gcd_eq_natAbs {a b : ℤ} : Int.gcd a b = Nat.gcd a.natAbs b.natAbs 
goal: a.gcd b = a.natAbs.gcd b.natAbs

full_name: associatesIntEquivNat
code: /-- Maps an associate class of integers consisting of `-n, n` to `n : ℕ` -/
def associatesIntEquivNat : Associates ℤ ≃ ℕ 
goal: Associates ℤ ≃ ℕ

full_name: Int.associated_natAbs
code: theorem Int.associated_natAbs (k : ℤ) : Associated k k.natAbs 
goal: Associated k ↑k.natAbs

full_name: Int.associated_iff_natAbs
code: theorem Int.associated_iff_natAbs {a b : ℤ} : Associated a b ↔ a.natAbs = b.natAbs 
goal: Associated a b ↔ a.natAbs = b.natAbs

full_name: Int.associated_iff
code: theorem Int.associated_iff {a b : ℤ} : Associated a b ↔ a = b ∨ a = -b 
goal: Associated a b ↔ a = b ∨ a = -b