File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

full_name: groupCohomology.zeroCochainsLequiv
code: /-- The 0th object in the complex of inhomogeneous cochains of `A : Rep k G` is isomorphic
to `A` as a `k`-module. -/
def zeroCochainsLequiv : (inhomogeneousCochains A).X 0 ≃ₗ[k] A 
goal: ↑((groupCohomology.inhomogeneousCochains A).X 0) ≃ₗ[k] CoeSort.coe A

full_name: groupCohomology.oneCochainsLequiv
code: /-- The 1st object in the complex of inhomogeneous cochains of `A : Rep k G` is isomorphic
to `Fun(G, A)` as a `k`-module. -/
def oneCochainsLequiv : (inhomogeneousCochains A).X 1 ≃ₗ[k] G → A 
goal: ↑((groupCohomology.inhomogeneousCochains A).X 1) ≃ₗ[k] G → CoeSort.coe A

full_name: groupCohomology.twoCochainsLequiv
code: /-- The 2nd object in the complex of inhomogeneous cochains of `A : Rep k G` is isomorphic
to `Fun(G², A)` as a `k`-module. -/
def twoCochainsLequiv : (inhomogeneousCochains A).X 2 ≃ₗ[k] G × G → A 
goal: ↑((groupCohomology.inhomogeneousCochains A).X 2) ≃ₗ[k] G × G → CoeSort.coe A

full_name: groupCohomology.threeCochainsLequiv
code: /-- The 3rd object in the complex of inhomogeneous cochains of `A : Rep k G` is isomorphic
to `Fun(G³, A)` as a `k`-module. -/
def threeCochainsLequiv : (inhomogeneousCochains A).X 3 ≃ₗ[k] G × G × G → A 
goal: ↑((groupCohomology.inhomogeneousCochains A).X 3) ≃ₗ[k] G × G × G → CoeSort.coe A

full_name: groupCohomology.dZero_apply
code: /-- The 0th differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
`k`-linear map `A → Fun(G, A)`. It sends `(a, g) ↦ ρ_A(g)(a) - a.` -/
@[simps]
def dZero : A →ₗ[k] G → A 
goal: (groupCohomology.dZero A) m g = (A.ρ g) m - m

full_name: groupCohomology.dZero
code: /-- The 0th differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
`k`-linear map `A → Fun(G, A)`. It sends `(a, g) ↦ ρ_A(g)(a) - a.` -/
@[simps]
def dZero : A →ₗ[k] G → A 
goal: CoeSort.coe A →ₗ[k] G → CoeSort.coe A

full_name: groupCohomology.dZero_ker_eq_invariants
code: theorem dZero_ker_eq_invariants : LinearMap.ker (dZero A) = invariants A.ρ 
goal: LinearMap.ker (groupCohomology.dZero A) = A.ρ.invariants

full_name: groupCohomology.dZero_eq_zero
code: @[simp] theorem dZero_eq_zero [A.IsTrivial] : dZero A = 0 
goal: groupCohomology.dZero A = 0

full_name: groupCohomology.dOne
code: /-- The 1st differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
`k`-linear map `Fun(G, A) → Fun(G × G, A)`. It sends
`(f, (g₁, g₂)) ↦ ρ_A(g₁)(f(g₂)) - f(g₁g₂) + f(g₁).` -/
@[simps]
def dOne : (G → A) →ₗ[k] G × G → A 
goal: (G → CoeSort.coe A) →ₗ[k] G × G → CoeSort.coe A

full_name: groupCohomology.dOne_apply
code: /-- The 1st differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
`k`-linear map `Fun(G, A) → Fun(G × G, A)`. It sends
`(f, (g₁, g₂)) ↦ ρ_A(g₁)(f(g₂)) - f(g₁g₂) + f(g₁).` -/
@[simps]
def dOne : (G → A) →ₗ[k] G × G → A 
goal: (groupCohomology.dOne A) f g = (A.ρ g.1) (f g.2) - f (g.1 * g.2) + f g.1

full_name: groupCohomology.dTwo
code: /-- The 2nd differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
`k`-linear map `Fun(G × G, A) → Fun(G × G × G, A)`. It sends
`(f, (g₁, g₂, g₃)) ↦ ρ_A(g₁)(f(g₂, g₃)) - f(g₁g₂, g₃) + f(g₁, g₂g₃) - f(g₁, g₂).` -/
@[simps]
def dTwo : (G × G → A) →ₗ[k] G × G × G → A 
goal: (G × G → CoeSort.coe A) →ₗ[k] G × G × G → CoeSort.coe A

full_name: groupCohomology.dTwo_apply
code: /-- The 2nd differential in the complex of inhomogeneous cochains of `A : Rep k G`, as a
`k`-linear map `Fun(G × G, A) → Fun(G × G × G, A)`. It sends
`(f, (g₁, g₂, g₃)) ↦ ρ_A(g₁)(f(g₂, g₃)) - f(g₁g₂, g₃) + f(g₁, g₂g₃) - f(g₁, g₂).` -/
@[simps]
def dTwo : (G × G → A) →ₗ[k] G × G × G → A 
goal: (groupCohomology.dTwo A) f g =
  (A.ρ g.1) (f (g.2.1, g.2.2)) - f (g.1 * g.2.1, g.2.2) + f (g.1, g.2.1 * g.2.2) - f (g.1, g.2.1)

full_name: groupCohomology.dZero_comp_eq
code: /-- Let `C(G, A)` denote the complex of inhomogeneous cochains of `A : Rep k G`. This lemma
says `dZero` gives a simpler expression for the 0th differential: that is, the following
square commutes:
```
  C⁰(G, A) ---d⁰---> C¹(G, A)
  |                    |
  |                    |
  |                    |
  v                    v
  A ---- dZero ---> Fun(G, A)
```
where the vertical arrows are `zeroCochainsLequiv` and `oneCochainsLequiv` respectively.
-/
theorem dZero_comp_eq : dZero A ∘ₗ (zeroCochainsLequiv A) =
    oneCochainsLequiv A ∘ₗ (inhomogeneousCochains A).d 0 1 
goal: groupCohomology.dZero A ∘ₗ ↑(groupCohomology.zeroCochainsLequiv A) =
  ↑(groupCohomology.oneCochainsLequiv A) ∘ₗ (groupCohomology.inhomogeneousCochains A).d 0 1

full_name: groupCohomology.dOne_comp_eq
code: /-- Let `C(G, A)` denote the complex of inhomogeneous cochains of `A : Rep k G`. This lemma
says `dOne` gives a simpler expression for the 1st differential: that is, the following
square commutes:
```
  C¹(G, A) ---d¹-----> C²(G, A)
    |                      |
    |                      |
    |                      |
    v                      v
  Fun(G, A) -dOne-> Fun(G × G, A)
```
where the vertical arrows are `oneCochainsLequiv` and `twoCochainsLequiv` respectively.
-/
theorem dOne_comp_eq : dOne A ∘ₗ oneCochainsLequiv A =
    twoCochainsLequiv A ∘ₗ (inhomogeneousCochains A).d 1 2 
goal: groupCohomology.dOne A ∘ₗ ↑(groupCohomology.oneCochainsLequiv A) =
  ↑(groupCohomology.twoCochainsLequiv A) ∘ₗ (groupCohomology.inhomogeneousCochains A).d 1 2

full_name: groupCohomology.dTwo_comp_eq
code: /-- Let `C(G, A)` denote the complex of inhomogeneous cochains of `A : Rep k G`. This lemma
says `dTwo` gives a simpler expression for the 2nd differential: that is, the following
square commutes:
```
      C²(G, A) -------d²-----> C³(G, A)
        |                         |
        |                         |
        |                         |
        v                         v
  Fun(G × G, A) --dTwo--> Fun(G × G × G, A)
```
where the vertical arrows are `twoCochainsLequiv` and `threeCochainsLequiv` respectively.
-/
theorem dTwo_comp_eq :
    dTwo A ∘ₗ twoCochainsLequiv A = threeCochainsLequiv A ∘ₗ (inhomogeneousCochains A).d 2 3 
goal: groupCohomology.dTwo A ∘ₗ ↑(groupCohomology.twoCochainsLequiv A) =
  ↑(groupCohomology.threeCochainsLequiv A) ∘ₗ (groupCohomology.inhomogeneousCochains A).d 2 3

full_name: groupCohomology.dOne_comp_dZero
code: theorem dOne_comp_dZero : dOne A ∘ₗ dZero A = 0 
goal: groupCohomology.dOne A ∘ₗ groupCohomology.dZero A = 0

full_name: groupCohomology.dTwo_comp_dOne
code: theorem dTwo_comp_dOne : dTwo A ∘ₗ dOne A = 0 
goal: groupCohomology.dTwo A ∘ₗ groupCohomology.dOne A = 0

full_name: groupCohomology.oneCocycles
code: /-- The 1-cocycles `Z¹(G, A)` of `A : Rep k G`, defined as the kernel of the map
`Fun(G, A) → Fun(G × G, A)` sending `(f, (g₁, g₂)) ↦ ρ_A(g₁)(f(g₂)) - f(g₁g₂) + f(g₁).` -/
def oneCocycles : Submodule k (G → A) 
goal: Submodule k (G → CoeSort.coe A)

full_name: groupCohomology.twoCocycles
code: /-- The 2-cocycles `Z²(G, A)` of `A : Rep k G`, defined as the kernel of the map
`Fun(G × G, A) → Fun(G × G × G, A)` sending
`(f, (g₁, g₂, g₃)) ↦ ρ_A(g₁)(f(g₂, g₃)) - f(g₁g₂, g₃) + f(g₁, g₂g₃) - f(g₁, g₂).` -/
def twoCocycles : Submodule k (G × G → A) 
goal: Submodule k (G × G → CoeSort.coe A)

full_name: groupCohomology.mem_oneCocycles_def
code: theorem mem_oneCocycles_def (f : G → A) :
    f ∈ oneCocycles A ↔ ∀ g h : G, A.ρ g (f h) - f (g * h) + f g = 0 
goal: f ∈ groupCohomology.oneCocycles A ↔ ∀ (g h : G), (A.ρ g) (f h) - f (g * h) + f g = 0

full_name: groupCohomology.mem_oneCocycles_iff
code: theorem mem_oneCocycles_iff (f : G → A) :
    f ∈ oneCocycles A ↔ ∀ g h : G, f (g * h) = A.ρ g (f h) + f g 
goal: f ∈ groupCohomology.oneCocycles A ↔ ∀ (g h : G), f (g * h) = (A.ρ g) (f h) + f g

full_name: groupCohomology.oneCocycles_map_one
code: @[simp] theorem oneCocycles_map_one (f : oneCocycles A) : f.1 1 = 0 
goal: ↑f 1 = 0

full_name: groupCohomology.oneCocycles_map_inv
code: @[simp] theorem oneCocycles_map_inv (f : oneCocycles A) (g : G) :
    A.ρ g (f.1 g⁻¹) = - f.1 g 
goal: (A.ρ g) (↑f g⁻¹) = -↑f g

full_name: groupCohomology.oneCocycles_map_mul_of_isTrivial
code: theorem oneCocycles_map_mul_of_isTrivial [A.IsTrivial] (f : oneCocycles A) (g h : G) :
    f.1 (g * h) = f.1 g + f.1 h 
goal: ↑f (g * h) = ↑f g + ↑f h

full_name: groupCohomology.mem_oneCocycles_of_addMonoidHom
code: theorem mem_oneCocycles_of_addMonoidHom [A.IsTrivial] (f : Additive G →+ A) :
    f ∘ Additive.ofMul ∈ oneCocycles A 
goal: ⇑f ∘ ⇑Additive.ofMul ∈ groupCohomology.oneCocycles A

full_name: groupCohomology.oneCocyclesLequivOfIsTrivial_apply_apply
code: /-- When `A : Rep k G` is a trivial representation of `G`, `Z¹(G, A)` is isomorphic to the
group homs `G → A`. -/
@[simps] def oneCocyclesLequivOfIsTrivial [hA : A.IsTrivial] :
    oneCocycles A ≃ₗ[k] Additive G →+ A 
goal: ∀ (a : Additive G), ((groupCohomology.oneCocyclesLequivOfIsTrivial A) f) a = (↑f ∘ ⇑Additive.toMul) a

full_name: groupCohomology.oneCocyclesLequivOfIsTrivial
code: /-- When `A : Rep k G` is a trivial representation of `G`, `Z¹(G, A)` is isomorphic to the
group homs `G → A`. -/
@[simps] def oneCocyclesLequivOfIsTrivial [hA : A.IsTrivial] :
    oneCocycles A ≃ₗ[k] Additive G →+ A 
goal: ↥(groupCohomology.oneCocycles A) ≃ₗ[k] Additive G →+ CoeSort.coe A

full_name: groupCohomology.oneCocyclesLequivOfIsTrivial_symm_apply_coe
code: /-- When `A : Rep k G` is a trivial representation of `G`, `Z¹(G, A)` is isomorphic to the
group homs `G → A`. -/
@[simps] def oneCocyclesLequivOfIsTrivial [hA : A.IsTrivial] :
    oneCocycles A ≃ₗ[k] Additive G →+ A 
goal: ↑((groupCohomology.oneCocyclesLequivOfIsTrivial A).symm f) a = f a

full_name: groupCohomology.mem_twoCocycles_def
code: theorem mem_twoCocycles_def (f : G × G → A) :
    f ∈ twoCocycles A ↔ ∀ g h j : G,
      A.ρ g (f (h, j)) - f (g * h, j) + f (g, h * j) - f (g, h) = 0 
goal: f ∈ groupCohomology.twoCocycles A ↔ ∀ (g h j : G), (A.ρ g) (f (h, j)) - f (g * h, j) + f (g, h * j) - f (g, h) = 0

full_name: groupCohomology.mem_twoCocycles_iff
code: theorem mem_twoCocycles_iff (f : G × G → A) :
    f ∈ twoCocycles A ↔ ∀ g h j : G,
      f (g * h, j) + f (g, h) =
        A.ρ g (f (h, j)) + f (g, h * j) 
goal: f ∈ groupCohomology.twoCocycles A ↔ ∀ (g h j : G), f (g * h, j) + f (g, h) = (A.ρ g) (f (h, j)) + f (g, h * j)

full_name: groupCohomology.twoCocycles_map_one_fst
code: theorem twoCocycles_map_one_fst (f : twoCocycles A) (g : G) :
    f.1 (1, g) = f.1 (1, 1) 
goal: ↑f (1, g) = ↑f (1, 1)

full_name: groupCohomology.twoCocycles_map_one_snd
code: theorem twoCocycles_map_one_snd (f : twoCocycles A) (g : G) :
    f.1 (g, 1) = A.ρ g (f.1 (1, 1)) 
goal: ↑f (g, 1) = (A.ρ g) (↑f (1, 1))

full_name: groupCohomology.twoCocycles_ρ_map_inv_sub_map_inv
code: lemma twoCocycles_ρ_map_inv_sub_map_inv (f : twoCocycles A) (g : G) :
    A.ρ g (f.1 (g⁻¹, g)) - f.1 (g, g⁻¹)
      = f.1 (1, 1) - f.1 (g, 1) 
goal: (A.ρ g) (↑f (g⁻¹, g)) - ↑f (g, g⁻¹) = ↑f (1, 1) - ↑f (g, 1)

full_name: groupCohomology.oneCoboundaries
code: /-- The 1-coboundaries `B¹(G, A)` of `A : Rep k G`, defined as the image of the map
`A → Fun(G, A)` sending `(a, g) ↦ ρ_A(g)(a) - a.` -/
def oneCoboundaries : Submodule k (oneCocycles A) 
goal: Submodule k ↥(groupCohomology.oneCocycles A)

full_name: groupCohomology.twoCoboundaries
code: /-- The 2-coboundaries `B²(G, A)` of `A : Rep k G`, defined as the image of the map
`Fun(G, A) → Fun(G × G, A)` sending `(f, (g₁, g₂)) ↦ ρ_A(g₁)(f(g₂)) - f(g₁g₂) + f(g₁).` -/
def twoCoboundaries : Submodule k (twoCocycles A) 
goal: Submodule k ↥(groupCohomology.twoCocycles A)

full_name: groupCohomology.oneCoboundariesOfMemRange
code: /-- Makes a 1-coboundary out of `f ∈ Im(d⁰)`. -/
def oneCoboundariesOfMemRange {f : G → A} (h : f ∈ LinearMap.range (dZero A)) :
    oneCoboundaries A 
goal: ↥(groupCohomology.oneCoboundaries A)

full_name: groupCohomology.oneCoboundaries_of_mem_range_apply
code: theorem oneCoboundaries_of_mem_range_apply {f : G → A} (h : f ∈ LinearMap.range (dZero A)) :
    (oneCoboundariesOfMemRange h).1.1 = f 
goal: ↑↑(groupCohomology.oneCoboundariesOfMemRange h) = f

full_name: groupCohomology.oneCoboundariesOfEq
code: /-- Makes a 1-coboundary out of `f : G → A` and `x` such that
`ρ(g)(x) - x = f(g)` for all `g : G`. -/
def oneCoboundariesOfEq {f : G → A} {x : A} (hf : ∀ g, A.ρ g x - x = f g) :
    oneCoboundaries A 
goal: ↥(groupCohomology.oneCoboundaries A)

full_name: groupCohomology.oneCoboundariesOfEq_apply
code: theorem oneCoboundariesOfEq_apply {f : G → A} {x : A} (hf : ∀ g, A.ρ g x - x = f g) :
    (oneCoboundariesOfEq hf).1.1 = f 
goal: ↑↑(groupCohomology.oneCoboundariesOfEq hf) = f

full_name: groupCohomology.mem_range_of_mem_oneCoboundaries
code: theorem mem_range_of_mem_oneCoboundaries {f : oneCocycles A} (h : f ∈ oneCoboundaries A) :
    f.1 ∈ LinearMap.range (dZero A) 
goal: ↑f ∈ LinearMap.range (groupCohomology.dZero A)

full_name: groupCohomology.oneCoboundaries_eq_bot_of_isTrivial
code: theorem oneCoboundaries_eq_bot_of_isTrivial (A : Rep k G) [A.IsTrivial] :
    oneCoboundaries A = ⊥ 
goal: groupCohomology.oneCoboundaries A = ⊥

full_name: groupCohomology.twoCoboundariesOfMemRange
code: /-- Makes a 2-coboundary out of `f ∈ Im(d¹)`. -/
def twoCoboundariesOfMemRange {f : G × G → A} (h : f ∈ LinearMap.range (dOne A)) :
    twoCoboundaries A 
goal: ↥(groupCohomology.twoCoboundaries A)

full_name: groupCohomology.twoCoboundariesOfMemRange_apply
code: theorem twoCoboundariesOfMemRange_apply {f : G × G → A} (h : f ∈ LinearMap.range (dOne A)) :
    (twoCoboundariesOfMemRange h).1.1 = f 
goal: ↑↑(groupCohomology.twoCoboundariesOfMemRange h) = f

full_name: groupCohomology.twoCoboundariesOfEq
code: /-- Makes a 2-coboundary out of `f : G × G → A` and `x : G → A` such that
`ρ(g)(x(h)) - x(gh) + x(g) = f(g, h)` for all `g, h : G`. -/
def twoCoboundariesOfEq {f : G × G → A} {x : G → A}
    (hf : ∀ g h, A.ρ g (x h) - x (g * h) + x g = f (g, h)) :
    twoCoboundaries A 
goal: ↥(groupCohomology.twoCoboundaries A)

full_name: groupCohomology.twoCoboundariesOfEq_apply
code: theorem twoCoboundariesOfEq_apply {f : G × G → A} {x : G → A}
    (hf : ∀ g h, A.ρ g (x h) - x (g * h) + x g = f (g, h)) :
    (twoCoboundariesOfEq hf).1.1 = f 
goal: ↑↑(groupCohomology.twoCoboundariesOfEq hf) = f

full_name: groupCohomology.mem_range_of_mem_twoCoboundaries
code: theorem mem_range_of_mem_twoCoboundaries {f : twoCocycles A} (h : f ∈ twoCoboundaries A) :
    (twoCocycles A).subtype f ∈ LinearMap.range (dOne A) 
goal: (groupCohomology.twoCocycles A).subtype f ∈ LinearMap.range (groupCohomology.dOne A)

full_name: groupCohomology.IsOneCocycle
code: /-- A function `f : G → A` satisfies the 1-cocycle condition if
`f(gh) = g • f(h) + f(g)` for all `g, h : G`. -/
def IsOneCocycle (f : G → A) : Prop 
goal: Prop

full_name: groupCohomology.IsTwoCocycle
code: /-- A function `f : G × G → A` satisfies the 2-cocycle condition if
`f(gh, j) + f(g, h) = g • f(h, j) + f(g, hj)` for all `g, h : G`. -/
def IsTwoCocycle (f : G × G → A) : Prop 
goal: Prop

full_name: groupCohomology.map_one_of_isOneCocycle
code: theorem map_one_of_isOneCocycle {f : G → A} (hf : IsOneCocycle f) :
    f 1 = 0 
goal: f 1 = 0

full_name: groupCohomology.map_one_fst_of_isTwoCocycle
code: theorem map_one_fst_of_isTwoCocycle {f : G × G → A} (hf : IsTwoCocycle f) (g : G) :
    f (1, g) = f (1, 1) 
goal: f (1, g) = f (1, 1)

full_name: groupCohomology.map_one_snd_of_isTwoCocycle
code: theorem map_one_snd_of_isTwoCocycle {f : G × G → A} (hf : IsTwoCocycle f) (g : G) :
    f (g, 1) = g • f (1, 1) 
goal: f (g, 1) = g • f (1, 1)

full_name: groupCohomology.map_inv_of_isOneCocycle
code: @[simp] theorem map_inv_of_isOneCocycle {f : G → A} (hf : IsOneCocycle f) (g : G) :
    g • f g⁻¹ = - f g 
goal: g • f g⁻¹ = -f g

full_name: groupCohomology.smul_map_inv_sub_map_inv_of_isTwoCocycle
code: theorem smul_map_inv_sub_map_inv_of_isTwoCocycle {f : G × G → A} (hf : IsTwoCocycle f) (g : G) :
    g • f (g⁻¹, g) - f (g, g⁻¹) = f (1, 1) - f (g, 1) 
goal: g • f (g⁻¹, g) - f (g, g⁻¹) = f (1, 1) - f (g, 1)

full_name: groupCohomology.IsOneCoboundary
code: /-- A function `f : G → A` satisfies the 1-coboundary condition if there's `x : A` such that
`g • x - x = f(g)` for all `g : G`. -/
def IsOneCoboundary (f : G → A) : Prop 
goal: Prop

full_name: groupCohomology.IsTwoCoboundary
code: /-- A function `f : G × G → A` satisfies the 2-coboundary condition if there's `x : G → A` such
that `g • x(h) - x(gh) + x(g) = f(g, h)` for all `g, h : G`. -/
def IsTwoCoboundary (f : G × G → A) : Prop 
goal: Prop

full_name: groupCohomology.oneCocyclesOfIsOneCocycle
code: /-- Given a `k`-module `A` with a compatible `DistribMulAction` of `G`, and a function
`f : G → A` satisfying the 1-cocycle condition, produces a 1-cocycle for the representation on
`A` induced by the `DistribMulAction`. -/
def oneCocyclesOfIsOneCocycle {f : G → A} (hf : IsOneCocycle f) :
    oneCocycles (Rep.ofDistribMulAction k G A) 
goal: ↥(groupCohomology.oneCocycles (Rep.ofDistribMulAction k G A))

full_name: groupCohomology.isOneCocycle_of_oneCocycles
code: theorem isOneCocycle_of_oneCocycles (f : oneCocycles (Rep.ofDistribMulAction k G A)) :
    IsOneCocycle (A := A) f.1 
goal: groupCohomology.IsOneCocycle ↑f

full_name: groupCohomology.oneCoboundariesOfIsOneCoboundary
code: /-- Given a `k`-module `A` with a compatible `DistribMulAction` of `G`, and a function
`f : G → A` satisfying the 1-coboundary condition, produces a 1-coboundary for the representation
on `A` induced by the `DistribMulAction`. -/
def oneCoboundariesOfIsOneCoboundary {f : G → A} (hf : IsOneCoboundary f) :
    oneCoboundaries (Rep.ofDistribMulAction k G A) 
goal: ↥(groupCohomology.oneCoboundaries (Rep.ofDistribMulAction k G A))

full_name: groupCohomology.isOneCoboundary_of_oneCoboundaries
code: theorem isOneCoboundary_of_oneCoboundaries (f : oneCoboundaries (Rep.ofDistribMulAction k G A)) :
    IsOneCoboundary (A := A) f.1.1 
goal: groupCohomology.IsOneCoboundary ↑↑f

full_name: groupCohomology.twoCocyclesOfIsTwoCocycle
code: /-- Given a `k`-module `A` with a compatible `DistribMulAction` of `G`, and a function
`f : G × G → A` satisfying the 2-cocycle condition, produces a 2-cocycle for the representation on
`A` induced by the `DistribMulAction`. -/
def twoCocyclesOfIsTwoCocycle {f : G × G → A} (hf : IsTwoCocycle f) :
    twoCocycles (Rep.ofDistribMulAction k G A) 
goal: ↥(groupCohomology.twoCocycles (Rep.ofDistribMulAction k G A))

full_name: groupCohomology.isTwoCocycle_of_twoCocycles
code: theorem isTwoCocycle_of_twoCocycles (f : twoCocycles (Rep.ofDistribMulAction k G A)) :
    IsTwoCocycle (A := A) f.1 
goal: groupCohomology.IsTwoCocycle ↑f

full_name: groupCohomology.twoCoboundariesOfIsTwoCoboundary
code: /-- Given a `k`-module `A` with a compatible `DistribMulAction` of `G`, and a function
`f : G × G → A` satisfying the 2-coboundary condition, produces a 2-coboundary for the
representation on `A` induced by the `DistribMulAction`. -/
def twoCoboundariesOfIsTwoCoboundary {f : G × G → A} (hf : IsTwoCoboundary f) :
    twoCoboundaries (Rep.ofDistribMulAction k G A) 
goal: ↥(groupCohomology.twoCoboundaries (Rep.ofDistribMulAction k G A))

full_name: groupCohomology.isTwoCoboundary_of_twoCoboundaries
code: theorem isTwoCoboundary_of_twoCoboundaries (f : twoCoboundaries (Rep.ofDistribMulAction k G A)) :
    IsTwoCoboundary (A := A) f.1.1 
goal: groupCohomology.IsTwoCoboundary ↑↑f

full_name: groupCohomology.IsMulOneCocycle
code: /-- A function `f : G → M` satisfies the multiplicative 1-cocycle condition if
`f(gh) = g • f(h) * f(g)` for all `g, h : G`. -/
def IsMulOneCocycle (f : G → M) : Prop 
goal: Prop

full_name: groupCohomology.IsMulTwoCocycle
code: /-- A function `f : G × G → M` satisfies the multiplicative 2-cocycle condition if
`f(gh, j) * f(g, h) = g • f(h, j) * f(g, hj)` for all `g, h : G`. -/
def IsMulTwoCocycle (f : G × G → M) : Prop 
goal: Prop

full_name: groupCohomology.map_one_of_isMulOneCocycle
code: theorem map_one_of_isMulOneCocycle {f : G → M} (hf : IsMulOneCocycle f) :
    f 1 = 1 
goal: f 1 = 1

full_name: groupCohomology.map_one_fst_of_isMulTwoCocycle
code: theorem map_one_fst_of_isMulTwoCocycle {f : G × G → M} (hf : IsMulTwoCocycle f) (g : G) :
    f (1, g) = f (1, 1) 
goal: f (1, g) = f (1, 1)

full_name: groupCohomology.map_one_snd_of_isMulTwoCocycle
code: theorem map_one_snd_of_isMulTwoCocycle {f : G × G → M} (hf : IsMulTwoCocycle f) (g : G) :
    f (g, 1) = g • f (1, 1) 
goal: f (g, 1) = g • f (1, 1)

full_name: groupCohomology.map_inv_of_isMulOneCocycle
code: @[simp] theorem map_inv_of_isMulOneCocycle {f : G → M} (hf : IsMulOneCocycle f) (g : G) :
    g • f g⁻¹ = (f g)⁻¹ 
goal: g • f g⁻¹ = (f g)⁻¹

full_name: groupCohomology.smul_map_inv_div_map_inv_of_isMulTwoCocycle
code: theorem smul_map_inv_div_map_inv_of_isMulTwoCocycle
    {f : G × G → M} (hf : IsMulTwoCocycle f) (g : G) :
    g • f (g⁻¹, g) / f (g, g⁻¹) = f (1, 1) / f (g, 1) 
goal: g • f (g⁻¹, g) / f (g, g⁻¹) = f (1, 1) / f (g, 1)

full_name: groupCohomology.IsMulOneCoboundary
code: /-- A function `f : G → M` satisfies the multiplicative 1-coboundary condition if there's `x : M`
such that `g • x / x = f(g)` for all `g : G`. -/
def IsMulOneCoboundary (f : G → M) : Prop 
goal: Prop

full_name: groupCohomology.IsMulTwoCoboundary
code: /-- A function `f : G × G → M` satisfies the 2-coboundary condition if there's `x : G → M` such
that `g • x(h) / x(gh) * x(g) = f(g, h)` for all `g, h : G`. -/
def IsMulTwoCoboundary (f : G × G → M) : Prop 
goal: Prop

full_name: groupCohomology.oneCocyclesOfIsMulOneCocycle
code: /-- Given an abelian group `M` with a `MulDistribMulAction` of `G`, and a function
`f : G → M` satisfying the multiplicative 1-cocycle condition, produces a 1-cocycle for the
representation on `Additive M` induced by the `MulDistribMulAction`. -/
def oneCocyclesOfIsMulOneCocycle {f : G → M} (hf : IsMulOneCocycle f) :
    oneCocycles (Rep.ofMulDistribMulAction G M) 
goal: ↥(groupCohomology.oneCocycles (Rep.ofMulDistribMulAction G M))

full_name: groupCohomology.isMulOneCocycle_of_oneCocycles
code: theorem isMulOneCocycle_of_oneCocycles (f : oneCocycles (Rep.ofMulDistribMulAction G M)) :
    IsMulOneCocycle (M := M) (Additive.toMul ∘ f.1) 
goal: groupCohomology.IsMulOneCocycle (⇑Additive.toMul ∘ ↑f)

full_name: groupCohomology.oneCoboundariesOfIsMulOneCoboundary
code: /-- Given an abelian group `M` with a `MulDistribMulAction` of `G`, and a function
`f : G → M` satisfying the multiplicative 1-coboundary condition, produces a
1-coboundary for the representation on `Additive M` induced by the `MulDistribMulAction`. -/
def oneCoboundariesOfIsMulOneCoboundary {f : G → M} (hf : IsMulOneCoboundary f) :
    oneCoboundaries (Rep.ofMulDistribMulAction G M) 
goal: ↥(groupCohomology.oneCoboundaries (Rep.ofMulDistribMulAction G M))

full_name: groupCohomology.isMulOneCoboundary_of_oneCoboundaries
code: theorem isMulOneCoboundary_of_oneCoboundaries
    (f : oneCoboundaries (Rep.ofMulDistribMulAction G M)) :
    IsMulOneCoboundary (M := M) (Additive.ofMul ∘ f.1.1) 
goal: groupCohomology.IsMulOneCoboundary (⇑Additive.ofMul ∘ ↑↑f)

full_name: groupCohomology.twoCocyclesOfIsMulTwoCocycle
code: /-- Given an abelian group `M` with a `MulDistribMulAction` of `G`, and a function
`f : G × G → M` satisfying the multiplicative 2-cocycle condition, produces a 2-cocycle for the
representation on `Additive M` induced by the `MulDistribMulAction`. -/
def twoCocyclesOfIsMulTwoCocycle {f : G × G → M} (hf : IsMulTwoCocycle f) :
    twoCocycles (Rep.ofMulDistribMulAction G M) 
goal: ↥(groupCohomology.twoCocycles (Rep.ofMulDistribMulAction G M))

full_name: groupCohomology.isMulTwoCocycle_of_twoCocycles
code: theorem isMulTwoCocycle_of_twoCocycles (f : twoCocycles (Rep.ofMulDistribMulAction G M)) :
    IsMulTwoCocycle (M := M) (Additive.toMul ∘ f.1) 
goal: groupCohomology.IsMulTwoCocycle (⇑Additive.toMul ∘ ↑f)

full_name: groupCohomology.twoCoboundariesOfIsMulTwoCoboundary
code: /-- Given an abelian group `M` with a `MulDistribMulAction` of `G`, and a function
`f : G × G → M` satisfying the multiplicative 2-coboundary condition, produces a
2-coboundary for the representation on `M` induced by the `MulDistribMulAction`. -/
def twoCoboundariesOfIsMulTwoCoboundary {f : G × G → M} (hf : IsMulTwoCoboundary f) :
    twoCoboundaries (Rep.ofMulDistribMulAction G M) 
goal: ↥(groupCohomology.twoCoboundaries (Rep.ofMulDistribMulAction G M))

full_name: groupCohomology.isMulTwoCoboundary_of_twoCoboundaries
code: theorem isMulTwoCoboundary_of_twoCoboundaries
    (f : twoCoboundaries (Rep.ofMulDistribMulAction G M)) :
    IsMulTwoCoboundary (M := M) (Additive.toMul ∘ f.1.1) 
goal: groupCohomology.IsMulTwoCoboundary (⇑Additive.toMul ∘ ↑↑f)

full_name: groupCohomology.H0
code: /-- We define the 0th group cohomology of a `k`-linear `G`-representation `A`, `H⁰(G, A)`, to be
the invariants of the representation, `Aᴳ`. -/
abbrev H0 
goal: Submodule k (CoeSort.coe A)

full_name: groupCohomology.H1
code: /-- We define the 1st group cohomology of a `k`-linear `G`-representation `A`, `H¹(G, A)`, to be
1-cocycles (i.e. `Z¹(G, A) := Ker(d¹ : Fun(G, A) → Fun(G², A)`) modulo 1-coboundaries
(i.e. `B¹(G, A) := Im(d⁰: A → Fun(G, A))`). -/
abbrev H1 
goal: Type u

full_name: groupCohomology.H1_π
code: /-- The quotient map `Z¹(G, A) → H¹(G, A).` -/
def H1_π : oneCocycles A →ₗ[k] H1 A 
goal: ↥(groupCohomology.oneCocycles A) →ₗ[k] groupCohomology.H1 A

full_name: groupCohomology.H2
code: /-- We define the 2nd group cohomology of a `k`-linear `G`-representation `A`, `H²(G, A)`, to be
2-cocycles (i.e. `Z²(G, A) := Ker(d² : Fun(G², A) → Fun(G³, A)`) modulo 2-coboundaries
(i.e. `B²(G, A) := Im(d¹: Fun(G, A) → Fun(G², A))`). -/
abbrev H2 
goal: Type u

full_name: groupCohomology.H2_π
code: /-- The quotient map `Z²(G, A) → H²(G, A).` -/
def H2_π : twoCocycles A →ₗ[k] H2 A 
goal: ↥(groupCohomology.twoCocycles A) →ₗ[k] groupCohomology.H2 A

full_name: groupCohomology.H0LequivOfIsTrivial
code: /-- When the representation on `A` is trivial, then `H⁰(G, A)` is all of `A.` -/
def H0LequivOfIsTrivial [A.IsTrivial] :
    H0 A ≃ₗ[k] A 
goal: ↥(groupCohomology.H0 A) ≃ₗ[k] CoeSort.coe A

full_name: groupCohomology.H0LequivOfIsTrivial_eq_subtype
code: @[simp] theorem H0LequivOfIsTrivial_eq_subtype [A.IsTrivial] :
    H0LequivOfIsTrivial A = A.ρ.invariants.subtype 
goal: ↑(groupCohomology.H0LequivOfIsTrivial A) = A.ρ.invariants.subtype

full_name: groupCohomology.H0LequivOfIsTrivial_apply
code: theorem H0LequivOfIsTrivial_apply [A.IsTrivial] (x : H0 A) :
    H0LequivOfIsTrivial A x = x 
goal: (groupCohomology.H0LequivOfIsTrivial A) x = ↑x

full_name: groupCohomology.H0LequivOfIsTrivial_symm_apply
code: @[simp] theorem H0LequivOfIsTrivial_symm_apply [A.IsTrivial] (x : A) :
    (H0LequivOfIsTrivial A).symm x = x 
goal: ↑((groupCohomology.H0LequivOfIsTrivial A).symm x) = x

full_name: groupCohomology.H1LequivOfIsTrivial
code: /-- When `A : Rep k G` is a trivial representation of `G`, `H¹(G, A)` is isomorphic to the
group homs `G → A`. -/
def H1LequivOfIsTrivial [A.IsTrivial] :
    H1 A ≃ₗ[k] Additive G →+ A 
goal: groupCohomology.H1 A ≃ₗ[k] Additive G →+ CoeSort.coe A

full_name: groupCohomology.H1LequivOfIsTrivial_comp_H1_π
code: theorem H1LequivOfIsTrivial_comp_H1_π [A.IsTrivial] :
    (H1LequivOfIsTrivial A).comp (H1_π A) = oneCocyclesLequivOfIsTrivial A 
goal: ↑(groupCohomology.H1LequivOfIsTrivial A) ∘ₗ groupCohomology.H1_π A = ↑(groupCohomology.oneCocyclesLequivOfIsTrivial A)

full_name: groupCohomology.H1LequivOfIsTrivial_H1_π_apply_apply
code: @[simp] theorem H1LequivOfIsTrivial_H1_π_apply_apply
    [A.IsTrivial] (f : oneCocycles A) (x : Additive G) :
    H1LequivOfIsTrivial A (H1_π A f) x = f.1 (Additive.toMul x) 
goal: ((groupCohomology.H1LequivOfIsTrivial A) ((groupCohomology.H1_π A) f)) x = ↑f (Additive.toMul x)

full_name: groupCohomology.H1LequivOfIsTrivial_symm_apply
code: @[simp] theorem H1LequivOfIsTrivial_symm_apply [A.IsTrivial] (f : Additive G →+ A) :
    (H1LequivOfIsTrivial A).symm f = H1_π A ((oneCocyclesLequivOfIsTrivial A).symm f) 
goal: (groupCohomology.H1LequivOfIsTrivial A).symm f =
  (groupCohomology.H1_π A) ((groupCohomology.oneCocyclesLequivOfIsTrivial A).symm f)

full_name: groupCohomology.dZero_comp_H0_subtype
code: lemma dZero_comp_H0_subtype : dZero A ∘ₗ (H0 A).subtype = 0 
goal: groupCohomology.dZero A ∘ₗ (groupCohomology.H0 A).subtype = 0

full_name: groupCohomology.shortComplexH0
code: /-- The (exact) short complex `A.ρ.invariants ⟶ A ⟶ (G → A)`. -/
def shortComplexH0 : ShortComplex (ModuleCat k) 
goal: CategoryTheory.ShortComplex (ModuleCat k)

full_name: groupCohomology.instMonoModuleCatFShortComplexH0
code: instance : Mono (shortComplexH0 A).f 
goal: CategoryTheory.Mono (groupCohomology.shortComplexH0 A).f

full_name: groupCohomology.shortComplexH0_exact
code: lemma shortComplexH0_exact : (shortComplexH0 A).Exact 
goal: (groupCohomology.shortComplexH0 A).Exact

full_name: groupCohomology.dZeroArrowIso_inv_right
code: /-- The arrow `A --dZero--> Fun(G, A)` is isomorphic to the differential
`(inhomogeneousCochains A).d 0 1` of the complex of inhomogeneous cochains of `A`. -/
@[simps! hom_left hom_right inv_left inv_right]
def dZeroArrowIso : Arrow.mk ((inhomogeneousCochains A).d 0 1) ≅
    Arrow.mk (ModuleCat.ofHom (dZero A)) 
goal: (groupCohomology.dZeroArrowIso A).inv.right = ↑(groupCohomology.oneCochainsLequiv A).symm

full_name: groupCohomology.dZeroArrowIso
code: /-- The arrow `A --dZero--> Fun(G, A)` is isomorphic to the differential
`(inhomogeneousCochains A).d 0 1` of the complex of inhomogeneous cochains of `A`. -/
@[simps! hom_left hom_right inv_left inv_right]
def dZeroArrowIso : Arrow.mk ((inhomogeneousCochains A).d 0 1) ≅
    Arrow.mk (ModuleCat.ofHom (dZero A)) 
goal: CategoryTheory.Arrow.mk ((groupCohomology.inhomogeneousCochains A).d 0 1) ≅
  CategoryTheory.Arrow.mk (ModuleCat.ofHom (groupCohomology.dZero A))

full_name: groupCohomology.dZeroArrowIso_inv_left
code: /-- The arrow `A --dZero--> Fun(G, A)` is isomorphic to the differential
`(inhomogeneousCochains A).d 0 1` of the complex of inhomogeneous cochains of `A`. -/
@[simps! hom_left hom_right inv_left inv_right]
def dZeroArrowIso : Arrow.mk ((inhomogeneousCochains A).d 0 1) ≅
    Arrow.mk (ModuleCat.ofHom (dZero A)) 
goal: (groupCohomology.dZeroArrowIso A).inv.left = ↑(groupCohomology.zeroCochainsLequiv A).symm

full_name: groupCohomology.dZeroArrowIso_hom_right
code: /-- The arrow `A --dZero--> Fun(G, A)` is isomorphic to the differential
`(inhomogeneousCochains A).d 0 1` of the complex of inhomogeneous cochains of `A`. -/
@[simps! hom_left hom_right inv_left inv_right]
def dZeroArrowIso : Arrow.mk ((inhomogeneousCochains A).d 0 1) ≅
    Arrow.mk (ModuleCat.ofHom (dZero A)) 
goal: (groupCohomology.dZeroArrowIso A).hom.right = ↑(groupCohomology.oneCochainsLequiv A)

full_name: groupCohomology.dZeroArrowIso_hom_left
code: /-- The arrow `A --dZero--> Fun(G, A)` is isomorphic to the differential
`(inhomogeneousCochains A).d 0 1` of the complex of inhomogeneous cochains of `A`. -/
@[simps! hom_left hom_right inv_left inv_right]
def dZeroArrowIso : Arrow.mk ((inhomogeneousCochains A).d 0 1) ≅
    Arrow.mk (ModuleCat.ofHom (dZero A)) 
goal: (groupCohomology.dZeroArrowIso A).hom.left = ↑(groupCohomology.zeroCochainsLequiv A)

full_name: groupCohomology.isoZeroCocycles
code: /-- The 0-cocycles of the complex of inhomogeneous cochains of `A` are isomorphic to
`A.ρ.invariants`, which is a simpler type. -/
def isoZeroCocycles : cocycles A 0 ≅ ModuleCat.of k A.ρ.invariants 
goal: groupCohomology.cocycles A 0 ≅ ModuleCat.of k ↥A.ρ.invariants

full_name: groupCohomology.isoZeroCocycles_hom_comp_subtype
code: lemma isoZeroCocycles_hom_comp_subtype :
    (isoZeroCocycles A).hom ≫ A.ρ.invariants.subtype =
      iCocycles A 0 ≫ (zeroCochainsLequiv A).toModuleIso.hom 
goal: (groupCohomology.isoZeroCocycles A).hom ≫ A.ρ.invariants.subtype =
  groupCohomology.iCocycles A 0 ≫ (groupCohomology.zeroCochainsLequiv A).toModuleIso.hom

full_name: groupCohomology.isoH0
code: /-- The 0th group cohomology of `A`, defined as the 0th cohomology of the complex of inhomogeneous
cochains, is isomorphic to the invariants of the representation on `A`. -/
def isoH0 : groupCohomology A 0 ≅ ModuleCat.of k (H0 A) 
goal: groupCohomology A 0 ≅ ModuleCat.of k ↥(groupCohomology.H0 A)

full_name: groupCohomology.groupCohomologyπ_comp_isoH0_hom
code: lemma groupCohomologyπ_comp_isoH0_hom  :
    groupCohomologyπ A 0 ≫ (isoH0 A).hom = (isoZeroCocycles A).hom 
goal: groupCohomologyπ A 0 ≫ (groupCohomology.isoH0 A).hom = (groupCohomology.isoZeroCocycles A).hom

full_name: groupCohomology.shortComplexH1
code: /-- The short complex `A --dZero--> Fun(G, A) --dOne--> Fun(G × G, A)`. -/
def shortComplexH1 : ShortComplex (ModuleCat k) 
goal: CategoryTheory.ShortComplex (ModuleCat k)

full_name: groupCohomology.shortComplexH1Iso
code: /-- The short complex `A --dZero--> Fun(G, A) --dOne--> Fun(G × G, A)` is isomorphic to the 1st
short complex associated to the complex of inhomogeneous cochains of `A`. -/
@[simps! hom inv]
def shortComplexH1Iso : (inhomogeneousCochains A).sc' 0 1 2 ≅ shortComplexH1 A 
goal: HomologicalComplex.sc' (groupCohomology.inhomogeneousCochains A) 0 1 2 ≅ groupCohomology.shortComplexH1 A

full_name: groupCohomology.shortComplexH1Iso_inv
code: /-- The short complex `A --dZero--> Fun(G, A) --dOne--> Fun(G × G, A)` is isomorphic to the 1st
short complex associated to the complex of inhomogeneous cochains of `A`. -/
@[simps! hom inv]
def shortComplexH1Iso : (inhomogeneousCochains A).sc' 0 1 2 ≅ shortComplexH1 A 
goal: (groupCohomology.shortComplexH1Iso A).inv =
  CategoryTheory.ShortComplex.homMk ↑(groupCohomology.zeroCochainsLequiv A).symm
    ↑(groupCohomology.oneCochainsLequiv A).symm ↑(groupCohomology.twoCochainsLequiv A).symm ⋯ ⋯

full_name: groupCohomology.shortComplexH1Iso_hom
code: /-- The short complex `A --dZero--> Fun(G, A) --dOne--> Fun(G × G, A)` is isomorphic to the 1st
short complex associated to the complex of inhomogeneous cochains of `A`. -/
@[simps! hom inv]
def shortComplexH1Iso : (inhomogeneousCochains A).sc' 0 1 2 ≅ shortComplexH1 A 
goal: (groupCohomology.shortComplexH1Iso A).hom =
  { τ₁ := ↑(groupCohomology.zeroCochainsLequiv A), τ₂ := ↑(groupCohomology.oneCochainsLequiv A),
    τ₃ := ↑(groupCohomology.twoCochainsLequiv A), comm₁₂ := ⋯, comm₂₃ := ⋯ }

full_name: groupCohomology.isoOneCocycles
code: /-- The 1-cocycles of the complex of inhomogeneous cochains of `A` are isomorphic to
`oneCocycles A`, which is a simpler type. -/
def isoOneCocycles : cocycles A 1 ≅ ModuleCat.of k (oneCocycles A) 
goal: groupCohomology.cocycles A 1 ≅ ModuleCat.of k ↥(groupCohomology.oneCocycles A)

full_name: groupCohomology.isoOneCocycles_hom_comp_subtype
code: lemma isoOneCocycles_hom_comp_subtype :
    (isoOneCocycles A).hom ≫ ModuleCat.ofHom (oneCocycles A).subtype =
      iCocycles A 1 ≫ (oneCochainsLequiv A).toModuleIso.hom 
goal: (groupCohomology.isoOneCocycles A).hom ≫ ModuleCat.ofHom (groupCohomology.oneCocycles A).subtype =
  groupCohomology.iCocycles A 1 ≫ (groupCohomology.oneCochainsLequiv A).toModuleIso.hom

full_name: groupCohomology.toCocycles_comp_isoOneCocycles_hom
code: lemma toCocycles_comp_isoOneCocycles_hom :
    toCocycles A 0 1 ≫ (isoOneCocycles A).hom =
      (zeroCochainsLequiv A).toModuleIso.hom ≫
        ModuleCat.ofHom (shortComplexH1 A).moduleCatToCycles 
goal: groupCohomology.toCocycles A 0 1 ≫ (groupCohomology.isoOneCocycles A).hom =
  (groupCohomology.zeroCochainsLequiv A).toModuleIso.hom ≫
    ModuleCat.ofHom (groupCohomology.shortComplexH1 A).moduleCatToCycles

full_name: groupCohomology.isoH1
code: /-- The 1st group cohomology of `A`, defined as the 1st cohomology of the complex of inhomogeneous
cochains, is isomorphic to `oneCocycles A ⧸ oneCoboundaries A`, which is a simpler type. -/
def isoH1 : groupCohomology A 1 ≅ ModuleCat.of k (H1 A) 
goal: groupCohomology A 1 ≅ ModuleCat.of k (groupCohomology.H1 A)

full_name: groupCohomology.groupCohomologyπ_comp_isoH1_hom
code: lemma groupCohomologyπ_comp_isoH1_hom  :
    groupCohomologyπ A 1 ≫ (isoH1 A).hom =
      (isoOneCocycles A).hom ≫ (shortComplexH1 A).moduleCatHomologyπ 
goal: groupCohomologyπ A 1 ≫ (groupCohomology.isoH1 A).hom =
  (groupCohomology.isoOneCocycles A).hom ≫ (groupCohomology.shortComplexH1 A).moduleCatHomologyπ

full_name: groupCohomology.shortComplexH2
code: /-- The short complex `Fun(G, A) --dOne--> Fun(G × G, A) --dTwo--> Fun(G × G × G, A)`. -/
def shortComplexH2 : ShortComplex (ModuleCat k) 
goal: CategoryTheory.ShortComplex (ModuleCat k)

full_name: groupCohomology.shortComplexH2Iso_inv
code: /-- The short complex `Fun(G, A) --dOne--> Fun(G × G, A) --dTwo--> Fun(G × G × G, A)` is
isomorphic to the 2nd short complex associated to the complex of inhomogeneous cochains of `A`. -/
@[simps! hom inv]
def shortComplexH2Iso :
    (inhomogeneousCochains A).sc' 1 2 3 ≅ shortComplexH2 A 
goal: (groupCohomology.shortComplexH2Iso A).inv =
  CategoryTheory.ShortComplex.homMk ↑(groupCohomology.oneCochainsLequiv A).symm
    ↑(groupCohomology.twoCochainsLequiv A).symm ↑(groupCohomology.threeCochainsLequiv A).symm ⋯ ⋯

full_name: groupCohomology.shortComplexH2Iso
code: /-- The short complex `Fun(G, A) --dOne--> Fun(G × G, A) --dTwo--> Fun(G × G × G, A)` is
isomorphic to the 2nd short complex associated to the complex of inhomogeneous cochains of `A`. -/
@[simps! hom inv]
def shortComplexH2Iso :
    (inhomogeneousCochains A).sc' 1 2 3 ≅ shortComplexH2 A 
goal: HomologicalComplex.sc' (groupCohomology.inhomogeneousCochains A) 1 2 3 ≅ groupCohomology.shortComplexH2 A

full_name: groupCohomology.shortComplexH2Iso_hom
code: /-- The short complex `Fun(G, A) --dOne--> Fun(G × G, A) --dTwo--> Fun(G × G × G, A)` is
isomorphic to the 2nd short complex associated to the complex of inhomogeneous cochains of `A`. -/
@[simps! hom inv]
def shortComplexH2Iso :
    (inhomogeneousCochains A).sc' 1 2 3 ≅ shortComplexH2 A 
goal: (groupCohomology.shortComplexH2Iso A).hom =
  { τ₁ := ↑(groupCohomology.oneCochainsLequiv A), τ₂ := ↑(groupCohomology.twoCochainsLequiv A),
    τ₃ := ↑(groupCohomology.threeCochainsLequiv A), comm₁₂ := ⋯, comm₂₃ := ⋯ }

full_name: groupCohomology.isoTwoCocycles
code: /-- The 2-cocycles of the complex of inhomogeneous cochains of `A` are isomorphic to
`twoCocycles A`, which is a simpler type. -/
def isoTwoCocycles : cocycles A 2 ≅ ModuleCat.of k (twoCocycles A) 
goal: groupCohomology.cocycles A 2 ≅ ModuleCat.of k ↥(groupCohomology.twoCocycles A)

full_name: groupCohomology.isoTwoCocycles_hom_comp_subtype
code: lemma isoTwoCocycles_hom_comp_subtype :
    (isoTwoCocycles A).hom ≫ ModuleCat.ofHom (twoCocycles A).subtype =
      iCocycles A 2 ≫ (twoCochainsLequiv A).toModuleIso.hom 
goal: (groupCohomology.isoTwoCocycles A).hom ≫ ModuleCat.ofHom (groupCohomology.twoCocycles A).subtype =
  groupCohomology.iCocycles A 2 ≫ (groupCohomology.twoCochainsLequiv A).toModuleIso.hom

full_name: groupCohomology.toCocycles_comp_isoTwoCocycles_hom
code: lemma toCocycles_comp_isoTwoCocycles_hom :
    toCocycles A 1 2 ≫ (isoTwoCocycles A).hom =
      (oneCochainsLequiv A).toModuleIso.hom ≫
        ModuleCat.ofHom (shortComplexH2 A).moduleCatToCycles 
goal: groupCohomology.toCocycles A 1 2 ≫ (groupCohomology.isoTwoCocycles A).hom =
  (groupCohomology.oneCochainsLequiv A).toModuleIso.hom ≫
    ModuleCat.ofHom (groupCohomology.shortComplexH2 A).moduleCatToCycles

full_name: groupCohomology.isoH2
code: /-- The 2nd group cohomology of `A`, defined as the 2nd cohomology of the complex of inhomogeneous
cochains, is isomorphic to `twoCocycles A ⧸ twoCoboundaries A`, which is a simpler type. -/
def isoH2 : groupCohomology A 2 ≅ ModuleCat.of k (H2 A) 
goal: groupCohomology A 2 ≅ ModuleCat.of k (groupCohomology.H2 A)

full_name: groupCohomology.groupCohomologyπ_comp_isoH2_hom
code: lemma groupCohomologyπ_comp_isoH2_hom  :
    groupCohomologyπ A 2 ≫ (isoH2 A).hom =
      (isoTwoCocycles A).hom ≫ (shortComplexH2 A).moduleCatHomologyπ 
goal: groupCohomologyπ A 2 ≫ (groupCohomology.isoH2 A).hom =
  (groupCohomology.isoTwoCocycles A).hom ≫ (groupCohomology.shortComplexH2 A).moduleCatHomologyπ