import Mathlib

namespace OAI

/-! Finite presentations of finite-relation quotients and products. -/

noncomputable section

open scoped Classical

namespace KaplanskyCounterexample.CurrentMain

lemma finitelyPresented_fg (G : Type*) [Group G] [Group.IsFinitelyPresented G] :
    Group.FG G := by
  obtain ⟨n, f, hf, _⟩ := Group.IsFinitelyPresented.out (G := G)
  exact Group.fg_of_surjective hf

lemma conGen_ker_finite {G J : Type*} [Group G] [Finite J] (u v : J → G) :
    (conGen (fun x y => ∃ j, x=u j ∧ y=v j)).mk'.ker.IsFinitelyNormallyGenerated := by
  let c := conGen (fun x y => ∃ j, x=u j ∧ y=v j)
  let R := Set.range (fun j => u j * (v j)⁻¹)
  refine ⟨R, Set.finite_range _, ?_⟩
  apply le_antisymm
  · apply Subgroup.normalClosure_le_normal
    rintro _ ⟨j, rfl⟩
    have he : c.mk' (u j) = c.mk' (v j) :=
      (Con.eq c).mpr (ConGen.Rel.of _ _ ⟨j, rfl, rfl⟩)
    change c.mk' (u j * (v j)⁻¹) = 1
    rw [map_mul, map_inv, he, mul_inv_cancel]
  · let q := QuotientGroup.mk' (Subgroup.normalClosure R)
    have hc : c ≤ Con.ker q := by
      apply Con.conGen_le.mpr
      rintro _ _ ⟨j, rfl, rfl⟩
      apply (Con.ker_rel q).mpr
      apply mul_inv_eq_one.mp
      rw [← map_inv, ← map_mul]
      exact (QuotientGroup.eq_one_iff _).mpr (Subgroup.subset_normalClosure ⟨j, rfl⟩)
    intro w hw
    apply (QuotientGroup.eq_one_iff w).mp
    change q w = 1
    rw [← map_one q]
    apply hc
    exact (Con.eq c).mp (MonoidHom.mem_ker.mp hw |>.trans (map_one c.mk').symm)

lemma finitelyPresented_finite_relations {G J : Type*} [Group G]
    [Group.IsFinitelyPresented G] [Finite J] (u v : J → G) :
    Group.IsFinitelyPresented (conGen (fun x y => ∃ j, x=u j ∧ y=v j)).Quotient :=
  Group.IsFinitelyPresented.of_surjective _ Con.mk'_surjective (conGen_ker_finite u v)

lemma commuting_of_generators {G H T : Type*} [Group G] [Group H] [Group T]
    (S : Set G) (U : Set H) (hS : Subgroup.closure S = ⊤) (hU : Subgroup.closure U = ⊤)
    (f : G →* T) (g : H →* T) (h : ∀ a ∈ S, ∀ b ∈ U, Commute (f a) (g b)) :
    ∀ a b, Commute (f a) (g b) := by
  intro a b
  have ha : a ∈ Subgroup.closure S := hS ▸ Subgroup.mem_top a
  have hb : b ∈ Subgroup.closure U := hU ▸ Subgroup.mem_top b
  induction ha using Subgroup.closure_induction with
  | mem a ha =>
    induction hb using Subgroup.closure_induction with
    | mem b hb => exact h a ha b hb
    | one => simp
    | mul b c hb hc hB hC => simpa only [map_mul] using hB.mul_right hC
    | inv b hb hB => simpa only [map_inv] using hB.inv_right
  | one => simp
  | mul a c ha hc hA hC => simpa only [map_mul] using hA.mul_left hC
  | inv a ha hA => simpa only [map_inv] using hA.inv_left

lemma finitelyPresented_prod (G H : Type*) [Group G] [Group H]
    [Group.IsFinitelyPresented G] [Group.IsFinitelyPresented H] :
    Group.IsFinitelyPresented (G × H) := by
  obtain ⟨S, hS, hSf⟩ := Group.fg_iff.mp (finitelyPresented_fg G)
  obtain ⟨U, hU, hUf⟩ := Group.fg_iff.mp (finitelyPresented_fg H)
  let J := S × U
  let : Finite S := hSf
  let : Finite U := hUf
  let u : J → Monoid.Coprod G H := fun j =>
    Monoid.Coprod.inl j.1.val * Monoid.Coprod.inr j.2.val
  let v : J → Monoid.Coprod G H := fun j =>
    Monoid.Coprod.inr j.2.val * Monoid.Coprod.inl j.1.val
  let c := conGen (fun x y => ∃ j, x=u j ∧ y=v j)
  let q := c.mk'
  let f : G →* c.Quotient := q.comp Monoid.Coprod.inl
  let g : H →* c.Quotient := q.comp Monoid.Coprod.inr
  have hgen : ∀ a ∈ S, ∀ b ∈ U, Commute (f a) (g b) := by
    intro a ha b hb
    change q (Monoid.Coprod.inl a) * q (Monoid.Coprod.inr b) =
      q (Monoid.Coprod.inr b) * q (Monoid.Coprod.inl a)
    rw [← map_mul, ← map_mul]
    exact (Con.eq c).mpr (ConGen.Rel.of _ _ ⟨(⟨a,ha⟩,⟨b,hb⟩),rfl,rfl⟩)
  let p : G × H →* c.Quotient :=
    MonoidHom.noncommCoprod f g (commuting_of_generators S U hS hU f g hgen)
  have hp : p.comp Monoid.Coprod.toProd = q := by
    apply Monoid.Coprod.hom_ext
    · ext a
      simp [p, f, g, MonoidHom.noncommCoprod]
    · ext b
      simp [p, f, g, MonoidHom.noncommCoprod]
  have hc : c ≤ Con.ker (Monoid.Coprod.toProd : Monoid.Coprod G H →* G × H) := by
    apply Con.conGen_le.mpr
    rintro _ _ ⟨j, rfl, rfl⟩
    simp [u, v]
  have hk : (Monoid.Coprod.toProd : Monoid.Coprod G H →* G × H).ker = q.ker := by
    ext w
    constructor
    · intro hw
      apply MonoidHom.mem_ker.mpr
      rw [← hp, MonoidHom.comp_apply, MonoidHom.mem_ker.mp hw, map_one]
    · intro hw
      have he : c w 1 := (Con.eq c).mp
        (MonoidHom.mem_ker.mp hw |>.trans (map_one q).symm)
      have he' := hc he
      apply MonoidHom.mem_ker.mpr
      simpa only [Con.ker_rel, map_one] using he'
  apply Group.IsFinitelyPresented.of_surjective _ Monoid.Coprod.toProd_surjective
  rw [hk]
  exact conGen_ker_finite u v

end KaplanskyCounterexample.CurrentMain

end

end OAI