Module docstring
{"# Lemmas about semiconjugate elements in a GroupWithZero.
"}
{"# Lemmas about semiconjugate elements in a GroupWithZero.
"}
SemiconjBy.zero_right
      theorem
     [MulZeroClass G₀] (a : G₀) : SemiconjBy a 0 0
        @[simp]
theorem zero_right [MulZeroClass G₀] (a : G₀) : SemiconjBy a 0 0 := by
  simp only [SemiconjBy, mul_zero, zero_mul]
        SemiconjBy.zero_left
      theorem
     [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y
        @[simp]
theorem zero_left [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y := by
  simp only [SemiconjBy, mul_zero, zero_mul]
        SemiconjBy.inv_symm_left_iff₀
      theorem
     : SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x
        @[simp]
theorem inv_symm_left_iff₀ : SemiconjBySemiconjBy a⁻¹ x y ↔ SemiconjBy a y x :=
  Classical.by_cases (fun ha : a = 0 => by simp only [ha, inv_zero, SemiconjBy.zero_left]) fun ha =>
    @units_inv_symm_left_iff _ _ (Units.mk0 a ha) _ _
        SemiconjBy.inv_symm_left₀
      theorem
     (h : SemiconjBy a x y) : SemiconjBy a⁻¹ y x
        theorem inv_symm_left₀ (h : SemiconjBy a x y) : SemiconjBy a⁻¹ y x :=
  SemiconjBy.inv_symm_left_iff₀.2 h
        SemiconjBy.inv_right₀
      theorem
     (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹
        theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ := by
  by_cases ha : a = 0
  · simp only [ha, zero_left]
  by_cases hx : x = 0
  · subst x
    simp only [SemiconjBy, mul_zero, @eq_comm _ _ (y * a), mul_eq_zero] at h
    simp [h.resolve_right ha]
  · have := mul_ne_zero ha hx
    rw [h.eq, mul_ne_zero_iff] at this
    exact @units_inv_right _ _ _ (Units.mk0 x hx) (Units.mk0 y this.1) h
        SemiconjBy.inv_right_iff₀
      theorem
     : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y
        @[simp]
theorem inv_right_iff₀ : SemiconjBySemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y :=
  ⟨fun h => inv_inv x ▸ inv_inv y ▸ h.inv_right₀, inv_right₀⟩
        SemiconjBy.div_right
      theorem
     (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') : SemiconjBy a (x / x') (y / y')
        theorem div_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x / x') (y / y') := by
  rw [div_eq_mul_inv, div_eq_mul_inv]
  exact h.mul_right h'.inv_right₀
        SemiconjBy.zpow_right₀
      theorem
     {a x y : G₀} (h : SemiconjBy a x y) : ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
        lemma zpow_right₀ {a x y : G₀} (h : SemiconjBy a x y) : ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  | (n : ℕ) => by simp [h.pow_right n]
  | .negSucc n => by simp only [zpow_negSucc, (h.pow_right (n + 1)).inv_right₀]
        Commute.zpow_right₀
      theorem
     (h : Commute a b) : ∀ m : ℤ, Commute a (b ^ m)
        lemma zpow_right₀ (h : Commute a b) : ∀ m : ℤ, Commute a (b ^ m) := SemiconjBy.zpow_right₀ h
        Commute.zpow_left₀
      theorem
     (h : Commute a b) (m : ℤ) : Commute (a ^ m) b
        lemma zpow_left₀ (h : Commute a b) (m : ℤ) : Commute (a ^ m) b := (h.symm.zpow_right₀ m).symm
        Commute.zpow_zpow₀
      theorem
     (h : Commute a b) (m n : ℤ) : Commute (a ^ m) (b ^ n)
        lemma zpow_zpow₀ (h : Commute a b) (m n : ℤ) : Commute (a ^ m) (b ^ n) :=
  (h.zpow_left₀ m).zpow_right₀ n
        Commute.zpow_self₀
      theorem
     (a : G₀) (n : ℤ) : Commute (a ^ n) a
        lemma zpow_self₀ (a : G₀) (n : ℤ) : Commute (a ^ n) a := (Commute.refl a).zpow_left₀ n
        Commute.self_zpow₀
      theorem
     (a : G₀) (n : ℤ) : Commute a (a ^ n)
        lemma self_zpow₀ (a : G₀) (n : ℤ) : Commute a (a ^ n) := (Commute.refl a).zpow_right₀ n
        Commute.zpow_zpow_self₀
      theorem
     (a : G₀) (m n : ℤ) : Commute (a ^ m) (a ^ n)
        lemma zpow_zpow_self₀ (a : G₀) (m n : ℤ) : Commute (a ^ m) (a ^ n) :=
  (Commute.refl a).zpow_zpow₀ m n