l3lab/ntp-mathlib huggingface dataset:
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      

Proof state:
case intro.intro.intro.refine'_2
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx✝ : x ∈ ↑(support (σ * τ))
hx : x ∈ ↑(support σ) ∨ x ∈ ↑(support τ)
⊢ ↑((Set.union (_ : ↑(support (f * σ * f⁻¹)) ⊓ ↑(support (g * τ * g⁻¹)) ≤ ⊥)).symm
        (Sum.map (⇑(subtypeEquiv f (_ : ∀ (a : α), a ∈ ↑(support σ) ↔ f a ∈ ↑(support (f * σ * f⁻¹)))))
          (⇑(subtypeEquiv g (_ : ∀ (a : α), a ∈ ↑(support τ) ↔ g a ∈ ↑(support (g * τ * g⁻¹)))))
          ((Set.union (_ : ↑(support σ) ⊓ ↑(support τ) ≤ ⊥))
            { val := (σ * τ) x,
              property :=
                (_ :
                  (Equiv.refl α) ↑{ val := (σ * τ) x, property := (_ : (σ * τ) x ∈ support (σ * τ)) } ∈
                    ↑(support σ) ∪ ↑(support τ)) }))) =
    (f * σ * f⁻¹ * (g * τ * g⁻¹))
      ↑((Set.union (_ : ↑(support (f * σ * f⁻¹)) ⊓ ↑(support (g * τ * g⁻¹)) ≤ ⊥)).symm
          (Sum.map (⇑(subtypeEquiv f (_ : ∀ (a : α), a ∈ ↑(support σ) ↔ f a ∈ ↑(support (f * σ * f⁻¹)))))
            (⇑(subtypeEquiv g (_ : ∀ (a : α), a ∈ ↑(support τ) ↔ g a ∈ ↑(support (g * τ * g⁻¹)))))
            ((Set.union (_ : ↑(support σ) ⊓ ↑(support τ) ≤ ⊥))
              { val := x,
                property := (_ : (Equiv.refl α) ↑{ val := x, property := hx✝ } ∈ ↑(support σ) ∪ ↑(support τ)) })))

Next tactic:
cases' hx with hxσ hxτ
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · 

Proof state:
case intro.intro.intro.refine'_2.inl
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : x ∈ ↑(support σ)
⊢ ↑((Set.union (_ : ↑(support (f * σ * f⁻¹)) ⊓ ↑(support (g * τ * g⁻¹)) ≤ ⊥)).symm
        (Sum.map (⇑(subtypeEquiv f (_ : ∀ (a : α), a ∈ ↑(support σ) ↔ f a ∈ ↑(support (f * σ * f⁻¹)))))
          (⇑(subtypeEquiv g (_ : ∀ (a : α), a ∈ ↑(support τ) ↔ g a ∈ ↑(support (g * τ * g⁻¹)))))
          ((Set.union (_ : ↑(support σ) ⊓ ↑(support τ) ≤ ⊥))
            { val := (σ * τ) x,
              property :=
                (_ :
                  (Equiv.refl α) ↑{ val := (σ * τ) x, property := (_ : (σ * τ) x ∈ support (σ * τ)) } ∈
                    ↑(support σ) ∪ ↑(support τ)) }))) =
    (f * σ * f⁻¹ * (g * τ * g⁻¹))
      ↑((Set.union (_ : ↑(support (f * σ * f⁻¹)) ⊓ ↑(support (g * τ * g⁻¹)) ≤ ⊥)).symm
          (Sum.map (⇑(subtypeEquiv f (_ : ∀ (a : α), a ∈ ↑(support σ) ↔ f a ∈ ↑(support (f * σ * f⁻¹)))))
            (⇑(subtypeEquiv g (_ : ∀ (a : α), a ∈ ↑(support τ) ↔ g a ∈ ↑(support (g * τ * g⁻¹)))))
            ((Set.union (_ : ↑(support σ) ⊓ ↑(support τ) ≤ ⊥))
              { val := x,
                property := (_ : (Equiv.refl α) ↑{ val := x, property := hx } ∈ ↑(support σ) ∪ ↑(support τ)) })))

Next tactic:
rw [mem_coe, mem_support] at hxσ
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · rw [mem_coe, mem_support] at hxσ
        

Proof state:
case intro.intro.intro.refine'_2.inl
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : σ x ≠ x
⊢ ↑((Set.union (_ : ↑(support (f * σ * f⁻¹)) ⊓ ↑(support (g * τ * g⁻¹)) ≤ ⊥)).symm
        (Sum.map (⇑(subtypeEquiv f (_ : ∀ (a : α), a ∈ ↑(support σ) ↔ f a ∈ ↑(support (f * σ * f⁻¹)))))
          (⇑(subtypeEquiv g (_ : ∀ (a : α), a ∈ ↑(support τ) ↔ g a ∈ ↑(support (g * τ * g⁻¹)))))
          ((Set.union (_ : ↑(support σ) ⊓ ↑(support τ) ≤ ⊥))
            { val := (σ * τ) x,
              property :=
                (_ :
                  (Equiv.refl α) ↑{ val := (σ * τ) x, property := (_ : (σ * τ) x ∈ support (σ * τ)) } ∈
                    ↑(support σ) ∪ ↑(support τ)) }))) =
    (f * σ * f⁻¹ * (g * τ * g⁻¹))
      ↑((Set.union (_ : ↑(support (f * σ * f⁻¹)) ⊓ ↑(support (g * τ * g⁻¹)) ≤ ⊥)).symm
          (Sum.map (⇑(subtypeEquiv f (_ : ∀ (a : α), a ∈ ↑(support σ) ↔ f a ∈ ↑(support (f * σ * f⁻¹)))))
            (⇑(subtypeEquiv g (_ : ∀ (a : α), a ∈ ↑(support τ) ↔ g a ∈ ↑(support (g * τ * g⁻¹)))))
            ((Set.union (_ : ↑(support σ) ⊓ ↑(support τ) ≤ ⊥))
              { val := x,
                property := (_ : (Equiv.refl α) ↑{ val := x, property := hx } ∈ ↑(support σ) ∪ ↑(support τ)) })))

Next tactic:
rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · rw [mem_coe, mem_support] at hxσ
        rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inl, comp_apply,
          Set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
        · 

Proof state:
case intro.intro.intro.refine'_2.inl
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : σ x ≠ x
⊢ τ x = f⁻¹ (g (τ (g⁻¹ (f x))))

Next tactic:
have h := (hd2 (f x)).resolve_left ?_
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · rw [mem_coe, mem_support] at hxσ
        rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inl, comp_apply,
          Set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
        · have h := (hd2 (f x)).resolve_left ?_
          · 

Proof state:
case intro.intro.intro.refine'_2.inl.refine_2
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : σ x ≠ x
h : (g * τ * g⁻¹) (f x) = f x
⊢ τ x = f⁻¹ (g (τ (g⁻¹ (f x))))

Next tactic:
rw [mul_apply, mul_apply] at h
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · rw [mem_coe, mem_support] at hxσ
        rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inl, comp_apply,
          Set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
        · have h := (hd2 (f x)).resolve_left ?_
          · rw [mul_apply, mul_apply] at h
            

Proof state:
case intro.intro.intro.refine'_2.inl.refine_2
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : σ x ≠ x
h : g (τ (g⁻¹ (f x))) = f x
⊢ τ x = f⁻¹ (g (τ (g⁻¹ (f x))))

Next tactic:
rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · rw [mem_coe, mem_support] at hxσ
        rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inl, comp_apply,
          Set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
        · have h := (hd2 (f x)).resolve_left ?_
          · rw [mul_apply, mul_apply] at h
            rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
          · 

Proof state:
case intro.intro.intro.refine'_2.inl.refine_1
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : σ x ≠ x
⊢ ¬(f * σ * f⁻¹) (f x) = f x

Next tactic:
rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · rw [mem_coe, mem_support] at hxσ
        rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inl, comp_apply,
          Set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
        · have h := (hd2 (f x)).resolve_left ?_
          · rw [mul_apply, mul_apply] at h
            rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
          · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
        · 

Proof state:
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : σ x ≠ x
⊢ ↑{ val := (σ * τ) x,
        property :=
          (_ :
            (Equiv.refl α) ↑{ val := (σ * τ) x, property := (_ : (σ * τ) x ∈ support (σ * τ)) } ∈
              ↑(support σ) ∪ ↑(support τ)) } ∈
    ↑(support σ)

Next tactic:
rwa [Subtype.coe_mk, Perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
            apply_mem_support, mem_support]
theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
  classical
    cases nonempty_fintype α
    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
    have hd1' := coe_inj.2 hd1.support_mul
    have hd2' := coe_inj.2 hd2.support_mul
    rw [coe_union] at *
    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
    refine' isConj_of_support_equiv _ _
    · refine'
          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
          apply_eq_iff_eq]
    · intro x hx
      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
        Equiv.sumCongr_apply]
      rw [hd1', Set.mem_union] at hx
      cases' hx with hxσ hxτ
      · rw [mem_coe, mem_support] at hxσ
        rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inl, comp_apply,
          Set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
        · have h := (hd2 (f x)).resolve_left ?_
          · rw [mul_apply, mul_apply] at h
            rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
          · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
        · rwa [Subtype.coe_mk, Perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
            apply_mem_support, mem_support]
        · 

Proof state:
ι : Type u_1
α✝ : Type u_2
β : Type u_3
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
σ✝ τ✝ : Perm α✝
α : Type u_4
inst✝ : Finite α
σ τ : Perm α
hd1 : Disjoint σ τ
val✝ : Fintype α
f : Perm α
hc1 : IsConj σ (f * σ * f⁻¹)
g : Perm α
hc2 : IsConj τ (g * τ * g⁻¹)
hd2 : Disjoint (f * σ * f⁻¹) (g * τ * g⁻¹)
hd1' : ↑(support (σ * τ)) = ↑(support σ) ∪ ↑(support τ)
hd2' : ↑(support (f * σ * f⁻¹ * (g * τ * g⁻¹))) = ↑(support (f * σ * f⁻¹)) ∪ ↑(support (g * τ * g⁻¹))
hd1'' : _root_.Disjoint ↑(support σ) ↑(support τ)
hd2'' : _root_.Disjoint ↑(support (f * σ * f⁻¹)) ↑(support (g * τ * g⁻¹))
x : α
hx : x ∈ ↑(support (σ * τ))
hxσ : σ x ≠ x
⊢ ↑{ val := x, property := (_ : (Equiv.refl α) ↑{ val := x, property := hx } ∈ ↑(support σ) ∪ ↑(support τ)) } ∈
    ↑(support σ)

Next tactic:
rwa [Subtype.coe_mk, mem_coe, mem_support]