l3lab/ntp-mathlib huggingface dataset:
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
      

Proof state:
case refine'_3.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n₁ n₂ : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ •
      (MultilinearMap.domDomCongr σ
          (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₁) + MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₂)))
        x✝ =
    Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₁))) x✝ +
      Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₂))) x✝

Next tactic:
first | rw [← smul_add] | rw [smul_comm]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
      first | 

Proof state:
case refine'_3.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n₁ n₂ : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ •
      (MultilinearMap.domDomCongr σ
          (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₁) + MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₂)))
        x✝ =
    Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₁))) x✝ +
      Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₂))) x✝

Next tactic:
rw [← smul_add]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
      first | rw [← smul_add] | rw [smul_comm]
      

Proof state:
case refine'_3.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n₁ n₂ : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ •
      (MultilinearMap.domDomCongr σ
          (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₁) + MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₂)))
        x✝ =
    Perm.sign σ •
      ((MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₁))) x✝ +
        (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n₂))) x✝)

Next tactic:
rfl
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · 

Proof state:
case refine'_4
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
⊢ domCoprod m (c • n) = c • domCoprod m n

Next tactic:
ext
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      

Proof state:
case refine'_4.H
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
⊢ (domCoprod m (c • n)) x✝ = (c • domCoprod m n) x✝

Next tactic:
simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      

Proof state:
case refine'_4.H
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
⊢ ∑ a : Perm.ModSumCongr ιa ιb,
      (Quotient.liftOn' a (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n)))
          (_ :
            ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
              Setoid.r σ₁ σ₂ →
                (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₁ =
                  (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₂))
        x✝ =
    ∑ x : Perm.ModSumCongr ιa ιb,
      c •
        (Quotient.liftOn' x (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n))
            (_ :
              ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
                Setoid.r σ₁ σ₂ →
                  (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₁ =
                    (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₂))
          x✝

Next tactic:
congr
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      

Proof state:
case refine'_4.H.e_f
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
⊢ (fun a =>
      (Quotient.liftOn' a (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n)))
          (_ :
            ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
              Setoid.r σ₁ σ₂ →
                (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₁ =
                  (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₂))
        x✝) =
    fun x =>
    c •
      (Quotient.liftOn' x (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n))
          (_ :
            ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
              Setoid.r σ₁ σ₂ →
                (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₁ =
                  (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₂))
        x✝

Next tactic:
ext σ
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      

Proof state:
case refine'_4.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ : Perm.ModSumCongr ιa ιb
⊢ (Quotient.liftOn' σ (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n)))
        (_ :
          ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
            Setoid.r σ₁ σ₂ →
              (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₁ =
                (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₂))
      x✝ =
    c •
      (Quotient.liftOn' σ (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n))
          (_ :
            ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
              Setoid.r σ₁ σ₂ →
                (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₁ =
                  (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₂))
        x✝

Next tactic:
refine Quotient.inductionOn' σ fun σ => ?_
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      

Proof state:
case refine'_4.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ (Quotient.liftOn' (Quotient.mk'' σ)
        (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n)))
        (_ :
          ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
            Setoid.r σ₁ σ₂ →
              (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₁ =
                (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑(c • n))) σ₂))
      x✝ =
    c •
      (Quotient.liftOn' (Quotient.mk'' σ)
          (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n))
          (_ :
            ∀ (σ₁ σ₂ : Perm (ιa ⊕ ιb)),
              Setoid.r σ₁ σ₂ →
                (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₁ =
                  (fun σ => Perm.sign σ • MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod ↑m ↑n)) σ₂))
        x✝

Next tactic:
simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      

Proof state:
case refine'_4.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] (c • ↑n)))) x✝ =
    c • Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝

Next tactic:
simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
      

Proof state:
case refine'_4.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ • (MultilinearMap.domDomCongr σ (c • MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝ =
    c • Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝

Next tactic:
first | rw [← smul_add] | rw [smul_comm]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
      first | 

Proof state:
case refine'_4.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ • (MultilinearMap.domDomCongr σ (c • MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝ =
    c • Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝

Next tactic:
rw [← smul_add]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
      first | rw [← smul_add] | 

Proof state:
case refine'_4.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ • (MultilinearMap.domDomCongr σ (c • MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝ =
    c • Perm.sign σ • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝

Next tactic:
rw [smul_comm]
/-- A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. -/
def domCoprod' :
    (Mᵢ [Λ^ιa]→ₗ[R'] N₁) ⊗[R'] (Mᵢ [Λ^ιb]→ₗ[R'] N₂) →ₗ[R']
      (Mᵢ [Λ^ιa ⊕ ιb]→ₗ[R'] (N₁ ⊗[R'] N₂)) :=
  TensorProduct.lift <| by
    refine'
      LinearMap.mk₂ R' domCoprod (fun m₁ m₂ n => _) (fun c m n => _) (fun m n₁ n₂ => _)
        fun c m n => _ <;>
    · ext
      simp only [domCoprod_apply, add_apply, smul_apply, ← Finset.sum_add_distrib,
        Finset.smul_sum, MultilinearMap.sum_apply, domCoprod.summand]
      congr
      ext σ
      refine Quotient.inductionOn' σ fun σ => ?_
      simp only [Quotient.liftOn'_mk'', coe_add, coe_smul, MultilinearMap.smul_apply,
        ← MultilinearMap.domCoprod'_apply]
      simp only [TensorProduct.add_tmul, ← TensorProduct.smul_tmul', TensorProduct.tmul_add,
        TensorProduct.tmul_smul, LinearMap.map_add, LinearMap.map_smul]
      first | rw [← smul_add] | rw [smul_comm]
      

Proof state:
case refine'_4.H.e_f.h
ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
c : R'
m : Mᵢ [Λ^ιa]→ₗ[R'] N₁
n : Mᵢ [Λ^ιb]→ₗ[R'] N₂
x✝ : ιa ⊕ ιb → Mᵢ
σ✝ : Perm.ModSumCongr ιa ιb
σ : Perm (ιa ⊕ ιb)
⊢ Perm.sign σ • (MultilinearMap.domDomCongr σ (c • MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝ =
    Perm.sign σ • c • (MultilinearMap.domDomCongr σ (MultilinearMap.domCoprod' (↑m ⊗ₜ[R'] ↑n))) x✝

Next tactic:
rfl