[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : SetLike σ R
inst✝ : AddSubmonoidClass σ R
A : ι → σ
i : ι
⊢ AddCommMonoid { x // x ∈ A i }
[PROOFSTEP]
infer_instance
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝² : Ring R
inst✝¹ : SetLike σ R
inst✝ : AddSubgroupClass σ R
A : ι → σ
i : ι
⊢ AddCommGroup { x // x ∈ A i }
[PROOFSTEP]
infer_instance
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : GradedOne A
s : S
⊢ ↑(algebraMap S R) s ∈ A 0
[PROOFSTEP]
rw [Algebra.algebraMap_eq_smul_one]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : GradedOne A
s : S
⊢ s • 1 ∈ A 0
[PROOFSTEP]
exact (A 0).smul_mem s <| SetLike.one_mem_graded _
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubmonoidClass σ R
A : ι → σ
inst✝ : GradedOne A
n : ℕ
⊢ ↑n ∈ A 0
[PROOFSTEP]
induction' n with _ n_ih
[GOAL]
case zero
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubmonoidClass σ R
A : ι → σ
inst✝ : GradedOne A
⊢ ↑Nat.zero ∈ A 0
[PROOFSTEP]
rw [Nat.cast_zero]
[GOAL]
case zero
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubmonoidClass σ R
A : ι → σ
inst✝ : GradedOne A
⊢ 0 ∈ A 0
[PROOFSTEP]
exact zero_mem (A 0)
[GOAL]
case succ
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubmonoidClass σ R
A : ι → σ
inst✝ : GradedOne A
n✝ : ℕ
n_ih : ↑n✝ ∈ A 0
⊢ ↑(Nat.succ n✝) ∈ A 0
[PROOFSTEP]
rw [Nat.cast_succ]
[GOAL]
case succ
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubmonoidClass σ R
A : ι → σ
inst✝ : GradedOne A
n✝ : ℕ
n_ih : ↑n✝ ∈ A 0
⊢ ↑n✝ + 1 ∈ A 0
[PROOFSTEP]
exact add_mem n_ih (SetLike.one_mem_graded _)
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddGroupWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubgroupClass σ R
A : ι → σ
inst✝ : GradedOne A
z : ℤ
⊢ ↑z ∈ A 0
[PROOFSTEP]
induction z
[GOAL]
case ofNat
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddGroupWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubgroupClass σ R
A : ι → σ
inst✝ : GradedOne A
a✝ : ℕ
⊢ ↑(Int.ofNat a✝) ∈ A 0
[PROOFSTEP]
rw [Int.ofNat_eq_coe, Int.cast_ofNat]
[GOAL]
case ofNat
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddGroupWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubgroupClass σ R
A : ι → σ
inst✝ : GradedOne A
a✝ : ℕ
⊢ ↑a✝ ∈ A 0
[PROOFSTEP]
exact SetLike.nat_cast_mem_graded _ _
[GOAL]
case negSucc
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddGroupWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubgroupClass σ R
A : ι → σ
inst✝ : GradedOne A
a✝ : ℕ
⊢ ↑(Int.negSucc a✝) ∈ A 0
[PROOFSTEP]
rw [Int.cast_negSucc]
[GOAL]
case negSucc
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁴ : Zero ι
inst✝³ : AddGroupWithOne R
inst✝² : SetLike σ R
inst✝¹ : AddSubgroupClass σ R
A : ι → σ
inst✝ : GradedOne A
a✝ : ℕ
⊢ -↑(a✝ + 1) ∈ A 0
[PROOFSTEP]
exact neg_mem (SetLike.nat_cast_mem_graded _ _)
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ↑(↑(r * r') n) =
    ∑ ij in Finset.filter (fun ij => ij.fst + ij.snd = n) (DFinsupp.support r ×ˢ DFinsupp.support r'),
      ↑(↑r ij.fst) * ↑(↑r' ij.snd)
[PROOFSTEP]
rw [mul_eq_sum_support_ghas_mul, DFinsupp.finset_sum_apply, AddSubmonoidClass.coe_finset_sum]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ∑ i in DFinsupp.support r ×ˢ DFinsupp.support r',
      ↑(↑(↑(of (fun i => (fun i => { x // x ∈ A i }) i) (i.fst + i.snd)) (GradedMonoid.GMul.mul (↑r i.fst) (↑r' i.snd)))
          n) =
    ∑ ij in Finset.filter (fun ij => ij.fst + ij.snd = n) (DFinsupp.support r ×ˢ DFinsupp.support r'),
      ↑(↑r ij.fst) * ↑(↑r' ij.snd)
[PROOFSTEP]
simp_rw [coe_of_apply, apply_ite, ZeroMemClass.coe_zero, ← Finset.sum_filter, SetLike.coe_gMul]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ↑(↑(r * r') n) = DFinsupp.sum r fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0
[PROOFSTEP]
rw [mul_eq_dfinsupp_sum]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ↑(↑(DFinsupp.sum r fun i ai =>
            DFinsupp.sum r' fun j aj => ↑(of (fun i => { x // x ∈ A i }) (i + j)) (GradedMonoid.GMul.mul ai aj))
        n) =
    DFinsupp.sum r fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0
[PROOFSTEP]
iterate 2 rw [DFinsupp.sum_apply, DFinsupp.sum, AddSubmonoidClass.coe_finset_sum]; congr; ext
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ↑(↑(DFinsupp.sum r fun i ai =>
            DFinsupp.sum r' fun j aj => ↑(of (fun i => { x // x ∈ A i }) (i + j)) (GradedMonoid.GMul.mul ai aj))
        n) =
    DFinsupp.sum r fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0
[PROOFSTEP]
rw [DFinsupp.sum_apply, DFinsupp.sum, AddSubmonoidClass.coe_finset_sum]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ ∑ i in DFinsupp.support r,
      ↑(↑(DFinsupp.sum r' fun j aj => ↑(of (fun i => { x // x ∈ A i }) (i + j)) (GradedMonoid.GMul.mul (↑r i) aj)) n) =
    DFinsupp.sum r fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0
[PROOFSTEP]
congr
[GOAL]
case e_f
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
⊢ (fun i =>
      ↑(↑(DFinsupp.sum r' fun j aj => ↑(of (fun i => { x // x ∈ A i }) (i + j)) (GradedMonoid.GMul.mul (↑r i) aj)) n)) =
    fun i => (fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0) i (↑r i)
[PROOFSTEP]
ext
[GOAL]
case e_f.h
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝ : ι
⊢ ↑(↑(DFinsupp.sum r' fun j aj => ↑(of (fun i => { x // x ∈ A i }) (x✝ + j)) (GradedMonoid.GMul.mul (↑r x✝) aj)) n) =
    (fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0) x✝ (↑r x✝)
[PROOFSTEP]
rw [DFinsupp.sum_apply, DFinsupp.sum, AddSubmonoidClass.coe_finset_sum]
[GOAL]
case e_f.h
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝ : ι
⊢ ∑ i in DFinsupp.support r',
      ↑(↑(↑(of (fun i => { x // x ∈ A i }) (x✝ + i)) (GradedMonoid.GMul.mul (↑r x✝) (↑r' i))) n) =
    (fun i ri => DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0) x✝ (↑r x✝)
[PROOFSTEP]
congr
[GOAL]
case e_f.h.e_f
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝ : ι
⊢ (fun i => ↑(↑(↑(of (fun i => { x // x ∈ A i }) (x✝ + i)) (GradedMonoid.GMul.mul (↑r x✝) (↑r' i))) n)) = fun i =>
    (fun j rj => if x✝ + j = n then ↑(↑r x✝) * ↑rj else 0) i (↑r' i)
[PROOFSTEP]
ext
[GOAL]
case e_f.h.e_f.h
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝¹ x✝ : ι
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) (x✝¹ + x✝)) (GradedMonoid.GMul.mul (↑r x✝¹) (↑r' x✝))) n) =
    (fun j rj => if x✝¹ + j = n then ↑(↑r x✝¹) * ↑rj else 0) x✝ (↑r' x✝)
[PROOFSTEP]
dsimp only
[GOAL]
case e_f.h.e_f.h
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝¹ x✝ : ι
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) (x✝¹ + x✝)) (GradedMonoid.GMul.mul (↑r x✝¹) (↑r' x✝))) n) =
    if x✝¹ + x✝ = n then ↑(↑r x✝¹) * ↑(↑r' x✝) else 0
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝¹ x✝ : ι
h : x✝¹ + x✝ = n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) (x✝¹ + x✝)) (GradedMonoid.GMul.mul (↑r x✝¹) (↑r' x✝))) n) = ↑(↑r x✝¹) * ↑(↑r' x✝)
[PROOFSTEP]
subst h
[GOAL]
case pos
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
x✝¹ x✝ : ι
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) (x✝¹ + x✝)) (GradedMonoid.GMul.mul (↑r x✝¹) (↑r' x✝))) (x✝¹ + x✝)) =
    ↑(↑r x✝¹) * ↑(↑r' x✝)
[PROOFSTEP]
rw [of_eq_same]
[GOAL]
case pos
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
x✝¹ x✝ : ι
⊢ ↑(GradedMonoid.GMul.mul (↑r x✝¹) (↑r' x✝)) = ↑(↑r x✝¹) * ↑(↑r' x✝)
[PROOFSTEP]
rfl
[GOAL]
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝¹ x✝ : ι
h : ¬x✝¹ + x✝ = n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) (x✝¹ + x✝)) (GradedMonoid.GMul.mul (↑r x✝¹) (↑r' x✝))) n) = 0
[PROOFSTEP]
rw [of_eq_of_ne _ _ _ _ h]
[GOAL]
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Semiring R
inst✝⁴ : SetLike σ R
inst✝³ : AddSubmonoidClass σ R
A : ι → σ
inst✝² : AddMonoid ι
inst✝¹ : SetLike.GradedMonoid A
inst✝ : (i : ι) → (x : { x // x ∈ A i }) → Decidable (x ≠ 0)
r r' : ⨁ (i : ι), { x // x ∈ A i }
n x✝¹ x✝ : ι
h : ¬x✝¹ + x✝ = n
⊢ ↑0 = 0
[PROOFSTEP]
rfl
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = ↑r * ↑(↑r' j)
[PROOFSTEP]
classical
rw [coe_mul_apply_eq_dfinsupp_sum]
apply (DFinsupp.sum_single_index _).trans
swap
· simp_rw [ZeroMemClass.coe_zero, zero_mul, ite_self]
  exact DFinsupp.sum_zero
simp_rw [DFinsupp.sum, H, Finset.sum_ite_eq']
split_ifs with h
rfl
rw [DFinsupp.not_mem_support_iff.mp h, ZeroMemClass.coe_zero, mul_zero]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = ↑r * ↑(↑r' j)
[PROOFSTEP]
rw [coe_mul_apply_eq_dfinsupp_sum]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ (DFinsupp.sum (↑(of (fun i => { x // x ∈ A i }) i) r) fun i ri =>
      DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0) =
    ↑r * ↑(↑r' j)
[PROOFSTEP]
apply (DFinsupp.sum_single_index _).trans
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑r * ↑rj else 0) = ↑r * ↑(↑r' j)
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑0 * ↑rj else 0) = 0
[PROOFSTEP]
swap
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑0 * ↑rj else 0) = 0
[PROOFSTEP]
simp_rw [ZeroMemClass.coe_zero, zero_mul, ite_self]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ (DFinsupp.sum r' fun j rj => 0) = 0
[PROOFSTEP]
exact DFinsupp.sum_zero
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑r * ↑rj else 0) = ↑r * ↑(↑r' j)
[PROOFSTEP]
simp_rw [DFinsupp.sum, H, Finset.sum_ite_eq']
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
⊢ (if j ∈ DFinsupp.support r' then ↑r * ↑(↑r' j) else 0) = ↑r * ↑(↑r' j)
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
h : j ∈ DFinsupp.support r'
⊢ ↑r * ↑(↑r' j) = ↑r * ↑(↑r' j)
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
h : ¬j ∈ DFinsupp.support r'
⊢ 0 = ↑r * ↑(↑r' j)
[PROOFSTEP]
rfl
[GOAL]
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), i + x = n ↔ x = j
h : ¬j ∈ DFinsupp.support r'
⊢ 0 = ↑r * ↑(↑r' j)
[PROOFSTEP]
rw [DFinsupp.not_mem_support_iff.mp h, ZeroMemClass.coe_zero, mul_zero]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ ↑(↑(r * ↑(of (fun i => { x // x ∈ A i }) i) r') n) = ↑(↑r j) * ↑r'
[PROOFSTEP]
classical
rw [coe_mul_apply_eq_dfinsupp_sum, DFinsupp.sum_comm]
apply (DFinsupp.sum_single_index _).trans
swap
· simp_rw [ZeroMemClass.coe_zero, mul_zero, ite_self]
  exact DFinsupp.sum_zero
simp_rw [DFinsupp.sum, H, Finset.sum_ite_eq']
split_ifs with h
rfl
rw [DFinsupp.not_mem_support_iff.mp h, ZeroMemClass.coe_zero, zero_mul]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ ↑(↑(r * ↑(of (fun i => { x // x ∈ A i }) i) r') n) = ↑(↑r j) * ↑r'
[PROOFSTEP]
rw [coe_mul_apply_eq_dfinsupp_sum, DFinsupp.sum_comm]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ (DFinsupp.sum (↑(of (fun i => { x // x ∈ A i }) i) r') fun i₂ x₂ =>
      DFinsupp.sum r fun i₁ x₁ => if i₁ + i₂ = n then ↑x₁ * ↑x₂ else 0) =
    ↑(↑r j) * ↑r'
[PROOFSTEP]
apply (DFinsupp.sum_single_index _).trans
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑r' else 0) = ↑(↑r j) * ↑r'
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑0 else 0) = 0
[PROOFSTEP]
swap
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑0 else 0) = 0
[PROOFSTEP]
simp_rw [ZeroMemClass.coe_zero, mul_zero, ite_self]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ (DFinsupp.sum r fun i₁ x₁ => 0) = 0
[PROOFSTEP]
exact DFinsupp.sum_zero
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑r' else 0) = ↑(↑r j) * ↑r'
[PROOFSTEP]
simp_rw [DFinsupp.sum, H, Finset.sum_ite_eq']
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
⊢ (if j ∈ DFinsupp.support r then ↑(↑r j) * ↑r' else 0) = ↑(↑r j) * ↑r'
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
h : j ∈ DFinsupp.support r
⊢ ↑(↑r j) * ↑r' = ↑(↑r j) * ↑r'
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
h : ¬j ∈ DFinsupp.support r
⊢ 0 = ↑(↑r j) * ↑r'
[PROOFSTEP]
rfl
[GOAL]
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : AddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
j n : ι
H : ∀ (x : ι), x + i = n ↔ x = j
h : ¬j ∈ DFinsupp.support r
⊢ 0 = ↑(↑r j) * ↑r'
[PROOFSTEP]
rw [DFinsupp.not_mem_support_iff.mp h, ZeroMemClass.coe_zero, zero_mul]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = 0
[PROOFSTEP]
classical
rw [coe_mul_apply_eq_dfinsupp_sum]
apply (DFinsupp.sum_single_index _).trans
swap
· simp_rw [ZeroMemClass.coe_zero, zero_mul, ite_self]
  exact DFinsupp.sum_zero
· rw [DFinsupp.sum, Finset.sum_ite_of_false _ _ fun x _ H => _, Finset.sum_const_zero]
  exact fun x _ H => h ((self_le_add_right i x).trans_eq H)
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = 0
[PROOFSTEP]
rw [coe_mul_apply_eq_dfinsupp_sum]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum (↑(of (fun i => { x // x ∈ A i }) i) r) fun i ri =>
      DFinsupp.sum r' fun j rj => if i + j = n then ↑ri * ↑rj else 0) =
    0
[PROOFSTEP]
apply (DFinsupp.sum_single_index _).trans
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑r * ↑rj else 0) = 0
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑0 * ↑rj else 0) = 0
[PROOFSTEP]
swap
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑0 * ↑rj else 0) = 0
[PROOFSTEP]
simp_rw [ZeroMemClass.coe_zero, zero_mul, ite_self]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r' fun j rj => 0) = 0
[PROOFSTEP]
exact DFinsupp.sum_zero
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r' fun j rj => if i + j = n then ↑r * ↑rj else 0) = 0
[PROOFSTEP]
rw [DFinsupp.sum, Finset.sum_ite_of_false _ _ fun x _ H => _, Finset.sum_const_zero]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ ∀ (x : ι), x ∈ DFinsupp.support r' → i + x = n → False
[PROOFSTEP]
exact fun x _ H => h ((self_le_add_right i x).trans_eq H)
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ ↑(↑(r * ↑(of (fun i => { x // x ∈ A i }) i) r') n) = 0
[PROOFSTEP]
classical
rw [coe_mul_apply_eq_dfinsupp_sum, DFinsupp.sum_comm]
apply (DFinsupp.sum_single_index _).trans
swap
· simp_rw [ZeroMemClass.coe_zero, mul_zero, ite_self]
  exact DFinsupp.sum_zero
· rw [DFinsupp.sum, Finset.sum_ite_of_false _ _ fun x _ H => _, Finset.sum_const_zero]
  exact fun x _ H => h ((self_le_add_left i x).trans_eq H)
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ ↑(↑(r * ↑(of (fun i => { x // x ∈ A i }) i) r') n) = 0
[PROOFSTEP]
rw [coe_mul_apply_eq_dfinsupp_sum, DFinsupp.sum_comm]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum (↑(of (fun i => { x // x ∈ A i }) i) r') fun i₂ x₂ =>
      DFinsupp.sum r fun i₁ x₁ => if i₁ + i₂ = n then ↑x₁ * ↑x₂ else 0) =
    0
[PROOFSTEP]
apply (DFinsupp.sum_single_index _).trans
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑r' else 0) = 0
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑0 else 0) = 0
[PROOFSTEP]
swap
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑0 else 0) = 0
[PROOFSTEP]
simp_rw [ZeroMemClass.coe_zero, mul_zero, ite_self]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r fun i₁ x₁ => 0) = 0
[PROOFSTEP]
exact DFinsupp.sum_zero
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ (DFinsupp.sum r fun i₁ x₁ => if i₁ + i = n then ↑x₁ * ↑r' else 0) = 0
[PROOFSTEP]
rw [DFinsupp.sum, Finset.sum_ite_of_false _ _ fun x _ H => _, Finset.sum_const_zero]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring R
inst✝³ : SetLike σ R
inst✝² : AddSubmonoidClass σ R
A : ι → σ
inst✝¹ : CanonicallyOrderedAddMonoid ι
inst✝ : SetLike.GradedMonoid A
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
h : ¬i ≤ n
⊢ ∀ (x : ι), x ∈ DFinsupp.support r → x + i = n → False
[PROOFSTEP]
exact fun x _ H => h ((self_le_add_left i x).trans_eq H)
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁸ : DecidableEq ι
inst✝⁷ : Semiring R
inst✝⁶ : SetLike σ R
inst✝⁵ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁴ : CanonicallyOrderedAddMonoid ι
inst✝³ : SetLike.GradedMonoid A
inst✝² : Sub ι
inst✝¹ : OrderedSub ι
inst✝ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
h : i ≤ n
x : ι
⊢ i + x = n ↔ x = n - i
[PROOFSTEP]
rw [eq_tsub_iff_add_eq_of_le h, add_comm]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
⊢ ↑(↑(r * ↑(of (fun i => { x // x ∈ A i }) i) r') n) = if i ≤ n then ↑(↑r (n - i)) * ↑r' else 0
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
h : i ≤ n
⊢ ↑(↑(r * ↑(of (fun i => { x // x ∈ A i }) i) r') n) = ↑(↑r (n - i)) * ↑r'
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
r : ⨁ (i : ι), { x // x ∈ A i }
i : ι
r' : { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
h : ¬i ≤ n
⊢ ↑(↑(r * ↑(of (fun i => { x // x ∈ A i }) i) r') n) = 0
[PROOFSTEP]
exacts [coe_mul_of_apply_of_le _ _ _ n h, coe_mul_of_apply_of_not_le _ _ _ n h]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = if i ≤ n then ↑r * ↑(↑r' (n - i)) else 0
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
h : i ≤ n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = ↑r * ↑(↑r' (n - i))
case neg
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁹ : DecidableEq ι
inst✝⁸ : Semiring R
inst✝⁷ : SetLike σ R
inst✝⁶ : AddSubmonoidClass σ R
A : ι → σ
inst✝⁵ : CanonicallyOrderedAddMonoid ι
inst✝⁴ : SetLike.GradedMonoid A
inst✝³ : Sub ι
inst✝² : OrderedSub ι
inst✝¹ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
i : ι
r : { x // x ∈ A i }
r' : ⨁ (i : ι), { x // x ∈ A i }
n : ι
inst✝ : Decidable (i ≤ n)
h : ¬i ≤ n
⊢ ↑(↑(↑(of (fun i => { x // x ∈ A i }) i) r * r') n) = 0
[PROOFSTEP]
exacts [coe_of_mul_apply_of_le _ _ _ n h, coe_of_mul_apply_of_not_le _ _ _ n h]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝³ : DecidableEq ι
inst✝² : CommSemiring S
inst✝¹ : Semiring R
inst✝ : Algebra S R
p : Submodule S R
⊢ 1 ∈ p ^ 0
[PROOFSTEP]
rw [← one_le, pow_zero]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝³ : DecidableEq ι
inst✝² : CommSemiring S
inst✝¹ : Semiring R
inst✝ : Algebra S R
p✝ : Submodule S R
i j : ℕ
p q : R
hp : p ∈ p✝ ^ i
hq : q ∈ p✝ ^ j
⊢ p * q ∈ p✝ ^ (i + j)
[PROOFSTEP]
rw [pow_add]
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝³ : DecidableEq ι
inst✝² : CommSemiring S
inst✝¹ : Semiring R
inst✝ : Algebra S R
p✝ : Submodule S R
i j : ℕ
p q : R
hp : p ∈ p✝ ^ i
hq : q ∈ p✝ ^ j
⊢ p * q ∈ p✝ ^ i * p✝ ^ j
[PROOFSTEP]
exact Submodule.mul_mem_mul hp hq
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddMonoid ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : SetLike.GradedMonoid A
i : ι
x : { x // x ∈ A i }
⊢ ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) 0) GradedMonoid.GOne.one = 1
[PROOFSTEP]
rfl
[GOAL]
ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddMonoid ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : SetLike.GradedMonoid A
i : ι
x : { x // x ∈ A i }
i✝ j✝ : ι
x✝¹ : { x // x ∈ A i✝ }
x✝ : { x // x ∈ A j✝ }
⊢ ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) (i✝ + j✝))
      (GradedMonoid.GMul.mul x✝¹ x✝) =
    ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) i✝) x✝¹ *
      ↑((fun i => LinearMap.toAddMonoidHom ((fun i => Submodule.subtype (A i)) i)) j✝) x✝
[PROOFSTEP]
rfl


[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
⊢ Linear k (Rep k G)
[PROOFSTEP]
infer_instance
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
⊢ AddCommGroup (CoeSort.coe V)
[PROOFSTEP]
change AddCommGroup ((forget₂ (Rep k G) (ModuleCat k)).obj V)
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
⊢ AddCommGroup ↑((forget₂ (Rep k G) (ModuleCat k)).obj V)
[PROOFSTEP]
infer_instance
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
⊢ Module k (CoeSort.coe V)
[PROOFSTEP]
change Module k ((forget₂ (Rep k G) (ModuleCat k)).obj V)
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
⊢ Module k ↑((forget₂ (Rep k G) (ModuleCat k)).obj V)
[PROOFSTEP]
infer_instance
[GOAL]
k G✝ : Type u
inst✝² : CommRing k
inst✝¹ : Monoid G✝
G : Type u
inst✝ : Group G
A : Rep k G
g : G
x : CoeSort.coe A
⊢ ↑(↑(ρ A) g⁻¹ * ↑(ρ A) g) x = x
[PROOFSTEP]
rw [← map_mul, inv_mul_self, map_one, LinearMap.one_apply]
[GOAL]
k G✝ : Type u
inst✝² : CommRing k
inst✝¹ : Monoid G✝
G : Type u
inst✝ : Group G
A : Rep k G
g : G
x : CoeSort.coe A
⊢ ↑(↑(ρ A) g * ↑(ρ A) g⁻¹) x = x
[PROOFSTEP]
rw [← map_mul, mul_inv_self, map_one, LinearMap.one_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X : Action (Type u) (MonCat.of G)
g : G
x : X.V
⊢ ↑(↑(ρ ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj X)) g) (Finsupp.single x 1) =
    Finsupp.single (↑X.ρ g x) 1
[PROOFSTEP]
rw [linearization_obj_ρ, Finsupp.lmapDomain_apply, Finsupp.mapDomain_single]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X : Action (Type u) (MonCat.of G)
g : G
x : X.V
r : k
⊢ ↑(↑(ρ ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj X)) g) (Finsupp.single x r) =
    Finsupp.single (↑X.ρ g x) r
[PROOFSTEP]
rw [linearization_obj_ρ, Finsupp.lmapDomain_apply, Finsupp.mapDomain_single]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ (inv (LaxMonoidalFunctor.μ (linearization k G).toLaxMonoidalFunctor X Y)).hom =
    ↑(LinearEquiv.symm (finsuppTensorFinsupp' k X.V Y.V))
[PROOFSTEP]
rw [← Action.forget_map, Functor.map_inv]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ inv
      ((Action.forget (ModuleCat k) (MonCat.of G)).map
        (LaxMonoidalFunctor.μ (linearization k G).toLaxMonoidalFunctor X Y)) =
    ↑(LinearEquiv.symm (finsuppTensorFinsupp' k X.V Y.V))
[PROOFSTEP]
apply IsIso.inv_eq_of_hom_inv_id
[GOAL]
case hom_inv_id
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ (Action.forget (ModuleCat k) (MonCat.of G)).map (LaxMonoidalFunctor.μ (linearization k G).toLaxMonoidalFunctor X Y) ≫
      ↑(LinearEquiv.symm (finsuppTensorFinsupp' k X.V Y.V)) =
    𝟙
      ((Action.forget (ModuleCat k) (MonCat.of G)).obj
        (MonoidalCategory.tensorObj ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj X)
          ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj Y)))
[PROOFSTEP]
exact LinearMap.ext fun x => LinearEquiv.symm_apply_apply (finsuppTensorFinsupp' k X.V Y.V) x
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
g : ↑(MonCat.of G)
⊢ (↑(ofMulAction k G G).ρ g ≫ ↑(Finsupp.lift ((fun x => CoeSort.coe A) x) k G) fun g => ↑(↑(ρ A) g) x) =
    (↑(Finsupp.lift ((fun x => CoeSort.coe A) x) k G) fun g => ↑(↑(ρ A) g) x) ≫ ↑A.ρ g
[PROOFSTEP]
refine'
  Finsupp.lhom_ext' fun y =>
    LinearMap.ext_ring
      _
        /- Porting note: rest of broken proof was
            simpa only [LinearMap.comp_apply, ModuleCat.comp_def, Finsupp.lsingle_apply, Finsupp.lift_apply,
              Action_ρ_eq_ρ, of_ρ_apply, Representation.ofMulAction_single, Finsupp.sum_single_index,
              zero_smul, one_smul, smul_eq_mul, A.ρ.map_mul] -/
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
g : ↑(MonCat.of G)
y : G
⊢ ↑(LinearMap.comp (↑(ofMulAction k G G).ρ g ≫ ↑(Finsupp.lift ((fun x => CoeSort.coe A) x) k G) fun g => ↑(↑(ρ A) g) x)
          (Finsupp.lsingle y))
      1 =
    ↑(LinearMap.comp ((↑(Finsupp.lift ((fun x => CoeSort.coe A) x) k G) fun g => ↑(↑(ρ A) g) x) ≫ ↑A.ρ g)
          (Finsupp.lsingle y))
      1
[PROOFSTEP]
simp only [LinearMap.comp_apply, ModuleCat.comp_def, Finsupp.lsingle_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
g : ↑(MonCat.of G)
y : G
⊢ ↑(↑(Finsupp.lift (CoeSort.coe A) k G) fun g => ↑(↑(ρ A) g) x) (↑(↑(ofMulAction k G G).ρ g) (Finsupp.single y 1)) =
    ↑(↑A.ρ g) (↑(↑(Finsupp.lift (CoeSort.coe A) k G) fun g => ↑(↑(ρ A) g) x) (Finsupp.single y 1))
[PROOFSTEP]
erw [Finsupp.lift_apply, Finsupp.lift_apply, Representation.ofMulAction_single (G := G)]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
g : ↑(MonCat.of G)
y : G
⊢ (Finsupp.sum (Finsupp.single (g • y) 1) fun x_1 r => r • ↑(↑(ρ A) x_1) x) =
    ↑(↑A.ρ g) (Finsupp.sum (Finsupp.single y 1) fun x_1 r => r • ↑(↑(ρ A) x_1) x)
[PROOFSTEP]
simp only [Finsupp.sum_single_index, zero_smul, one_smul, smul_eq_mul, A.ρ.map_mul, of_ρ]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
g : ↑(MonCat.of G)
y : G
⊢ ↑(↑(ρ A) g * ↑(ρ A) y) x = ↑(↑A.ρ g) (↑(↑(ρ A) y) x)
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
⊢ ↑(leftRegularHom A x).hom (Finsupp.single 1 1) = x
[PROOFSTEP]
rw [leftRegularHom_hom, Finsupp.lift_apply, Finsupp.sum_single_index, one_smul, A.ρ.map_one, LinearMap.one_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
⊢ 0 • ↑(↑(ρ A) 1) x = 0
[PROOFSTEP]
rw [zero_smul]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
⊢ (fun x => leftRegularHom A x)
      (AddHom.toFun
        {
            toAddHom :=
              { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                map_add' :=
                  (_ :
                    ∀ (x y : ofMulAction k G G ⟶ A),
                      (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                        (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) },
            map_smul' :=
              (_ :
                ∀ (r : k) (x : ofMulAction k G G ⟶ A),
                  AddHom.toFun
                      { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                        map_add' :=
                          (_ :
                            ∀ (x y : ofMulAction k G G ⟶ A),
                              (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) }
                      (r • x) =
                    AddHom.toFun
                      { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                        map_add' :=
                          (_ :
                            ∀ (x y : ofMulAction k G G ⟶ A),
                              (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) }
                      (r • x)) }.toAddHom
        f) =
    f
[PROOFSTEP]
refine' Action.Hom.ext _ _ (Finsupp.lhom_ext' fun x : G => LinearMap.ext_ring _)
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
⊢ ↑(LinearMap.comp
          ((fun x => leftRegularHom A x)
              (AddHom.toFun
                {
                    toAddHom :=
                      { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                        map_add' :=
                          (_ :
                            ∀ (x y : ofMulAction k G G ⟶ A),
                              (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) },
                    map_smul' :=
                      (_ :
                        ∀ (r : k) (x : ofMulAction k G G ⟶ A),
                          AddHom.toFun
                              { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : ofMulAction k G G ⟶ A),
                                      (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                        (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) }
                              (r • x) =
                            AddHom.toFun
                              { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : ofMulAction k G G ⟶ A),
                                      (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                        (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) }
                              (r • x)) }.toAddHom
                f)).hom
          (Finsupp.lsingle x))
      1 =
    ↑(LinearMap.comp f.hom (Finsupp.lsingle x)) 1
[PROOFSTEP]
have :
  f.hom ((ofMulAction k G G).ρ x (Finsupp.single (1 : G) (1 : k))) = A.ρ x (f.hom (Finsupp.single (1 : G) (1 : k))) :=
  LinearMap.ext_iff.1 (f.comm x)
    (Finsupp.single 1 1)
      /- Porting note: rest of broken proof was
          simp only [LinearMap.comp_apply, Finsupp.lsingle_apply, left_regular_hom_hom,
            Finsupp.lift_apply, Finsupp.sum_single_index, one_smul, ← this, zero_smul, of_ρ_apply,
            Representation.ofMulAction_single x (1 : G) (1 : k), smul_eq_mul, mul_one] -/
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ ↑(LinearMap.comp
          ((fun x => leftRegularHom A x)
              (AddHom.toFun
                {
                    toAddHom :=
                      { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                        map_add' :=
                          (_ :
                            ∀ (x y : ofMulAction k G G ⟶ A),
                              (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) },
                    map_smul' :=
                      (_ :
                        ∀ (r : k) (x : ofMulAction k G G ⟶ A),
                          AddHom.toFun
                              { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : ofMulAction k G G ⟶ A),
                                      (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                        (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) }
                              (r • x) =
                            AddHom.toFun
                              { toFun := fun f => ↑f.hom (Finsupp.single 1 1),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : ofMulAction k G G ⟶ A),
                                      (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y) =
                                        (fun f => ↑f.hom (Finsupp.single 1 1)) (x + y)) }
                              (r • x)) }.toAddHom
                f)).hom
          (Finsupp.lsingle x))
      1 =
    ↑(LinearMap.comp f.hom (Finsupp.lsingle x)) 1
[PROOFSTEP]
simp only [LinearMap.comp_apply, Finsupp.lsingle_apply, leftRegularHom_hom]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ ↑(↑(Finsupp.lift (CoeSort.coe A) k G) fun g => ↑(↑(ρ A) g) (↑f.hom (Finsupp.single 1 1))) (Finsupp.single x 1) =
    ↑f.hom (Finsupp.single x 1)
[PROOFSTEP]
erw [Finsupp.lift_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ (Finsupp.sum (Finsupp.single x 1) fun x r => r • ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))) =
    ↑f.hom (Finsupp.single x 1)
[PROOFSTEP]
rw [Finsupp.sum_single_index, ← this, of_ρ_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ 1 • ↑f.hom (↑(↑(Representation.ofMulAction k G G) x) (Finsupp.single 1 1)) = ↑f.hom (Finsupp.single x 1)
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ 0 • ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1)) = 0
[PROOFSTEP]
erw [Representation.ofMulAction_single x (1 : G) (1 : k)]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ 1 • ↑f.hom (Finsupp.single (x • 1) 1) = ↑f.hom (Finsupp.single x 1)
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ 0 • ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1)) = 0
[PROOFSTEP]
simp only [one_smul, smul_eq_mul, mul_one]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f✝ : X ⟶ Y
A : Rep k G
f : ofMulAction k G G ⟶ A
x : G
this : ↑f.hom (↑(↑(ρ (ofMulAction k G G)) x) (Finsupp.single 1 1)) = ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1))
⊢ 0 • ↑(↑(ρ A) x) (↑f.hom (Finsupp.single 1 1)) = 0
[PROOFSTEP]
rw [zero_smul]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
g : G
⊢ ↑(↑(LinearEquiv.symm (leftRegularHomEquiv A)) x).hom (Finsupp.single g 1) = ↑(↑(ρ A) g) x
[PROOFSTEP]
rw [leftRegularHomEquiv_symm_apply, leftRegularHom_hom, Finsupp.lift_apply, Finsupp.sum_single_index, one_smul]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X Y : Action (Type u) (MonCat.of G)
f : X ⟶ Y
A : Rep k G
x : CoeSort.coe A
g : G
⊢ 0 • ↑(↑(ρ A) g) x = 0
[PROOFSTEP]
rw [zero_smul]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B C A X Y : Rep k G
f : X ⟶ Y
g : ↑(MonCat.of G)
x : ↑((fun B => of (Representation.linHom (ρ A) (ρ B))) X).V
y : CoeSort.coe A
⊢ ↑(↑(↑((fun B => of (Representation.linHom (ρ A) (ρ B))) X).ρ g ≫
              ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom))
          x)
      y =
    ↑(↑(ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom) ≫
              ↑((fun B => of (Representation.linHom (ρ A) (ρ B))) Y).ρ g)
          x)
      y
[PROOFSTEP]
show f.hom (X.ρ g _) = _
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B C A X Y : Rep k G
f : X ⟶ Y
g : ↑(MonCat.of G)
x : ↑((fun B => of (Representation.linHom (ρ A) (ρ B))) X).V
y : CoeSort.coe A
⊢ ↑f.hom (↑(↑(ρ X) g) (↑(LinearMap.comp x (↑(ρ A) g⁻¹)) y)) =
    ↑(↑(ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom) ≫
              ↑((fun B => of (Representation.linHom (ρ A) (ρ B))) Y).ρ g)
          x)
      y
[PROOFSTEP]
simp only [hom_comm_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B C A X Y : Rep k G
f : X ⟶ Y
g : ↑(MonCat.of G)
x : ↑((fun B => of (Representation.linHom (ρ A) (ρ B))) X).V
y : CoeSort.coe A
⊢ ↑(↑(ρ Y) g) (↑f.hom (↑(LinearMap.comp x (↑(ρ A) g⁻¹)) y)) =
    ↑(↑(ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom) ≫
              ↑(of (Representation.linHom (ρ A) (ρ Y))).ρ g)
          x)
      y
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B C A x✝ : Rep k G
⊢ { obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
          map := fun {X Y} f => Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
      (𝟙 x✝) =
    𝟙
      ({ obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
            map := fun {X Y} f => Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.obj
        x✝)
[PROOFSTEP]
ext
[GOAL]
case h.h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B C A x✝¹ : Rep k G
x✝ :
  ↑({ obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
            map := fun {X Y} f => Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.obj
        x✝¹).V
⊢ ↑({ obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
                map := fun {X Y} f =>
                  Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
            (𝟙 x✝¹)).hom
      x✝ =
    ↑(𝟙
            ({ obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
                  map := fun {X Y} f =>
                    Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.obj
              x✝¹)).hom
      x✝
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B C A X✝ Y✝ Z✝ : Rep k G
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ { obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
          map := fun {X Y} f => Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
      (x✝¹ ≫ x✝) =
    { obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
            map := fun {X Y} f => Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
        x✝¹ ≫
      { obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
            map := fun {X Y} f => Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
        x✝
[PROOFSTEP]
ext
[GOAL]
case h.h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B C A X✝ Y✝ Z✝ : Rep k G
x✝² : X✝ ⟶ Y✝
x✝¹ : Y✝ ⟶ Z✝
x✝ :
  ↑({ obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
            map := fun {X Y} f => Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.obj
        X✝).V
⊢ ↑({ obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
                map := fun {X Y} f =>
                  Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
            (x✝² ≫ x✝¹)).hom
      x✝ =
    ↑({ obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
                  map := fun {X Y} f =>
                    Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
              x✝² ≫
            { obj := fun B => of (Representation.linHom (ρ A) (ρ B)),
                  map := fun {X Y} f =>
                    Hom.mk (ModuleCat.ofHom (↑(LinearMap.llcomp k (CoeSort.coe A) ↑X.V ↑Y.V) f.hom)) }.map
              x✝¹).hom
      x✝
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : A ⊗ B ⟶ C
g : ↑(MonCat.of G)
⊢ ↑B.ρ g ≫ LinearMap.flip (TensorProduct.curry f.hom) =
    LinearMap.flip (TensorProduct.curry f.hom) ≫ ↑((Rep.ihom A).obj C).ρ g
[PROOFSTEP]
refine' LinearMap.ext fun x => LinearMap.ext fun y => _
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : A ⊗ B ⟶ C
g : ↑(MonCat.of G)
x : ↑B.V
y : CoeSort.coe A
⊢ ↑(↑(↑B.ρ g ≫ LinearMap.flip (TensorProduct.curry f.hom)) x) y =
    ↑(↑(LinearMap.flip (TensorProduct.curry f.hom) ≫ ↑((Rep.ihom A).obj C).ρ g) x) y
[PROOFSTEP]
change f.hom (_ ⊗ₜ[k] _) = C.ρ g (f.hom (_ ⊗ₜ[k] _))
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : A ⊗ B ⟶ C
g : ↑(MonCat.of G)
x : ↑B.V
y : CoeSort.coe A
⊢ ↑f.hom (y ⊗ₜ[k] ↑(↑B.ρ g) x) = ↑(↑(ρ C) g) (↑f.hom (↑(↑(ρ A) g⁻¹) y ⊗ₜ[k] x))
[PROOFSTEP]
rw [← hom_comm_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : A ⊗ B ⟶ C
g : ↑(MonCat.of G)
x : ↑B.V
y : CoeSort.coe A
⊢ ↑f.hom (y ⊗ₜ[k] ↑(↑B.ρ g) x) = ↑f.hom (↑(↑(ρ (A ⊗ B)) g) (↑(↑(ρ A) g⁻¹) y ⊗ₜ[k] x))
[PROOFSTEP]
change _ = f.hom ((A.ρ g * A.ρ g⁻¹) y ⊗ₜ[k] _)
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : A ⊗ B ⟶ C
g : ↑(MonCat.of G)
x : ↑B.V
y : CoeSort.coe A
⊢ ↑f.hom (y ⊗ₜ[k] ↑(↑B.ρ g) x) =
    ↑f.hom
      (↑(↑(ρ A) g * ↑(ρ A) g⁻¹) y ⊗ₜ[k]
        ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj B).map
              g)
          (↑(↑(ρ A) g⁻¹) y, x).snd)
[PROOFSTEP]
simp only [← map_mul, mul_inv_self, map_one]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : A ⊗ B ⟶ C
g : ↑(MonCat.of G)
x : ↑B.V
y : CoeSort.coe A
⊢ ↑f.hom (y ⊗ₜ[k] ↑(↑B.ρ g) x) =
    ↑f.hom
      (↑1 y ⊗ₜ[k]
        ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj B).map
              g)
          x)
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : B ⟶ (Rep.ihom A).obj C
g : ↑(MonCat.of G)
x :
  ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj A).obj
      PUnit.unit)
y :
  ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj B).obj
      PUnit.unit)
⊢ ↑(↑(A ⊗ B).ρ g ≫ ↑(TensorProduct.uncurry k (CoeSort.coe A) (↑B.V) (CoeSort.coe C)) (LinearMap.flip f.hom))
      (x ⊗ₜ[k] y) =
    ↑(↑(TensorProduct.uncurry k (CoeSort.coe A) (↑B.V) (CoeSort.coe C)) (LinearMap.flip f.hom) ≫ ↑C.ρ g) (x ⊗ₜ[k] y)
[PROOFSTEP]
change
  TensorProduct.uncurry k _ _ _ f.hom.flip (A.ρ g x ⊗ₜ[k] B.ρ g y) =
    C.ρ g (TensorProduct.uncurry k _ _ _ f.hom.flip (x ⊗ₜ[k] y))
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : B ⟶ (Rep.ihom A).obj C
g : ↑(MonCat.of G)
x :
  ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj A).obj
      PUnit.unit)
y :
  ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj B).obj
      PUnit.unit)
⊢ ↑(↑(TensorProduct.uncurry k (CoeSort.coe A) (↑B.V) (CoeSort.coe C)) (LinearMap.flip f.hom))
      (↑(↑(ρ A) g) x ⊗ₜ[k] ↑(↑(ρ B) g) y) =
    ↑(↑(ρ C) g)
      (↑(↑(TensorProduct.uncurry k (CoeSort.coe A) (↑B.V) (CoeSort.coe C)) (LinearMap.flip f.hom)) (x ⊗ₜ[k] y))
[PROOFSTEP]
rw [TensorProduct.uncurry_apply, LinearMap.flip_apply, hom_comm_apply, Rep.ihom_obj_ρ_apply, LinearMap.comp_apply,
  LinearMap.comp_apply, ρ_inv_self_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : B ⟶ (Rep.ihom A).obj C
g : ↑(MonCat.of G)
x :
  ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj A).obj
      PUnit.unit)
y :
  ↑(((CategoryTheory.Equivalence.symm (functorCategoryEquivalence (ModuleCat k) (MonCat.of G))).inverse.obj B).obj
      PUnit.unit)
⊢ ↑(↑(ρ C) g) (↑(↑f.hom y) x) =
    ↑(↑(ρ C) g)
      (↑(↑(TensorProduct.uncurry k (CoeSort.coe A) (↑B.V) (CoeSort.coe C)) (LinearMap.flip f.hom)) (x ⊗ₜ[k] y))
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : B ⟶ (Rep.ihom A).obj C
⊢ (fun f => Hom.mk (LinearMap.flip (TensorProduct.curry f.hom)))
      ((fun f => Hom.mk (↑(TensorProduct.uncurry k (CoeSort.coe A) (↑B.V) (CoeSort.coe C)) (LinearMap.flip f.hom))) f) =
    f
[PROOFSTEP]
ext
[GOAL]
case h.h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C✝ A B C : Rep k G
f : B ⟶ (Rep.ihom A).obj C
x✝ : ↑B.V
⊢ ↑((fun f => Hom.mk (LinearMap.flip (TensorProduct.curry f.hom)))
            ((fun f =>
                Hom.mk (↑(TensorProduct.uncurry k (CoeSort.coe A) (↑B.V) (CoeSort.coe C)) (LinearMap.flip f.hom)))
              f)).hom
      x✝ =
    ↑f.hom x✝
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C A B : Rep k G
⊢ (NatTrans.app (ihom.ev A) B).hom =
    ↑(TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe A →ₗ[k] CoeSort.coe B) (CoeSort.coe B))
      (LinearMap.flip LinearMap.id)
[PROOFSTEP]
ext
[GOAL]
case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A✝ B✝ C A B : Rep k G
x✝ : ↑((ihom A ⋙ tensorLeft A).obj B).V
⊢ ↑(NatTrans.app (ihom.ev A) B).hom x✝ =
    ↑(↑(TensorProduct.uncurry k (CoeSort.coe A) (CoeSort.coe A →ₗ[k] CoeSort.coe B) (CoeSort.coe B))
          (LinearMap.flip LinearMap.id))
      x✝
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
⊢ SymmetricCategory (Rep k G)
[PROOFSTEP]
infer_instance
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
⊢ MonoidalPreadditive (Rep k G)
[PROOFSTEP]
infer_instance
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
⊢ MonoidalLinear k (Rep k G)
[PROOFSTEP]
infer_instance
[GOAL]
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r : MonoidAlgebra k G
x : V
⊢ ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) r) x) = ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) r) (↑f x)
[PROOFSTEP]
apply MonoidAlgebra.induction_on r
[GOAL]
case hM
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r : MonoidAlgebra k G
x : V
⊢ ∀ (g : G),
    ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (↑(MonoidAlgebra.of k G) g)) x) =
      ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (↑(MonoidAlgebra.of k G) g)) (↑f x)
[PROOFSTEP]
intro g
[GOAL]
case hM
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r : MonoidAlgebra k G
x : V
g : G
⊢ ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (↑(MonoidAlgebra.of k G) g)) x) =
    ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (↑(MonoidAlgebra.of k G) g)) (↑f x)
[PROOFSTEP]
simp only [one_smul, MonoidAlgebra.lift_single, MonoidAlgebra.of_apply]
[GOAL]
case hM
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r : MonoidAlgebra k G
x : V
g : G
⊢ ↑f (↑(↑ρ g) x) = ↑(↑σ g) (↑f x)
[PROOFSTEP]
exact LinearMap.congr_fun (w g) x
[GOAL]
case hadd
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r : MonoidAlgebra k G
x : V
⊢ ∀ (f_1 g : MonoidAlgebra k G),
    ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) f_1) x) =
        ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) f_1) (↑f x) →
      ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) g) x) = ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) g) (↑f x) →
        ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (f_1 + g)) x) =
          ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (f_1 + g)) (↑f x)
[PROOFSTEP]
intro g h gw hw
[GOAL]
case hadd
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r : MonoidAlgebra k G
x : V
g h : MonoidAlgebra k G
gw : ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) g) x) = ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) g) (↑f x)
hw : ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) h) x) = ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) h) (↑f x)
⊢ ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (g + h)) x) =
    ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (g + h)) (↑f x)
[PROOFSTEP]
simp only [map_add, add_left_inj, LinearMap.add_apply, hw, gw]
[GOAL]
case hsmul
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r : MonoidAlgebra k G
x : V
⊢ ∀ (r : k) (f_1 : MonoidAlgebra k G),
    ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) f_1) x) =
        ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) f_1) (↑f x) →
      ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (r • f_1)) x) =
        ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (r • f_1)) (↑f x)
[PROOFSTEP]
intro r g w
[GOAL]
case hsmul
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Monoid G✝
k : Type u_1
G : Type u_2
inst✝⁵ : CommRing k
inst✝⁴ : Monoid G
V : Type u_3
W : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup W
inst✝¹ : Module k V
inst✝ : Module k W
ρ : G →* V →ₗ[k] V
σ : G →* W →ₗ[k] W
f : V →ₗ[k] W
w✝ : ∀ (g : G), LinearMap.comp f (↑ρ g) = LinearMap.comp (↑σ g) f
r✝ : MonoidAlgebra k G
x : V
r : k
g : MonoidAlgebra k G
w : ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) g) x) = ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) g) (↑f x)
⊢ ↑f (↑(↑(↑(MonoidAlgebra.lift k G (V →ₗ[k] V)) ρ) (r • g)) x) =
    ↑(↑(↑(MonoidAlgebra.lift k G (W →ₗ[k] W)) σ) (r • g)) (↑f x)
[PROOFSTEP]
simp only [AlgHom.map_smul, w, RingHom.id_apply, LinearMap.smul_apply, LinearMap.map_smulₛₗ]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : ModuleCat (MonoidAlgebra k G)
f : X✝ ⟶ Y✝
g : ↑(MonCat.of G)
⊢ ↑((fun M => of (Representation.ofModule ↑M)) X✝).ρ g ≫
      { toAddHom := f.toAddHom,
        map_smul' :=
          (_ :
            ∀ (r : k) (x : ↑((fun M => of (Representation.ofModule ↑M)) X✝).V),
              ↑f (↑(algebraMap k (MonoidAlgebra k G)) r • x) = ↑(algebraMap k (MonoidAlgebra k G)) r • ↑f x) } =
    { toAddHom := f.toAddHom,
        map_smul' :=
          (_ :
            ∀ (r : k) (x : ↑((fun M => of (Representation.ofModule ↑M)) X✝).V),
              ↑f (↑(algebraMap k (MonoidAlgebra k G)) r • x) = ↑(algebraMap k (MonoidAlgebra k G)) r • ↑f x) } ≫
      ↑((fun M => of (Representation.ofModule ↑M)) Y✝).ρ g
[PROOFSTEP]
ext
[GOAL]
case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : ModuleCat (MonoidAlgebra k G)
f : X✝ ⟶ Y✝
g : ↑(MonCat.of G)
x✝ : ↑((fun M => of (Representation.ofModule ↑M)) X✝).V
⊢ ↑(↑((fun M => of (Representation.ofModule ↑M)) X✝).ρ g ≫
          { toAddHom := f.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : k) (x : ↑((fun M => of (Representation.ofModule ↑M)) X✝).V),
                  ↑f (↑(algebraMap k (MonoidAlgebra k G)) r • x) = ↑(algebraMap k (MonoidAlgebra k G)) r • ↑f x) })
      x✝ =
    ↑({ toAddHom := f.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : k) (x : ↑((fun M => of (Representation.ofModule ↑M)) X✝).V),
                  ↑f (↑(algebraMap k (MonoidAlgebra k G)) r • x) = ↑(algebraMap k (MonoidAlgebra k G)) r • ↑f x) } ≫
          ↑((fun M => of (Representation.ofModule ↑M)) Y✝).ρ g)
      x✝
[PROOFSTEP]
apply f.map_smul
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
M : ModuleCat (MonoidAlgebra k G)
⊢ ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M) ≃+ ↑M
[PROOFSTEP]
dsimp [ofModuleMonoidAlgebra, toModuleMonoidAlgebra]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
M : ModuleCat (MonoidAlgebra k G)
⊢ ↑(ModuleCat.of (MonoidAlgebra k G) (Representation.asModule (Representation.ofModule ↑M))) ≃+ ↑M
[PROOFSTEP]
refine' (Representation.ofModule M).asModuleEquiv.trans (RestrictScalars.addEquiv k (MonoidAlgebra k G) _)
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
⊢ CoeSort.coe V ≃+ CoeSort.coe ((toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V)
[PROOFSTEP]
dsimp [ofModuleMonoidAlgebra, toModuleMonoidAlgebra]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
⊢ CoeSort.coe V ≃+
    RestrictScalars k (MonoidAlgebra k G) ↑(ModuleCat.of (MonoidAlgebra k G) (Representation.asModule (ρ V)))
[PROOFSTEP]
refine' V.ρ.asModuleEquiv.symm.trans _
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
⊢ Representation.asModule (ρ V) ≃+
    RestrictScalars k (MonoidAlgebra k G) ↑(ModuleCat.of (MonoidAlgebra k G) (Representation.asModule (ρ V)))
[PROOFSTEP]
exact (RestrictScalars.addEquiv _ _ _).symm
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
M : ModuleCat (MonoidAlgebra k G)
src✝ : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M) ≃+ ↑M := counitIsoAddEquiv
r : MonoidAlgebra k G
x : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M)
⊢ AddHom.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ (x y : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M)),
              Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
      (r • x) =
    ↑(RingHom.id (MonoidAlgebra k G)) r •
      AddHom.toFun
        { toFun := src✝.toFun,
          map_add' :=
            (_ :
              ∀ (x y : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M)),
                Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
        x
[PROOFSTEP]
dsimp [counitIsoAddEquiv]
  /- Porting note: rest of broken proof was `simp`. -/
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
M : ModuleCat (MonoidAlgebra k G)
src✝ : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M) ≃+ ↑M := counitIsoAddEquiv
r : MonoidAlgebra k G
x : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M)
⊢ ↑↑(AddEquiv.trans (Representation.asModuleEquiv (Representation.ofModule ↑M))
            (RestrictScalars.addEquiv k (MonoidAlgebra k G) ↑M))
      (r • x) =
    r •
      ↑↑(AddEquiv.trans (Representation.asModuleEquiv (Representation.ofModule ↑M))
              (RestrictScalars.addEquiv k (MonoidAlgebra k G) ↑M))
        x
[PROOFSTEP]
rw [AddEquiv.coe_toEquiv, AddEquiv.trans_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
M : ModuleCat (MonoidAlgebra k G)
src✝ : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M) ≃+ ↑M := counitIsoAddEquiv
r : MonoidAlgebra k G
x : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M)
⊢ ↑(RestrictScalars.addEquiv k (MonoidAlgebra k G) ↑M)
      (↑(Representation.asModuleEquiv (Representation.ofModule ↑M)) (r • x)) =
    r •
      ↑(AddEquiv.trans (Representation.asModuleEquiv (Representation.ofModule ↑M))
            (RestrictScalars.addEquiv k (MonoidAlgebra k G) ↑M))
        x
[PROOFSTEP]
erw [Representation.ofModule_asAlgebraHom_apply_apply]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
M : ModuleCat (MonoidAlgebra k G)
src✝ : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M) ≃+ ↑M := counitIsoAddEquiv
r : MonoidAlgebra k G
x : ↑((ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).obj M)
⊢ ↑(AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) ((fun x => ↑M) x)))
      (r • ↑(RestrictScalars.addEquiv k (MonoidAlgebra k G) ↑M) x) =
    r •
      ↑(AddEquiv.trans (Representation.asModuleEquiv (Representation.ofModule ↑M))
            (RestrictScalars.addEquiv k (MonoidAlgebra k G) ↑M))
        x
[PROOFSTEP]
exact AddEquiv.symm_apply_apply _ _
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ ↑unitIsoAddEquiv (AddHom.toFun (↑(ρ V) g).toAddHom x) =
    AddHom.toFun (↑(ρ (ofModuleMonoidAlgebra.obj (toModuleMonoidAlgebra.obj V))) g).toAddHom (↑unitIsoAddEquiv x)
[PROOFSTEP]
dsimp [unitIsoAddEquiv, ofModuleMonoidAlgebra, toModuleMonoidAlgebra]
  /- Porting note: rest of broken proof was
    simp only [AddEquiv.apply_eq_iff_eq, AddEquiv.apply_symm_apply,
      Representation.asModuleEquiv_symm_map_rho, Representation.ofModule_asModule_act] -/
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ ↑(AddEquiv.trans (AddEquiv.symm (Representation.asModuleEquiv (ρ V)))
          (AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) (Representation.asModule (ρ V)))))
      (↑(↑(ρ V) g) x) =
    AddHom.toFun
      (↑(Representation.ofModule ↑(ModuleCat.of (MonoidAlgebra k G) (Representation.asModule (ρ V)))) g).toAddHom
      (↑(AddEquiv.trans (AddEquiv.symm (Representation.asModuleEquiv (ρ V)))
            (AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) (Representation.asModule (ρ V)))))
        x)
[PROOFSTEP]
erw [Representation.asModuleEquiv_symm_map_rho]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : G
x : CoeSort.coe V
⊢ ↑(MonoidAlgebra.of k G) g • ↑(AddEquiv.symm (Representation.asModuleEquiv (ρ V))) x =
    AddHom.toFun
      (↑(Representation.ofModule ↑(ModuleCat.of (MonoidAlgebra k G) (Representation.asModule (ρ V)))) g).toAddHom
      (↑(AddEquiv.trans (AddEquiv.symm (Representation.asModuleEquiv (ρ V)))
            (AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) (Representation.asModule (ρ V)))))
        x)
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
src✝ : CoeSort.coe V ≃+ CoeSort.coe ((toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V) := unitIsoAddEquiv
r : k
x : ↑V.V
⊢ AddHom.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ (x y : CoeSort.coe V),
              Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
      (r • x) =
    ↑(RingHom.id k) r •
      AddHom.toFun
        { toFun := src✝.toFun,
          map_add' :=
            (_ :
              ∀ (x y : CoeSort.coe V),
                Equiv.toFun src✝.toEquiv (x + y) = Equiv.toFun src✝.toEquiv x + Equiv.toFun src✝.toEquiv y) }
        x
[PROOFSTEP]
dsimp [unitIsoAddEquiv]
  /- Porting note: rest of broken proof was
            simp only [Representation.asModuleEquiv_symm_map_smul,
              RestrictScalars.addEquiv_symm_map_algebraMap_smul] -/
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
src✝ : CoeSort.coe V ≃+ CoeSort.coe ((toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V) := unitIsoAddEquiv
r : k
x : ↑V.V
⊢ ↑↑(AddEquiv.trans (AddEquiv.symm (Representation.asModuleEquiv (ρ V)))
            (AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) (Representation.asModule (ρ V)))))
      (r • x) =
    r •
      ↑↑(AddEquiv.trans (AddEquiv.symm (Representation.asModuleEquiv (ρ V)))
              (AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) (Representation.asModule (ρ V)))))
        x
[PROOFSTEP]
rw [AddEquiv.coe_toEquiv, AddEquiv.trans_apply, Representation.asModuleEquiv_symm_map_smul,
  RestrictScalars.addEquiv_symm_map_algebraMap_smul]
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
src✝ : CoeSort.coe V ≃+ CoeSort.coe ((toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V) := unitIsoAddEquiv
r : k
x : ↑V.V
⊢ r •
      ↑(AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) (Representation.asModule (ρ V))))
        (↑(AddEquiv.symm (Representation.asModuleEquiv (ρ V))) x) =
    r •
      ↑(AddEquiv.trans (AddEquiv.symm (Representation.asModuleEquiv (ρ V)))
            (AddEquiv.symm (RestrictScalars.addEquiv k (MonoidAlgebra k G) (Representation.asModule (ρ V)))))
        x
[PROOFSTEP]
rfl
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : ↑(MonCat.of G)
⊢ ↑V.ρ g ≫
      (LinearEquiv.toModuleIso'
          (let src := unitIsoAddEquiv;
          {
            toLinearMap :=
              {
                toAddHom :=
                  { toFun := src.toFun,
                    map_add' :=
                      (_ :
                        ∀ (x y : CoeSort.coe V),
                          Equiv.toFun src.toEquiv (x + y) = Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) },
                map_smul' :=
                  (_ :
                    ∀ (r : k) (x : ↑V.V),
                      AddHom.toFun
                          { toFun := src.toFun,
                            map_add' :=
                              (_ :
                                ∀ (x y : CoeSort.coe V),
                                  Equiv.toFun src.toEquiv (x + y) =
                                    Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                          (r • x) =
                        ↑(RingHom.id k) r •
                          AddHom.toFun
                            { toFun := src.toFun,
                              map_add' :=
                                (_ :
                                  ∀ (x y : CoeSort.coe V),
                                    Equiv.toFun src.toEquiv (x + y) =
                                      Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                            x) },
            invFun := src.invFun, left_inv := (_ : Function.LeftInverse src.invFun src.toFun),
            right_inv := (_ : Function.RightInverse src.invFun src.toFun) })).hom =
    (LinearEquiv.toModuleIso'
          (let src := unitIsoAddEquiv;
          {
            toLinearMap :=
              {
                toAddHom :=
                  { toFun := src.toFun,
                    map_add' :=
                      (_ :
                        ∀ (x y : CoeSort.coe V),
                          Equiv.toFun src.toEquiv (x + y) = Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) },
                map_smul' :=
                  (_ :
                    ∀ (r : k) (x : ↑V.V),
                      AddHom.toFun
                          { toFun := src.toFun,
                            map_add' :=
                              (_ :
                                ∀ (x y : CoeSort.coe V),
                                  Equiv.toFun src.toEquiv (x + y) =
                                    Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                          (r • x) =
                        ↑(RingHom.id k) r •
                          AddHom.toFun
                            { toFun := src.toFun,
                              map_add' :=
                                (_ :
                                  ∀ (x y : CoeSort.coe V),
                                    Equiv.toFun src.toEquiv (x + y) =
                                      Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                            x) },
            invFun := src.invFun, left_inv := (_ : Function.LeftInverse src.invFun src.toFun),
            right_inv := (_ : Function.RightInverse src.invFun src.toFun) })).hom ≫
      ↑((toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V).ρ g
[PROOFSTEP]
ext
[GOAL]
case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
V : Rep k G
g : ↑(MonCat.of G)
x✝ : ↑V.V
⊢ ↑(↑V.ρ g ≫
          (LinearEquiv.toModuleIso'
              (let src := unitIsoAddEquiv;
              {
                toLinearMap :=
                  {
                    toAddHom :=
                      { toFun := src.toFun,
                        map_add' :=
                          (_ :
                            ∀ (x y : CoeSort.coe V),
                              Equiv.toFun src.toEquiv (x + y) =
                                Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) },
                    map_smul' :=
                      (_ :
                        ∀ (r : k) (x : ↑V.V),
                          AddHom.toFun
                              { toFun := src.toFun,
                                map_add' :=
                                  (_ :
                                    ∀ (x y : CoeSort.coe V),
                                      Equiv.toFun src.toEquiv (x + y) =
                                        Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                              (r • x) =
                            ↑(RingHom.id k) r •
                              AddHom.toFun
                                { toFun := src.toFun,
                                  map_add' :=
                                    (_ :
                                      ∀ (x y : CoeSort.coe V),
                                        Equiv.toFun src.toEquiv (x + y) =
                                          Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                                x) },
                invFun := src.invFun, left_inv := (_ : Function.LeftInverse src.invFun src.toFun),
                right_inv := (_ : Function.RightInverse src.invFun src.toFun) })).hom)
      x✝ =
    ↑((LinearEquiv.toModuleIso'
              (let src := unitIsoAddEquiv;
              {
                toLinearMap :=
                  {
                    toAddHom :=
                      { toFun := src.toFun,
                        map_add' :=
                          (_ :
                            ∀ (x y : CoeSort.coe V),
                              Equiv.toFun src.toEquiv (x + y) =
                                Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) },
                    map_smul' :=
                      (_ :
                        ∀ (r : k) (x : ↑V.V),
                          AddHom.toFun
                              { toFun := src.toFun,
                                map_add' :=
                                  (_ :
                                    ∀ (x y : CoeSort.coe V),
                                      Equiv.toFun src.toEquiv (x + y) =
                                        Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                              (r • x) =
                            ↑(RingHom.id k) r •
                              AddHom.toFun
                                { toFun := src.toFun,
                                  map_add' :=
                                    (_ :
                                      ∀ (x y : CoeSort.coe V),
                                        Equiv.toFun src.toEquiv (x + y) =
                                          Equiv.toFun src.toEquiv x + Equiv.toFun src.toEquiv y) }
                                x) },
                invFun := src.invFun, left_inv := (_ : Function.LeftInverse src.invFun src.toFun),
                right_inv := (_ : Function.RightInverse src.invFun src.toFun) })).hom ≫
          ↑((toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).obj V).ρ g)
      x✝
[PROOFSTEP]
apply unit_iso_comm
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
⊢ ∀ {X Y : Rep k G} (f : X ⟶ Y),
    (𝟭 (Rep k G)).map f ≫ ((fun V => unitIso V) Y).hom =
      ((fun V => unitIso V) X).hom ≫ (toModuleMonoidAlgebra ⋙ ofModuleMonoidAlgebra).map f
[PROOFSTEP]
aesop_cat
[GOAL]
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
⊢ ∀ {X Y : ModuleCat (MonoidAlgebra k G)} (f : X ⟶ Y),
    (ofModuleMonoidAlgebra ⋙ toModuleMonoidAlgebra).map f ≫ ((fun M => counitIso M) Y).hom =
      ((fun M => counitIso M) X).hom ≫ (𝟭 (ModuleCat (MonoidAlgebra k G))).map f
[PROOFSTEP]
aesop_cat


[GOAL]
⊢ ConcreteCategory SemiNormedGroupCat
[PROOFSTEP]
dsimp [SemiNormedGroupCat]
[GOAL]
⊢ ConcreteCategory (Bundled SeminormedAddCommGroup)
[PROOFSTEP]
infer_instance
[GOAL]
V W : SemiNormedGroupCat
f g : V ⟶ W
h : (forget SemiNormedGroupCat).map f = (forget SemiNormedGroupCat).map g
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
V W : SemiNormedGroupCat
g : V ⟶ W
toFun✝ : ↑V → ↑W
map_add'✝ : ∀ (v₁ v₂ : ↑V), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : ↑V), ‖toFun✝ v‖ ≤ C * ‖v‖
h :
  (forget SemiNormedGroupCat).map { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } =
    (forget SemiNormedGroupCat).map g
⊢ { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
V W : SemiNormedGroupCat
toFun✝¹ : ↑V → ↑W
map_add'✝¹ : ∀ (v₁ v₂ : ↑V), toFun✝¹ (v₁ + v₂) = toFun✝¹ v₁ + toFun✝¹ v₂
bound'✝¹ : ∃ C, ∀ (v : ↑V), ‖toFun✝¹ v‖ ≤ C * ‖v‖
toFun✝ : ↑V → ↑W
map_add'✝ : ∀ (v₁ v₂ : ↑V), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : ↑V), ‖toFun✝ v‖ ≤ C * ‖v‖
h :
  (forget SemiNormedGroupCat).map { toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    (forget SemiNormedGroupCat).map { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
⊢ { toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
[PROOFSTEP]
congr
[GOAL]
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
⊢ Limits.IsZero V
[PROOFSTEP]
refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
[GOAL]
case refine'_1
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : V ⟶ X
⊢ f = default
[PROOFSTEP]
ext x
[GOAL]
case refine'_1.h
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : V ⟶ X
x : ↑V
⊢ ↑f x = ↑default x
[PROOFSTEP]
have : x = 0 := Subsingleton.elim _ _
[GOAL]
case refine'_1.h
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : V ⟶ X
x : ↑V
this : x = 0
⊢ ↑f x = ↑default x
[PROOFSTEP]
simp only [this, map_zero]
[GOAL]
case refine'_2
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : X ⟶ V
⊢ f = default
[PROOFSTEP]
ext
[GOAL]
case refine'_2.h
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : X ⟶ V
x✝ : ↑X
⊢ ↑f x✝ = ↑default x✝
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
⊢ Isometry ↑i.hom
[PROOFSTEP]
apply AddMonoidHomClass.isometry_of_norm
[GOAL]
case a
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
⊢ ∀ (x : ↑V), ‖↑i.hom x‖ = ‖x‖
[PROOFSTEP]
intro v
[GOAL]
case a
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
v : ↑V
⊢ ‖↑i.hom v‖ = ‖v‖
[PROOFSTEP]
apply le_antisymm (h1 v)
[GOAL]
case a
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
v : ↑V
⊢ ‖v‖ ≤ ‖↑i.hom v‖
[PROOFSTEP]
calc
  ‖v‖ = ‖i.inv (i.hom v)‖ := by rw [Iso.hom_inv_id_apply]
  _ ≤ ‖i.hom v‖ := h2 _
[GOAL]
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
v : ↑V
⊢ ‖v‖ = ‖↑i.inv (↑i.hom v)‖
[PROOFSTEP]
rw [Iso.hom_inv_id_apply]
[GOAL]
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ mkHom f.hom i ≫ mkHom f.inv i' = 𝟙 (of ↑M)
[PROOFSTEP]
apply Subtype.eq
[GOAL]
case a
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ ↑(mkHom f.hom i ≫ mkHom f.inv i') = ↑(𝟙 (of ↑M))
[PROOFSTEP]
exact f.hom_inv_id
[GOAL]
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ mkHom f.inv i' ≫ mkHom f.hom i = 𝟙 (of ↑N)
[PROOFSTEP]
apply Subtype.eq
[GOAL]
case a
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ ↑(mkHom f.inv i' ≫ mkHom f.hom i) = ↑(𝟙 (of ↑N))
[PROOFSTEP]
exact f.inv_hom_id
[GOAL]
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
⊢ Limits.IsZero V
[PROOFSTEP]
refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
[GOAL]
case refine'_1
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : V ⟶ X
⊢ f = default
[PROOFSTEP]
ext x
[GOAL]
case refine'_1.w.h
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : V ⟶ X
x : ↑V
⊢ ↑f x = ↑default x
[PROOFSTEP]
have : x = 0 := Subsingleton.elim _ _
[GOAL]
case refine'_1.w.h
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : V ⟶ X
x : ↑V
this : x = 0
⊢ ↑f x = ↑default x
[PROOFSTEP]
simp only [this, map_zero]
[GOAL]
case refine'_2
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : X ⟶ V
⊢ f = default
[PROOFSTEP]
ext
[GOAL]
case refine'_2.w.h
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : X ⟶ V
x✝ : ↑X
⊢ ↑f x✝ = ↑default x✝
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
V W : SemiNormedGroupCat₁
i : V ≅ W
⊢ Isometry ↑i.hom
[PROOFSTEP]
change Isometry (⟨⟨i.hom, map_zero _⟩, fun _ _ => map_add _ _ _⟩ : V →+ W)
[GOAL]
V W : SemiNormedGroupCat₁
i : V ≅ W
⊢ Isometry
    ↑{ toZeroHom := { toFun := ↑i.hom, map_zero' := (_ : ↑i.hom 0 = 0) },
        map_add' := (_ : ∀ (x x_1 : ↑V), ↑i.hom (x + x_1) = ↑i.hom x + ↑i.hom x_1) }
[PROOFSTEP]
refine' AddMonoidHomClass.isometry_of_norm _ _
[GOAL]
V W : SemiNormedGroupCat₁
i : V ≅ W
⊢ ∀ (x : ↑V),
    ‖↑{ toZeroHom := { toFun := ↑i.hom, map_zero' := (_ : ↑i.hom 0 = 0) },
              map_add' := (_ : ∀ (x x_1 : ↑V), ↑i.hom (x + x_1) = ↑i.hom x + ↑i.hom x_1) }
          x‖ =
      ‖x‖
[PROOFSTEP]
intro v
[GOAL]
V W : SemiNormedGroupCat₁
i : V ≅ W
v : ↑V
⊢ ‖↑{ toZeroHom := { toFun := ↑i.hom, map_zero' := (_ : ↑i.hom 0 = 0) },
            map_add' := (_ : ∀ (x x_1 : ↑V), ↑i.hom (x + x_1) = ↑i.hom x + ↑i.hom x_1) }
        v‖ =
    ‖v‖
[PROOFSTEP]
apply le_antisymm (i.hom.2 v)
[GOAL]
V W : SemiNormedGroupCat₁
i : V ≅ W
v : ↑V
⊢ ‖v‖ ≤ ‖↑↑i.hom v‖
[PROOFSTEP]
calc
  ‖v‖ = ‖i.inv (i.hom v)‖ := by rw [Iso.hom_inv_id_apply]
  _ ≤ ‖i.hom v‖ := i.inv.2 _
[GOAL]
V W : SemiNormedGroupCat₁
i : V ≅ W
v : ↑V
⊢ ‖v‖ = ‖↑i.inv (↑i.hom v)‖
[PROOFSTEP]
rw [Iso.hom_inv_id_apply]