File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

full_name: «_aux_Mathlib_RepresentationTheory_GroupCohomology_Resolution___macroRules_termGⁿ_1»
code: local notation "Gⁿ" => Fin n → G
goal: Lean.Macro

full_name: «_aux_Mathlib_RepresentationTheory_GroupCohomology_Resolution___macroRules_termGⁿ⁺¹_1»
code: local notation "Gⁿ⁺¹" => Fin (n + 1) → G
goal: Lean.Macro

full_name: groupCohomology.resolution.actionDiagonalSucc
code: /-- An isomorphism of `G`-sets `Gⁿ⁺¹ ≅ G × Gⁿ`, where `G` acts by left multiplication on `Gⁿ⁺¹` and
`G` but trivially on `Gⁿ`. The map sends `(g₀, ..., gₙ) ↦ (g₀, (g₀⁻¹g₁, g₁⁻¹g₂, ..., gₙ₋₁⁻¹gₙ))`,
and the inverse is `(g₀, (g₁, ..., gₙ)) ↦ (g₀, g₀g₁, g₀g₁g₂, ..., g₀g₁...gₙ).` -/
def actionDiagonalSucc (G : Type u) [Group G] :
    ∀ n : ℕ, diagonal G (n + 1) ≅ leftRegular G ⊗ Action.mk (Fin n → G) 1
  
goal: Action.diagonal G (n + 1) ≅ CategoryTheory.MonoidalCategory.tensorObj (Action.leftRegular G) { V := Fin n → G, ρ := 1 }

full_name: groupCohomology.resolution.actionDiagonalSucc_hom_apply
code: theorem actionDiagonalSucc_hom_apply {G : Type u} [Group G] {n : ℕ} (f : Fin (n + 1) → G) :
    (actionDiagonalSucc G n).hom.hom f = (f 0, fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) 
goal: (groupCohomology.resolution.actionDiagonalSucc G n).hom.hom f = (f 0, fun i => (f i.castSucc)⁻¹ * f i.succ)

full_name: groupCohomology.resolution.actionDiagonalSucc_inv_apply
code: theorem actionDiagonalSucc_inv_apply {G : Type u} [Group G] {n : ℕ} (g : G) (f : Fin n → G) :
    (actionDiagonalSucc G n).inv.hom (g, f) = (g • Fin.partialProd f : Fin (n + 1) → G) 
goal: (groupCohomology.resolution.actionDiagonalSucc G n).inv.hom (g, f) = g • Fin.partialProd f

full_name: groupCohomology.resolution.diagonalSucc
code: /-- An isomorphism of `k`-linear representations of `G` from `k[Gⁿ⁺¹]` to `k[G] ⊗ₖ k[Gⁿ]` (on
which `G` acts by `ρ(g₁)(g₂ ⊗ x) = (g₁ * g₂) ⊗ x`) sending `(g₀, ..., gₙ)` to
`g₀ ⊗ (g₀⁻¹g₁, g₁⁻¹g₂, ..., gₙ₋₁⁻¹gₙ)`. The inverse sends `g₀ ⊗ (g₁, ..., gₙ)` to
`(g₀, g₀g₁, ..., g₀g₁...gₙ)`. -/
def diagonalSucc (n : ℕ) :
    diagonal k G (n + 1) ≅ leftRegular k G ⊗ trivial k G ((Fin n → G) →₀ k) 
goal: Rep.diagonal k G (n + 1) ≅
  CategoryTheory.MonoidalCategory.tensorObj (Rep.leftRegular k G) (Rep.trivial k G ((Fin n → G) →₀ k))

full_name: groupCohomology.resolution.diagonalSucc_hom_single
code: theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a 
goal: (groupCohomology.resolution.diagonalSucc k G n).hom.hom (Finsupp.single f a) =
  Finsupp.single (f 0) 1 ⊗ₜ[k] Finsupp.single (fun i => (f i.castSucc)⁻¹ * f i.succ) a

full_name: groupCohomology.resolution.diagonalSucc_inv_single_single
code: theorem diagonalSucc_inv_single_single (g : G) (f : Gⁿ) (a b : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g a ⊗ₜ Finsupp.single f b) =
      single (g • partialProd f) (a * b) 
goal: (groupCohomology.resolution.diagonalSucc k G n).inv.hom (Finsupp.single g a ⊗ₜ[k] Finsupp.single f b) =
  Finsupp.single (g • Fin.partialProd f) (a * b)

full_name: groupCohomology.resolution.diagonalSucc_inv_single_left
code: theorem diagonalSucc_inv_single_left (g : G) (f : Gⁿ →₀ k) (r : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g r ⊗ₜ f) =
      Finsupp.lift (Gⁿ⁺¹ →₀ k) k Gⁿ (fun f => single (g • partialProd f) r) f 
goal: (groupCohomology.resolution.diagonalSucc k G n).inv.hom (Finsupp.single g r ⊗ₜ[k] f) =
  ((Finsupp.lift ((Fin (n + 1) → G) →₀ k) k (Fin n → G)) fun f => Finsupp.single (g • Fin.partialProd f) r) f

full_name: groupCohomology.resolution.diagonalSucc_inv_single_right
code: theorem diagonalSucc_inv_single_right (g : G →₀ k) (f : Gⁿ) (r : k) :
    (diagonalSucc k G n).inv.hom (g ⊗ₜ Finsupp.single f r) =
      Finsupp.lift _ k G (fun a => single (a • partialProd f) r) g 
goal: (groupCohomology.resolution.diagonalSucc k G n).inv.hom (g ⊗ₜ[k] Finsupp.single f r) =
  ((Finsupp.lift ((Fin (n + 1) → G) →₀ k) k G) fun a => Finsupp.single (a • Fin.partialProd f) r) g

full_name: groupCohomology.resolution.ofMulActionBasisAux
code: /-- The `k[G]`-linear isomorphism `k[G] ⊗ₖ k[Gⁿ] ≃ k[Gⁿ⁺¹]`, where the `k[G]`-module structure on
the lefthand side is `TensorProduct.leftModule`, whilst that of the righthand side comes from
`Representation.asModule`. Allows us to use `Algebra.TensorProduct.basis` to get a `k[G]`-basis
of the righthand side. -/
def ofMulActionBasisAux :
    MonoidAlgebra k G ⊗[k] ((Fin n → G) →₀ k) ≃ₗ[MonoidAlgebra k G]
      (ofMulAction k G (Fin (n + 1) → G)).asModule 
goal: TensorProduct k (MonoidAlgebra k G) ((Fin n → G) →₀ k) ≃ₗ[MonoidAlgebra k G]
  (Representation.ofMulAction k G (Fin (n + 1) → G)).asModule

full_name: groupCohomology.resolution.ofMulActionBasis
code: /-- A `k[G]`-basis of `k[Gⁿ⁺¹]`, coming from the `k[G]`-linear isomorphism
`k[G] ⊗ₖ k[Gⁿ] ≃ k[Gⁿ⁺¹].` -/
def ofMulActionBasis :
    Basis (Fin n → G) (MonoidAlgebra k G) (ofMulAction k G (Fin (n + 1) → G)).asModule 
goal: Basis (Fin n → G) (MonoidAlgebra k G) (Representation.ofMulAction k G (Fin (n + 1) → G)).asModule

full_name: groupCohomology.resolution.ofMulAction_free
code: theorem ofMulAction_free :
    Module.Free (MonoidAlgebra k G) (ofMulAction k G (Fin (n + 1) → G)).asModule 
goal: Module.Free (MonoidAlgebra k G) (Representation.ofMulAction k G (Fin (n + 1) → G)).asModule

full_name: Rep.diagonalHomEquiv
code: /-- Given a `k`-linear `G`-representation `A`, the set of representation morphisms
`Hom(k[Gⁿ⁺¹], A)` is `k`-linearly isomorphic to the set of functions `Gⁿ → A`. -/
noncomputable def diagonalHomEquiv :
    (Rep.ofMulAction k G (Fin (n + 1) → G) ⟶ A) ≃ₗ[k] (Fin n → G) → A 
goal: (Rep.ofMulAction k G (Fin (n + 1) → G) ⟶ A) ≃ₗ[k] (Fin n → G) → CoeSort.coe A

full_name: Rep.diagonalHomEquiv_apply
code: /-- Given a `k`-linear `G`-representation `A`, `diagonalHomEquiv` is a `k`-linear isomorphism of
the set of representation morphisms `Hom(k[Gⁿ⁺¹], A)` with `Fun(Gⁿ, A)`. This lemma says that this
sends a morphism of representations `f : k[Gⁿ⁺¹] ⟶ A` to the function
`(g₁, ..., gₙ) ↦ f(1, g₁, g₁g₂, ..., g₁g₂...gₙ).` -/
theorem diagonalHomEquiv_apply (f : Rep.ofMulAction k G (Fin (n + 1) → G) ⟶ A) (x : Fin n → G) :
    diagonalHomEquiv n A f x = f.hom (Finsupp.single (Fin.partialProd x) 1) 
goal: (Rep.diagonalHomEquiv n A) f x = f.hom (Finsupp.single (Fin.partialProd x) 1)

full_name: Rep.diagonalHomEquiv_symm_apply
code: /-- Given a `k`-linear `G`-representation `A`, `diagonalHomEquiv` is a `k`-linear isomorphism of
the set of representation morphisms `Hom(k[Gⁿ⁺¹], A)` with `Fun(Gⁿ, A)`. This lemma says that the
inverse map sends a function `f : Gⁿ → A` to the representation morphism sending
`(g₀, ... gₙ) ↦ ρ(g₀)(f(g₀⁻¹g₁, g₁⁻¹g₂, ..., gₙ₋₁⁻¹gₙ))`, where `ρ` is the representation attached
to `A`. -/
theorem diagonalHomEquiv_symm_apply (f : (Fin n → G) → A) (x : Fin (n + 1) → G) :
    ((diagonalHomEquiv n A).symm f).hom (Finsupp.single x 1) =
      A.ρ (x 0) (f fun i : Fin n => (x (Fin.castSucc i))⁻¹ * x i.succ) 
goal: ((Rep.diagonalHomEquiv n A).symm f).hom (Finsupp.single x 1) = (A.ρ (x 0)) (f fun i => (x i.castSucc)⁻¹ * x i.succ)

full_name: Rep.diagonalHomEquiv_symm_partialProd_succ
code: /-- Auxiliary lemma for defining group cohomology, used to show that the isomorphism
`diagonalHomEquiv` commutes with the differentials in two complexes which compute
group cohomology. -/
theorem diagonalHomEquiv_symm_partialProd_succ (f : (Fin n → G) → A) (g : Fin (n + 1) → G)
    (a : Fin (n + 1)) :
    ((diagonalHomEquiv n A).symm f).hom (Finsupp.single (Fin.partialProd g ∘ a.succ.succAbove) 1)
      = f (Fin.contractNth a (· * ·) g) 
goal: ((Rep.diagonalHomEquiv n A).symm f).hom (Finsupp.single (Fin.partialProd g ∘ a.succ.succAbove) 1) =
  f (a.contractNth (fun x x_1 => x * x_1) g)

full_name: classifyingSpaceUniversalCover
code: /-- The simplicial `G`-set sending `[n]` to `Gⁿ⁺¹` equipped with the diagonal action of `G`. -/
def classifyingSpaceUniversalCover [Monoid G] :
    SimplicialObject (Action (Type u) <| MonCat.of G) 
goal: CategoryTheory.SimplicialObject (Action (Type u) (MonCat.of G))

full_name: classifyingSpaceUniversalCover.cechNerveTerminalFromIso
code: /-- When the category is `G`-Set, `cechNerveTerminalFrom` of `G` with the left regular action is
isomorphic to `EG`, the universal cover of the classifying space of `G` as a simplicial `G`-set. -/
def cechNerveTerminalFromIso :
    cechNerveTerminalFrom (Action.ofMulAction G G) ≅ classifyingSpaceUniversalCover G 
goal: CategoryTheory.cechNerveTerminalFrom (Action.ofMulAction G G) ≅ classifyingSpaceUniversalCover G

full_name: classifyingSpaceUniversalCover.cechNerveTerminalFromIsoCompForget
code: /-- As a simplicial set, `cechNerveTerminalFrom` of a monoid `G` is isomorphic to the universal
cover of the classifying space of `G` as a simplicial set. -/
def cechNerveTerminalFromIsoCompForget :
    cechNerveTerminalFrom G ≅ classifyingSpaceUniversalCover G ⋙ forget _ 
goal: CategoryTheory.cechNerveTerminalFrom G ≅
  classifyingSpaceUniversalCover G ⋙ CategoryTheory.forget (Action (Type u) (MonCat.of G))

full_name: classifyingSpaceUniversalCover.compForgetAugmented
code: /-- The universal cover of the classifying space of `G` as a simplicial set, augmented by the map
from `Fin 1 → G` to the terminal object in `Type u`. -/
def compForgetAugmented : SimplicialObject.Augmented (Type u) 
goal: CategoryTheory.SimplicialObject.Augmented (Type u)

full_name: classifyingSpaceUniversalCover.extraDegeneracyAugmentedCechNerve
code: /-- The augmented Čech nerve of the map from `Fin 1 → G` to the terminal object in `Type u` has an
extra degeneracy. -/
def extraDegeneracyAugmentedCechNerve :
    ExtraDegeneracy (Arrow.mk <| terminal.from G).augmentedCechNerve 
goal: SimplicialObject.Augmented.ExtraDegeneracy
  (CategoryTheory.Arrow.mk (CategoryTheory.Limits.terminal.from G)).augmentedCechNerve

full_name: classifyingSpaceUniversalCover.extraDegeneracyCompForgetAugmented
code: /-- The universal cover of the classifying space of `G` as a simplicial set, augmented by the map
from `Fin 1 → G` to the terminal object in `Type u`, has an extra degeneracy. -/
def extraDegeneracyCompForgetAugmented : ExtraDegeneracy (compForgetAugmented G) 
goal: SimplicialObject.Augmented.ExtraDegeneracy (classifyingSpaceUniversalCover.compForgetAugmented G)

full_name: classifyingSpaceUniversalCover.compForgetAugmented.toModule
code: /-- The free functor `Type u ⥤ ModuleCat.{u} k` applied to the universal cover of the classifying
space of `G` as a simplicial set, augmented by the map from `Fin 1 → G` to the terminal object
in `Type u`. -/
def compForgetAugmented.toModule : SimplicialObject.Augmented (ModuleCat.{u} k) 
goal: CategoryTheory.SimplicialObject.Augmented (ModuleCat k)

full_name: classifyingSpaceUniversalCover.extraDegeneracyCompForgetAugmentedToModule
code: /-- If we augment the universal cover of the classifying space of `G` as a simplicial set by the
map from `Fin 1 → G` to the terminal object in `Type u`, then apply the free functor
`Type u ⥤ ModuleCat.{u} k`, the resulting augmented simplicial `k`-module has an extra
degeneracy. -/
def extraDegeneracyCompForgetAugmentedToModule :
    ExtraDegeneracy (compForgetAugmented.toModule k G) 
goal: SimplicialObject.Augmented.ExtraDegeneracy (classifyingSpaceUniversalCover.compForgetAugmented.toModule k G)

full_name: groupCohomology.resolution
code: /-- The standard resolution of `k` as a trivial representation, defined as the alternating
face map complex of a simplicial `k`-linear `G`-representation. -/
def groupCohomology.resolution [Monoid G] 
goal: ChainComplex (Rep k G) ℕ

full_name: groupCohomology.resolution.d
code: /-- The `k`-linear map underlying the differential in the standard resolution of `k` as a trivial
`k`-linear `G`-representation. It sends `(g₀, ..., gₙ) ↦ ∑ (-1)ⁱ • (g₀, ..., ĝᵢ, ..., gₙ)`. -/
def d (G : Type u) (n : ℕ) : ((Fin (n + 1) → G) →₀ k) →ₗ[k] (Fin n → G) →₀ k 
goal: ((Fin (n + 1) → G) →₀ k) →ₗ[k] (Fin n → G) →₀ k

full_name: groupCohomology.resolution.d_of
code: @[simp]
theorem d_of {G : Type u} {n : ℕ} (c : Fin (n + 1) → G) :
    d k G n (Finsupp.single c 1) =
      Finset.univ.sum fun p : Fin (n + 1) =>
        Finsupp.single (c ∘ p.succAbove) ((-1 : k) ^ (p : ℕ)) 
goal: (groupCohomology.resolution.d k G n) (Finsupp.single c 1) =
  ∑ p : Fin (n + 1), Finsupp.single (c ∘ p.succAbove) ((-1) ^ ↑p)

full_name: groupCohomology.resolution.xIso
code: /-- The `n`th object of the standard resolution of `k` is definitionally isomorphic to `k[Gⁿ⁺¹]`
equipped with the representation induced by the diagonal action of `G`. -/
def xIso (n : ℕ) : (groupCohomology.resolution k G).X n ≅ Rep.ofMulAction k G (Fin (n + 1) → G) 
goal: (groupCohomology.resolution k G).X n ≅ Rep.ofMulAction k G (Fin (n + 1) → G)

full_name: groupCohomology.resolution.x_projective
code: instance x_projective (G : Type u) [Group G] (n : ℕ) :
    Projective ((groupCohomology.resolution k G).X n) 
goal: CategoryTheory.Projective ((groupCohomology.resolution k G).X n)

full_name: groupCohomology.resolution.d_eq
code: /-- Simpler expression for the differential in the standard resolution of `k` as a
`G`-representation. It sends `(g₀, ..., gₙ₊₁) ↦ ∑ (-1)ⁱ • (g₀, ..., ĝᵢ, ..., gₙ₊₁)`. -/
theorem d_eq (n : ℕ) : ((groupCohomology.resolution k G).d (n + 1) n).hom = d k G (n + 1) 
goal: ((groupCohomology.resolution k G).d (n + 1) n).hom = groupCohomology.resolution.d k G (n + 1)

full_name: groupCohomology.resolution.forget₂ToModuleCat
code: /-- The standard resolution of `k` as a trivial representation as a complex of `k`-modules. -/
def forget₂ToModuleCat 
goal: HomologicalComplex (ModuleCat k) (ComplexShape.down ℕ)

full_name: groupCohomology.resolution.compForgetAugmentedIso
code: /-- If we apply the free functor `Type u ⥤ ModuleCat.{u} k` to the universal cover of the
classifying space of `G` as a simplicial set, then take the alternating face map complex, the result
is isomorphic to the standard resolution of the trivial `G`-representation `k` as a complex of
`k`-modules. -/
def compForgetAugmentedIso :
    AlternatingFaceMapComplex.obj
        (SimplicialObject.Augmented.drop.obj (compForgetAugmented.toModule k G)) ≅
      groupCohomology.resolution.forget₂ToModuleCat k G 
goal: AlgebraicTopology.AlternatingFaceMapComplex.obj
    (CategoryTheory.SimplicialObject.Augmented.drop.obj
      (classifyingSpaceUniversalCover.compForgetAugmented.toModule k G)) ≅
  groupCohomology.resolution.forget₂ToModuleCat k G

full_name: groupCohomology.resolution.forget₂ToModuleCatHomotopyEquiv
code: /-- As a complex of `k`-modules, the standard resolution of the trivial `G`-representation `k` is
homotopy equivalent to the complex which is `k` at 0 and 0 elsewhere. -/
def forget₂ToModuleCatHomotopyEquiv :
    HomotopyEquiv (groupCohomology.resolution.forget₂ToModuleCat k G)
      ((ChainComplex.single₀ (ModuleCat k)).obj ((forget₂ (Rep k G) _).obj <| Rep.trivial k G k)) 
goal: HomotopyEquiv (groupCohomology.resolution.forget₂ToModuleCat k G)
  ((ChainComplex.single₀ (ModuleCat k)).obj ((CategoryTheory.forget₂ (Rep k G) (ModuleCat k)).obj (Rep.trivial k G k)))

full_name: groupCohomology.resolution.ε
code: /-- The hom of `k`-linear `G`-representations `k[G¹] → k` sending `∑ nᵢgᵢ ↦ ∑ nᵢ`. -/
def ε : Rep.ofMulAction k G (Fin 1 → G) ⟶ Rep.trivial k G k 
goal: Rep.ofMulAction k G (Fin 1 → G) ⟶ Rep.trivial k G k

full_name: groupCohomology.resolution.forget₂ToModuleCatHomotopyEquiv_f_0_eq
code: /-- The homotopy equivalence of complexes of `k`-modules between the standard resolution of `k` as
a trivial `G`-representation, and the complex which is `k` at 0 and 0 everywhere else, acts as
`∑ nᵢgᵢ ↦ ∑ nᵢ : k[G¹] → k` at 0. -/
theorem forget₂ToModuleCatHomotopyEquiv_f_0_eq :
    (forget₂ToModuleCatHomotopyEquiv k G).1.f 0 = (forget₂ (Rep k G) _).map (ε k G) 
goal: (groupCohomology.resolution.forget₂ToModuleCatHomotopyEquiv k G).hom.f 0 =
  (CategoryTheory.forget₂ (Rep k G) (ModuleCat k)).map (groupCohomology.resolution.ε k G)

full_name: groupCohomology.resolution.d_comp_ε
code: theorem d_comp_ε : (groupCohomology.resolution k G).d 1 0 ≫ ε k G = 0 
goal: (groupCohomology.resolution k G).d 1 0 ≫ groupCohomology.resolution.ε k G = 0

full_name: groupCohomology.resolution.εToSingle₀
code: /-- The chain map from the standard resolution of `k` to `k[0]` given by `∑ nᵢgᵢ ↦ ∑ nᵢ` in
degree zero. -/
def εToSingle₀ :
    groupCohomology.resolution k G ⟶ (ChainComplex.single₀ _).obj (Rep.trivial k G k) 
goal: groupCohomology.resolution k G ⟶ (ChainComplex.single₀ (Rep k G)).obj (Rep.trivial k G k)

full_name: groupCohomology.resolution.εToSingle₀_comp_eq
code: theorem εToSingle₀_comp_eq :
    ((forget₂ _ (ModuleCat.{u} k)).mapHomologicalComplex _).map (εToSingle₀ k G) ≫
        (HomologicalComplex.singleMapHomologicalComplex _ _ _).hom.app _ =
      (forget₂ToModuleCatHomotopyEquiv k G).hom 
goal: ((CategoryTheory.forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map
      (groupCohomology.resolution.εToSingle₀ k G) ≫
    (HomologicalComplex.singleMapHomologicalComplex (CategoryTheory.forget₂ (Rep k G) (ModuleCat k))
            (ComplexShape.down ℕ) 0).hom.app
      (Rep.trivial k G k) =
  (groupCohomology.resolution.forget₂ToModuleCatHomotopyEquiv k G).hom

full_name: groupCohomology.resolution.quasiIso_forget₂_εToSingle₀
code: theorem quasiIso_forget₂_εToSingle₀ :
    QuasiIso (((forget₂ _ (ModuleCat.{u} k)).mapHomologicalComplex _).map (εToSingle₀ k G)) 
goal: QuasiIso
  (((CategoryTheory.forget₂ (Rep k G) (ModuleCat k)).mapHomologicalComplex (ComplexShape.down ℕ)).map
    (groupCohomology.resolution.εToSingle₀ k G))

full_name: groupCohomology.resolution.instQuasiIsoNatRepεToSingle₀
code: instance : QuasiIso (εToSingle₀ k G) 
goal: QuasiIso (groupCohomology.resolution.εToSingle₀ k G)

full_name: groupCohomology.projectiveResolution
code: /-- The standard projective resolution of `k` as a trivial `k`-linear `G`-representation. -/
def groupCohomology.projectiveResolution : ProjectiveResolution (Rep.trivial k G k) 
goal: CategoryTheory.ProjectiveResolution (Rep.trivial k G k)

full_name: instEnoughProjectivesRep
code: instance : EnoughProjectives (Rep k G) 
goal: CategoryTheory.EnoughProjectives (Rep k G)

full_name: groupCohomology.extIso
code: /-- Given a `k`-linear `G`-representation `V`, `Extⁿ(k, V)` (where `k` is a trivial `k`-linear
`G`-representation) is isomorphic to the `n`th cohomology group of `Hom(P, V)`, where `P` is the
standard resolution of `k` called `groupCohomology.resolution k G`. -/
def groupCohomology.extIso (V : Rep k G) (n : ℕ) :
    ((Ext k (Rep k G) n).obj (Opposite.op <| Rep.trivial k G k)).obj V ≅
      ((groupCohomology.resolution k G).linearYonedaObj k V).homology n 
goal: ((Ext k (Rep k G) n).obj (Opposite.op (Rep.trivial k G k))).obj V ≅
  HomologicalComplex.homology ((groupCohomology.resolution k G).linearYonedaObj k V) n