Blame for lean/ComparatorChallenges/BassTrace.lean

import Mathlib.Algebra.Group.Conj
import Mathlib.Algebra.MonoidAlgebra.Basic
import Mathlib.Basic.Complex.Basic
import Mathlib.GroupTheory.FreeAbelianGroup
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.LinearAlgebra.Matrix.Trace
import Mathlib.LinearAlgebra.Matrix.ToLin
import Mathlib.RingTheory.Finiteness.Projective
import Mathlib.Tactic

namespace OAI

noncomputable section

namespace BassTrace

open scoped Classical

noncomputable def classCoefficient {G : Type*} [Group G]
    (g : G) (a : MonoidAlgebra ℂ G) : ℂ := by
  classical
  exact a.coeff.sum fun h z => if IsConj h g then z else 0

namespace K0

open scoped Classical BigOperators

section

structure Idempotent (R : Type*) [Ring R] where
  size : ℕ
  matrix : Matrix (Fin size) (Fin size) R
  idem : matrix*matrix=matrix

variable {R : Type*} [Ring R]

def directSum (e f : Idempotent R) : Idempotent R where
  size := e.size+f.size
  matrix := Matrix.reindexRingEquiv R finSumFinEquiv (Matrix.fromBlocks e.matrix 0 0 f.matrix)
  idem := by
    rw [←map_mul,Matrix.fromBlocks_multiply]
    simp only [Matrix.mul_zero,Matrix.zero_mul,add_zero,zero_add,e.idem,f.idem]

def relationGenerators (R : Type*) [Ring R] : Set (FreeAbelianGroup (Idempotent R)) :=
  {x | (∃e f : Idempotent R,∃a : Matrix (Fin e.size) (Fin f.size) R,
    ∃b : Matrix (Fin f.size) (Fin e.size) R,
    a*b=e.matrix ∧ b*a=f.matrix ∧ x=FreeAbelianGroup.of e-FreeAbelianGroup.of f) ∨
    (∃e f : Idempotent R,x=FreeAbelianGroup.of (directSum e f)-FreeAbelianGroup.of e-FreeAbelianGroup.of f)}

def relations (R : Type*) [Ring R] : AddSubgroup (FreeAbelianGroup (Idempotent R)) :=
  AddSubgroup.closure (relationGenerators R)

instance relations_normal (R : Type*) [Ring R] : (relations R).Normal := inferInstance

abbrev Group (R : Type*) [Ring R] := FreeAbelianGroup (Idempotent R) ⧸ relations R

def classOf (e : Idempotent R) : Group R := QuotientAddGroup.mk' (relations R) (FreeAbelianGroup.of e)

variable {G : Type*} [_root_.Group G]

instance groupRingRelations_normal : (relations (MonoidAlgebra ℂ G)).Normal := inferInstance

def rawCoefficient (g : G) : FreeAbelianGroup (Idempotent (MonoidAlgebra ℂ G)) →+ ℂ :=
  FreeAbelianGroup.lift (fun e=>classCoefficient g (Matrix.trace e.matrix))

end

variable {G : Type*} [_root_.Group G]

def classTrace (a : MonoidAlgebra ℂ G) : ConjClasses G →₀ ℂ :=
  Finsupp.mapDomain ConjClasses.mk a.coeff

def rawTrace : FreeAbelianGroup (Idempotent (MonoidAlgebra ℂ G)) →+ (ConjClasses G →₀ ℂ) :=
  FreeAbelianGroup.lift (fun e=>classTrace (Matrix.trace e.matrix))

def HattoriStallings : Group (MonoidAlgebra ℂ G) →+ (ConjClasses G →₀ ℂ) := by
  have classCoefficient_zero (g : G) :
      classCoefficient g 0 = 0 := by
    simp [classCoefficient]
  have classCoefficient_single (g h : G) (z : ℂ) :
      classCoefficient g (MonoidAlgebra.single h z) = if IsConj h g then z else 0 := by
    classical
    simp [classCoefficient, Finsupp.sum_single_index]
  have classCoefficient_add (g : G) (a b : MonoidAlgebra ℂ G) :
      classCoefficient g (a + b) = classCoefficient g a + classCoefficient g b := by
    classical
    apply Finsupp.sum_add_index
    · intro h _
      simp
    · intro h _ z w
      split_ifs <;> simp
  have classCoefficient_smul (g : G) (z : ℂ) (a : MonoidAlgebra ℂ G) :
      classCoefficient g (z • a) = z * classCoefficient g a := by
    classical
    unfold classCoefficient
    rw [MonoidAlgebra.coeff_smul, Finsupp.sum_smul_index (fun _ => by simp)]
    rw [Finsupp.sum, Finsupp.sum, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro h _
    split_ifs <;> simp
  have classCoefficient_sum {ι : Type} (g : G) (s : Finset ι)
      (f : ι → MonoidAlgebra ℂ G) :
      classCoefficient g (∑ i ∈ s, f i) = ∑ i ∈ s, classCoefficient g (f i) := by
    classical
    induction s using Finset.induction_on with
    | empty => simp [classCoefficient_zero]
    | @insert a s ha ih => simp [classCoefficient_add, ha, ih]
  have classCoefficient_mul_comm (g : G) (a b : MonoidAlgebra ℂ G) :
      classCoefficient g (a * b) = classCoefficient g (b * a) := by
    induction a using MonoidAlgebra.induction_on with
    | of h =>
        induction b using MonoidAlgebra.induction_on with
        | of k =>
            have hconj : IsConj (h * k) (k * h) := by
              apply isConj_iff.mpr
              exact ⟨k, by simp [mul_assoc]⟩
            have hiff : IsConj (h * k) g ↔ IsConj (k * h) g :=
              ⟨hconj.symm.trans, hconj.trans⟩
            change classCoefficient g (MonoidAlgebra.single h 1 * MonoidAlgebra.single k 1) =
              classCoefficient g (MonoidAlgebra.single k 1 * MonoidAlgebra.single h 1)
            simp only [MonoidAlgebra.single_mul_single, classCoefficient_single, hiff]
        | add b c hb hc => simp only [mul_add, add_mul, classCoefficient_add, hb, hc]
        | smul z b hb => simp only [mul_smul_comm, smul_mul_assoc, classCoefficient_smul, hb]
    | add a c ha hc => simp only [add_mul, mul_add, classCoefficient_add, ha, hc]
    | smul z a ha => simp only [mul_smul_comm, smul_mul_assoc, classCoefficient_smul, ha]
  have classCoefficient_matrix_mul_comm {ι κ : Type} [Fintype ι] [Fintype κ]
      (g : G) (a : Matrix ι κ (MonoidAlgebra ℂ G))
      (b : Matrix κ ι (MonoidAlgebra ℂ G)) :
      classCoefficient g (Matrix.trace (a * b)) =
        classCoefficient g (Matrix.trace (b * a)) := by
    classical
    simp only [Matrix.trace, Matrix.diag, Matrix.mul_apply, classCoefficient_sum]
    rw [Finset.sum_comm]
    apply Finset.sum_congr rfl
    intro i _
    apply Finset.sum_congr rfl
    intro j _
    exact classCoefficient_mul_comm g _ _
  have trace_reindex {α β : Type} [Fintype α] [Fintype β]
      (j : α≃β) (a : Matrix α α (MonoidAlgebra ℂ G)) :
      Matrix.trace (Matrix.reindexRingEquiv (MonoidAlgebra ℂ G) j a)=Matrix.trace a := by
    change (∑i, a (j.symm i) (j.symm i))=∑i,a i i
    exact Equiv.sum_comp j.symm (fun i=>a i i)
  have trace_directSum (e f : Idempotent (MonoidAlgebra ℂ G)) :
      Matrix.trace (directSum e f).matrix=Matrix.trace e.matrix+Matrix.trace f.matrix := by
    rw [directSum,trace_reindex]
    simp only [Matrix.trace,Matrix.diag,Fintype.sum_sum_type,Matrix.fromBlocks_apply₁₁,Matrix.fromBlocks_apply₂₂]
  have relations_in_kernel (g : G) : relations (MonoidAlgebra ℂ G)≤(rawCoefficient g).ker := by
    apply (AddSubgroup.closure_le _).mpr
    intro x hx
    rcases hx with ⟨e,f,a,b,hab,hba,rfl⟩|⟨e,f,rfl⟩
    · change rawCoefficient g (FreeAbelianGroup.of e-FreeAbelianGroup.of f)=0
      simp only [map_sub,rawCoefficient,FreeAbelianGroup.lift_apply_of]
      apply sub_eq_zero.mpr
      rw [←hab,←hba]
      exact classCoefficient_matrix_mul_comm g a b
    · change rawCoefficient g (FreeAbelianGroup.of (directSum e f)-FreeAbelianGroup.of e-FreeAbelianGroup.of f)=0
      simp only [map_sub,rawCoefficient,FreeAbelianGroup.lift_apply_of,trace_directSum,classCoefficient_add]
      rw [add_sub_cancel_left, sub_self]
  have classTrace_apply (a : MonoidAlgebra ℂ G) (g : G) :
      classTrace a (ConjClasses.mk g)=classCoefficient g a := by
    unfold classTrace classCoefficient
    simp only [Finsupp.mapDomain,Finsupp.sum_apply,Finsupp.single_apply]
    apply Finset.sum_congr rfl
    intro h hh
    dsimp only
    by_cases hc : IsConj h g
    · rw [ite_eq_left (ConjClasses.mk_eq_mk_iff_isConj.mpr hc), ite_eq_left hc]
    · rw [ite_eq_right (mt ConjClasses.mk_eq_mk_iff_isConj.mp hc), ite_eq_right hc]
  have rawTrace_apply (z : FreeAbelianGroup (Idempotent (MonoidAlgebra ℂ G))) (g : G) :
      rawTrace z (ConjClasses.mk g)=rawCoefficient g z := by
    induction z using FreeAbelianGroup.induction_on with
    | zero => simp only [map_zero,Finsupp.zero_apply]
    | of e =>
      simp only [rawTrace,rawCoefficient,FreeAbelianGroup.lift_apply_of]
      exact classTrace_apply _ g
    | neg e he => simp only [map_neg,Finsupp.neg_apply,he]
    | add x y hx hy => simp only [map_add,Finsupp.add_apply,hx,hy]
  have relations_in_trace_kernel : relations (MonoidAlgebra ℂ G)≤(rawTrace (G := G)).ker := by
    intro z hz
    change rawTrace z=0
    ext c
    obtain ⟨g,rfl⟩ := ConjClasses.mk_surjective c
    rw [rawTrace_apply,Finsupp.zero_apply]
    exact relations_in_kernel g hz
  exact QuotientAddGroup.lift (relations (MonoidAlgebra ℂ G)) rawTrace relations_in_trace_kernel

end K0

namespace RightProjective

open scoped Classical BigOperators

open MulOpposite

section

variable {R : Type*} [Ring R]

instance rightModuleIdentityRingHomInvPair :
    RingHomInvPair (RingHom.id Rᵐᵒᵖ) (RingHom.id Rᵐᵒᵖ) := RingHomInvPair.ids

def unopTranspose {m n : Type*} (a : Matrix m n Rᵐᵒᵖ) : Matrix n m R :=
  fun i j=>unop (a j i)

def rightMatrix {m n : ℕ} (f : (Fin m → Rᵐᵒᵖ) →ₗ[Rᵐᵒᵖ] (Fin n → Rᵐᵒᵖ)) :
    Matrix (Fin n) (Fin m) R := unopTranspose (LinearMap.toMatrixRight' f)

structure Retraction (R M : Type*) [Ring R] [AddCommGroup M] [Module Rᵐᵒᵖ M] where
  size : ℕ
  proj : (Fin size →Rᵐᵒᵖ) →ₗ[Rᵐᵒᵖ] M
  inc : M →ₗ[Rᵐᵒᵖ] (Fin size →Rᵐᵒᵖ)
  split : proj.comp inc=LinearMap.id

variable {M N : Type*} [AddCommGroup M] [Module Rᵐᵒᵖ M]
  [AddCommGroup N] [Module Rᵐᵒᵖ N]

def Retraction.idempotent (r : Retraction R M) : K0.Idempotent R := by
  have unopTranspose_mul {l m n : Type} [Fintype m]
      (a : Matrix l m Rᵐᵒᵖ) (b : Matrix m n Rᵐᵒᵖ) :
      unopTranspose (a*b)=unopTranspose b*unopTranspose a := by
    ext i j
    simp only [unopTranspose,Matrix.mul_apply]
    change (opAddEquiv.symm : Rᵐᵒᵖ≃+R) (∑k,a j k*b k i)=_
    rw [map_sum]
    rfl
  have rightMatrix_comp {l m n : ℕ}
      (f : (Fin l →Rᵐᵒᵖ) →ₗ[Rᵐᵒᵖ] (Fin m →Rᵐᵒᵖ))
      (g : (Fin m →Rᵐᵒᵖ) →ₗ[Rᵐᵒᵖ] (Fin n →Rᵐᵒᵖ)) :
      rightMatrix (g.comp f)=rightMatrix g*rightMatrix f := by
    simp only [rightMatrix,LinearMap.toMatrixRight'_comp,unopTranspose_mul]
  exact {
    size := r.size
    matrix := rightMatrix (r.inc.comp r.proj)
    idem := by
      rw [←rightMatrix_comp]
      congr 1
      calc (r.inc.comp r.proj).comp (r.inc.comp r.proj) =
          r.inc.comp ((r.proj.comp r.inc).comp r.proj) := by simp only [LinearMap.comp_assoc]
        _ = r.inc.comp r.proj := by rw [r.split,LinearMap.id_comp] }

def Retraction.transport (r : Retraction R M) (u : M≃ₗ[Rᵐᵒᵖ] N) : Retraction R N where
  size := r.size
  proj := u.toLinearMap.comp r.proj
  inc := r.inc.comp u.symm.toLinearMap
  split := by
    calc (u.toLinearMap.comp r.proj).comp (r.inc.comp u.symm.toLinearMap) =
      u.toLinearMap.comp ((r.proj.comp r.inc).comp u.symm.toLinearMap) := by simp only [LinearMap.comp_assoc]
      _ = LinearMap.id := by rw [r.split,LinearMap.id_comp,LinearEquiv.comp_symm]

def freeSplit (n m : ℕ) : (Fin (n+m)→Rᵐᵒᵖ) ≃ₗ[Rᵐᵒᵖ] (Fin n→Rᵐᵒᵖ) × (Fin m→Rᵐᵒᵖ) :=
  (LinearEquiv.piCongrLeft' Rᵐᵒᵖ (fun _ : Fin (n+m)=>Rᵐᵒᵖ) finSumFinEquiv.symm).trans
    (LinearEquiv.sumArrowLequivProdArrow (Fin n) (Fin m) Rᵐᵒᵖ Rᵐᵒᵖ)

def Retraction.prod (r : Retraction R M) (s : Retraction R N) : Retraction R (M×N) where
  size := r.size+s.size
  proj := (r.proj.prodMap s.proj).comp (freeSplit r.size s.size).toLinearMap
  inc := (freeSplit r.size s.size).symm.toLinearMap.comp (r.inc.prodMap s.inc)
  split := by
    apply LinearMap.ext
    intro x
    change ((r.proj.prodMap s.proj) ((freeSplit r.size s.size)
      ((freeSplit r.size s.size).symm ((r.inc.prodMap s.inc) x))))=x
    rw [LinearEquiv.apply_symm_apply]
    have hr := LinearMap.congr_fun r.split x.1
    have hs := LinearMap.congr_fun s.split x.2
    exact Prod.ext hr hs

end

open scoped Classical

universe u v

structure Object (R : Type u) [Ring R] where
  carrier : Type v
  [addCommGroup : AddCommGroup carrier]
  [module : Module Rᵐᵒᵖ carrier]
  [finite : Module.Finite Rᵐᵒᵖ carrier]
  [projective : Module.Projective Rᵐᵒᵖ carrier]

attribute [instance] Object.addCommGroup Object.module Object.finite Object.projective

variable {R : Type u} [Ring R]

def Object.prod (P Q : Object.{u,v} R) : Object.{u,v} R where
  carrier := P.carrier × Q.carrier

def Object.retraction (P : Object.{u,v} R) : Retraction R P.carrier :=
  Classical.choice (by
    obtain ⟨n, f, g, _, _, h⟩ := Module.Finite.exists_comp_eq_id_of_projective Rᵐᵒᵖ P.carrier
    exact ⟨⟨n, f, g, h⟩⟩)

def Object.presentationClass (P : Object.{u,v} R) : K0.Group R :=
  K0.classOf P.retraction.idempotent

def moduleRelationGenerators (R : Type u) [Ring R] : Set (FreeAbelianGroup (Object.{u,v} R)) :=
  {x | (∃P Q : Object.{u,v} R, Nonempty (P.carrier≃ₗ[Rᵐᵒᵖ] Q.carrier) ∧
    x=FreeAbelianGroup.of P-FreeAbelianGroup.of Q) ∨
    (∃P Q : Object.{u,v} R,
      x=FreeAbelianGroup.of (P.prod Q)-FreeAbelianGroup.of P-FreeAbelianGroup.of Q)}

def moduleRelations (R : Type u) [Ring R] : AddSubgroup (FreeAbelianGroup (Object.{u,v} R)) :=
  AddSubgroup.closure (moduleRelationGenerators R)

abbrev ModuleK0 (R : Type u) [Ring R] :=
  FreeAbelianGroup (Object.{u,v} R) ⧸ moduleRelations R

def rawPresentation : FreeAbelianGroup (Object.{u,v} R) →+ K0.Group R :=
  FreeAbelianGroup.lift Object.presentationClass

def presentation : ModuleK0.{u,v} R →+ K0.Group R := by
  have unopTranspose_mul {l m n : ℕ}
      (a : Matrix (Fin l) (Fin m) Rᵐᵒᵖ) (b : Matrix (Fin m) (Fin n) Rᵐᵒᵖ) :
      unopTranspose (a*b)=unopTranspose b*unopTranspose a := by
    ext i j
    simp only [unopTranspose,Matrix.mul_apply]
    change (opAddEquiv.symm : Rᵐᵒᵖ≃+R) (∑k,a j k*b k i)=_
    rw [map_sum]
    rfl
  have rightMatrix_comp {l m n : ℕ}
      (f : (Fin l →Rᵐᵒᵖ) →ₗ[Rᵐᵒᵖ] (Fin m →Rᵐᵒᵖ))
      (g : (Fin m →Rᵐᵒᵖ) →ₗ[Rᵐᵒᵖ] (Fin n →Rᵐᵒᵖ)) :
      rightMatrix (g.comp f)=rightMatrix g*rightMatrix f := by
    simp only [rightMatrix,LinearMap.toMatrixRight'_comp,unopTranspose_mul]
  have classOf_eq_of_rectangular (e f : K0.Idempotent R)
      (a : Matrix (Fin e.size) (Fin f.size) R)
      (b : Matrix (Fin f.size) (Fin e.size) R) (hab : a*b=e.matrix) (hba : b*a=f.matrix) :
      K0.classOf e=K0.classOf f := by
    apply sub_eq_zero.mp
    change (QuotientAddGroup.mk' (K0.relations R)) (FreeAbelianGroup.of e)-
      (QuotientAddGroup.mk' (K0.relations R)) (FreeAbelianGroup.of f)=0
    rw [←map_sub]
    change (QuotientAddGroup.mk (FreeAbelianGroup.of e-FreeAbelianGroup.of f) : K0.Group R)=0
    apply (QuotientAddGroup.eq_zero_iff _).mpr
    exact AddSubgroup.subset_closure (Or.inl ⟨e,f,a,b,hab,hba,rfl⟩)
  have Retraction.class_eq {M : Type v} [AddCommGroup M] [Module Rᵐᵒᵖ M] (r s : Retraction R M) :
      K0.classOf r.idempotent=K0.classOf s.idempotent := by
    apply classOf_eq_of_rectangular _ _
      (rightMatrix (r.inc.comp s.proj)) (rightMatrix (s.inc.comp r.proj))
    · change rightMatrix (r.inc.comp s.proj)*rightMatrix (s.inc.comp r.proj)=
        rightMatrix (r.inc.comp r.proj)
      rw [←rightMatrix_comp]
      congr 1
      calc (r.inc.comp s.proj).comp (s.inc.comp r.proj) =
          r.inc.comp ((s.proj.comp s.inc).comp r.proj) := by simp only [LinearMap.comp_assoc]
        _ = r.inc.comp r.proj := by rw [s.split,LinearMap.id_comp]
    · change rightMatrix (s.inc.comp r.proj)*rightMatrix (r.inc.comp s.proj)=
        rightMatrix (s.inc.comp s.proj)
      rw [←rightMatrix_comp]
      congr 1
      calc (s.inc.comp r.proj).comp (r.inc.comp s.proj) =
          s.inc.comp ((r.proj.comp r.inc).comp s.proj) := by simp only [LinearMap.comp_assoc]
        _ = s.inc.comp s.proj := by rw [r.split,LinearMap.id_comp]
  have Retraction.transport_idempotent {M N : Type v} [AddCommGroup M] [Module Rᵐᵒᵖ M] [AddCommGroup N] [Module Rᵐᵒᵖ N] (r : Retraction R M) (u : M≃ₗ[Rᵐᵒᵖ] N) :
      (r.transport u).idempotent=r.idempotent := by
    dsimp only [Retraction.idempotent]
    congr 1
    change rightMatrix ((r.inc.comp u.symm.toLinearMap).comp (u.toLinearMap.comp r.proj))=
      rightMatrix (r.inc.comp r.proj)
    congr 1
    apply LinearMap.ext
    intro x
    change r.inc (u.symm (u (r.proj x)))=r.inc (r.proj x)
    rw [u.symm_apply_apply]
  have freeSplit_apply_left (n m : ℕ) (v : Fin (n+m)→Rᵐᵒᵖ) (i : Fin n) :
      (freeSplit n m v).1 i=v (finSumFinEquiv (Sum.inl i)) := rfl
  have freeSplit_apply_right (n m : ℕ) (v : Fin (n+m)→Rᵐᵒᵖ) (i : Fin m) :
      (freeSplit n m v).2 i=v (finSumFinEquiv (Sum.inr i)) := rfl
  have freeSplit_symm_left (n m : ℕ) (v : Fin n→Rᵐᵒᵖ) (w : Fin m→Rᵐᵒᵖ) (i : Fin n) :
      (freeSplit n m).symm (v,w) (finSumFinEquiv (Sum.inl i))=v i := by
    have h := congrArg (fun x=>(x.1 : Fin n→Rᵐᵒᵖ) i) ((freeSplit (R := R) n m).apply_symm_apply (v,w))
    exact h
  have freeSplit_symm_right (n m : ℕ) (v : Fin n→Rᵐᵒᵖ) (w : Fin m→Rᵐᵒᵖ) (i : Fin m) :
      (freeSplit n m).symm (v,w) (finSumFinEquiv (Sum.inr i))=w i := by
    have h := congrArg (fun x=>(x.2 : Fin m→Rᵐᵒᵖ) i) ((freeSplit (R := R) n m).apply_symm_apply (v,w))
    exact h
  have freeSplit_single_left (n m : ℕ) (i : Fin n) :
      freeSplit (R := R) n m (Pi.single (finSumFinEquiv (Sum.inl i)) 1)=(Pi.single i 1,0) := by
    apply Prod.ext
    · ext j
      rw [freeSplit_apply_left]
      simp only [Pi.single_apply,Equiv.apply_eq_iff_eq,Sum.inl.injEq]
    · ext j
      rw [freeSplit_apply_right]
      simp only [Pi.single_apply,Equiv.apply_eq_iff_eq,Sum.inr_ne_inl,ite_false,Pi.zero_apply]
  have freeSplit_single_right (n m : ℕ) (i : Fin m) :
      freeSplit (R := R) n m (Pi.single (finSumFinEquiv (Sum.inr i)) 1)=(0,Pi.single i 1) := by
    apply Prod.ext
    · ext j
      rw [freeSplit_apply_left]
      simp only [Pi.single_apply,Equiv.apply_eq_iff_eq,Sum.inl_ne_inr,ite_false,Pi.zero_apply]
    · ext j
      rw [freeSplit_apply_right]
      simp only [Pi.single_apply,Equiv.apply_eq_iff_eq,Sum.inr.injEq]
  have Retraction.prod_matrix {M N : Type v} [AddCommGroup M] [Module Rᵐᵒᵖ M] [AddCommGroup N] [Module Rᵐᵒᵖ N] (r : Retraction R M) (s : Retraction R N) :
      (r.prod s).idempotent.matrix=(K0.directSum r.idempotent s.idempotent).matrix := by
    ext i j
    obtain ⟨i,rfl⟩ := finSumFinEquiv.surjective i
    obtain ⟨j,rfl⟩ := finSumFinEquiv.surjective j
    change unop ((freeSplit r.size s.size).symm ((r.inc.prodMap s.inc)
      ((r.proj.prodMap s.proj) ((freeSplit r.size s.size)
        (Pi.single (finSumFinEquiv j) 1)))) (finSumFinEquiv i))=
      Matrix.fromBlocks (rightMatrix (r.inc.comp r.proj)) 0 0 (rightMatrix (s.inc.comp s.proj))
        (finSumFinEquiv.symm (finSumFinEquiv i)) (finSumFinEquiv.symm (finSumFinEquiv j))
    simp only [Equiv.symm_apply_apply]
    cases i with | inl i => ?_ | inr i => ?_
    all_goals cases j with | inl j => ?_ | inr j => ?_
    · rw [freeSplit_single_left]
      simp only [LinearMap.prodMap_apply,map_zero,freeSplit_symm_left,Matrix.fromBlocks_apply₁₁]
      rfl
    · rw [freeSplit_single_right]
      simp only [LinearMap.prodMap_apply,map_zero,freeSplit_symm_left,Matrix.fromBlocks_apply₁₂,
        Pi.zero_apply,unop_zero,Matrix.zero_apply]
    · rw [freeSplit_single_left]
      simp only [LinearMap.prodMap_apply,map_zero,freeSplit_symm_right,Matrix.fromBlocks_apply₂₁,
        Pi.zero_apply,unop_zero,Matrix.zero_apply]
    · rw [freeSplit_single_right]
      simp only [LinearMap.prodMap_apply,map_zero,freeSplit_symm_right,Matrix.fromBlocks_apply₂₂]
      rfl
  have Retraction.prod_idempotent {M N : Type v} [AddCommGroup M] [Module Rᵐᵒᵖ M] [AddCommGroup N] [Module Rᵐᵒᵖ N] (r : Retraction R M) (s : Retraction R N) :
      (r.prod s).idempotent=K0.directSum r.idempotent s.idempotent := by
    dsimp only [Retraction.idempotent, K0.directSum]
    congr 1
    exact Retraction.prod_matrix r s
  have classOf_directSum (e f : K0.Idempotent R) :
      K0.classOf (K0.directSum e f)=K0.classOf e+K0.classOf f := by
    apply sub_eq_zero.mp
    change QuotientAddGroup.mk' (K0.relations R) (FreeAbelianGroup.of (K0.directSum e f))-
      (QuotientAddGroup.mk' (K0.relations R) (FreeAbelianGroup.of e)+
      QuotientAddGroup.mk' (K0.relations R) (FreeAbelianGroup.of f))=0
    rw [←map_add,←map_sub]
    change (QuotientAddGroup.mk (FreeAbelianGroup.of (K0.directSum e f)-
      (FreeAbelianGroup.of e+FreeAbelianGroup.of f)) : K0.Group R)=0
    apply (QuotientAddGroup.eq_zero_iff _).mpr
    rw [sub_add_eq_sub_sub]
    exact AddSubgroup.subset_closure (Or.inr ⟨e,f,rfl⟩)
  have Object.presentationClass_eq (P : Object.{u,v} R) (r : Retraction R P.carrier) :
      P.presentationClass=K0.classOf r.idempotent := Retraction.class_eq P.retraction r
  have Object.presentationClass_iso (P Q : Object.{u,v} R)
      (i : P.carrier ≃ₗ[Rᵐᵒᵖ] Q.carrier) : P.presentationClass=Q.presentationClass := by
    rw [Object.presentationClass_eq Q (P.retraction.transport i), Retraction.transport_idempotent]
    rfl
  have Object.presentationClass_prod (P Q : Object.{u,v} R) :
      (P.prod Q).presentationClass=P.presentationClass+Q.presentationClass := by
    calc
      _ = K0.classOf (P.retraction.prod Q.retraction).idempotent :=
        Object.presentationClass_eq (P.prod Q) (P.retraction.prod Q.retraction)
      _ = P.presentationClass+Q.presentationClass := by
        rw [Retraction.prod_idempotent,classOf_directSum]
        rfl
  have moduleRelations_in_kernel : moduleRelations R≤(rawPresentation.{u,v} (R := R)).ker := by
    apply (AddSubgroup.closure_le _).mpr
    intro x hx
    rcases hx with ⟨P,Q,⟨i⟩,rfl⟩ | ⟨P,Q,rfl⟩
    · change rawPresentation (FreeAbelianGroup.of P-FreeAbelianGroup.of Q)=0
      simp only [map_sub,rawPresentation,FreeAbelianGroup.lift_apply_of]
      exact sub_eq_zero.mpr (Object.presentationClass_iso P Q i)
    · change rawPresentation
        (FreeAbelianGroup.of (P.prod Q)-FreeAbelianGroup.of P-FreeAbelianGroup.of Q)=0
      simp only [map_sub,rawPresentation,FreeAbelianGroup.lift_apply_of,Object.presentationClass_prod]
      abel
  exact QuotientAddGroup.lift (moduleRelations R) rawPresentation moduleRelations_in_kernel

variable {G : Type u} [_root_.Group G]

def HattoriStallings : ModuleK0.{u,v} (MonoidAlgebra ℂ G) →+ (ConjClasses G →₀ ℂ) :=
  K0.HattoriStallings.comp presentation

theorem bassTraceModules_vanishing_and_support {G : Type u} [_root_.Group G]
    (x : ModuleK0.{u,v} (MonoidAlgebra ℂ G)) :
    (∀ g : G, ¬IsOfFinOrder g → HattoriStallings x (ConjClasses.mk g) = 0) ∧
      ↑(HattoriStallings x).support ⊆
        {c | ∃ g : G, IsOfFinOrder g ∧ ConjClasses.mk g = c} :=
  by sorry

end RightProjective

end BassTrace

end

end OAI