l3lab/ntp-mathlib huggingface dataset:
/-- The addition on `EReal` is continuous except where it doesn't make sense (i.e., at `(⊥, ⊤)`
and at `(⊤, ⊥)`). -/
theorem continuousAt_add {p : EReal × EReal} (h : p.1 ≠ ⊤ ∨ p.2 ≠ ⊥) (h' : p.1 ≠ ⊥ ∨ p.2 ≠ ⊤) :
    ContinuousAt (fun p : EReal × EReal => p.1 + p.2) p := by
  rcases p with ⟨x, y⟩
  induction x using EReal.rec <;> induction y using EReal.rec
  · exact continuousAt_add_bot_bot
  · exact continuousAt_add_bot_coe _
  · simp at h'
  · exact continuousAt_add_coe_bot _
  · exact continuousAt_add_coe_coe _ _
  · exact continuousAt_add_coe_top _
  · simp at h
  · 

Proof state:
case mk.h_top.h_real
α : Type u_1
inst✝ : TopologicalSpace α
a✝ : ℝ
h : (⊤, ↑a✝).1 ≠ ⊤ ∨ (⊤, ↑a✝).2 ≠ ⊥
h' : (⊤, ↑a✝).1 ≠ ⊥ ∨ (⊤, ↑a✝).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊤, ↑a✝)

Next tactic:
exact continuousAt_add_top_coe _
/-- The addition on `EReal` is continuous except where it doesn't make sense (i.e., at `(⊥, ⊤)`
and at `(⊤, ⊥)`). -/
theorem continuousAt_add {p : EReal × EReal} (h : p.1 ≠ ⊤ ∨ p.2 ≠ ⊥) (h' : p.1 ≠ ⊥ ∨ p.2 ≠ ⊤) :
    ContinuousAt (fun p : EReal × EReal => p.1 + p.2) p := by
  rcases p with ⟨x, y⟩
  induction x using EReal.rec <;> induction y using EReal.rec
  · exact continuousAt_add_bot_bot
  · exact continuousAt_add_bot_coe _
  · simp at h'
  · exact continuousAt_add_coe_bot _
  · exact continuousAt_add_coe_coe _ _
  · exact continuousAt_add_coe_top _
  · simp at h
  · exact continuousAt_add_top_coe _
  · 

Proof state:
case mk.h_top.h_top
α : Type u_1
inst✝ : TopologicalSpace α
h : (⊤, ⊤).1 ≠ ⊤ ∨ (⊤, ⊤).2 ≠ ⊥
h' : (⊤, ⊤).1 ≠ ⊥ ∨ (⊤, ⊤).2 ≠ ⊤
⊢ ContinuousAt (fun p => p.1 + p.2) (⊤, ⊤)

Next tactic:
exact continuousAt_add_top_top
instance funLike : FunLike (M [Λ^ι]→ₗ[R] N) (ι → M) (fun _ => N) where
  coe f := f.toFun
  coe_injective' := fun f g h ↦ by
    

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f✝ f' : M [Λ^ι]→ₗ[R] N
g✝ g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v : ι → M
v' : ι → M'
f g : M [Λ^ι]→ₗ[R] N
h : (fun f => f.toFun) f = (fun f => f.toFun) g
⊢ f = g

Next tactic:
rcases f with ⟨⟨_, _, _⟩, _⟩
instance funLike : FunLike (M [Λ^ι]→ₗ[R] N) (ι → M) (fun _ => N) where
  coe f := f.toFun
  coe_injective' := fun f g h ↦ by
    rcases f with ⟨⟨_, _, _⟩, _⟩
    

Proof state:
case mk.mk
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g✝ g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v : ι → M
v' : ι → M'
g : M [Λ^ι]→ₗ[R] N
toFun✝ : (ι → M) → N
map_add'✝ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
    toFun✝ (update m i (x + y)) = toFun✝ (update m i x) + toFun✝ (update m i y)
map_smul'✝ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M), toFun✝ (update m i (c • x)) = c • toFun✝ (update m i x)
map_eq_zero_of_eq'✝ :
  ∀ (v : ι → M) (i j : ι),
    v i = v j → i ≠ j → MultilinearMap.toFun { toFun := toFun✝, map_add' := map_add'✝, map_smul' := map_smul'✝ } v = 0
h :
  (fun f => f.toFun)
      { toMultilinearMap := { toFun := toFun✝, map_add' := map_add'✝, map_smul' := map_smul'✝ },
        map_eq_zero_of_eq' := map_eq_zero_of_eq'✝ } =
    (fun f => f.toFun) g
⊢ { toMultilinearMap := { toFun := toFun✝, map_add' := map_add'✝, map_smul' := map_smul'✝ },
      map_eq_zero_of_eq' := map_eq_zero_of_eq'✝ } =
    g

Next tactic:
rcases g with ⟨⟨_, _, _⟩, _⟩
instance funLike : FunLike (M [Λ^ι]→ₗ[R] N) (ι → M) (fun _ => N) where
  coe f := f.toFun
  coe_injective' := fun f g h ↦ by
    rcases f with ⟨⟨_, _, _⟩, _⟩
    rcases g with ⟨⟨_, _, _⟩, _⟩
    

Proof state:
case mk.mk.mk.mk
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v : ι → M
v' : ι → M'
toFun✝¹ : (ι → M) → N
map_add'✝¹ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
    toFun✝¹ (update m i (x + y)) = toFun✝¹ (update m i x) + toFun✝¹ (update m i y)
map_smul'✝¹ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
    toFun✝¹ (update m i (c • x)) = c • toFun✝¹ (update m i x)
map_eq_zero_of_eq'✝¹ :
  ∀ (v : ι → M) (i j : ι),
    v i = v j →
      i ≠ j → MultilinearMap.toFun { toFun := toFun✝¹, map_add' := map_add'✝¹, map_smul' := map_smul'✝¹ } v = 0
toFun✝ : (ι → M) → N
map_add'✝ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
    toFun✝ (update m i (x + y)) = toFun✝ (update m i x) + toFun✝ (update m i y)
map_smul'✝ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M), toFun✝ (update m i (c • x)) = c • toFun✝ (update m i x)
map_eq_zero_of_eq'✝ :
  ∀ (v : ι → M) (i j : ι),
    v i = v j → i ≠ j → MultilinearMap.toFun { toFun := toFun✝, map_add' := map_add'✝, map_smul' := map_smul'✝ } v = 0
h :
  (fun f => f.toFun)
      { toMultilinearMap := { toFun := toFun✝¹, map_add' := map_add'✝¹, map_smul' := map_smul'✝¹ },
        map_eq_zero_of_eq' := map_eq_zero_of_eq'✝¹ } =
    (fun f => f.toFun)
      { toMultilinearMap := { toFun := toFun✝, map_add' := map_add'✝, map_smul' := map_smul'✝ },
        map_eq_zero_of_eq' := map_eq_zero_of_eq'✝ }
⊢ { toMultilinearMap := { toFun := toFun✝¹, map_add' := map_add'✝¹, map_smul' := map_smul'✝¹ },
      map_eq_zero_of_eq' := map_eq_zero_of_eq'✝¹ } =
    { toMultilinearMap := { toFun := toFun✝, map_add' := map_add'✝, map_smul' := map_smul'✝ },
      map_eq_zero_of_eq' := map_eq_zero_of_eq'✝ }

Next tactic:
congr
theorem coe_multilinearMap_mk (f : (ι → M) → N) (h₁ h₂ h₃) :
    ((⟨⟨f, h₁, h₂⟩, h₃⟩ : M [Λ^ι]→ₗ[R] N) : MultilinearMap R (fun _ : ι => M) N) =
      ⟨f, @h₁, @h₂⟩ :=
  by 

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f✝ f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v : ι → M
v' : ι → M'
f : (ι → M) → N
h₁ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M), f (update m i (x + y)) = f (update m i x) + f (update m i y)
h₂ : ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M), f (update m i (c • x)) = c • f (update m i x)
h₃ :
  ∀ (v : ι → M) (i j : ι),
    v i = v j →
      i ≠ j →
        MultilinearMap.toFun
            { toFun := f,
              map_add' :=
                (_ :
                  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                    f (update m i (x + y)) = f (update m i x) + f (update m i y)),
              map_smul' :=
                (_ :
                  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                    f (update m i (c • x)) = c • f (update m i x)) }
            v =
          0
⊢ ↑{
        toMultilinearMap :=
          { toFun := f,
            map_add' :=
              (_ :
                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                  f (update m i (x + y)) = f (update m i x) + f (update m i y)),
            map_smul' :=
              (_ :
                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                  f (update m i (c • x)) = c • f (update m i x)) },
        map_eq_zero_of_eq' := h₃ } =
    { toFun := f, map_add' := h₁, map_smul' := h₂ }

Next tactic:
simp
theorem map_eq_zero_of_not_injective (v : ι → M) (hv : ¬Function.Injective v) : f v = 0 := by
  

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
v : ι → M
hv : ¬Injective v
⊢ f v = 0

Next tactic:
rw [Function.Injective] at hv
theorem map_eq_zero_of_not_injective (v : ι → M) (hv : ¬Function.Injective v) : f v = 0 := by
  rw [Function.Injective] at hv
  

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
v : ι → M
hv : ¬∀ ⦃a₁ a₂ : ι⦄, v a₁ = v a₂ → a₁ = a₂
⊢ f v = 0

Next tactic:
push_neg at hv
theorem map_eq_zero_of_not_injective (v : ι → M) (hv : ¬Function.Injective v) : f v = 0 := by
  rw [Function.Injective] at hv
  push_neg at hv
  

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
v : ι → M
hv : ∃ a₁ a₂, v a₁ = v a₂ ∧ a₁ ≠ a₂
⊢ f v = 0

Next tactic:
rcases hv with ⟨i₁, i₂, heq, hne⟩
theorem map_eq_zero_of_not_injective (v : ι → M) (hv : ¬Function.Injective v) : f v = 0 := by
  rw [Function.Injective] at hv
  push_neg at hv
  rcases hv with ⟨i₁, i₂, heq, hne⟩
  

Proof state:
case intro.intro.intro
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
v : ι → M
i₁ i₂ : ι
heq : v i₁ = v i₂
hne : i₁ ≠ i₂
⊢ f v = 0

Next tactic:
exact f.map_eq_zero_of_eq v heq hne
instance smul : SMul S (M [Λ^ι]→ₗ[R] N) :=
  ⟨fun c f =>
    { c • (f : MultilinearMap R (fun _ : ι => M) N) with
      map_eq_zero_of_eq' := fun v i j h hij => by 

Proof state:
R : Type u_1
inst✝¹³ : Semiring R
M : Type u_2
inst✝¹² : AddCommMonoid M
inst✝¹¹ : Module R M
N : Type u_3
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : Module R N
P : Type u_4
inst✝⁸ : AddCommMonoid P
inst✝⁷ : Module R P
M' : Type u_5
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M'
N' : Type u_6
inst✝⁴ : AddCommGroup N'
inst✝³ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f✝ f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
S : Type u_10
inst✝² : Monoid S
inst✝¹ : DistribMulAction S N
inst✝ : SMulCommClass R S N
c : S
f : M [Λ^ι]→ₗ[R] N
src✝ : MultilinearMap R (fun x => M) N := c • ↑f
v : ι → M
i j : ι
h : v i = v j
hij : i ≠ j
⊢ MultilinearMap.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
              MultilinearMap.toFun src✝ (update m i (x + y)) =
                MultilinearMap.toFun src✝ (update m i x) + MultilinearMap.toFun src✝ (update m i y)),
        map_smul' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
              MultilinearMap.toFun src✝ (update m i (c • x)) = c • MultilinearMap.toFun src✝ (update m i x)) }
      v =
    0

Next tactic:
simp [f.map_eq_zero_of_eq v h hij]
/-- Given an alternating `R`-multilinear map `f` taking values in `R`, `f.smul_right z` is the map
sending `m` to `f m • z`. -/
@[simps!]
def smulRight {R M₁ M₂ ι : Type*} [CommSemiring R] [AddCommMonoid M₁] [AddCommMonoid M₂]
    [Module R M₁] [Module R M₂] (f : M₁ [Λ^ι]→ₗ[R] R) (z : M₂) : M₁ [Λ^ι]→ₗ[R] M₂ :=
  { f.toMultilinearMap.smulRight z with
    map_eq_zero_of_eq' := fun v i j h hne => by 

Proof state:
R✝ : Type u_1
inst✝¹⁵ : Semiring R✝
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R✝ M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R✝ N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R✝ P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R✝ M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R✝ N'
ι✝ : Type u_7
ι' : Type u_8
ι'' : Type u_9
f✝ f' : M [Λ^ι✝]→ₗ[R✝] N
g g₂ : M [Λ^ι✝]→ₗ[R✝] N'
g' : M' [Λ^ι✝]→ₗ[R✝] N'
v✝ : ι✝ → M
v' : ι✝ → M'
R : Type u_10
M₁ : Type u_11
M₂ : Type u_12
ι : Type u_13
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
f : M₁ [Λ^ι]→ₗ[R] R
z : M₂
src✝ : MultilinearMap R (fun x => M₁) M₂ := MultilinearMap.smulRight (↑f) z
v : ι → M₁
i j : ι
h : v i = v j
hne : i ≠ j
⊢ MultilinearMap.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M₁) (i : ι) (x y : M₁),
              MultilinearMap.toFun src✝ (update m i (x + y)) =
                MultilinearMap.toFun src✝ (update m i x) + MultilinearMap.toFun src✝ (update m i y)),
        map_smul' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M₁) (i : ι) (c : R) (x : M₁),
              MultilinearMap.toFun src✝ (update m i (c • x)) = c • MultilinearMap.toFun src✝ (update m i x)) }
      v =
    0

Next tactic:
simp [f.map_eq_zero_of_eq v h hne]
instance add : Add (M [Λ^ι]→ₗ[R] N) :=
  ⟨fun a b =>
    { (a + b : MultilinearMap R (fun _ : ι => M) N) with
      map_eq_zero_of_eq' := fun v i j h hij => by
        

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
a b : M [Λ^ι]→ₗ[R] N
src✝ : MultilinearMap R (fun x => M) N := ↑a + ↑b
v : ι → M
i j : ι
h : v i = v j
hij : i ≠ j
⊢ MultilinearMap.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
              MultilinearMap.toFun src✝ (update m i (x + y)) =
                MultilinearMap.toFun src✝ (update m i x) + MultilinearMap.toFun src✝ (update m i y)),
        map_smul' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
              MultilinearMap.toFun src✝ (update m i (c • x)) = c • MultilinearMap.toFun src✝ (update m i x)) }
      v =
    0

Next tactic:
simp [a.map_eq_zero_of_eq v h hij, b.map_eq_zero_of_eq v h hij]
instance zero : Zero (M [Λ^ι]→ₗ[R] N) :=
  ⟨{ (0 : MultilinearMap R (fun _ : ι => M) N) with
      map_eq_zero_of_eq' := fun v i j _ _ => by 

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
src✝ : MultilinearMap R (fun x => M) N := 0
v : ι → M
i j : ι
x✝¹ : v i = v j
x✝ : i ≠ j
⊢ MultilinearMap.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
              MultilinearMap.toFun src✝ (update m i (x + y)) =
                MultilinearMap.toFun src✝ (update m i x) + MultilinearMap.toFun src✝ (update m i y)),
        map_smul' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
              MultilinearMap.toFun src✝ (update m i (c • x)) = c • MultilinearMap.toFun src✝ (update m i x)) }
      v =
    0

Next tactic:
simp
instance neg : Neg (M [Λ^ι]→ₗ[R] N') :=
  ⟨fun f =>
    { -(f : MultilinearMap R (fun _ : ι => M) N') with
      map_eq_zero_of_eq' := fun v i j h hij => by 

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f✝ f' : M [Λ^ι]→ₗ[R] N
g g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
f : M [Λ^ι]→ₗ[R] N'
src✝ : MultilinearMap R (fun x => M) N' := -↑f
v : ι → M
i j : ι
h : v i = v j
hij : i ≠ j
⊢ MultilinearMap.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
              MultilinearMap.toFun src✝ (update m i (x + y)) =
                MultilinearMap.toFun src✝ (update m i x) + MultilinearMap.toFun src✝ (update m i y)),
        map_smul' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
              MultilinearMap.toFun src✝ (update m i (c • x)) = c • MultilinearMap.toFun src✝ (update m i x)) }
      v =
    0

Next tactic:
simp [f.map_eq_zero_of_eq v h hij]
instance sub : Sub (M [Λ^ι]→ₗ[R] N') :=
  ⟨fun f g =>
    { (f - g : MultilinearMap R (fun _ : ι => M) N') with
      map_eq_zero_of_eq' := fun v i j h hij => by
        

Proof state:
R : Type u_1
inst✝¹⁰ : Semiring R
M : Type u_2
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_3
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type u_4
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type u_5
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type u_6
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
f✝ f' : M [Λ^ι]→ₗ[R] N
g✝ g₂ : M [Λ^ι]→ₗ[R] N'
g' : M' [Λ^ι]→ₗ[R] N'
v✝ : ι → M
v' : ι → M'
f g : M [Λ^ι]→ₗ[R] N'
src✝ : MultilinearMap R (fun x => M) N' := ↑f - ↑g
v : ι → M
i j : ι
h : v i = v j
hij : i ≠ j
⊢ MultilinearMap.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
              MultilinearMap.toFun src✝ (update m i (x + y)) =
                MultilinearMap.toFun src✝ (update m i x) + MultilinearMap.toFun src✝ (update m i y)),
        map_smul' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
              MultilinearMap.toFun src✝ (update m i (c • x)) = c • MultilinearMap.toFun src✝ (update m i x)) }
      v =
    0

Next tactic:
simp [f.map_eq_zero_of_eq v h hij, g.map_eq_zero_of_eq v h hij]
/-- Composing an alternating map with a linear map on the left gives again an alternating map. -/
def compAlternatingMap (g : N →ₗ[R] N₂) : (M [Λ^ι]→ₗ[R] N) →+ (M [Λ^ι]→ₗ[R] N₂) where
  toFun f :=
    { g.compMultilinearMap (f : MultilinearMap R (fun _ : ι => M) N) with
      map_eq_zero_of_eq' := fun v i j h hij => by 

Proof state:
R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
N₂ : Type u_10
inst✝¹ : AddCommMonoid N₂
inst✝ : Module R N₂
g : N →ₗ[R] N₂
f : M [Λ^ι]→ₗ[R] N
src✝ : MultilinearMap R (fun x => M) N₂ := compMultilinearMap g ↑f
v : ι → M
i j : ι
h : v i = v j
hij : i ≠ j
⊢ MultilinearMap.toFun
      { toFun := src✝.toFun,
        map_add' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
              MultilinearMap.toFun src✝ (Function.update m i (x + y)) =
                MultilinearMap.toFun src✝ (Function.update m i x) + MultilinearMap.toFun src✝ (Function.update m i y)),
        map_smul' :=
          (_ :
            ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
              MultilinearMap.toFun src✝ (Function.update m i (c • x)) =
                c • MultilinearMap.toFun src✝ (Function.update m i x)) }
      v =
    0

Next tactic:
simp [f.map_eq_zero_of_eq v h hij]
/-- Composing an alternating map with a linear map on the left gives again an alternating map. -/
def compAlternatingMap (g : N →ₗ[R] N₂) : (M [Λ^ι]→ₗ[R] N) →+ (M [Λ^ι]→ₗ[R] N₂) where
  toFun f :=
    { g.compMultilinearMap (f : MultilinearMap R (fun _ : ι => M) N) with
      map_eq_zero_of_eq' := fun v i j h hij => by simp [f.map_eq_zero_of_eq v h hij] }
  map_zero' := by
    

Proof state:
R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type u_3
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type u_4
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type u_5
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_6
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
N₂ : Type u_10
inst✝¹ : AddCommMonoid N₂
inst✝ : Module R N₂
g : N →ₗ[R] N₂
⊢ (fun f =>
        let src := compMultilinearMap g ↑f;
        {
          toMultilinearMap :=
            { toFun := src.toFun,
              map_add' :=
                (_ :
                  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                    MultilinearMap.toFun src (Function.update m i (x + y)) =
                      MultilinearMap.toFun src (Function.update m i x) +
                        MultilinearMap.toFun src (Function.update m i y)),
              map_smul' :=
                (_ :
                  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                    MultilinearMap.toFun src (Function.update m i (c • x)) =
                      c • MultilinearMap.toFun src (Function.update m i x)) },
          map_eq_zero_of_eq' := (_ : ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → g (f v) = 0) })
      0 =
    0

Next tactic:
ext