l3lab/ntp-mathlib huggingface dataset:
/-- A continuous linear equivalence of codomains defines an equivalence between continuous
alternating maps. -/
def _root_.ContinuousLinearEquiv.compContinuousAlternatingMap (e : N ≃L[R] N') :
    M [Λ^ι]→L[R] N ≃ M [Λ^ι]→L[R] N' where
  toFun := (e : N →L[R] N').compContinuousAlternatingMap
  invFun := (e.symm : N' →L[R] N).compContinuousAlternatingMap
  left_inv f := by ext; simp [(· ∘ ·)]
  right_inv f := by 

Proof state:
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
inst✝⁹ : TopologicalSpace M
inst✝⁸ : AddCommMonoid M'
inst✝⁷ : Module R M'
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : AddCommMonoid N'
inst✝¹ : Module R N'
inst✝ : TopologicalSpace N'
n : ℕ
f✝ g : M[Λ^ι]→L[R]N
e : N ≃L[R] N'
f : M[Λ^ι]→L[R]N'
⊢ ContinuousLinearMap.compContinuousAlternatingMap (↑e)
      (ContinuousLinearMap.compContinuousAlternatingMap (↑(ContinuousLinearEquiv.symm e)) f) =
    f

Next tactic:
ext
/-- A continuous linear equivalence of codomains defines an equivalence between continuous
alternating maps. -/
def _root_.ContinuousLinearEquiv.compContinuousAlternatingMap (e : N ≃L[R] N') :
    M [Λ^ι]→L[R] N ≃ M [Λ^ι]→L[R] N' where
  toFun := (e : N →L[R] N').compContinuousAlternatingMap
  invFun := (e.symm : N' →L[R] N).compContinuousAlternatingMap
  left_inv f := by ext; simp [(· ∘ ·)]
  right_inv f := by ext; 

Proof state:
case H
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
inst✝⁹ : TopologicalSpace M
inst✝⁸ : AddCommMonoid M'
inst✝⁷ : Module R M'
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : AddCommMonoid N'
inst✝¹ : Module R N'
inst✝ : TopologicalSpace N'
n : ℕ
f✝ g : M[Λ^ι]→L[R]N
e : N ≃L[R] N'
f : M[Λ^ι]→L[R]N'
x✝ : ι → M
⊢ (ContinuousLinearMap.compContinuousAlternatingMap (↑e)
        (ContinuousLinearMap.compContinuousAlternatingMap (↑(ContinuousLinearEquiv.symm e)) f))
      x✝ =
    f x✝

Next tactic:
simp [(· ∘ ·)]
/-- `ContinuousAlternatingMap.pi` as an `Equiv`. -/
@[simps]
def piEquiv {ι' : Type*} {N : ι' → Type*} [∀ i, AddCommMonoid (N i)] [∀ i, TopologicalSpace (N i)]
    [∀ i, Module R (N i)] : (∀ i, M [Λ^ι]→L[R] N i) ≃ M [Λ^ι]→L[R] ∀ i, N i where
  toFun := pi
  invFun f i := (ContinuousLinearMap.proj i : _ →L[R] N i).compContinuousAlternatingMap f
  left_inv f := by 

Proof state:
R : Type u_1
M : Type u_2
M' : Type u_3
N✝ : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁵ : Semiring R
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
inst✝¹² : TopologicalSpace M
inst✝¹¹ : AddCommMonoid M'
inst✝¹⁰ : Module R M'
inst✝⁹ : TopologicalSpace M'
inst✝⁸ : AddCommMonoid N✝
inst✝⁷ : Module R N✝
inst✝⁶ : TopologicalSpace N✝
inst✝⁵ : AddCommMonoid N'
inst✝⁴ : Module R N'
inst✝³ : TopologicalSpace N'
n : ℕ
f✝ g : M[Λ^ι]→L[R]N✝
ι' : Type u_7
N : ι' → Type u_8
inst✝² : (i : ι') → AddCommMonoid (N i)
inst✝¹ : (i : ι') → TopologicalSpace (N i)
inst✝ : (i : ι') → Module R (N i)
f : (i : ι') → M[Λ^ι]→L[R]N i
⊢ (fun f i => ContinuousLinearMap.compContinuousAlternatingMap (ContinuousLinearMap.proj i) f) (pi f) = f

Next tactic:
ext
/-- `ContinuousAlternatingMap.pi` as an `Equiv`. -/
@[simps]
def piEquiv {ι' : Type*} {N : ι' → Type*} [∀ i, AddCommMonoid (N i)] [∀ i, TopologicalSpace (N i)]
    [∀ i, Module R (N i)] : (∀ i, M [Λ^ι]→L[R] N i) ≃ M [Λ^ι]→L[R] ∀ i, N i where
  toFun := pi
  invFun f i := (ContinuousLinearMap.proj i : _ →L[R] N i).compContinuousAlternatingMap f
  left_inv f := by ext; 

Proof state:
case h.H
R : Type u_1
M : Type u_2
M' : Type u_3
N✝ : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁵ : Semiring R
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
inst✝¹² : TopologicalSpace M
inst✝¹¹ : AddCommMonoid M'
inst✝¹⁰ : Module R M'
inst✝⁹ : TopologicalSpace M'
inst✝⁸ : AddCommMonoid N✝
inst✝⁷ : Module R N✝
inst✝⁶ : TopologicalSpace N✝
inst✝⁵ : AddCommMonoid N'
inst✝⁴ : Module R N'
inst✝³ : TopologicalSpace N'
n : ℕ
f✝ g : M[Λ^ι]→L[R]N✝
ι' : Type u_7
N : ι' → Type u_8
inst✝² : (i : ι') → AddCommMonoid (N i)
inst✝¹ : (i : ι') → TopologicalSpace (N i)
inst✝ : (i : ι') → Module R (N i)
f : (i : ι') → M[Λ^ι]→L[R]N i
x✝¹ : ι'
x✝ : ι → M
⊢ ((fun f i => ContinuousLinearMap.compContinuousAlternatingMap (ContinuousLinearMap.proj i) f) (pi f) x✝¹) x✝ =
    (f x✝¹) x✝

Next tactic:
rfl
/-- `ContinuousAlternatingMap.pi` as an `Equiv`. -/
@[simps]
def piEquiv {ι' : Type*} {N : ι' → Type*} [∀ i, AddCommMonoid (N i)] [∀ i, TopologicalSpace (N i)]
    [∀ i, Module R (N i)] : (∀ i, M [Λ^ι]→L[R] N i) ≃ M [Λ^ι]→L[R] ∀ i, N i where
  toFun := pi
  invFun f i := (ContinuousLinearMap.proj i : _ →L[R] N i).compContinuousAlternatingMap f
  left_inv f := by ext; rfl
  right_inv f := by 

Proof state:
R : Type u_1
M : Type u_2
M' : Type u_3
N✝ : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁵ : Semiring R
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
inst✝¹² : TopologicalSpace M
inst✝¹¹ : AddCommMonoid M'
inst✝¹⁰ : Module R M'
inst✝⁹ : TopologicalSpace M'
inst✝⁸ : AddCommMonoid N✝
inst✝⁷ : Module R N✝
inst✝⁶ : TopologicalSpace N✝
inst✝⁵ : AddCommMonoid N'
inst✝⁴ : Module R N'
inst✝³ : TopologicalSpace N'
n : ℕ
f✝ g : M[Λ^ι]→L[R]N✝
ι' : Type u_7
N : ι' → Type u_8
inst✝² : (i : ι') → AddCommMonoid (N i)
inst✝¹ : (i : ι') → TopologicalSpace (N i)
inst✝ : (i : ι') → Module R (N i)
f : M[Λ^ι]→L[R]((i : ι') → N i)
⊢ pi ((fun f i => ContinuousLinearMap.compContinuousAlternatingMap (ContinuousLinearMap.proj i) f) f) = f

Next tactic:
ext
/-- `ContinuousAlternatingMap.pi` as an `Equiv`. -/
@[simps]
def piEquiv {ι' : Type*} {N : ι' → Type*} [∀ i, AddCommMonoid (N i)] [∀ i, TopologicalSpace (N i)]
    [∀ i, Module R (N i)] : (∀ i, M [Λ^ι]→L[R] N i) ≃ M [Λ^ι]→L[R] ∀ i, N i where
  toFun := pi
  invFun f i := (ContinuousLinearMap.proj i : _ →L[R] N i).compContinuousAlternatingMap f
  left_inv f := by ext; rfl
  right_inv f := by ext; 

Proof state:
case H.h
R : Type u_1
M : Type u_2
M' : Type u_3
N✝ : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁵ : Semiring R
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
inst✝¹² : TopologicalSpace M
inst✝¹¹ : AddCommMonoid M'
inst✝¹⁰ : Module R M'
inst✝⁹ : TopologicalSpace M'
inst✝⁸ : AddCommMonoid N✝
inst✝⁷ : Module R N✝
inst✝⁶ : TopologicalSpace N✝
inst✝⁵ : AddCommMonoid N'
inst✝⁴ : Module R N'
inst✝³ : TopologicalSpace N'
n : ℕ
f✝ g : M[Λ^ι]→L[R]N✝
ι' : Type u_7
N : ι' → Type u_8
inst✝² : (i : ι') → AddCommMonoid (N i)
inst✝¹ : (i : ι') → TopologicalSpace (N i)
inst✝ : (i : ι') → Module R (N i)
f : M[Λ^ι]→L[R]((i : ι') → N i)
x✝¹ : ι → M
x✝ : ι'
⊢ (pi ((fun f i => ContinuousLinearMap.compContinuousAlternatingMap (ContinuousLinearMap.proj i) f) f)) x✝¹ x✝ =
    f x✝¹ x✝

Next tactic:
rfl
/-- `ContinuousAlternatingMap.compContinuousLinearMap` as a bundled `LinearMap`. -/
@[simps]
def compContinuousLinearMapₗ (f : M →L[R] M') : (M' [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N) where
  toFun g := g.compContinuousLinearMap f
  map_add' g g' := by 

Proof state:
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
f : M →L[R] M'
g g' : M'[Λ^ι]→L[R]N
⊢ (fun g => compContinuousLinearMap g f) (g + g') =
    (fun g => compContinuousLinearMap g f) g + (fun g => compContinuousLinearMap g f) g'

Next tactic:
ext
/-- `ContinuousAlternatingMap.compContinuousLinearMap` as a bundled `LinearMap`. -/
@[simps]
def compContinuousLinearMapₗ (f : M →L[R] M') : (M' [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N) where
  toFun g := g.compContinuousLinearMap f
  map_add' g g' := by ext; 

Proof state:
case H
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
f : M →L[R] M'
g g' : M'[Λ^ι]→L[R]N
x✝ : ι → M
⊢ ((fun g => compContinuousLinearMap g f) (g + g')) x✝ =
    ((fun g => compContinuousLinearMap g f) g + (fun g => compContinuousLinearMap g f) g') x✝

Next tactic:
simp
/-- `ContinuousAlternatingMap.compContinuousLinearMap` as a bundled `LinearMap`. -/
@[simps]
def compContinuousLinearMapₗ (f : M →L[R] M') : (M' [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N) where
  toFun g := g.compContinuousLinearMap f
  map_add' g g' := by ext; simp
  map_smul' c g := by 

Proof state:
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
f : M →L[R] M'
c : R
g : M'[Λ^ι]→L[R]N
⊢ AddHom.toFun
      { toFun := fun g => compContinuousLinearMap g f,
        map_add' :=
          (_ :
            ∀ (g g' : M'[Λ^ι]→L[R]N),
              (fun g => compContinuousLinearMap g f) (g + g') =
                (fun g => compContinuousLinearMap g f) g + (fun g => compContinuousLinearMap g f) g') }
      (c • g) =
    (RingHom.id R) c •
      AddHom.toFun
        { toFun := fun g => compContinuousLinearMap g f,
          map_add' :=
            (_ :
              ∀ (g g' : M'[Λ^ι]→L[R]N),
                (fun g => compContinuousLinearMap g f) (g + g') =
                  (fun g => compContinuousLinearMap g f) g + (fun g => compContinuousLinearMap g f) g') }
        g

Next tactic:
ext
/-- `ContinuousAlternatingMap.compContinuousLinearMap` as a bundled `LinearMap`. -/
@[simps]
def compContinuousLinearMapₗ (f : M →L[R] M') : (M' [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N) where
  toFun g := g.compContinuousLinearMap f
  map_add' g g' := by ext; simp
  map_smul' c g := by ext; 

Proof state:
case H
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
f : M →L[R] M'
c : R
g : M'[Λ^ι]→L[R]N
x✝ : ι → M
⊢ (AddHom.toFun
        { toFun := fun g => compContinuousLinearMap g f,
          map_add' :=
            (_ :
              ∀ (g g' : M'[Λ^ι]→L[R]N),
                (fun g => compContinuousLinearMap g f) (g + g') =
                  (fun g => compContinuousLinearMap g f) g + (fun g => compContinuousLinearMap g f) g') }
        (c • g))
      x✝ =
    ((RingHom.id R) c •
        AddHom.toFun
          { toFun := fun g => compContinuousLinearMap g f,
            map_add' :=
              (_ :
                ∀ (g g' : M'[Λ^ι]→L[R]N),
                  (fun g => compContinuousLinearMap g f) (g + g') =
                    (fun g => compContinuousLinearMap g f) g + (fun g => compContinuousLinearMap g f) g') }
          g)
      x✝

Next tactic:
simp
/-- `ContinuousLinearMap.compContinuousAlternatingMap` as a bundled bilinear map. -/
def _root_.ContinuousLinearMap.compContinuousAlternatingMapₗ :
    (N →L[R] N') →ₗ[R] (M [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N') :=
  LinearMap.mk₂ R ContinuousLinearMap.compContinuousAlternatingMap (fun f₁ f₂ g => rfl)
    (fun c f g => rfl) (fun f g₁ g₂ => by 

Proof state:
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
f : N →L[R] N'
g₁ g₂ : M[Λ^ι]→L[R]N
⊢ ContinuousLinearMap.compContinuousAlternatingMap f (g₁ + g₂) =
    ContinuousLinearMap.compContinuousAlternatingMap f g₁ + ContinuousLinearMap.compContinuousAlternatingMap f g₂

Next tactic:
ext1
/-- `ContinuousLinearMap.compContinuousAlternatingMap` as a bundled bilinear map. -/
def _root_.ContinuousLinearMap.compContinuousAlternatingMapₗ :
    (N →L[R] N') →ₗ[R] (M [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N') :=
  LinearMap.mk₂ R ContinuousLinearMap.compContinuousAlternatingMap (fun f₁ f₂ g => rfl)
    (fun c f g => rfl) (fun f g₁ g₂ => by ext1; 

Proof state:
case H
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
f : N →L[R] N'
g₁ g₂ : M[Λ^ι]→L[R]N
x✝ : ι → M
⊢ (ContinuousLinearMap.compContinuousAlternatingMap f (g₁ + g₂)) x✝ =
    (ContinuousLinearMap.compContinuousAlternatingMap f g₁ + ContinuousLinearMap.compContinuousAlternatingMap f g₂) x✝

Next tactic:
apply f.map_add
/-- `ContinuousLinearMap.compContinuousAlternatingMap` as a bundled bilinear map. -/
def _root_.ContinuousLinearMap.compContinuousAlternatingMapₗ :
    (N →L[R] N') →ₗ[R] (M [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N') :=
  LinearMap.mk₂ R ContinuousLinearMap.compContinuousAlternatingMap (fun f₁ f₂ g => rfl)
    (fun c f g => rfl) (fun f g₁ g₂ => by ext1; apply f.map_add) fun c f g => by 

Proof state:
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
c : R
f : N →L[R] N'
g : M[Λ^ι]→L[R]N
⊢ ContinuousLinearMap.compContinuousAlternatingMap f (c • g) = c • ContinuousLinearMap.compContinuousAlternatingMap f g

Next tactic:
ext1
/-- `ContinuousLinearMap.compContinuousAlternatingMap` as a bundled bilinear map. -/
def _root_.ContinuousLinearMap.compContinuousAlternatingMapₗ :
    (N →L[R] N') →ₗ[R] (M [Λ^ι]→L[R] N) →ₗ[R] (M [Λ^ι]→L[R] N') :=
  LinearMap.mk₂ R ContinuousLinearMap.compContinuousAlternatingMap (fun f₁ f₂ g => rfl)
    (fun c f g => rfl) (fun f g₁ g₂ => by ext1; apply f.map_add) fun c f g => by ext1; 

Proof state:
case H
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
ι : Type u_6
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommMonoid M'
inst✝¹¹ : Module R M'
inst✝¹⁰ : TopologicalSpace M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
inst✝⁷ : TopologicalSpace N
inst✝⁶ : ContinuousAdd N
inst✝⁵ : ContinuousConstSMul R N
inst✝⁴ : AddCommMonoid N'
inst✝³ : Module R N'
inst✝² : TopologicalSpace N'
inst✝¹ : ContinuousAdd N'
inst✝ : ContinuousConstSMul R N'
c : R
f : N →L[R] N'
g : M[Λ^ι]→L[R]N
x✝ : ι → M
⊢ (ContinuousLinearMap.compContinuousAlternatingMap f (c • g)) x✝ =
    (c • ContinuousLinearMap.compContinuousAlternatingMap f g) x✝

Next tactic:
simp
/-- Alternatization of a continuous multilinear map. -/
@[simps (config := .lemmasOnly) apply_toContinuousMultilinearMap]
def alternatization : ContinuousMultilinearMap R (fun _ : ι => M) N →+ M [Λ^ι]→L[R] N where
  toFun f :=
    { toContinuousMultilinearMap := ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f.domDomCongr σ
      map_eq_zero_of_eq' := fun v i j hv hne => by
        

Proof state:
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : TopologicalSpace M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : TopologicalAddGroup N
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f✝ g f : ContinuousMultilinearMap R (fun x => M) N
v : ι → M
i j : ι
hv : v i = v j
hne : i ≠ j
⊢ MultilinearMap.toFun (∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • domDomCongr σ f).toMultilinearMap v = 0

Next tactic:
simpa [MultilinearMap.alternatization_apply]
          using f.1.alternatization.map_eq_zero_of_eq' v i j hv hne
/-- Alternatization of a continuous multilinear map. -/
@[simps (config := .lemmasOnly) apply_toContinuousMultilinearMap]
def alternatization : ContinuousMultilinearMap R (fun _ : ι => M) N →+ M [Λ^ι]→L[R] N where
  toFun f :=
    { toContinuousMultilinearMap := ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f.domDomCongr σ
      map_eq_zero_of_eq' := fun v i j hv hne => by
        simpa [MultilinearMap.alternatization_apply]
          using f.1.alternatization.map_eq_zero_of_eq' v i j hv hne }
  map_zero' := by 

Proof state:
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : TopologicalSpace M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : TopologicalAddGroup N
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f g : ContinuousMultilinearMap R (fun x => M) N
⊢ (fun f =>
        { toContinuousMultilinearMap := ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • domDomCongr σ f,
          map_eq_zero_of_eq' :=
            (_ :
              ∀ (v : ι → M) (i j : ι),
                v i = v j →
                  i ≠ j →
                    MultilinearMap.toFun (∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • domDomCongr σ f).toMultilinearMap v =
                      0) })
      0 =
    0

Next tactic:
ext
/-- Alternatization of a continuous multilinear map. -/
@[simps (config := .lemmasOnly) apply_toContinuousMultilinearMap]
def alternatization : ContinuousMultilinearMap R (fun _ : ι => M) N →+ M [Λ^ι]→L[R] N where
  toFun f :=
    { toContinuousMultilinearMap := ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f.domDomCongr σ
      map_eq_zero_of_eq' := fun v i j hv hne => by
        simpa [MultilinearMap.alternatization_apply]
          using f.1.alternatization.map_eq_zero_of_eq' v i j hv hne }
  map_zero' := by ext; 

Proof state:
case H
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : TopologicalSpace M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : TopologicalAddGroup N
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f g : ContinuousMultilinearMap R (fun x => M) N
x✝ : ι → M
⊢ ((fun f =>
          { toContinuousMultilinearMap := ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • domDomCongr σ f,
            map_eq_zero_of_eq' :=
              (_ :
                ∀ (v : ι → M) (i j : ι),
                  v i = v j →
                    i ≠ j →
                      MultilinearMap.toFun (∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • domDomCongr σ f).toMultilinearMap
                          v =
                        0) })
        0)
      x✝ =
    0 x✝

Next tactic:
simp
theorem alternatization_apply_apply (v : ι → M) :
    alternatization f v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f (v ∘ σ) := by
  

Proof state:
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : TopologicalSpace M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : TopologicalAddGroup N
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f g : ContinuousMultilinearMap R (fun x => M) N
v : ι → M
⊢ (alternatization f) v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f (v ∘ ⇑σ)

Next tactic:
simp [alternatization, (· ∘ ·)]
@[simp]
theorem alternatization_apply_toAlternatingMap :
    (alternatization f).toAlternatingMap = MultilinearMap.alternatization f.1 := by
  

Proof state:
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : TopologicalSpace M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : TopologicalAddGroup N
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f g : ContinuousMultilinearMap R (fun x => M) N
⊢ ContinuousAlternatingMap.toAlternatingMap (alternatization f) = MultilinearMap.alternatization f.toMultilinearMap

Next tactic:
ext v
@[simp]
theorem alternatization_apply_toAlternatingMap :
    (alternatization f).toAlternatingMap = MultilinearMap.alternatization f.1 := by
  ext v
  

Proof state:
case H
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : TopologicalSpace M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : TopologicalSpace N
inst✝² : TopologicalAddGroup N
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f g : ContinuousMultilinearMap R (fun x => M) N
v : ι → M
⊢ (ContinuousAlternatingMap.toAlternatingMap (alternatization f)) v =
    (MultilinearMap.alternatization f.toMultilinearMap) v

Next tactic:
simp [alternatization_apply_apply, MultilinearMap.alternatization_apply, (· ∘ ·)]
/-- Split coequalizers are absolute: they are preserved by any functor. -/
@[simps]
def IsSplitCoequalizer.map {Z : C} {π : Y ⟶ Z} (q : IsSplitCoequalizer f g π) (F : C ⥤ D) :
    IsSplitCoequalizer (F.map f) (F.map g) (F.map π)
    where
  rightSection := F.map q.rightSection
  leftSection := F.map q.leftSection
  condition := by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
Z : C
π : Y ⟶ Z
q : IsSplitCoequalizer f g π
F : C ⥤ D
⊢ F.map f ≫ F.map π = F.map g ≫ F.map π

Next tactic:
rw [← F.map_comp, q.condition, F.map_comp]
/-- Split coequalizers are absolute: they are preserved by any functor. -/
@[simps]
def IsSplitCoequalizer.map {Z : C} {π : Y ⟶ Z} (q : IsSplitCoequalizer f g π) (F : C ⥤ D) :
    IsSplitCoequalizer (F.map f) (F.map g) (F.map π)
    where
  rightSection := F.map q.rightSection
  leftSection := F.map q.leftSection
  condition := by rw [← F.map_comp, q.condition, F.map_comp]
  rightSection_π := by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
Z : C
π : Y ⟶ Z
q : IsSplitCoequalizer f g π
F : C ⥤ D
⊢ F.map q.rightSection ≫ F.map π = 𝟙 (F.obj Z)

Next tactic:
rw [← F.map_comp, q.rightSection_π, F.map_id]
/-- Split coequalizers are absolute: they are preserved by any functor. -/
@[simps]
def IsSplitCoequalizer.map {Z : C} {π : Y ⟶ Z} (q : IsSplitCoequalizer f g π) (F : C ⥤ D) :
    IsSplitCoequalizer (F.map f) (F.map g) (F.map π)
    where
  rightSection := F.map q.rightSection
  leftSection := F.map q.leftSection
  condition := by rw [← F.map_comp, q.condition, F.map_comp]
  rightSection_π := by rw [← F.map_comp, q.rightSection_π, F.map_id]
  leftSection_bottom := by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
Z : C
π : Y ⟶ Z
q : IsSplitCoequalizer f g π
F : C ⥤ D
⊢ F.map q.leftSection ≫ F.map g = 𝟙 (F.obj Y)

Next tactic:
rw [← F.map_comp, q.leftSection_bottom, F.map_id]