File: Mathlib/Algebra/GCDMonoid/Basic.lean

full_name: NormalizationMonoid.normUnit_coe_units
code: /-- Normalization monoid: multiplying with `normUnit` gives a normal form for associated
elements. -/
class NormalizationMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- `normUnit` assigns to each element of the monoid a unit of the monoid. -/
  normUnit : α → αˣ
  /-- The proposition that `normUnit` maps `0` to the identity. -/
  normUnit_zero : normUnit 0 = 1
  /-- The proposition that `normUnit` respects multiplication of non-zero elements. -/
  normUnit_mul : ∀ {a b}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b
  /-- The proposition that `normUnit` maps units to their inverses. -/
  normUnit_coe_units : ∀ u : αˣ, normUnit u = u⁻¹
goal: normUnit ↑u = u⁻¹

full_name: NormalizationMonoid.normUnit
code: /-- Normalization monoid: multiplying with `normUnit` gives a normal form for associated
elements. -/
class NormalizationMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- `normUnit` assigns to each element of the monoid a unit of the monoid. -/
  normUnit : α → αˣ
  /-- The proposition that `normUnit` maps `0` to the identity. -/
  normUnit_zero : normUnit 0 = 1
  /-- The proposition that `normUnit` respects multiplication of non-zero elements. -/
  normUnit_mul : ∀ {a b}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b
  /-- The proposition that `normUnit` maps units to their inverses. -/
  normUnit_coe_units : ∀ u : αˣ, normUnit u = u⁻¹
goal: α → αˣ

full_name: NormalizationMonoid
code: /-- Normalization monoid: multiplying with `normUnit` gives a normal form for associated
elements. -/
class NormalizationMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- `normUnit` assigns to each element of the monoid a unit of the monoid. -/
  normUnit : α → αˣ
  /-- The proposition that `normUnit` maps `0` to the identity. -/
  normUnit_zero : normUnit 0 = 1
  /-- The proposition that `normUnit` respects multiplication of non-zero elements. -/
  normUnit_mul : ∀ {a b}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b
  /-- The proposition that `normUnit` maps units to their inverses. -/
  normUnit_coe_units : ∀ u : αˣ, normUnit u = u⁻¹
goal: Type u_2

full_name: NormalizationMonoid.normUnit_zero
code: /-- Normalization monoid: multiplying with `normUnit` gives a normal form for associated
elements. -/
class NormalizationMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- `normUnit` assigns to each element of the monoid a unit of the monoid. -/
  normUnit : α → αˣ
  /-- The proposition that `normUnit` maps `0` to the identity. -/
  normUnit_zero : normUnit 0 = 1
  /-- The proposition that `normUnit` respects multiplication of non-zero elements. -/
  normUnit_mul : ∀ {a b}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b
  /-- The proposition that `normUnit` maps units to their inverses. -/
  normUnit_coe_units : ∀ u : αˣ, normUnit u = u⁻¹
goal: normUnit 0 = 1

full_name: NormalizationMonoid.normUnit_mul
code: /-- Normalization monoid: multiplying with `normUnit` gives a normal form for associated
elements. -/
class NormalizationMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- `normUnit` assigns to each element of the monoid a unit of the monoid. -/
  normUnit : α → αˣ
  /-- The proposition that `normUnit` maps `0` to the identity. -/
  normUnit_zero : normUnit 0 = 1
  /-- The proposition that `normUnit` respects multiplication of non-zero elements. -/
  normUnit_mul : ∀ {a b}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b
  /-- The proposition that `normUnit` maps units to their inverses. -/
  normUnit_coe_units : ∀ u : αˣ, normUnit u = u⁻¹
goal: a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b

full_name: normUnit_one
code: @[simp]
theorem normUnit_one : normUnit (1 : α) = 1 
goal: normUnit 1 = 1

full_name: normalize
code: /-- Chooses an element of each associate class, by multiplying by `normUnit` -/
def normalize : α →*₀ α 
goal: α →*₀ α

full_name: associated_normalize
code: theorem associated_normalize (x : α) : Associated x (normalize x) 
goal: Associated x (normalize x)

full_name: normalize_associated
code: theorem normalize_associated (x : α) : Associated (normalize x) x 
goal: Associated (normalize x) x

full_name: associated_normalize_iff
code: theorem associated_normalize_iff {x y : α} : Associated x (normalize y) ↔ Associated x y 
goal: Associated x (normalize y) ↔ Associated x y

full_name: normalize_associated_iff
code: theorem normalize_associated_iff {x y : α} : Associated (normalize x) y ↔ Associated x y 
goal: Associated (normalize x) y ↔ Associated x y

full_name: Associates.mk_normalize
code: theorem Associates.mk_normalize (x : α) : Associates.mk (normalize x) = Associates.mk x 
goal: Associates.mk (normalize x) = Associates.mk x

full_name: normalize_apply
code: @[simp]
theorem normalize_apply (x : α) : normalize x = x * normUnit x 
goal: normalize x = x * ↑(normUnit x)

full_name: normalize_zero
code: theorem normalize_zero : normalize (0 : α) = 0 
goal: normalize 0 = 0

full_name: normalize_one
code: theorem normalize_one : normalize (1 : α) = 1 
goal: normalize 1 = 1

full_name: normalize_coe_units
code: theorem normalize_coe_units (u : αˣ) : normalize (u : α) = 1 
goal: normalize ↑u = 1

full_name: normalize_eq_zero
code: theorem normalize_eq_zero {x : α} : normalize x = 0 ↔ x = 0 
goal: normalize x = 0 ↔ x = 0

full_name: normalize_eq_one
code: theorem normalize_eq_one {x : α} : normalize x = 1 ↔ IsUnit x 
goal: normalize x = 1 ↔ IsUnit x

full_name: normUnit_mul_normUnit
code: @[simp]
theorem normUnit_mul_normUnit (a : α) : normUnit (a * normUnit a) = 1 
goal: normUnit (a * ↑(normUnit a)) = 1

full_name: normalize_idem
code: theorem normalize_idem (x : α) : normalize (normalize x) = normalize x 
goal: normalize (normalize x) = normalize x

full_name: normalize_eq_normalize
code: theorem normalize_eq_normalize {a b : α} (hab : a ∣ b) (hba : b ∣ a) :
    normalize a = normalize b 
goal: normalize a = normalize b

full_name: normalize_eq_normalize_iff
code: theorem normalize_eq_normalize_iff {x y : α} : normalize x = normalize y ↔ x ∣ y ∧ y ∣ x 
goal: normalize x = normalize y ↔ x ∣ y ∧ y ∣ x

full_name: dvd_antisymm_of_normalize_eq
code: theorem dvd_antisymm_of_normalize_eq {a b : α} (ha : normalize a = a) (hb : normalize b = b)
    (hab : a ∣ b) (hba : b ∣ a) : a = b 
goal: a = b

full_name: Associated.eq_of_normalized
code: theorem Associated.eq_of_normalized
    {a b : α} (h : Associated a b) (ha : normalize a = a) (hb : normalize b = b) :
    a = b 
goal: a = b

full_name: dvd_normalize_iff
code: theorem dvd_normalize_iff {a b : α} : a ∣ normalize b ↔ a ∣ b 
goal: a ∣ normalize b ↔ a ∣ b

full_name: normalize_dvd_iff
code: theorem normalize_dvd_iff {a b : α} : normalize a ∣ b ↔ a ∣ b 
goal: normalize a ∣ b ↔ a ∣ b

full_name: Associates.out
code: /-- Maps an element of `Associates` back to the normalized element of its associate class -/
protected def out : Associates α → α 
goal: Associates α → α

full_name: Associates.out_mk
code: @[simp]
theorem out_mk (a : α) : (Associates.mk a).out = normalize a 
goal: (Associates.mk a).out = normalize a

full_name: Associates.out_one
code: @[simp]
theorem out_one : (1 : Associates α).out = 1 
goal: Associates.out 1 = 1

full_name: Associates.out_mul
code: theorem out_mul (a b : Associates α) : (a * b).out = a.out * b.out 
goal: (a * b).out = a.out * b.out

full_name: Associates.dvd_out_iff
code: theorem dvd_out_iff (a : α) (b : Associates α) : a ∣ b.out ↔ Associates.mk a ≤ b 
goal: a ∣ b.out ↔ Associates.mk a ≤ b

full_name: Associates.out_dvd_iff
code: theorem out_dvd_iff (a : α) (b : Associates α) : b.out ∣ a ↔ b ≤ Associates.mk a 
goal: b.out ∣ a ↔ b ≤ Associates.mk a

full_name: Associates.out_top
code: @[simp]
theorem out_top : (⊤ : Associates α).out = 0 
goal: ⊤.out = 0

full_name: Associates.normalize_out
code: @[simp 1100]
theorem normalize_out (a : Associates α) : normalize a.out = a.out 
goal: normalize a.out = a.out

full_name: Associates.mk_out
code: @[simp]
theorem mk_out (a : Associates α) : Associates.mk a.out = a 
goal: Associates.mk a.out = a

full_name: Associates.out_injective
code: theorem out_injective : Function.Injective (Associates.out : _ → α) 
goal: Function.Injective Associates.out

full_name: GCDMonoid.lcm_zero_left
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: lcm 0 a = 0

full_name: GCDMonoid.dvd_gcd
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: a ∣ c → a ∣ b → a ∣ gcd c b

full_name: GCDMonoid.gcd_mul_lcm
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: Associated (gcd a b * lcm a b) (a * b)

full_name: GCDMonoid.lcm_zero_right
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: lcm a 0 = 0

full_name: GCDMonoid.gcd
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: α → α → α

full_name: GCDMonoid
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: Type u_2

full_name: GCDMonoid.gcd_dvd_right
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: gcd a b ∣ b

full_name: GCDMonoid.gcd_dvd_left
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: gcd a b ∣ a

full_name: GCDMonoid.lcm
code: /-- GCD monoid: a `CancelCommMonoidWithZero` with `gcd` (greatest common divisor) and
`lcm` (least common multiple) operations, determined up to a unit. The type class focuses on `gcd`
and we derive the corresponding `lcm` facts from `gcd`.
-/
class GCDMonoid (α : Type*) [CancelCommMonoidWithZero α] where
  /-- The greatest common divisor between two elements. -/
  gcd : α → α → α
  /-- The least common multiple between two elements. -/
  lcm : α → α → α
  /-- The GCD is a divisor of the first element. -/
  gcd_dvd_left : ∀ a b, gcd a b ∣ a
  /-- The GCD is a divisor of the second element. -/
  gcd_dvd_right : ∀ a b, gcd a b ∣ b
  /-- Any common divisor of both elements is a divisor of the GCD. -/
  dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b
  /-- The product of two elements is `Associated` with the product of their GCD and LCM. -/
  gcd_mul_lcm : ∀ a b, Associated (gcd a b * lcm a b) (a * b)
  /-- `0` is left-absorbing. -/
  lcm_zero_left : ∀ a, lcm 0 a = 0
  /-- `0` is right-absorbing. -/
  lcm_zero_right : ∀ a, lcm a 0 = 0
goal: α → α → α

full_name: NormalizedGCDMonoid.normalize_gcd
code: /-- Normalized GCD monoid: a `CancelCommMonoidWithZero` with normalization and `gcd`
(greatest common divisor) and `lcm` (least common multiple) operations. In this setting `gcd` and
`lcm` form a bounded lattice on the associated elements where `gcd` is the infimum, `lcm` is the
supremum, `1` is bottom, and `0` is top. The type class focuses on `gcd` and we derive the
corresponding `lcm` facts from `gcd`.
-/
class NormalizedGCDMonoid (α : Type*) [CancelCommMonoidWithZero α] extends NormalizationMonoid α,
  GCDMonoid α where
  /-- The GCD is normalized to itself. -/
  normalize_gcd : ∀ a b, normalize (gcd a b) = gcd a b
  /-- The LCM is normalized to itself. -/
  normalize_lcm : ∀ a b, normalize (lcm a b) = lcm a b
goal: normalize (gcd a b) = gcd a b

full_name: NormalizedGCDMonoid.normalize_lcm
code: /-- Normalized GCD monoid: a `CancelCommMonoidWithZero` with normalization and `gcd`
(greatest common divisor) and `lcm` (least common multiple) operations. In this setting `gcd` and
`lcm` form a bounded lattice on the associated elements where `gcd` is the infimum, `lcm` is the
supremum, `1` is bottom, and `0` is top. The type class focuses on `gcd` and we derive the
corresponding `lcm` facts from `gcd`.
-/
class NormalizedGCDMonoid (α : Type*) [CancelCommMonoidWithZero α] extends NormalizationMonoid α,
  GCDMonoid α where
  /-- The GCD is normalized to itself. -/
  normalize_gcd : ∀ a b, normalize (gcd a b) = gcd a b
  /-- The LCM is normalized to itself. -/
  normalize_lcm : ∀ a b, normalize (lcm a b) = lcm a b
goal: normalize (lcm a b) = lcm a b

full_name: NormalizedGCDMonoid
code: /-- Normalized GCD monoid: a `CancelCommMonoidWithZero` with normalization and `gcd`
(greatest common divisor) and `lcm` (least common multiple) operations. In this setting `gcd` and
`lcm` form a bounded lattice on the associated elements where `gcd` is the infimum, `lcm` is the
supremum, `1` is bottom, and `0` is top. The type class focuses on `gcd` and we derive the
corresponding `lcm` facts from `gcd`.
-/
class NormalizedGCDMonoid (α : Type*) [CancelCommMonoidWithZero α] extends NormalizationMonoid α,
  GCDMonoid α where
  /-- The GCD is normalized to itself. -/
  normalize_gcd : ∀ a b, normalize (gcd a b) = gcd a b
  /-- The LCM is normalized to itself. -/
  normalize_lcm : ∀ a b, normalize (lcm a b) = lcm a b
goal: Type u_2

full_name: instNonemptyNormalizationMonoid
code: instance [NormalizationMonoid α] : Nonempty (NormalizationMonoid α) 
goal: Nonempty (NormalizationMonoid α)

full_name: instNonemptyGCDMonoid
code: instance [GCDMonoid α] : Nonempty (GCDMonoid α) 
goal: Nonempty (GCDMonoid α)

full_name: instNonemptyNormalizedGCDMonoid
code: instance [NormalizedGCDMonoid α] : Nonempty (NormalizedGCDMonoid α) 
goal: Nonempty (NormalizedGCDMonoid α)

full_name: instNonemptyNormalizationMonoidOfNormalizedGCDMonoid
code: instance [h : Nonempty (NormalizedGCDMonoid α)] : Nonempty (NormalizationMonoid α) 
goal: Nonempty (NormalizationMonoid α)

full_name: instNonemptyGCDMonoidOfNormalizedGCDMonoid
code: instance [h : Nonempty (NormalizedGCDMonoid α)] : Nonempty (GCDMonoid α) 
goal: Nonempty (GCDMonoid α)

full_name: gcd_isUnit_iff_isRelPrime
code: theorem gcd_isUnit_iff_isRelPrime [GCDMonoid α] {a b : α} :
    IsUnit (gcd a b) ↔ IsRelPrime a b 
goal: IsUnit (gcd a b) ↔ IsRelPrime a b

full_name: normalize_gcd
code: @[simp 1100]
theorem normalize_gcd [NormalizedGCDMonoid α] : ∀ a b : α, normalize (gcd a b) = gcd a b 
goal: normalize (gcd a b) = gcd a b

full_name: gcd_mul_lcm
code: theorem gcd_mul_lcm [GCDMonoid α] : ∀ a b : α, Associated (gcd a b * lcm a b) (a * b) 
goal: Associated (gcd a b * lcm a b) (a * b)

full_name: dvd_gcd_iff
code: theorem dvd_gcd_iff [GCDMonoid α] (a b c : α) : a ∣ gcd b c ↔ a ∣ b ∧ a ∣ c 
goal: a ∣ gcd b c ↔ a ∣ b ∧ a ∣ c

full_name: gcd_comm
code: theorem gcd_comm [NormalizedGCDMonoid α] (a b : α) : gcd a b = gcd b a 
goal: gcd a b = gcd b a

full_name: gcd_comm'
code: theorem gcd_comm' [GCDMonoid α] (a b : α) : Associated (gcd a b) (gcd b a) 
goal: Associated (gcd a b) (gcd b a)

full_name: gcd_assoc
code: theorem gcd_assoc [NormalizedGCDMonoid α] (m n k : α) : gcd (gcd m n) k = gcd m (gcd n k) 
goal: gcd (gcd m n) k = gcd m (gcd n k)

full_name: gcd_assoc'
code: theorem gcd_assoc' [GCDMonoid α] (m n k : α) : Associated (gcd (gcd m n) k) (gcd m (gcd n k)) 
goal: Associated (gcd (gcd m n) k) (gcd m (gcd n k))

full_name: instCommutativeGcd
code: instance [NormalizedGCDMonoid α] : Std.Commutative (α := α) gcd 
goal: Std.Commutative gcd

full_name: instAssociativeGcd
code: instance [NormalizedGCDMonoid α] : Std.Associative (α := α) gcd 
goal: Std.Associative gcd

full_name: gcd_eq_normalize
code: theorem gcd_eq_normalize [NormalizedGCDMonoid α] {a b c : α} (habc : gcd a b ∣ c)
    (hcab : c ∣ gcd a b) : gcd a b = normalize c 
goal: gcd a b = normalize c

full_name: gcd_zero_left
code: @[simp]
theorem gcd_zero_left [NormalizedGCDMonoid α] (a : α) : gcd 0 a = normalize a 
goal: gcd 0 a = normalize a

full_name: gcd_zero_left'
code: theorem gcd_zero_left' [GCDMonoid α] (a : α) : Associated (gcd 0 a) a 
goal: Associated (gcd 0 a) a

full_name: gcd_zero_right
code: @[simp]
theorem gcd_zero_right [NormalizedGCDMonoid α] (a : α) : gcd a 0 = normalize a 
goal: gcd a 0 = normalize a

full_name: gcd_zero_right'
code: theorem gcd_zero_right' [GCDMonoid α] (a : α) : Associated (gcd a 0) a 
goal: Associated (gcd a 0) a

full_name: gcd_eq_zero_iff
code: @[simp]
theorem gcd_eq_zero_iff [GCDMonoid α] (a b : α) : gcd a b = 0 ↔ a = 0 ∧ b = 0 
goal: gcd a b = 0 ↔ a = 0 ∧ b = 0

full_name: gcd_one_left
code: @[simp]
theorem gcd_one_left [NormalizedGCDMonoid α] (a : α) : gcd 1 a = 1 
goal: gcd 1 a = 1

full_name: isUnit_gcd_one_left
code: @[simp]
theorem isUnit_gcd_one_left [GCDMonoid α] (a : α) : IsUnit (gcd 1 a) 
goal: IsUnit (gcd 1 a)

full_name: gcd_one_left'
code: theorem gcd_one_left' [GCDMonoid α] (a : α) : Associated (gcd 1 a) 1 
goal: Associated (gcd 1 a) 1

full_name: gcd_one_right
code: @[simp]
theorem gcd_one_right [NormalizedGCDMonoid α] (a : α) : gcd a 1 = 1 
goal: gcd a 1 = 1

full_name: isUnit_gcd_one_right
code: @[simp]
theorem isUnit_gcd_one_right [GCDMonoid α] (a : α) : IsUnit (gcd a 1) 
goal: IsUnit (gcd a 1)

full_name: gcd_one_right'
code: theorem gcd_one_right' [GCDMonoid α] (a : α) : Associated (gcd a 1) 1 
goal: Associated (gcd a 1) 1

full_name: gcd_dvd_gcd
code: theorem gcd_dvd_gcd [GCDMonoid α] {a b c d : α} (hab : a ∣ b) (hcd : c ∣ d) : gcd a c ∣ gcd b d 
goal: gcd a c ∣ gcd b d

full_name: Associated.gcd
code: protected theorem Associated.gcd [GCDMonoid α]
    {a₁ a₂ b₁ b₂ : α} (ha : Associated a₁ a₂) (hb : Associated b₁ b₂) :
    Associated (gcd a₁ b₁) (gcd a₂ b₂) 
goal: Associated (gcd a₁ b₁) (gcd a₂ b₂)

full_name: gcd_same
code: @[simp]
theorem gcd_same [NormalizedGCDMonoid α] (a : α) : gcd a a = normalize a 
goal: gcd a a = normalize a

full_name: gcd_mul_left
code: @[simp]
theorem gcd_mul_left [NormalizedGCDMonoid α] (a b c : α) :
    gcd (a * b) (a * c) = normalize a * gcd b c 
goal: gcd (a * b) (a * c) = normalize a * gcd b c

full_name: gcd_mul_left'
code: theorem gcd_mul_left' [GCDMonoid α] (a b c : α) :
    Associated (gcd (a * b) (a * c)) (a * gcd b c) 
goal: Associated (gcd (a * b) (a * c)) (a * gcd b c)

full_name: gcd_mul_right
code: @[simp]
theorem gcd_mul_right [NormalizedGCDMonoid α] (a b c : α) :
    gcd (b * a) (c * a) = gcd b c * normalize a 
goal: gcd (b * a) (c * a) = gcd b c * normalize a

full_name: gcd_mul_right'
code: @[simp]
theorem gcd_mul_right' [GCDMonoid α] (a b c : α) :
    Associated (gcd (b * a) (c * a)) (gcd b c * a) 
goal: Associated (gcd (b * a) (c * a)) (gcd b c * a)

full_name: gcd_eq_left_iff
code: theorem gcd_eq_left_iff [NormalizedGCDMonoid α] (a b : α) (h : normalize a = a) :
    gcd a b = a ↔ a ∣ b 
goal: gcd a b = a ↔ a ∣ b

full_name: gcd_eq_right_iff
code: theorem gcd_eq_right_iff [NormalizedGCDMonoid α] (a b : α) (h : normalize b = b) :
    gcd a b = b ↔ b ∣ a 
goal: gcd a b = b ↔ b ∣ a

full_name: gcd_dvd_gcd_mul_left
code: theorem gcd_dvd_gcd_mul_left [GCDMonoid α] (m n k : α) : gcd m n ∣ gcd (k * m) n 
goal: gcd m n ∣ gcd (k * m) n

full_name: gcd_dvd_gcd_mul_right
code: theorem gcd_dvd_gcd_mul_right [GCDMonoid α] (m n k : α) : gcd m n ∣ gcd (m * k) n 
goal: gcd m n ∣ gcd (m * k) n

full_name: gcd_dvd_gcd_mul_left_right
code: theorem gcd_dvd_gcd_mul_left_right [GCDMonoid α] (m n k : α) : gcd m n ∣ gcd m (k * n) 
goal: gcd m n ∣ gcd m (k * n)

full_name: gcd_dvd_gcd_mul_right_right
code: theorem gcd_dvd_gcd_mul_right_right [GCDMonoid α] (m n k : α) : gcd m n ∣ gcd m (n * k) 
goal: gcd m n ∣ gcd m (n * k)

full_name: Associated.gcd_eq_left
code: theorem Associated.gcd_eq_left [NormalizedGCDMonoid α] {m n : α} (h : Associated m n) (k : α) :
    gcd m k = gcd n k 
goal: gcd m k = gcd n k

full_name: Associated.gcd_eq_right
code: theorem Associated.gcd_eq_right [NormalizedGCDMonoid α] {m n : α} (h : Associated m n) (k : α) :
    gcd k m = gcd k n 
goal: gcd k m = gcd k n

full_name: dvd_gcd_mul_of_dvd_mul
code: theorem dvd_gcd_mul_of_dvd_mul [GCDMonoid α] {m n k : α} (H : k ∣ m * n) : k ∣ gcd k m * n 
goal: k ∣ gcd k m * n

full_name: dvd_gcd_mul_iff_dvd_mul
code: theorem dvd_gcd_mul_iff_dvd_mul [GCDMonoid α] {m n k : α} : k ∣ gcd k m * n ↔ k ∣ m * n 
goal: k ∣ gcd k m * n ↔ k ∣ m * n

full_name: dvd_mul_gcd_of_dvd_mul
code: theorem dvd_mul_gcd_of_dvd_mul [GCDMonoid α] {m n k : α} (H : k ∣ m * n) : k ∣ m * gcd k n 
goal: k ∣ m * gcd k n

full_name: dvd_mul_gcd_iff_dvd_mul
code: theorem dvd_mul_gcd_iff_dvd_mul [GCDMonoid α] {m n k : α} : k ∣ m * gcd k n ↔ k ∣ m * n 
goal: k ∣ m * gcd k n ↔ k ∣ m * n

full_name: instDecompositionMonoidOfNonemptyGCDMonoid
code: /-- Represent a divisor of `m * n` as a product of a divisor of `m` and a divisor of `n`.

Note: In general, this representation is highly non-unique.

See `Nat.prodDvdAndDvdOfDvdProd` for a constructive version on `ℕ`.  -/
instance [h : Nonempty (GCDMonoid α)] : DecompositionMonoid α 
goal: DecompositionMonoid α

full_name: gcd_mul_dvd_mul_gcd
code: theorem gcd_mul_dvd_mul_gcd [GCDMonoid α] (k m n : α) : gcd k (m * n) ∣ gcd k m * gcd k n 
goal: gcd k (m * n) ∣ gcd k m * gcd k n

full_name: gcd_pow_right_dvd_pow_gcd
code: theorem gcd_pow_right_dvd_pow_gcd [GCDMonoid α] {a b : α} {k : ℕ} :
    gcd a (b ^ k) ∣ gcd a b ^ k 
goal: gcd a (b ^ k) ∣ gcd a b ^ k

full_name: gcd_pow_left_dvd_pow_gcd
code: theorem gcd_pow_left_dvd_pow_gcd [GCDMonoid α] {a b : α} {k : ℕ} : gcd (a ^ k) b ∣ gcd a b ^ k 
goal: gcd (a ^ k) b ∣ gcd a b ^ k

full_name: pow_dvd_of_mul_eq_pow
code: theorem pow_dvd_of_mul_eq_pow [GCDMonoid α] {a b c d₁ d₂ : α} (ha : a ≠ 0) (hab : IsUnit (gcd a b))
    {k : ℕ} (h : a * b = c ^ k) (hc : c = d₁ * d₂) (hd₁ : d₁ ∣ a) : d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a 
goal: d₁ ^ k ≠ 0 ∧ d₁ ^ k ∣ a

full_name: exists_associated_pow_of_mul_eq_pow
code: theorem exists_associated_pow_of_mul_eq_pow [GCDMonoid α] {a b c : α} (hab : IsUnit (gcd a b))
    {k : ℕ} (h : a * b = c ^ k) : ∃ d : α, Associated (d ^ k) a 
goal: ∃ d, Associated (d ^ k) a

full_name: exists_eq_pow_of_mul_eq_pow
code: theorem exists_eq_pow_of_mul_eq_pow [GCDMonoid α] [Unique αˣ] {a b c : α} (hab : IsUnit (gcd a b))
    {k : ℕ} (h : a * b = c ^ k) : ∃ d : α, a = d ^ k 
goal: ∃ d, a = d ^ k

full_name: gcd_greatest
code: theorem gcd_greatest {α : Type*} [CancelCommMonoidWithZero α] [NormalizedGCDMonoid α] {a b d : α}
    (hda : d ∣ a) (hdb : d ∣ b) (hd : ∀ e : α, e ∣ a → e ∣ b → e ∣ d) :
    GCDMonoid.gcd a b = normalize d 
goal: gcd a b = normalize d

full_name: gcd_greatest_associated
code: theorem gcd_greatest_associated {α : Type*} [CancelCommMonoidWithZero α] [GCDMonoid α] {a b d : α}
    (hda : d ∣ a) (hdb : d ∣ b) (hd : ∀ e : α, e ∣ a → e ∣ b → e ∣ d) :
    Associated d (GCDMonoid.gcd a b) 
goal: Associated d (gcd a b)

full_name: isUnit_gcd_of_eq_mul_gcd
code: theorem isUnit_gcd_of_eq_mul_gcd {α : Type*} [CancelCommMonoidWithZero α] [GCDMonoid α]
    {x y x' y' : α} (ex : x = gcd x y * x') (ey : y = gcd x y * y') (h : gcd x y ≠ 0) :
    IsUnit (gcd x' y') 
goal: IsUnit (gcd x' y')

full_name: extract_gcd
code: theorem extract_gcd {α : Type*} [CancelCommMonoidWithZero α] [GCDMonoid α] (x y : α) :
    ∃ x' y', x = gcd x y * x' ∧ y = gcd x y * y' ∧ IsUnit (gcd x' y') 
goal: ∃ x' y', x = gcd x y * x' ∧ y = gcd x y * y' ∧ IsUnit (gcd x' y')

full_name: associated_gcd_left_iff
code: theorem associated_gcd_left_iff [GCDMonoid α] {x y : α} : Associated x (gcd x y) ↔ x ∣ y 
goal: Associated x (gcd x y) ↔ x ∣ y

full_name: associated_gcd_right_iff
code: theorem associated_gcd_right_iff [GCDMonoid α] {x y : α} : Associated y (gcd x y) ↔ y ∣ x 
goal: Associated y (gcd x y) ↔ y ∣ x

full_name: Irreducible.isUnit_gcd_iff
code: theorem Irreducible.isUnit_gcd_iff [GCDMonoid α] {x y : α} (hx : Irreducible x) :
    IsUnit (gcd x y) ↔ ¬(x ∣ y) 
goal: IsUnit (gcd x y) ↔ ¬x ∣ y

full_name: Irreducible.gcd_eq_one_iff
code: theorem Irreducible.gcd_eq_one_iff [NormalizedGCDMonoid α] {x y : α} (hx : Irreducible x) :
    gcd x y = 1 ↔ ¬(x ∣ y) 
goal: gcd x y = 1 ↔ ¬x ∣ y

full_name: gcd_neg'
code: lemma gcd_neg' [GCDMonoid α] {a b : α} : Associated (gcd a (-b)) (gcd a b) 
goal: Associated (gcd a (-b)) (gcd a b)

full_name: gcd_neg
code: lemma gcd_neg [NormalizedGCDMonoid α] {a b : α} : gcd a (-b) = gcd a b 
goal: gcd a (-b) = gcd a b

full_name: neg_gcd'
code: lemma neg_gcd' [GCDMonoid α] {a b : α} : Associated (gcd (-a) b) (gcd a b) 
goal: Associated (gcd (-a) b) (gcd a b)

full_name: neg_gcd
code: lemma neg_gcd [NormalizedGCDMonoid α] {a b : α} : gcd (-a) b = gcd a b 
goal: gcd (-a) b = gcd a b

full_name: lcm_dvd_iff
code: theorem lcm_dvd_iff [GCDMonoid α] {a b c : α} : lcm a b ∣ c ↔ a ∣ c ∧ b ∣ c 
goal: lcm a b ∣ c ↔ a ∣ c ∧ b ∣ c

full_name: dvd_lcm_left
code: theorem dvd_lcm_left [GCDMonoid α] (a b : α) : a ∣ lcm a b 
goal: a ∣ lcm a b

full_name: dvd_lcm_right
code: theorem dvd_lcm_right [GCDMonoid α] (a b : α) : b ∣ lcm a b 
goal: b ∣ lcm a b

full_name: lcm_dvd
code: theorem lcm_dvd [GCDMonoid α] {a b c : α} (hab : a ∣ b) (hcb : c ∣ b) : lcm a c ∣ b 
goal: lcm a c ∣ b

full_name: lcm_eq_zero_iff
code: @[simp]
theorem lcm_eq_zero_iff [GCDMonoid α] (a b : α) : lcm a b = 0 ↔ a = 0 ∨ b = 0 
goal: lcm a b = 0 ↔ a = 0 ∨ b = 0

full_name: normalize_lcm
code: @[simp 1100]
theorem normalize_lcm [NormalizedGCDMonoid α] (a b : α) : normalize (lcm a b) = lcm a b 
goal: normalize (lcm a b) = lcm a b

full_name: lcm_comm
code: theorem lcm_comm [NormalizedGCDMonoid α] (a b : α) : lcm a b = lcm b a 
goal: lcm a b = lcm b a

full_name: lcm_comm'
code: theorem lcm_comm' [GCDMonoid α] (a b : α) : Associated (lcm a b) (lcm b a) 
goal: Associated (lcm a b) (lcm b a)

full_name: lcm_assoc
code: theorem lcm_assoc [NormalizedGCDMonoid α] (m n k : α) : lcm (lcm m n) k = lcm m (lcm n k) 
goal: lcm (lcm m n) k = lcm m (lcm n k)

full_name: lcm_assoc'
code: theorem lcm_assoc' [GCDMonoid α] (m n k : α) : Associated (lcm (lcm m n) k) (lcm m (lcm n k)) 
goal: Associated (lcm (lcm m n) k) (lcm m (lcm n k))

full_name: instCommutativeLcm
code: instance [NormalizedGCDMonoid α] : Std.Commutative (α := α) lcm 
goal: Std.Commutative lcm

full_name: instAssociativeLcm
code: instance [NormalizedGCDMonoid α] : Std.Associative (α := α) lcm 
goal: Std.Associative lcm

full_name: lcm_eq_normalize
code: theorem lcm_eq_normalize [NormalizedGCDMonoid α] {a b c : α} (habc : lcm a b ∣ c)
    (hcab : c ∣ lcm a b) : lcm a b = normalize c 
goal: lcm a b = normalize c

full_name: lcm_dvd_lcm
code: theorem lcm_dvd_lcm [GCDMonoid α] {a b c d : α} (hab : a ∣ b) (hcd : c ∣ d) : lcm a c ∣ lcm b d 
goal: lcm a c ∣ lcm b d

full_name: Associated.lcm
code: protected theorem Associated.lcm [GCDMonoid α]
    {a₁ a₂ b₁ b₂ : α} (ha : Associated a₁ a₂) (hb : Associated b₁ b₂) :
    Associated (lcm a₁ b₁) (lcm a₂ b₂) 
goal: Associated (lcm a₁ b₁) (lcm a₂ b₂)

full_name: lcm_units_coe_left
code: @[simp]
theorem lcm_units_coe_left [NormalizedGCDMonoid α] (u : αˣ) (a : α) : lcm (↑u) a = normalize a 
goal: lcm (↑u) a = normalize a

full_name: lcm_units_coe_right
code: @[simp]
theorem lcm_units_coe_right [NormalizedGCDMonoid α] (a : α) (u : αˣ) : lcm a ↑u = normalize a 
goal: lcm a ↑u = normalize a

full_name: lcm_one_left
code: @[simp]
theorem lcm_one_left [NormalizedGCDMonoid α] (a : α) : lcm 1 a = normalize a 
goal: lcm 1 a = normalize a

full_name: lcm_one_right
code: @[simp]
theorem lcm_one_right [NormalizedGCDMonoid α] (a : α) : lcm a 1 = normalize a 
goal: lcm a 1 = normalize a

full_name: lcm_same
code: @[simp]
theorem lcm_same [NormalizedGCDMonoid α] (a : α) : lcm a a = normalize a 
goal: lcm a a = normalize a

full_name: lcm_eq_one_iff
code: @[simp]
theorem lcm_eq_one_iff [NormalizedGCDMonoid α] (a b : α) : lcm a b = 1 ↔ a ∣ 1 ∧ b ∣ 1 
goal: lcm a b = 1 ↔ a ∣ 1 ∧ b ∣ 1

full_name: lcm_mul_left
code: @[simp]
theorem lcm_mul_left [NormalizedGCDMonoid α] (a b c : α) :
    lcm (a * b) (a * c) = normalize a * lcm b c 
goal: lcm (a * b) (a * c) = normalize a * lcm b c

full_name: lcm_mul_right
code: @[simp]
theorem lcm_mul_right [NormalizedGCDMonoid α] (a b c : α) :
    lcm (b * a) (c * a) = lcm b c * normalize a 
goal: lcm (b * a) (c * a) = lcm b c * normalize a

full_name: lcm_eq_left_iff
code: theorem lcm_eq_left_iff [NormalizedGCDMonoid α] (a b : α) (h : normalize a = a) :
    lcm a b = a ↔ b ∣ a 
goal: lcm a b = a ↔ b ∣ a

full_name: lcm_eq_right_iff
code: theorem lcm_eq_right_iff [NormalizedGCDMonoid α] (a b : α) (h : normalize b = b) :
    lcm a b = b ↔ a ∣ b 
goal: lcm a b = b ↔ a ∣ b

full_name: lcm_dvd_lcm_mul_left
code: theorem lcm_dvd_lcm_mul_left [GCDMonoid α] (m n k : α) : lcm m n ∣ lcm (k * m) n 
goal: lcm m n ∣ lcm (k * m) n

full_name: lcm_dvd_lcm_mul_right
code: theorem lcm_dvd_lcm_mul_right [GCDMonoid α] (m n k : α) : lcm m n ∣ lcm (m * k) n 
goal: lcm m n ∣ lcm (m * k) n

full_name: lcm_dvd_lcm_mul_left_right
code: theorem lcm_dvd_lcm_mul_left_right [GCDMonoid α] (m n k : α) : lcm m n ∣ lcm m (k * n) 
goal: lcm m n ∣ lcm m (k * n)

full_name: lcm_dvd_lcm_mul_right_right
code: theorem lcm_dvd_lcm_mul_right_right [GCDMonoid α] (m n k : α) : lcm m n ∣ lcm m (n * k) 
goal: lcm m n ∣ lcm m (n * k)

full_name: lcm_eq_of_associated_left
code: theorem lcm_eq_of_associated_left [NormalizedGCDMonoid α] {m n : α} (h : Associated m n) (k : α) :
    lcm m k = lcm n k 
goal: lcm m k = lcm n k

full_name: lcm_eq_of_associated_right
code: theorem lcm_eq_of_associated_right [NormalizedGCDMonoid α] {m n : α} (h : Associated m n) (k : α) :
    lcm k m = lcm k n 
goal: lcm k m = lcm k n

full_name: normalizationMonoidOfUniqueUnits
code: instance (priority := 100) normalizationMonoidOfUniqueUnits : NormalizationMonoid α 
goal: NormalizationMonoid α

full_name: uniqueNormalizationMonoidOfUniqueUnits
code: instance uniqueNormalizationMonoidOfUniqueUnits : Unique (NormalizationMonoid α) 
goal: Unique (NormalizationMonoid α)

full_name: subsingleton_gcdMonoid_of_unique_units
code: instance subsingleton_gcdMonoid_of_unique_units : Subsingleton (GCDMonoid α) 
goal: Subsingleton (GCDMonoid α)

full_name: subsingleton_normalizedGCDMonoid_of_unique_units
code: instance subsingleton_normalizedGCDMonoid_of_unique_units : Subsingleton (NormalizedGCDMonoid α) 
goal: Subsingleton (NormalizedGCDMonoid α)

full_name: normUnit_eq_one
code: @[simp]
theorem normUnit_eq_one (x : α) : normUnit x = 1 
goal: normUnit x = 1

full_name: normalize_eq
code: theorem normalize_eq (x : α) : normalize x = x 
goal: normalize x = x

full_name: associatesEquivOfUniqueUnits_apply
code: /-- If a monoid's only unit is `1`, then it is isomorphic to its associates. -/
@[simps]
def associatesEquivOfUniqueUnits : Associates α ≃* α 
goal: ∀ (a : Associates α), associatesEquivOfUniqueUnits a = a.out

full_name: associatesEquivOfUniqueUnits_symm_apply
code: /-- If a monoid's only unit is `1`, then it is isomorphic to its associates. -/
@[simps]
def associatesEquivOfUniqueUnits : Associates α ≃* α 
goal: associatesEquivOfUniqueUnits.symm a = Associates.mk a

full_name: associatesEquivOfUniqueUnits
code: /-- If a monoid's only unit is `1`, then it is isomorphic to its associates. -/
@[simps]
def associatesEquivOfUniqueUnits : Associates α ≃* α 
goal: Associates α ≃* α

full_name: gcd_eq_of_dvd_sub_right
code: theorem gcd_eq_of_dvd_sub_right {a b c : α} (h : a ∣ b - c) : gcd a b = gcd a c 
goal: gcd a b = gcd a c

full_name: gcd_eq_of_dvd_sub_left
code: theorem gcd_eq_of_dvd_sub_left {a b c : α} (h : a ∣ b - c) : gcd b a = gcd c a 
goal: gcd b a = gcd c a

full_name: _private.Mathlib.Algebra.GCDMonoid.Basic.0.map_mk_unit_aux
code: private theorem map_mk_unit_aux [DecidableEq α] {f : Associates α →* α}
    (hinv : Function.RightInverse f Associates.mk) (a : α) :
    a * ↑(Classical.choose (associated_map_mk hinv a)) = f (Associates.mk a) 
goal: a * ↑(Classical.choose ⋯) = f (Associates.mk a)

full_name: normalizationMonoidOfMonoidHomRightInverse
code: /-- Define `NormalizationMonoid` on a structure from a `MonoidHom` inverse to `Associates.mk`. -/
def normalizationMonoidOfMonoidHomRightInverse [DecidableEq α] (f : Associates α →* α)
    (hinv : Function.RightInverse f Associates.mk) :
    NormalizationMonoid α 
goal: NormalizationMonoid α

full_name: gcdMonoidOfGCD
code: /-- Define `GCDMonoid` on a structure just from the `gcd` and its properties. -/
noncomputable def gcdMonoidOfGCD [DecidableEq α] (gcd : α → α → α)
    (gcd_dvd_left : ∀ a b, gcd a b ∣ a) (gcd_dvd_right : ∀ a b, gcd a b ∣ b)
    (dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b) : GCDMonoid α 
goal: GCDMonoid α

full_name: normalizedGCDMonoidOfGCD
code: /-- Define `NormalizedGCDMonoid` on a structure just from the `gcd` and its properties. -/
noncomputable def normalizedGCDMonoidOfGCD [NormalizationMonoid α] [DecidableEq α] (gcd : α → α → α)
    (gcd_dvd_left : ∀ a b, gcd a b ∣ a) (gcd_dvd_right : ∀ a b, gcd a b ∣ b)
    (dvd_gcd : ∀ {a b c}, a ∣ c → a ∣ b → a ∣ gcd c b)
    (normalize_gcd : ∀ a b, normalize (gcd a b) = gcd a b) : NormalizedGCDMonoid α 
goal: NormalizedGCDMonoid α

full_name: gcdMonoidOfLCM
code: /-- Define `GCDMonoid` on a structure just from the `lcm` and its properties. -/
noncomputable def gcdMonoidOfLCM [DecidableEq α] (lcm : α → α → α)
    (dvd_lcm_left : ∀ a b, a ∣ lcm a b) (dvd_lcm_right : ∀ a b, b ∣ lcm a b)
    (lcm_dvd : ∀ {a b c}, c ∣ a → b ∣ a → lcm c b ∣ a) : GCDMonoid α 
goal: GCDMonoid α

full_name: normalizedGCDMonoidOfLCM
code: /-- Define `NormalizedGCDMonoid` on a structure just from the `lcm` and its properties. -/
noncomputable def normalizedGCDMonoidOfLCM [NormalizationMonoid α] [DecidableEq α] (lcm : α → α → α)
    (dvd_lcm_left : ∀ a b, a ∣ lcm a b) (dvd_lcm_right : ∀ a b, b ∣ lcm a b)
    (lcm_dvd : ∀ {a b c}, c ∣ a → b ∣ a → lcm c b ∣ a)
    (normalize_lcm : ∀ a b, normalize (lcm a b) = lcm a b) : NormalizedGCDMonoid α 
goal: NormalizedGCDMonoid α

full_name: gcdMonoidOfExistsGCD
code: /-- Define a `GCDMonoid` structure on a monoid just from the existence of a `gcd`. -/
noncomputable def gcdMonoidOfExistsGCD [DecidableEq α]
    (h : ∀ a b : α, ∃ c : α, ∀ d : α, d ∣ a ∧ d ∣ b ↔ d ∣ c) : GCDMonoid α 
goal: GCDMonoid α

full_name: normalizedGCDMonoidOfExistsGCD
code: /-- Define a `NormalizedGCDMonoid` structure on a monoid just from the existence of a `gcd`. -/
noncomputable def normalizedGCDMonoidOfExistsGCD [NormalizationMonoid α] [DecidableEq α]
    (h : ∀ a b : α, ∃ c : α, ∀ d : α, d ∣ a ∧ d ∣ b ↔ d ∣ c) : NormalizedGCDMonoid α 
goal: NormalizedGCDMonoid α

full_name: gcdMonoidOfExistsLCM
code: /-- Define a `GCDMonoid` structure on a monoid just from the existence of an `lcm`. -/
noncomputable def gcdMonoidOfExistsLCM [DecidableEq α]
    (h : ∀ a b : α, ∃ c : α, ∀ d : α, a ∣ d ∧ b ∣ d ↔ c ∣ d) : GCDMonoid α 
goal: GCDMonoid α

full_name: normalizedGCDMonoidOfExistsLCM
code: /-- Define a `NormalizedGCDMonoid` structure on a monoid just from the existence of an `lcm`. -/
noncomputable def normalizedGCDMonoidOfExistsLCM [NormalizationMonoid α] [DecidableEq α]
    (h : ∀ a b : α, ∃ c : α, ∀ d : α, a ∣ d ∧ b ∣ d ↔ c ∣ d) : NormalizedGCDMonoid α 
goal: NormalizedGCDMonoid α

full_name: CommGroupWithZero.instNormalizedGCDMonoid
code: instance (priority := 100) : NormalizedGCDMonoid G₀ 
goal: NormalizedGCDMonoid G₀

full_name: CommGroupWithZero.coe_normUnit
code: @[simp]
theorem coe_normUnit {a : G₀} (h0 : a ≠ 0) : (↑(normUnit a) : G₀) = a⁻¹ 
goal: ↑(normUnit a) = a⁻¹

full_name: CommGroupWithZero.normalize_eq_one
code: theorem normalize_eq_one {a : G₀} (h0 : a ≠ 0) : normalize a = 1 
goal: normalize a = 1

full_name: Associates.instGCDMonoid
code: instance instGCDMonoid : GCDMonoid (Associates α) 
goal: GCDMonoid (Associates α)

full_name: Associates.gcd_mk_mk
code: theorem gcd_mk_mk {a b : α} : gcd (Associates.mk a) (Associates.mk b) = Associates.mk (gcd a b) 
goal: gcd (Associates.mk a) (Associates.mk b) = Associates.mk (gcd a b)

full_name: Associates.lcm_mk_mk
code: theorem lcm_mk_mk {a b : α} : lcm (Associates.mk a) (Associates.mk b) = Associates.mk (lcm a b) 
goal: lcm (Associates.mk a) (Associates.mk b) = Associates.mk (lcm a b)