l3lab/ntp-mathlib huggingface dataset:
theorem smul_diff_smul' [hH : Normal H] (g : Gᵐᵒᵖ) :
    diff (MonoidHom.id H) (g • α) (g • β) =
      ⟨g.unop⁻¹ * (diff (MonoidHom.id H) α β : H) * g.unop,
        hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩ := by
  letI := H.fintypeQuotientOfFiniteIndex
  let ϕ : H →* H :=
    { toFun := fun h =>
        ⟨g.unop⁻¹ * h * g.unop,
          hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩
      map_one' := by rw [Subtype.ext_iff, coe_mk, coe_one, mul_one, inv_mul_self]
      map_mul' := fun h₁ h₂ => by
        

Proof state:
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : IsCommutative H
inst✝ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
hH : Normal H
g : Gᵐᵒᵖ
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
h₁ h₂ : ↥H
⊢ OneHom.toFun
      { toFun := fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) },
        map_one' :=
          (_ : (fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) }) 1 = 1) }
      (h₁ * h₂) =
    OneHom.toFun
        { toFun := fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) },
          map_one' :=
            (_ : (fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) }) 1 = 1) }
        h₁ *
      OneHom.toFun
        { toFun := fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) },
          map_one' :=
            (_ : (fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) }) 1 = 1) }
        h₂

Next tactic:
simp only [Subtype.ext_iff, coe_mk, coe_mul, mul_assoc, mul_inv_cancel_left]
theorem smul_diff_smul' [hH : Normal H] (g : Gᵐᵒᵖ) :
    diff (MonoidHom.id H) (g • α) (g • β) =
      ⟨g.unop⁻¹ * (diff (MonoidHom.id H) α β : H) * g.unop,
        hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩ := by
  letI := H.fintypeQuotientOfFiniteIndex
  let ϕ : H →* H :=
    { toFun := fun h =>
        ⟨g.unop⁻¹ * h * g.unop,
          hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩
      map_one' := by rw [Subtype.ext_iff, coe_mk, coe_one, mul_one, inv_mul_self]
      map_mul' := fun h₁ h₂ => by
        simp only [Subtype.ext_iff, coe_mk, coe_mul, mul_assoc, mul_inv_cancel_left] }
  

Proof state:
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : IsCommutative H
inst✝ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
hH : Normal H
g : Gᵐᵒᵖ
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
ϕ : ↥H →* ↥H :=
  {
    toOneHom :=
      { toFun := fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) },
        map_one' :=
          (_ : (fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) }) 1 = 1) },
    map_mul' :=
      (_ :
        ∀ (h₁ h₂ : ↥H),
          { val := (unop g)⁻¹ * ↑(h₁ * h₂) * unop g, property := (_ : (unop g)⁻¹ * ↑(h₁ * h₂) * unop g ∈ H) } =
            { val := (unop g)⁻¹ * ↑h₁ * unop g, property := (_ : (unop g)⁻¹ * ↑h₁ * unop g ∈ H) } *
              { val := (unop g)⁻¹ * ↑h₂ * unop g, property := (_ : (unop g)⁻¹ * ↑h₂ * unop g ∈ H) }) }
⊢ diff (MonoidHom.id ↥H) (g • α) (g • β) =
    { val := (unop g)⁻¹ * ↑(diff (MonoidHom.id ↥H) α β) * unop g,
      property := (_ : (unop g)⁻¹ * ↑(diff (MonoidHom.id ↥H) α β) * unop g ∈ H) }

Next tactic:
refine'
    Eq.trans
      (Finset.prod_bij' (fun q _ => g⁻¹ • q) (fun q _ => Finset.mem_univ _)
        (fun q _ => Subtype.ext _) (fun q _ => g • q) (fun q _ => Finset.mem_univ _)
        (fun q _ => smul_inv_smul g q) fun q _ => inv_smul_smul g q)
      (map_prod ϕ _ _).symm
theorem smul_diff_smul' [hH : Normal H] (g : Gᵐᵒᵖ) :
    diff (MonoidHom.id H) (g • α) (g • β) =
      ⟨g.unop⁻¹ * (diff (MonoidHom.id H) α β : H) * g.unop,
        hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩ := by
  letI := H.fintypeQuotientOfFiniteIndex
  let ϕ : H →* H :=
    { toFun := fun h =>
        ⟨g.unop⁻¹ * h * g.unop,
          hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩
      map_one' := by rw [Subtype.ext_iff, coe_mk, coe_one, mul_one, inv_mul_self]
      map_mul' := fun h₁ h₂ => by
        simp only [Subtype.ext_iff, coe_mk, coe_mul, mul_assoc, mul_inv_cancel_left] }
  refine'
    Eq.trans
      (Finset.prod_bij' (fun q _ => g⁻¹ • q) (fun q _ => Finset.mem_univ _)
        (fun q _ => Subtype.ext _) (fun q _ => g • q) (fun q _ => Finset.mem_univ _)
        (fun q _ => smul_inv_smul g q) fun q _ => inv_smul_smul g q)
      (map_prod ϕ _ _).symm
  

Proof state:
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : IsCommutative H
inst✝ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
hH : Normal H
g : Gᵐᵒᵖ
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
ϕ : ↥H →* ↥H :=
  {
    toOneHom :=
      { toFun := fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) },
        map_one' :=
          (_ : (fun h => { val := (unop g)⁻¹ * ↑h * unop g, property := (_ : (unop g)⁻¹ * ↑h * unop g ∈ H) }) 1 = 1) },
    map_mul' :=
      (_ :
        ∀ (h₁ h₂ : ↥H),
          { val := (unop g)⁻¹ * ↑(h₁ * h₂) * unop g, property := (_ : (unop g)⁻¹ * ↑(h₁ * h₂) * unop g ∈ H) } =
            { val := (unop g)⁻¹ * ↑h₁ * unop g, property := (_ : (unop g)⁻¹ * ↑h₁ * unop g ∈ H) } *
              { val := (unop g)⁻¹ * ↑h₂ * unop g, property := (_ : (unop g)⁻¹ * ↑h₂ * unop g ∈ H) }) }
q : G ⧸ H
x✝ : q ∈ Finset.univ
⊢ ↑((MonoidHom.id ↥H)
        {
          val :=
            (↑((toEquiv (_ : ↑(g • α) ∈ leftTransversals ↑H)) q))⁻¹ *
              ↑((toEquiv (_ : ↑(g • β) ∈ leftTransversals ↑H)) q),
          property :=
            (_ :
              (↑((toEquiv (_ : ↑(g • α) ∈ leftTransversals ↑H)) q))⁻¹ *
                  ↑((toEquiv (_ : ↑(g • β) ∈ leftTransversals ↑H)) q) ∈
                H) }) =
    ↑(ϕ
        ((MonoidHom.id ↥H)
          {
            val :=
              (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) ((fun q x => g⁻¹ • q) q x✝)))⁻¹ *
                ↑((toEquiv (_ : ↑β ∈ leftTransversals ↑H)) ((fun q x => g⁻¹ • q) q x✝)),
            property :=
              (_ :
                (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) ((fun q x => g⁻¹ • q) q x✝)))⁻¹ *
                    ↑((toEquiv (_ : ↑β ∈ leftTransversals ↑H)) ((fun q x => g⁻¹ • q) q x✝)) ∈
                  H) }))

Next tactic:
simp only [MonoidHom.id_apply, MonoidHom.coe_mk, OneHom.coe_mk,
    smul_apply_eq_smul_apply_inv_smul, smul_eq_mul_unop, mul_inv_rev, mul_assoc]
noncomputable instance : MulAction G H.QuotientDiff where
  smul g :=
    Quotient.map' (fun α => op g⁻¹ • α) fun α β h =>
      Subtype.ext
        (by
          

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α✝ β✝ : ↑(leftTransversals ↑H)
inst✝ : Normal H
g : G
α β : ↑(leftTransversals ↑H)
h : Setoid.r α β
⊢ ↑(diff (MonoidHom.id ↥H) ((fun α => op g⁻¹ • α) α) ((fun α => op g⁻¹ • α) β)) = ↑1

Next tactic:
rwa [smul_diff_smul', coe_mk, coe_one, mul_eq_one_iff_eq_inv, mul_right_eq_self, ←
            coe_one, ← Subtype.ext_iff]
noncomputable instance : MulAction G H.QuotientDiff where
  smul g :=
    Quotient.map' (fun α => op g⁻¹ • α) fun α β h =>
      Subtype.ext
        (by
          rwa [smul_diff_smul', coe_mk, coe_one, mul_eq_one_iff_eq_inv, mul_right_eq_self, ←
            coe_one, ← Subtype.ext_iff])
  mul_smul g₁ g₂ q :=
    Quotient.inductionOn' q fun T =>
      congr_arg Quotient.mk'' (by rw [mul_inv_rev]; exact mul_smul (op g₁⁻¹) (op g₂⁻¹) T)
  one_smul q :=
    Quotient.inductionOn' q fun T =>
      congr_arg Quotient.mk'' (by 

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
q : QuotientDiff H
T : ↑(leftTransversals ↑H)
⊢ (fun α => op 1⁻¹ • α) T = T

Next tactic:
rw [inv_one]
noncomputable instance : MulAction G H.QuotientDiff where
  smul g :=
    Quotient.map' (fun α => op g⁻¹ • α) fun α β h =>
      Subtype.ext
        (by
          rwa [smul_diff_smul', coe_mk, coe_one, mul_eq_one_iff_eq_inv, mul_right_eq_self, ←
            coe_one, ← Subtype.ext_iff])
  mul_smul g₁ g₂ q :=
    Quotient.inductionOn' q fun T =>
      congr_arg Quotient.mk'' (by rw [mul_inv_rev]; exact mul_smul (op g₁⁻¹) (op g₂⁻¹) T)
  one_smul q :=
    Quotient.inductionOn' q fun T =>
      congr_arg Quotient.mk'' (by rw [inv_one]; 

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
q : QuotientDiff H
T : ↑(leftTransversals ↑H)
⊢ (fun α => op 1 • α) T = T

Next tactic:
apply one_smul Gᵐᵒᵖ T
noncomputable instance : MulAction G H.QuotientDiff where
  smul g :=
    Quotient.map' (fun α => op g⁻¹ • α) fun α β h =>
      Subtype.ext
        (by
          rwa [smul_diff_smul', coe_mk, coe_one, mul_eq_one_iff_eq_inv, mul_right_eq_self, ←
            coe_one, ← Subtype.ext_iff])
  mul_smul g₁ g₂ q :=
    Quotient.inductionOn' q fun T =>
      congr_arg Quotient.mk'' (by 

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
g₁ g₂ : G
q : QuotientDiff H
T : ↑(leftTransversals ↑H)
⊢ (fun α => op (g₁ * g₂)⁻¹ • α) T = (fun α => op g₁⁻¹ • α) ((fun α => op g₂⁻¹ • α) T)

Next tactic:
rw [mul_inv_rev]
noncomputable instance : MulAction G H.QuotientDiff where
  smul g :=
    Quotient.map' (fun α => op g⁻¹ • α) fun α β h =>
      Subtype.ext
        (by
          rwa [smul_diff_smul', coe_mk, coe_one, mul_eq_one_iff_eq_inv, mul_right_eq_self, ←
            coe_one, ← Subtype.ext_iff])
  mul_smul g₁ g₂ q :=
    Quotient.inductionOn' q fun T =>
      congr_arg Quotient.mk'' (by rw [mul_inv_rev]; 

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
g₁ g₂ : G
q : QuotientDiff H
T : ↑(leftTransversals ↑H)
⊢ (fun α => op (g₂⁻¹ * g₁⁻¹) • α) T = (fun α => op g₁⁻¹ • α) ((fun α => op g₂⁻¹ • α) T)

Next tactic:
exact mul_smul (op g₁⁻¹) (op g₂⁻¹) T
theorem smul_diff' (h : H) :
    diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index := by
  

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
h : ↥H
⊢ diff (MonoidHom.id ↥H) α (op ↑h • β) = diff (MonoidHom.id ↥H) α β * h ^ index H

Next tactic:
letI := H.fintypeQuotientOfFiniteIndex
theorem smul_diff' (h : H) :
    diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index := by
  letI := H.fintypeQuotientOfFiniteIndex
  

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
h : ↥H
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
⊢ diff (MonoidHom.id ↥H) α (op ↑h • β) = diff (MonoidHom.id ↥H) α β * h ^ index H

Next tactic:
rw [diff, diff, index_eq_card, ← Finset.card_univ, ← Finset.prod_const, ← Finset.prod_mul_distrib]
theorem smul_diff' (h : H) :
    diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index := by
  letI := H.fintypeQuotientOfFiniteIndex
  rw [diff, diff, index_eq_card, ← Finset.card_univ, ← Finset.prod_const, ← Finset.prod_mul_distrib]
  

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
h : ↥H
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
⊢ (let α_1 := toEquiv (_ : ↑α ∈ leftTransversals ↑H);
    let β_1 := toEquiv (_ : ↑(op ↑h • β) ∈ leftTransversals ↑H);
    ∏ q : G ⧸ H,
      (MonoidHom.id ↥H)
        { val := (↑(α_1 q))⁻¹ * ↑(β_1 q),
          property :=
            (_ :
              (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) q))⁻¹ *
                  ↑((toEquiv (_ : ↑(op ↑h • β) ∈ leftTransversals ↑H)) q) ∈
                H) }) =
    ∏ x : G ⧸ H,
      (MonoidHom.id ↥H)
          { val := (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) x))⁻¹ * ↑((toEquiv (_ : ↑β ∈ leftTransversals ↑H)) x),
            property :=
              (_ :
                (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) x))⁻¹ * ↑((toEquiv (_ : ↑β ∈ leftTransversals ↑H)) x) ∈
                  H) } *
        h

Next tactic:
refine' Finset.prod_congr rfl fun q _ => _
theorem smul_diff' (h : H) :
    diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index := by
  letI := H.fintypeQuotientOfFiniteIndex
  rw [diff, diff, index_eq_card, ← Finset.card_univ, ← Finset.prod_const, ← Finset.prod_mul_distrib]
  refine' Finset.prod_congr rfl fun q _ => _
  

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
h : ↥H
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
q : G ⧸ H
x✝ : q ∈ Finset.univ
⊢ (MonoidHom.id ↥H)
      {
        val :=
          (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) q))⁻¹ * ↑((toEquiv (_ : ↑(op ↑h • β) ∈ leftTransversals ↑H)) q),
        property :=
          (_ :
            (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) q))⁻¹ *
                ↑((toEquiv (_ : ↑(op ↑h • β) ∈ leftTransversals ↑H)) q) ∈
              H) } =
    (MonoidHom.id ↥H)
        { val := (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) q))⁻¹ * ↑((toEquiv (_ : ↑β ∈ leftTransversals ↑H)) q),
          property :=
            (_ :
              (↑((toEquiv (_ : ↑α ∈ leftTransversals ↑H)) q))⁻¹ * ↑((toEquiv (_ : ↑β ∈ leftTransversals ↑H)) q) ∈ H) } *
      h

Next tactic:
simp_rw [Subtype.ext_iff, MonoidHom.id_apply, coe_mul, mul_assoc, mul_right_inj]
theorem smul_diff' (h : H) :
    diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index := by
  letI := H.fintypeQuotientOfFiniteIndex
  rw [diff, diff, index_eq_card, ← Finset.card_univ, ← Finset.prod_const, ← Finset.prod_mul_distrib]
  refine' Finset.prod_congr rfl fun q _ => _
  simp_rw [Subtype.ext_iff, MonoidHom.id_apply, coe_mul, mul_assoc, mul_right_inj]
  

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
h : ↥H
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
q : G ⧸ H
x✝ : q ∈ Finset.univ
⊢ ↑((toEquiv (_ : ↑(op ↑h • β) ∈ leftTransversals ↑H)) q) = ↑((toEquiv (_ : ↑β ∈ leftTransversals ↑H)) q) * ↑h

Next tactic:
rw [smul_apply_eq_smul_apply_inv_smul, smul_eq_mul_unop, unop_op, mul_left_inj, ← Subtype.ext_iff,
    Equiv.apply_eq_iff_eq, inv_smul_eq_iff]
theorem smul_diff' (h : H) :
    diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index := by
  letI := H.fintypeQuotientOfFiniteIndex
  rw [diff, diff, index_eq_card, ← Finset.card_univ, ← Finset.prod_const, ← Finset.prod_mul_distrib]
  refine' Finset.prod_congr rfl fun q _ => _
  simp_rw [Subtype.ext_iff, MonoidHom.id_apply, coe_mul, mul_assoc, mul_right_inj]
  rw [smul_apply_eq_smul_apply_inv_smul, smul_eq_mul_unop, unop_op, mul_left_inj, ← Subtype.ext_iff,
    Equiv.apply_eq_iff_eq, inv_smul_eq_iff]
  

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α β : ↑(leftTransversals ↑H)
inst✝ : Normal H
h : ↥H
this : Fintype (G ⧸ H) := fintypeQuotientOfFiniteIndex H
q : G ⧸ H
x✝ : q ∈ Finset.univ
⊢ q = op ↑h • q

Next tactic:
exact self_eq_mul_right.mpr ((QuotientGroup.eq_one_iff _).mpr h.2)
theorem eq_one_of_smul_eq_one (hH : Nat.Coprime (Nat.card H) H.index) (α : H.QuotientDiff)
    (h : H) : h • α = α → h = 1 :=
  Quotient.inductionOn' α fun α hα =>
    (powCoprime hH).injective <|
      calc
        h ^ H.index = diff (MonoidHom.id H) (op ((h⁻¹ : H) : G) • α) α := by
          

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α✝¹ β : ↑(leftTransversals ↑H)
inst✝ : Normal H
hH : Nat.Coprime (Nat.card ↥H) (index H)
α✝ : QuotientDiff H
h : ↥H
α : ↑(leftTransversals ↑H)
hα : h • Quotient.mk'' α = Quotient.mk'' α
⊢ h ^ index H = diff (MonoidHom.id ↥H) (op ↑h⁻¹ • α) α

Next tactic:
rw [← diff_inv, smul_diff', diff_self, one_mul, inv_pow, inv_inv]
theorem exists_smul_eq (hH : Nat.Coprime (Nat.card H) H.index) (α β : H.QuotientDiff) :
    ∃ h : H, h • α = β :=
  Quotient.inductionOn' α
    (Quotient.inductionOn' β fun β α =>
      Exists.imp (fun n => Quotient.sound')
        ⟨(powCoprime hH).symm (diff (MonoidHom.id H) β α),
          (diff_inv _ _ _).symm.trans
            (inv_eq_one.mpr
              ((smul_diff' β α ((powCoprime hH).symm (diff (MonoidHom.id H) β α))⁻¹).trans
                (by 

Proof state:
G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α✝¹ β✝¹ : ↑(leftTransversals ↑H)
inst✝ : Normal H
hH : Nat.Coprime (Nat.card ↥H) (index H)
α✝ β✝ : QuotientDiff H
β α : ↑(leftTransversals ↑H)
⊢ diff (MonoidHom.id ↥H) β α * ((powCoprime hH).symm (diff (MonoidHom.id ↥H) β α))⁻¹ ^ index H = 1

Next tactic:
rw [inv_pow, ← powCoprime_apply hH, Equiv.apply_symm_apply, mul_inv_self]
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step0 : N ≠ ⊥ := by
  

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
h3 : ∀ (H : Subgroup G), ¬IsComplement' N H
⊢ N ≠ ⊥

Next tactic:
rintro rfl
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step0 : N ≠ ⊥ := by
  rintro rfl
  

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
inst✝ : Normal ⊥
h1 : Nat.Coprime (Fintype.card ↥⊥) (index ⊥)
h3 : ∀ (H : Subgroup G), ¬IsComplement' ⊥ H
⊢ False

Next tactic:
exact h3 ⊤ isComplement'_bot_top
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
  

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
h3 : ∀ (H : Subgroup G), ¬IsComplement' N H
K : Subgroup G
hK : K ⊔ N = ⊤
⊢ K = ⊤

Next tactic:
contrapose! h3
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
  contrapose! h3
  

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
K : Subgroup G
hK : K ⊔ N = ⊤
h3 : K ≠ ⊤
⊢ ∃ H, IsComplement' N H

Next tactic:
have h4 : (N.comap K.subtype).index = N.index := by
    rw [← N.relindex_top_right, ← hK]
    exact (relindex_sup_right K N).symm
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
  contrapose! h3
  have h4 : (N.comap K.subtype).index = N.index := by
    

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
K : Subgroup G
hK : K ⊔ N = ⊤
h3 : K ≠ ⊤
⊢ index (comap (Subgroup.subtype K) N) = index N

Next tactic:
rw [← N.relindex_top_right, ← hK]
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
  contrapose! h3
  have h4 : (N.comap K.subtype).index = N.index := by
    rw [← N.relindex_top_right, ← hK]
    

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
K : Subgroup G
hK : K ⊔ N = ⊤
h3 : K ≠ ⊤
⊢ index (comap (Subgroup.subtype K) N) = relindex N (K ⊔ N)

Next tactic:
exact (relindex_sup_right K N).symm
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
  contrapose! h3
  have h4 : (N.comap K.subtype).index = N.index := by
    rw [← N.relindex_top_right, ← hK]
    exact (relindex_sup_right K N).symm
  

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
K : Subgroup G
hK : K ⊔ N = ⊤
h3 : K ≠ ⊤
h4 : index (comap (Subgroup.subtype K) N) = index N
⊢ ∃ H, IsComplement' N H

Next tactic:
have h5 : Fintype.card K < Fintype.card G := by
    rw [← K.index_mul_card]
    exact lt_mul_of_one_lt_left Fintype.card_pos (one_lt_index_of_ne_top h3)
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
  contrapose! h3
  have h4 : (N.comap K.subtype).index = N.index := by
    rw [← N.relindex_top_right, ← hK]
    exact (relindex_sup_right K N).symm
  have h5 : Fintype.card K < Fintype.card G := by
    

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
K : Subgroup G
hK : K ⊔ N = ⊤
h3 : K ≠ ⊤
h4 : index (comap (Subgroup.subtype K) N) = index N
⊢ Fintype.card ↥K < Fintype.card G

Next tactic:
rw [← K.index_mul_card]
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
  contrapose! h3
  have h4 : (N.comap K.subtype).index = N.index := by
    rw [← N.relindex_top_right, ← hK]
    exact (relindex_sup_right K N).symm
  have h5 : Fintype.card K < Fintype.card G := by
    rw [← K.index_mul_card]
    

Proof state:
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.Coprime (Fintype.card ↥N) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'], Nat.Coprime (Fintype.card ↥N') (index N') → ∃ H', IsComplement' N' H'
K : Subgroup G
hK : K ⊔ N = ⊤
h3 : K ≠ ⊤
h4 : index (comap (Subgroup.subtype K) N) = index N
⊢ Fintype.card ↥K < index K * Fintype.card ↥K

Next tactic:
exact lt_mul_of_one_lt_left Fintype.card_pos (one_lt_index_of_ne_top h3)