l3lab/ntp-mathlib huggingface dataset:
theorem lmapDomain_disjoint_ker (f : α → α') {s : Set α}
    (H : ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), f a = f b → a = b) :
    Disjoint (supported M R s) (ker (lmapDomain M R f)) := by
  rw [disjoint_iff_inf_le]
  rintro l ⟨h₁, h₂⟩
  rw [SetLike.mem_coe, mem_ker, lmapDomain_apply, mapDomain] at h₂
  simp; ext x
  haveI := Classical.decPred fun x => x ∈ s
  by_cases xs : x ∈ s
  · have : Finsupp.sum l (fun a => Finsupp.single (f a)) (f x) = 0 := by
      rw [h₂]
      rfl
    rw [Finsupp.sum_apply, Finsupp.sum_eq_single x, single_eq_same] at this
    · simpa
    · intro y hy xy
      simp only [SetLike.mem_coe, mem_supported, subset_def, Finset.mem_coe, mem_support_iff] at h₁
      

Proof state:
case pos.h₀
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α' : Type u_7
α'' : Type u_8
f : α → α'
s : Set α
H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b
l : α →₀ M
h₂ : (sum l fun a => single (f a)) = 0
x : α
this✝ : DecidablePred fun x => x ∈ s
xs : x ∈ s
this : (sum l fun a₁ b => (fun₀ | f a₁ => b) (f x)) = 0
y : α
hy : l y ≠ 0
xy : y ≠ x
h₁ : ∀ (x : α), l x ≠ 0 → x ∈ s
⊢ (fun₀ | f y => l y) (f x) = 0

Next tactic:
simp [mt (H _ (h₁ _ hy) _ xs) xy]
theorem lmapDomain_disjoint_ker (f : α → α') {s : Set α}
    (H : ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), f a = f b → a = b) :
    Disjoint (supported M R s) (ker (lmapDomain M R f)) := by
  rw [disjoint_iff_inf_le]
  rintro l ⟨h₁, h₂⟩
  rw [SetLike.mem_coe, mem_ker, lmapDomain_apply, mapDomain] at h₂
  simp; ext x
  haveI := Classical.decPred fun x => x ∈ s
  by_cases xs : x ∈ s
  · have : Finsupp.sum l (fun a => Finsupp.single (f a)) (f x) = 0 := by
      rw [h₂]
      rfl
    rw [Finsupp.sum_apply, Finsupp.sum_eq_single x, single_eq_same] at this
    · simpa
    · intro y hy xy
      simp only [SetLike.mem_coe, mem_supported, subset_def, Finset.mem_coe, mem_support_iff] at h₁
      simp [mt (H _ (h₁ _ hy) _ xs) xy]
    · 

Proof state:
case pos.h₁
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α' : Type u_7
α'' : Type u_8
f : α → α'
s : Set α
H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b
l : α →₀ M
h₁ : l ∈ ↑(supported M R s)
h₂ : (sum l fun a => single (f a)) = 0
x : α
this✝ : DecidablePred fun x => x ∈ s
xs : x ∈ s
this : (sum l fun a₁ b => (fun₀ | f a₁ => b) (f x)) = 0
⊢ l x = 0 → (fun₀ | f x => 0) (f x) = 0

Next tactic:
simp (config := { contextual := true })
theorem lmapDomain_disjoint_ker (f : α → α') {s : Set α}
    (H : ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), f a = f b → a = b) :
    Disjoint (supported M R s) (ker (lmapDomain M R f)) := by
  rw [disjoint_iff_inf_le]
  rintro l ⟨h₁, h₂⟩
  rw [SetLike.mem_coe, mem_ker, lmapDomain_apply, mapDomain] at h₂
  simp; ext x
  haveI := Classical.decPred fun x => x ∈ s
  by_cases xs : x ∈ s
  · have : Finsupp.sum l (fun a => Finsupp.single (f a)) (f x) = 0 := by
      rw [h₂]
      rfl
    rw [Finsupp.sum_apply, Finsupp.sum_eq_single x, single_eq_same] at this
    · simpa
    · intro y hy xy
      simp only [SetLike.mem_coe, mem_supported, subset_def, Finset.mem_coe, mem_support_iff] at h₁
      simp [mt (H _ (h₁ _ hy) _ xs) xy]
    · simp (config := { contextual := true })
  · 

Proof state:
case neg
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α' : Type u_7
α'' : Type u_8
f : α → α'
s : Set α
H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b
l : α →₀ M
h₁ : l ∈ ↑(supported M R s)
h₂ : (sum l fun a => single (f a)) = 0
x : α
this : DecidablePred fun x => x ∈ s
xs : x ∉ s
⊢ l x = 0 x

Next tactic:
by_contra h
theorem lmapDomain_disjoint_ker (f : α → α') {s : Set α}
    (H : ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), f a = f b → a = b) :
    Disjoint (supported M R s) (ker (lmapDomain M R f)) := by
  rw [disjoint_iff_inf_le]
  rintro l ⟨h₁, h₂⟩
  rw [SetLike.mem_coe, mem_ker, lmapDomain_apply, mapDomain] at h₂
  simp; ext x
  haveI := Classical.decPred fun x => x ∈ s
  by_cases xs : x ∈ s
  · have : Finsupp.sum l (fun a => Finsupp.single (f a)) (f x) = 0 := by
      rw [h₂]
      rfl
    rw [Finsupp.sum_apply, Finsupp.sum_eq_single x, single_eq_same] at this
    · simpa
    · intro y hy xy
      simp only [SetLike.mem_coe, mem_supported, subset_def, Finset.mem_coe, mem_support_iff] at h₁
      simp [mt (H _ (h₁ _ hy) _ xs) xy]
    · simp (config := { contextual := true })
  · by_contra h
    

Proof state:
case neg
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α' : Type u_7
α'' : Type u_8
f : α → α'
s : Set α
H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b
l : α →₀ M
h₁ : l ∈ ↑(supported M R s)
h₂ : (sum l fun a => single (f a)) = 0
x : α
this : DecidablePred fun x => x ∈ s
xs : x ∉ s
h : ¬l x = 0 x
⊢ False

Next tactic:
exact xs (h₁ <| Finsupp.mem_support_iff.2 h)
/-- Given `f : α → β` and a proof `hf` that `f` is injective, `lcomapDomain f hf` is the linear map
sending `l : β →₀ M` to the finitely supported function from `α` to `M` given by composing
`l` with `f`.

This is the linear version of `Finsupp.comapDomain`. -/
def lcomapDomain (f : α → β) (hf : Function.Injective f) : (β →₀ M) →ₗ[R] α →₀ M
    where
  toFun l := Finsupp.comapDomain f l (hf.injOn _)
  map_add' x y := by 

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
β : Type u_7
f : α → β
hf : Function.Injective f
x y : β →₀ M
⊢ (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) (x + y) =
    (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) x +
      (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) y

Next tactic:
ext
/-- Given `f : α → β` and a proof `hf` that `f` is injective, `lcomapDomain f hf` is the linear map
sending `l : β →₀ M` to the finitely supported function from `α` to `M` given by composing
`l` with `f`.

This is the linear version of `Finsupp.comapDomain`. -/
def lcomapDomain (f : α → β) (hf : Function.Injective f) : (β →₀ M) →ₗ[R] α →₀ M
    where
  toFun l := Finsupp.comapDomain f l (hf.injOn _)
  map_add' x y := by ext; 

Proof state:
case h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
β : Type u_7
f : α → β
hf : Function.Injective f
x y : β →₀ M
a✝ : α
⊢ ((fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) (x + y)) a✝ =
    ((fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) x +
        (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) y)
      a✝

Next tactic:
simp
/-- Given `f : α → β` and a proof `hf` that `f` is injective, `lcomapDomain f hf` is the linear map
sending `l : β →₀ M` to the finitely supported function from `α` to `M` given by composing
`l` with `f`.

This is the linear version of `Finsupp.comapDomain`. -/
def lcomapDomain (f : α → β) (hf : Function.Injective f) : (β →₀ M) →ₗ[R] α →₀ M
    where
  toFun l := Finsupp.comapDomain f l (hf.injOn _)
  map_add' x y := by ext; simp
  map_smul' c x := by 

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
β : Type u_7
f : α → β
hf : Function.Injective f
c : R
x : β →₀ M
⊢ AddHom.toFun
      { toFun := fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support)),
        map_add' :=
          (_ :
            ∀ (x y : β →₀ M),
              (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) (x + y) =
                (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) x +
                  (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) y) }
      (c • x) =
    (RingHom.id R) c •
      AddHom.toFun
        { toFun := fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support)),
          map_add' :=
            (_ :
              ∀ (x y : β →₀ M),
                (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) (x + y) =
                  (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) x +
                    (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) y) }
        x

Next tactic:
ext
/-- Given `f : α → β` and a proof `hf` that `f` is injective, `lcomapDomain f hf` is the linear map
sending `l : β →₀ M` to the finitely supported function from `α` to `M` given by composing
`l` with `f`.

This is the linear version of `Finsupp.comapDomain`. -/
def lcomapDomain (f : α → β) (hf : Function.Injective f) : (β →₀ M) →ₗ[R] α →₀ M
    where
  toFun l := Finsupp.comapDomain f l (hf.injOn _)
  map_add' x y := by ext; simp
  map_smul' c x := by ext; 

Proof state:
case h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
β : Type u_7
f : α → β
hf : Function.Injective f
c : R
x : β →₀ M
a✝ : α
⊢ (AddHom.toFun
        { toFun := fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support)),
          map_add' :=
            (_ :
              ∀ (x y : β →₀ M),
                (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) (x + y) =
                  (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) x +
                    (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) y) }
        (c • x))
      a✝ =
    ((RingHom.id R) c •
        AddHom.toFun
          { toFun := fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support)),
            map_add' :=
              (_ :
                ∀ (x y : β →₀ M),
                  (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) (x + y) =
                    (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) x +
                      (fun l => comapDomain f l (_ : InjOn f (f ⁻¹' ↑l.support))) y) }
          x)
      a✝

Next tactic:
simp
theorem total_apply_of_mem_supported {l : α →₀ R} {s : Finset α}
    (hs : l ∈ supported R R (↑s : Set α)) : Finsupp.total α M R v l = s.sum fun i => l i • v i :=
  Finset.sum_subset hs fun x _ hxg =>
    show l x • v x = 0 by 

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
l : α →₀ R
s : Finset α
hs : l ∈ supported R R ↑s
x : α
x✝ : x ∈ s
hxg : x ∉ l.support
⊢ l x • v x = 0

Next tactic:
rw [not_mem_support_iff.1 hxg, zero_smul]
@[simp]
theorem total_single (c : R) (a : α) : Finsupp.total α M R v (single a c) = c • v a := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
c : R
a : α
⊢ ((Finsupp.total α M R v) fun₀ | a => c) = c • v a

Next tactic:
simp [total_apply, sum_single_index]
theorem total_zero_apply (x : α →₀ R) : (Finsupp.total α M R 0) x = 0 := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : α →₀ R
⊢ (Finsupp.total α M R 0) x = 0

Next tactic:
simp [Finsupp.total_apply]
theorem apply_total (f : M →ₗ[R] M') (v) (l : α →₀ R) :
    f (Finsupp.total α M R v l) = Finsupp.total α M' R (f ∘ v) l := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v✝ : α → M
v' : α' → M'
f : M →ₗ[R] M'
v : α → M
l : α →₀ R
⊢ f ((Finsupp.total α M R v) l) = (Finsupp.total α M' R (⇑f ∘ v)) l

Next tactic:
apply Finsupp.induction_linear l
theorem apply_total (f : M →ₗ[R] M') (v) (l : α →₀ R) :
    f (Finsupp.total α M R v l) = Finsupp.total α M' R (f ∘ v) l := by
  apply Finsupp.induction_linear l <;> 

Proof state:
case h0
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v✝ : α → M
v' : α' → M'
f : M →ₗ[R] M'
v : α → M
l : α →₀ R
⊢ f ((Finsupp.total α M R v) 0) = (Finsupp.total α M' R (⇑f ∘ v)) 0

Next tactic:
simp (config := { contextual := true })
theorem apply_total (f : M →ₗ[R] M') (v) (l : α →₀ R) :
    f (Finsupp.total α M R v l) = Finsupp.total α M' R (f ∘ v) l := by
  apply Finsupp.induction_linear l <;> 

Proof state:
case hadd
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v✝ : α → M
v' : α' → M'
f : M →ₗ[R] M'
v : α → M
l : α →₀ R
⊢ ∀ (f_1 g : α →₀ R),
    f ((Finsupp.total α M R v) f_1) = (Finsupp.total α M' R (⇑f ∘ v)) f_1 →
      f ((Finsupp.total α M R v) g) = (Finsupp.total α M' R (⇑f ∘ v)) g →
        f ((Finsupp.total α M R v) (f_1 + g)) = (Finsupp.total α M' R (⇑f ∘ v)) (f_1 + g)

Next tactic:
simp (config := { contextual := true })
theorem apply_total (f : M →ₗ[R] M') (v) (l : α →₀ R) :
    f (Finsupp.total α M R v l) = Finsupp.total α M' R (f ∘ v) l := by
  apply Finsupp.induction_linear l <;> 

Proof state:
case hsingle
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v✝ : α → M
v' : α' → M'
f : M →ₗ[R] M'
v : α → M
l : α →₀ R
⊢ ∀ (a : α) (b : R), f ((Finsupp.total α M R v) fun₀ | a => b) = (Finsupp.total α M' R (⇑f ∘ v)) fun₀ | a => b

Next tactic:
simp (config := { contextual := true })
theorem total_unique [Unique α] (l : α →₀ R) (v) :
    Finsupp.total α M R v l = l default • v default := by 

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝¹⁰ : Semiring R
inst✝⁹ : Semiring S
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
inst✝⁴ : AddCommMonoid P
inst✝³ : Module R P
α' : Type u_7
M' : Type u_8
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
v✝ : α → M
v' : α' → M'
inst✝ : Unique α
l : α →₀ R
v : α → M
⊢ (Finsupp.total α M R v) l = l default • v default

Next tactic:
rw [← total_single, ← unique_single l]
theorem total_surjective (h : Function.Surjective v) :
    Function.Surjective (Finsupp.total α M R v) := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
h : Function.Surjective v
⊢ Function.Surjective ⇑(Finsupp.total α M R v)

Next tactic:
intro x
theorem total_surjective (h : Function.Surjective v) :
    Function.Surjective (Finsupp.total α M R v) := by
  intro x
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
h : Function.Surjective v
x : M
⊢ ∃ a, (Finsupp.total α M R v) a = x

Next tactic:
obtain ⟨y, hy⟩ := h x
theorem total_surjective (h : Function.Surjective v) :
    Function.Surjective (Finsupp.total α M R v) := by
  intro x
  obtain ⟨y, hy⟩ := h x
  

Proof state:
case intro
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
h : Function.Surjective v
x : M
y : α
hy : v y = x
⊢ ∃ a, (Finsupp.total α M R v) a = x

Next tactic:
exact ⟨Finsupp.single y 1, by simp [hy]⟩
theorem total_surjective (h : Function.Surjective v) :
    Function.Surjective (Finsupp.total α M R v) := by
  intro x
  obtain ⟨y, hy⟩ := h x
  exact ⟨Finsupp.single y 1, by 

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
h : Function.Surjective v
x : M
y : α
hy : v y = x
⊢ ((Finsupp.total α M R v) fun₀ | y => 1) = x

Next tactic:
simp [hy]
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
⊢ LinearMap.range (Finsupp.total α M R v) = span R (Set.range v)

Next tactic:
ext x
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  ext x
  

Proof state:
case h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : M
⊢ x ∈ LinearMap.range (Finsupp.total α M R v) ↔ x ∈ span R (Set.range v)

Next tactic:
constructor
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  ext x
  constructor
  · 

Proof state:
case h.mp
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : M
⊢ x ∈ LinearMap.range (Finsupp.total α M R v) → x ∈ span R (Set.range v)

Next tactic:
intro hx
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  ext x
  constructor
  · intro hx
    

Proof state:
case h.mp
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : M
hx : x ∈ LinearMap.range (Finsupp.total α M R v)
⊢ x ∈ span R (Set.range v)

Next tactic:
rw [LinearMap.mem_range] at hx
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  ext x
  constructor
  · intro hx
    rw [LinearMap.mem_range] at hx
    

Proof state:
case h.mp
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : M
hx : ∃ y, (Finsupp.total α M R v) y = x
⊢ x ∈ span R (Set.range v)

Next tactic:
rcases hx with ⟨l, hl⟩
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  ext x
  constructor
  · intro hx
    rw [LinearMap.mem_range] at hx
    rcases hx with ⟨l, hl⟩
    

Proof state:
case h.mp.intro
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : M
l : α →₀ R
hl : (Finsupp.total α M R v) l = x
⊢ x ∈ span R (Set.range v)

Next tactic:
rw [← hl]
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  ext x
  constructor
  · intro hx
    rw [LinearMap.mem_range] at hx
    rcases hx with ⟨l, hl⟩
    rw [← hl]
    

Proof state:
case h.mp.intro
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : M
l : α →₀ R
hl : (Finsupp.total α M R v) l = x
⊢ (Finsupp.total α M R v) l ∈ span R (Set.range v)

Next tactic:
rw [Finsupp.total_apply]
theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) := by
  ext x
  constructor
  · intro hx
    rw [LinearMap.mem_range] at hx
    rcases hx with ⟨l, hl⟩
    rw [← hl]
    rw [Finsupp.total_apply]
    

Proof state:
case h.mp.intro
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
x : M
l : α →₀ R
hl : (Finsupp.total α M R v) l = x
⊢ (sum l fun i a => a • v i) ∈ span R (Set.range v)

Next tactic:
exact sum_mem fun i _ => Submodule.smul_mem _ _ (subset_span (mem_range_self i))