[GOAL]
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
⊢ Supports G (g • s) (g • b)
[PROOFSTEP]
rintro g' hg'
[GOAL]
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
⊢ g' • g • b = g • b
[PROOFSTEP]
rw [smul_comm, h]
[GOAL]
case a
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
⊢ ∀ ⦃a : α⦄, a ∈ s → g' • a = a
[PROOFSTEP]
rintro a ha
[GOAL]
case a
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
a : α
ha : a ∈ s
⊢ g' • a = a
[PROOFSTEP]
have := Set.ball_image_iff.1 hg' a ha
[GOAL]
case a
G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
inst✝⁶ : Group H
inst✝⁵ : SMul G α
inst✝⁴ : SMul G β
inst✝³ : MulAction H α
inst✝² : SMul H β
inst✝¹ : SMulCommClass G H β
inst✝ : SMulCommClass G H α
s t : Set α
b : β
g : H
h : Supports G s b
g' : G
hg' : ∀ ⦃a : α⦄, a ∈ g • s → g' • a = a
a : α
ha : a ∈ s
this : g' • g • a = g • a
⊢ g' • a = a
[PROOFSTEP]
rwa [smul_comm, smul_left_cancel_iff] at this


[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
ι : Type u_5
⊢ Module R (AlternatingMap R M N ι)
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
⊢ ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] ExteriorAlgebra R M →ₗ[R] N
[PROOFSTEP]
suffices (∀ i, AlternatingMap R M N (Fin i)) →ₗ[R] ExteriorAlgebra R M →ₗ[R] ∀ i, AlternatingMap R M N (Fin i)
  by
  refine' LinearMap.compr₂ this _
  refine' (LinearEquiv.toLinearMap _).comp (LinearMap.proj 0)
  exact AlternatingMap.constLinearEquivOfIsEmpty.symm
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
this : ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] ExteriorAlgebra R M →ₗ[R] (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] ExteriorAlgebra R M →ₗ[R] N
[PROOFSTEP]
refine' LinearMap.compr₂ this _
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
this : ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] ExteriorAlgebra R M →ₗ[R] (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] N
[PROOFSTEP]
refine' (LinearEquiv.toLinearMap _).comp (LinearMap.proj 0)
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
this : ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] ExteriorAlgebra R M →ₗ[R] (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ AlternatingMap R M N (Fin 0) ≃ₗ[R] N
[PROOFSTEP]
exact AlternatingMap.constLinearEquivOfIsEmpty.symm
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
⊢ ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] ExteriorAlgebra R M →ₗ[R] (i : ℕ) → AlternatingMap R M N (Fin i)
[PROOFSTEP]
refine' CliffordAlgebra.foldl _ _ _
[GOAL]
case refine'_1
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
⊢ M →ₗ[R] ((i : ℕ) → AlternatingMap R M N (Fin i)) →ₗ[R] (i : ℕ) → AlternatingMap R M N (Fin i)
[PROOFSTEP]
refine'
  LinearMap.mk₂ R (fun m f i => (f i.succ).curryLeft m) (fun m₁ m₂ f => _) (fun c m f => _) (fun m f₁ f₂ => _)
    fun c m f => _
[GOAL]
case refine'_1.refine'_1
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m₁ m₂ : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f
case refine'_1.refine'_2
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
c : R
m : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
    c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f
case refine'_1.refine'_3
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂
case refine'_1.refine'_4
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
c : R
m : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
    c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f
[PROOFSTEP]
all_goals
  ext i : 1
  simp only [map_smul, map_add, Pi.add_apply, Pi.smul_apply, AlternatingMap.curryLeft_add,
    AlternatingMap.curryLeft_smul, map_add, map_smul, LinearMap.add_apply, LinearMap.smul_apply]
[GOAL]
case refine'_1.refine'_1
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m₁ m₂ : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f
[PROOFSTEP]
ext i : 1
[GOAL]
case refine'_1.refine'_1.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m₁ m₂ : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
i : ℕ
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f i =
    ((fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
      i
[PROOFSTEP]
simp only [map_smul, map_add, Pi.add_apply, Pi.smul_apply, AlternatingMap.curryLeft_add, AlternatingMap.curryLeft_smul,
  map_add, map_smul, LinearMap.add_apply, LinearMap.smul_apply]
[GOAL]
case refine'_1.refine'_2
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
c : R
m : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
    c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f
[PROOFSTEP]
ext i : 1
[GOAL]
case refine'_1.refine'_2.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
c : R
m : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
i : ℕ
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f i =
    (c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f) i
[PROOFSTEP]
simp only [map_smul, map_add, Pi.add_apply, Pi.smul_apply, AlternatingMap.curryLeft_add, AlternatingMap.curryLeft_smul,
  map_add, map_smul, LinearMap.add_apply, LinearMap.smul_apply]
[GOAL]
case refine'_1.refine'_3
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂
[PROOFSTEP]
ext i : 1
[GOAL]
case refine'_1.refine'_3.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)
i : ℕ
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) i =
    ((fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
      i
[PROOFSTEP]
simp only [map_smul, map_add, Pi.add_apply, Pi.smul_apply, AlternatingMap.curryLeft_add, AlternatingMap.curryLeft_smul,
  map_add, map_smul, LinearMap.add_apply, LinearMap.smul_apply]
[GOAL]
case refine'_1.refine'_4
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
c : R
m : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
    c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f
[PROOFSTEP]
ext i : 1
[GOAL]
case refine'_1.refine'_4.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
c : R
m : M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
i : ℕ
⊢ (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) i =
    (c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f) i
[PROOFSTEP]
simp only [map_smul, map_add, Pi.add_apply, Pi.smul_apply, AlternatingMap.curryLeft_add, AlternatingMap.curryLeft_smul,
  map_add, map_smul, LinearMap.add_apply, LinearMap.smul_apply]
[GOAL]
case refine'_2
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
⊢ ∀ (m : M) (x : (i : ℕ) → AlternatingMap R M N (Fin i)),
    ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                (_ :
                  ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                (_ :
                  ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                      c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                (_ :
                  ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                (_ :
                  ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                      c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
            m)
        (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                  (_ :
                    ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                  (_ :
                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                  (_ :
                    ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                  (_ :
                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
              m)
          x) =
      ↑0 m • x
[PROOFSTEP]
intro m x
[GOAL]
case refine'_2
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
x : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
              (_ :
                ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                  (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
              (_ :
                ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                  (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                    c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
              (_ :
                ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                  (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
              (_ :
                ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                  (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                    c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
          m)
      (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                (_ :
                  ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                (_ :
                  ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                      c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                (_ :
                  ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                (_ :
                  ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                    (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                      c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
            m)
        x) =
    ↑0 m • x
[PROOFSTEP]
dsimp only [LinearMap.mk₂_apply, QuadraticForm.coeFn_zero, Pi.zero_apply]
[GOAL]
case refine'_2
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
x : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun i => ↑(AlternatingMap.curryLeft (↑(AlternatingMap.curryLeft (x (Nat.succ (Nat.succ i)))) m)) m) = 0 • x
[PROOFSTEP]
simp_rw [zero_smul]
[GOAL]
case refine'_2
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
x : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (fun i => ↑(AlternatingMap.curryLeft (↑(AlternatingMap.curryLeft (x (Nat.succ (Nat.succ i)))) m)) m) = 0
[PROOFSTEP]
ext i : 1
[GOAL]
case refine'_2.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
m : M
x : (i : ℕ) → AlternatingMap R M N (Fin i)
i : ℕ
⊢ ↑(AlternatingMap.curryLeft (↑(AlternatingMap.curryLeft (x (Nat.succ (Nat.succ i)))) m)) m = OfNat.ofNat 0 i
[PROOFSTEP]
exact AlternatingMap.curryLeft_same _ _
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
m : M
⊢ ↑(↑liftAlternating f) (↑(ι R) m) = ↑(f 1) ![m]
[PROOFSTEP]
dsimp [liftAlternating]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
m : M
⊢ ↑(↑(↑(foldl 0
                  (LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                    (_ :
                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                    (_ :
                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                  (_ :
                    ∀ (m : M) (x : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                  (_ :
                                    ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                  (_ :
                                    ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                              m)
                          (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                    (_ :
                                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                    (_ :
                                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                                m)
                            x) =
                        ↑0 m • x))
              f)
          (↑(ι R) m) 0)
      0 =
    ↑(f 1) ![m]
[PROOFSTEP]
rw [foldl_ι, LinearMap.mk₂_apply, AlternatingMap.curryLeft_apply_apply]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
m : M
⊢ ↑(f (Nat.succ 0)) (Matrix.vecCons m 0) = ↑(f 1) ![m]
[PROOFSTEP]
congr
  -- porting note: In Lean 3, `congr` could use the `[Subsingleton (Fin 0 → M)]` instance to finish
    -- the proof. Here, the instance can be synthesized but `congr` does not use it so the following
    -- line is provided.
[GOAL]
case h.e_6.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
m : M
⊢ Matrix.vecCons m 0 = ![m]
[PROOFSTEP]
rw [Matrix.zero_empty]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
m : M
x : ExteriorAlgebra R M
⊢ ↑(↑liftAlternating f) (↑(ι R) m * x) = ↑(↑liftAlternating fun i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) x
[PROOFSTEP]
dsimp [liftAlternating]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
m : M
x : ExteriorAlgebra R M
⊢ ↑(↑(↑(foldl 0
                  (LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                    (_ :
                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                    (_ :
                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                  (_ :
                    ∀ (m : M) (x : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                  (_ :
                                    ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                  (_ :
                                    ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                              m)
                          (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                    (_ :
                                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                    (_ :
                                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                                m)
                            x) =
                        ↑0 m • x))
              f)
          (↑(ι R) m * x) 0)
      0 =
    ↑(↑(↑(foldl 0
                  (LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                    (_ :
                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                    (_ :
                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                  (_ :
                    ∀ (m : M) (x : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                  (_ :
                                    ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                  (_ :
                                    ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                              m)
                          (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                    (_ :
                                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                    (_ :
                                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                                m)
                            x) =
                        ↑0 m • x))
              fun i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
          x 0)
      0
[PROOFSTEP]
rw [foldl_mul, foldl_ι]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
m : M
x : ExteriorAlgebra R M
⊢ ↑(↑(↑(foldl 0
                  (LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                    (_ :
                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                    (_ :
                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                  (_ :
                    ∀ (m : M) (x : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                  (_ :
                                    ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                  (_ :
                                    ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                              m)
                          (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                    (_ :
                                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                    (_ :
                                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                                m)
                            x) =
                        ↑0 m • x))
              (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                        (_ :
                          ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                              (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                        (_ :
                          ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                              c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                        (_ :
                          ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                              (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                        (_ :
                          ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                              c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                    m)
                f))
          x 0)
      0 =
    ↑(↑(↑(foldl 0
                  (LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                    (_ :
                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                    (_ :
                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                  (_ :
                    ∀ (m : M) (x : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                  (_ :
                                    ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                  (_ :
                                    ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                              m)
                          (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                    (_ :
                                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                    (_ :
                                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                                m)
                            x) =
                        ↑0 m • x))
              fun i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
          x 0)
      0
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ↑(↑liftAlternating f) 1 = ↑(f 0) 0
[PROOFSTEP]
dsimp [liftAlternating]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ↑(↑(↑(foldl 0
                  (LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                    (_ :
                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                    (_ :
                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                    (_ :
                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                  (_ :
                    ∀ (m : M) (x : (i : ℕ) → AlternatingMap R M N (Fin i)),
                      ↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                  (_ :
                                    ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                  (_ :
                                    ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                  (_ :
                                    ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                      (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                        c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                              m)
                          (↑(↑(LinearMap.mk₂ R (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)
                                    (_ :
                                      ∀ (m₁ m₂ : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (m₁ + m₂) f =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₁ f +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m₂ f)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) (c • m) f =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f)
                                    (_ :
                                      ∀ (m : M) (f₁ f₂ : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (f₁ + f₂) =
                                          (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₁ +
                                            (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f₂)
                                    (_ :
                                      ∀ (c : R) (m : M) (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
                                        (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m (c • f) =
                                          c • (fun m f i => ↑(AlternatingMap.curryLeft (f (Nat.succ i))) m) m f))
                                m)
                            x) =
                        ↑0 m • x))
              f)
          1 0)
      0 =
    ↑(f 0) 0
[PROOFSTEP]
rw [foldl_one]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
r : R
⊢ ↑(↑liftAlternating f) (↑(algebraMap R (ExteriorAlgebra R M)) r) = r • ↑(f 0) 0
[PROOFSTEP]
rw [Algebra.algebraMap_eq_smul_one, map_smul, liftAlternating_one]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin n → M
⊢ ↑(↑liftAlternating f) (↑(ιMulti R n) v) = ↑(f n) v
[PROOFSTEP]
rw [ιMulti_apply]
  -- porting note: `v` is generalized automatically so it was removed from the next line
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin n → M
⊢ ↑(↑liftAlternating f) (List.prod (List.ofFn fun i => ↑(ι R) (v i))) = ↑(f n) v
[PROOFSTEP]
induction' n with n ih generalizing f
[GOAL]
case zero
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
v✝ : Fin n → M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin Nat.zero → M
⊢ ↑(↑liftAlternating f) (List.prod (List.ofFn fun i => ↑(ι R) (v i))) = ↑(f Nat.zero) v
[PROOFSTEP]
letI : Subsingleton (Fin 0 → M) := by infer_instance
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
v✝ : Fin n → M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin Nat.zero → M
⊢ Subsingleton (Fin 0 → M)
[PROOFSTEP]
infer_instance
[GOAL]
case zero
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
v✝ : Fin n → M
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin Nat.zero → M
this : Subsingleton (Fin 0 → M) := inferInstance
⊢ ↑(↑liftAlternating f) (List.prod (List.ofFn fun i => ↑(ι R) (v i))) = ↑(f Nat.zero) v
[PROOFSTEP]
rw [List.ofFn_zero, List.prod_nil, liftAlternating_one, Subsingleton.elim 0 v]
[GOAL]
case succ
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n✝ : ℕ
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
v✝ : Fin n✝ → M
n : ℕ
ih :
  ∀ (f : (i : ℕ) → AlternatingMap R M N (Fin i)) (v : Fin n → M),
    ↑(↑liftAlternating f) (List.prod (List.ofFn fun i => ↑(ι R) (v i))) = ↑(f n) v
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin (Nat.succ n) → M
⊢ ↑(↑liftAlternating f) (List.prod (List.ofFn fun i => ↑(ι R) (v i))) = ↑(f (Nat.succ n)) v
[PROOFSTEP]
rw [List.ofFn_succ, List.prod_cons, liftAlternating_ι_mul, ih, AlternatingMap.curryLeft_apply_apply]
[GOAL]
case succ
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n✝ : ℕ
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
v✝ : Fin n✝ → M
n : ℕ
ih :
  ∀ (f : (i : ℕ) → AlternatingMap R M N (Fin i)) (v : Fin n → M),
    ↑(↑liftAlternating f) (List.prod (List.ofFn fun i => ↑(ι R) (v i))) = ↑(f n) v
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin (Nat.succ n) → M
⊢ ↑(f (Nat.succ n)) (Matrix.vecCons (v 0) fun i => v (Fin.succ i)) = ↑(f (Nat.succ n)) v
[PROOFSTEP]
congr
[GOAL]
case succ.h.e_6.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n✝ : ℕ
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
v✝ : Fin n✝ → M
n : ℕ
ih :
  ∀ (f : (i : ℕ) → AlternatingMap R M N (Fin i)) (v : Fin n → M),
    ↑(↑liftAlternating f) (List.prod (List.ofFn fun i => ↑(ι R) (v i))) = ↑(f n) v
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : Fin (Nat.succ n) → M
⊢ (Matrix.vecCons (v 0) fun i => v (Fin.succ i)) = v
[PROOFSTEP]
exact Matrix.cons_head_tail _
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
g : N →ₗ[R] N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ (↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) = LinearMap.comp g (↑liftAlternating f)
[PROOFSTEP]
ext v
[GOAL]
case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
g : N →ₗ[R] N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : ExteriorAlgebra R M
⊢ ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) v = ↑(LinearMap.comp g (↑liftAlternating f)) v
[PROOFSTEP]
rw [LinearMap.comp_apply]
[GOAL]
case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
g : N →ₗ[R] N'
f : (i : ℕ) → AlternatingMap R M N (Fin i)
v : ExteriorAlgebra R M
⊢ ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) v = ↑g (↑(↑liftAlternating f) v)
[PROOFSTEP]
induction' v using CliffordAlgebra.left_induction with r x y hx hy x m hx generalizing f
[GOAL]
case h.hr
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
g : N →ₗ[R] N'
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
r : R
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) (↑(algebraMap R (CliffordAlgebra 0)) r) =
    ↑g (↑(↑liftAlternating f) (↑(algebraMap R (CliffordAlgebra 0)) r))
[PROOFSTEP]
rw [liftAlternating_algebraMap, liftAlternating_algebraMap, map_smul, LinearMap.compAlternatingMap_apply]
[GOAL]
case h.h_add
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
g : N →ₗ[R] N'
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
x y : CliffordAlgebra 0
hx :
  ∀ (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
    ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) x = ↑g (↑(↑liftAlternating f) x)
hy :
  ∀ (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
    ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) y = ↑g (↑(↑liftAlternating f) y)
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) (x + y) = ↑g (↑(↑liftAlternating f) (x + y))
[PROOFSTEP]
rw [map_add, map_add, map_add, hx, hy]
[GOAL]
case h.h_mul_ι
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
g : N →ₗ[R] N'
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
x : CliffordAlgebra 0
m : M
hx :
  ∀ (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
    ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) x = ↑g (↑(↑liftAlternating f) x)
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) (↑(CliffordAlgebra.ι 0) m * x) =
    ↑g (↑(↑liftAlternating f) (↑(CliffordAlgebra.ι 0) m * x))
[PROOFSTEP]
rw [liftAlternating_ι_mul, liftAlternating_ι_mul, ← hx]
[GOAL]
case h.h_mul_ι
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
g : N →ₗ[R] N'
f✝ : (i : ℕ) → AlternatingMap R M N (Fin i)
x : CliffordAlgebra 0
m : M
hx :
  ∀ (f : (i : ℕ) → AlternatingMap R M N (Fin i)),
    ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (f i)) x = ↑g (↑(↑liftAlternating f) x)
f : (i : ℕ) → AlternatingMap R M N (Fin i)
⊢ ↑(↑liftAlternating fun i => ↑(AlternatingMap.curryLeft (↑(LinearMap.compAlternatingMap g) (f (Nat.succ i)))) m) x =
    ↑(↑liftAlternating fun i => ↑(LinearMap.compAlternatingMap g) (↑(AlternatingMap.curryLeft (f (Nat.succ i))) m)) x
[PROOFSTEP]
simp_rw [AlternatingMap.curryLeft_compAlternatingMap]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
⊢ ↑liftAlternating (ιMulti R) = LinearMap.id
[PROOFSTEP]
ext v
[GOAL]
case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
v : ExteriorAlgebra R M
⊢ ↑(↑liftAlternating (ιMulti R)) v = ↑LinearMap.id v
[PROOFSTEP]
dsimp
[GOAL]
case h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
v : ExteriorAlgebra R M
⊢ ↑(↑liftAlternating (ιMulti R)) v = v
[PROOFSTEP]
induction' v using CliffordAlgebra.left_induction with r x y hx hy x m hx
[GOAL]
case h.hr
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
r : R
⊢ ↑(↑liftAlternating (ιMulti R)) (↑(algebraMap R (CliffordAlgebra 0)) r) = ↑(algebraMap R (CliffordAlgebra 0)) r
[PROOFSTEP]
rw [liftAlternating_algebraMap, ιMulti_zero_apply, Algebra.algebraMap_eq_smul_one]
[GOAL]
case h.h_add
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
x y : CliffordAlgebra 0
hx : ↑(↑liftAlternating (ιMulti R)) x = x
hy : ↑(↑liftAlternating (ιMulti R)) y = y
⊢ ↑(↑liftAlternating (ιMulti R)) (x + y) = x + y
[PROOFSTEP]
rw [map_add, hx, hy]
[GOAL]
case h.h_mul_ι
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
x : CliffordAlgebra 0
m : M
hx : ↑(↑liftAlternating (ιMulti R)) x = x
⊢ ↑(↑liftAlternating (ιMulti R)) (↑(CliffordAlgebra.ι 0) m * x) = ↑(CliffordAlgebra.ι 0) m * x
[PROOFSTEP]
simp_rw [liftAlternating_ι_mul, ιMulti_succ_curryLeft, liftAlternating_comp, LinearMap.comp_apply,
  LinearMap.mulLeft_apply, hx]
[GOAL]
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
F : ExteriorAlgebra R M →ₗ[R] N
⊢ LinearMap.comp F (↑liftAlternating fun i => ιMulti R i) = F
[PROOFSTEP]
rw [liftAlternating_ιMulti, LinearMap.comp_id]


[GOAL]
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : PartialOrder α
inst✝ : TopologicalSpace β
a : α
f : α → β
⊢ ContinuousWithinAt f (Ioi a) a ↔ ContinuousWithinAt f (Ici a) a
[PROOFSTEP]
simp only [← Ici_diff_left, continuousWithinAt_diff_self]
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[Iic a] a ⊔ 𝓝[Ici a] a = 𝓝 a
[PROOFSTEP]
rw [← nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[Iio a] a ⊔ 𝓝[Ici a] a = 𝓝 a
[PROOFSTEP]
rw [← nhdsWithin_union, Iio_union_Ici, nhdsWithin_univ]
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[Iic a] a ⊔ 𝓝[Ioi a] a = 𝓝 a
[PROOFSTEP]
rw [← nhdsWithin_union, Iic_union_Ioi, nhdsWithin_univ]
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[Iio a] a ⊔ 𝓝[Ioi a] a = 𝓝[{a}ᶜ] a
[PROOFSTEP]
rw [← nhdsWithin_union, Iio_union_Ioi]
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
f : α → β
⊢ ContinuousAt f a ↔ ContinuousWithinAt f (Iic a) a ∧ ContinuousWithinAt f (Ici a) a
[PROOFSTEP]
simp only [ContinuousWithinAt, ContinuousAt, ← tendsto_sup, nhds_left_sup_nhds_right]
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
f : α → β
⊢ ContinuousAt f a ↔ ContinuousWithinAt f (Iio a) a ∧ ContinuousWithinAt f (Ioi a) a
[PROOFSTEP]
rw [continuousWithinAt_Ioi_iff_Ici, continuousWithinAt_Iio_iff_Iic, continuousAt_iff_continuous_left_right]