[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : f.domain = g.domain
h' : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
⊢ f = g
[PROOFSTEP]
rcases f with ⟨f_dom, f⟩
[GOAL]
case mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : E →ₗ.[R] F
f_dom : Submodule R E
f : { x // x ∈ f_dom } →ₗ[R] F
h : { domain := f_dom, toFun := f }.domain = g.domain
h' :
  ∀ ⦃x : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑g y
⊢ { domain := f_dom, toFun := f } = g
[PROOFSTEP]
rcases g with ⟨g_dom, g⟩
[GOAL]
case mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f_dom : Submodule R E
f : { x // x ∈ f_dom } →ₗ[R] F
g_dom : Submodule R E
g : { x // x ∈ g_dom } →ₗ[R] F
h : { domain := f_dom, toFun := f }.domain = { domain := g_dom, toFun := g }.domain
h' :
  ∀ ⦃x : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄ ⦃y : { x // x ∈ { domain := g_dom, toFun := g }.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑{ domain := g_dom, toFun := g } y
⊢ { domain := f_dom, toFun := f } = { domain := g_dom, toFun := g }
[PROOFSTEP]
obtain rfl : f_dom = g_dom := h
[GOAL]
case mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f_dom : Submodule R E
f g : { x // x ∈ f_dom } →ₗ[R] F
h' :
  ∀ ⦃x : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄ ⦃y : { x // x ∈ { domain := f_dom, toFun := g }.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑{ domain := f_dom, toFun := g } y
⊢ { domain := f_dom, toFun := f } = { domain := f_dom, toFun := g }
[PROOFSTEP]
obtain rfl : f = g := LinearMap.ext fun x => h' rfl
[GOAL]
case mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f_dom : Submodule R E
f : { x // x ∈ f_dom } →ₗ[R] F
h' :
  ∀ ⦃x y : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑{ domain := f_dom, toFun := f } y
⊢ { domain := f_dom, toFun := f } = { domain := f_dom, toFun := f }
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
EQ : f = g
x y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑f x = ↑f y
[PROOFSTEP]
congr
[GOAL]
case e_a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
EQ : f = g
x y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ x = y
[PROOFSTEP]
exact_mod_cast h
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
⊢ ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y = c₂ • y
[PROOFSTEP]
intro c₁ c₂ h
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c₁ c₂ : R
h : c₁ • x = c₂ • x
⊢ c₁ • y = c₂ • y
[PROOFSTEP]
rw [← sub_eq_zero, ← sub_smul] at h ⊢
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c₁ c₂ : R
h✝ : c₁ • x = c₂ • x
h : (c₁ - c₂) • x = 0
⊢ (c₁ - c₂) • y = 0
[PROOFSTEP]
exact H _ h
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y✝ : F
H✝ : ∀ (c : R), c • x = 0 → c • y✝ = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y✝ = c₂ • y✝
y z : { x_1 // x_1 ∈ span R {x} }
⊢ (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y✝) (y + z) =
    (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y✝) y + (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y✝) z
[PROOFSTEP]
dsimp only []
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y✝ : F
H✝ : ∀ (c : R), c • x = 0 → c • y✝ = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y✝ = c₂ • y✝
y z : { x_1 // x_1 ∈ span R {x} }
⊢ Classical.choose (_ : ∃ a, a • x = ↑(y + z)) • y✝ =
    Classical.choose (_ : ∃ a, a • x = ↑y) • y✝ + Classical.choose (_ : ∃ a, a • x = ↑z) • y✝
[PROOFSTEP]
rw [← add_smul]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y✝ : F
H✝ : ∀ (c : R), c • x = 0 → c • y✝ = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y✝ = c₂ • y✝
y z : { x_1 // x_1 ∈ span R {x} }
⊢ Classical.choose (_ : ∃ a, a • x = ↑(y + z)) • y✝ =
    (Classical.choose (_ : ∃ a, a • x = ↑y) + Classical.choose (_ : ∃ a, a • x = ↑z)) • y✝
[PROOFSTEP]
apply H
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y✝ : F
H✝ : ∀ (c : R), c • x = 0 → c • y✝ = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y✝ = c₂ • y✝
y z : { x_1 // x_1 ∈ span R {x} }
⊢ Classical.choose (_ : ∃ a, a • x = ↑(y + z)) • x =
    (Classical.choose (_ : ∃ a, a • x = ↑y) + Classical.choose (_ : ∃ a, a • x = ↑z)) • x
[PROOFSTEP]
simp only [add_smul, sub_smul, fun w : R ∙ x => Classical.choose_spec (mem_span_singleton.1 w.prop)]
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y✝ : F
H✝ : ∀ (c : R), c • x = 0 → c • y✝ = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y✝ = c₂ • y✝
y z : { x_1 // x_1 ∈ span R {x} }
⊢ ↑(y + z) = ↑y + ↑z
[PROOFSTEP]
apply coe_add
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H✝ : ∀ (c : R), c • x = 0 → c • y = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y = c₂ • y
c : R
z : { x_1 // x_1 ∈ span R {x} }
⊢ AddHom.toFun
      { toFun := fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y,
        map_add' :=
          (_ :
            ∀ (y_1 z : { x_1 // x_1 ∈ span R {x} }),
              (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y) (y_1 + z) =
                (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y) y_1 +
                  (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y) z) }
      (c • z) =
    ↑(RingHom.id R) c •
      AddHom.toFun
        { toFun := fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y,
          map_add' :=
            (_ :
              ∀ (y_1 z : { x_1 // x_1 ∈ span R {x} }),
                (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y) (y_1 + z) =
                  (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y) y_1 +
                    (fun z => Classical.choose (_ : ∃ a, a • x = ↑z) • y) z) }
        z
[PROOFSTEP]
dsimp only []
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H✝ : ∀ (c : R), c • x = 0 → c • y = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y = c₂ • y
c : R
z : { x_1 // x_1 ∈ span R {x} }
⊢ Classical.choose (_ : ∃ a, a • x = ↑(c • z)) • y = ↑(RingHom.id R) c • Classical.choose (_ : ∃ a, a • x = ↑z) • y
[PROOFSTEP]
rw [smul_smul]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H✝ : ∀ (c : R), c • x = 0 → c • y = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y = c₂ • y
c : R
z : { x_1 // x_1 ∈ span R {x} }
⊢ Classical.choose (_ : ∃ a, a • x = ↑(c • z)) • y = (↑(RingHom.id R) c * Classical.choose (_ : ∃ a, a • x = ↑z)) • y
[PROOFSTEP]
apply H
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H✝ : ∀ (c : R), c • x = 0 → c • y = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y = c₂ • y
c : R
z : { x_1 // x_1 ∈ span R {x} }
⊢ Classical.choose (_ : ∃ a, a • x = ↑(c • z)) • x = (↑(RingHom.id R) c * Classical.choose (_ : ∃ a, a • x = ↑z)) • x
[PROOFSTEP]
simp only [mul_smul, fun w : R ∙ x => Classical.choose_spec (mem_span_singleton.1 w.prop)]
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H✝ : ∀ (c : R), c • x = 0 → c • y = 0
H : ∀ (c₁ c₂ : R), c₁ • x = c₂ • x → c₁ • y = c₂ • y
c : R
z : { x_1 // x_1 ∈ span R {x} }
⊢ ↑(c • z) = ↑(RingHom.id R) c • ↑z
[PROOFSTEP]
apply coe_smul
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ ↑(mkSpanSingleton' x y H) { val := c • x, property := h } = c • y
[PROOFSTEP]
dsimp [mkSpanSingleton']
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ Classical.choose (_ : ∃ a, a • x = c • x) • y = c • y
[PROOFSTEP]
rw [← sub_eq_zero, ← sub_smul]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ (Classical.choose (_ : ∃ a, a • x = c • x) - c) • y = 0
[PROOFSTEP]
apply H
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ (Classical.choose (_ : ∃ a, a • x = c • x) - c) • x = 0
[PROOFSTEP]
simp only [sub_smul, one_smul, sub_eq_zero]
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
c : R
h : c • x ∈ (mkSpanSingleton' x y H).domain
⊢ Classical.choose (_ : ∃ a, a • x = c • x) • x = c • x
[PROOFSTEP]
apply Classical.choose_spec (mem_span_singleton.1 h)
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
⊢ ↑(mkSpanSingleton' x y H) { val := x, property := h } = y
[PROOFSTEP]
have := by refine mkSpanSingleton'_apply x y H 1 ?_; rwa [one_smul]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
⊢ ?m.88594
[PROOFSTEP]
refine mkSpanSingleton'_apply x y H 1 ?_
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
⊢ 1 • x ∈ (mkSpanSingleton' x y H).domain
[PROOFSTEP]
rwa [one_smul]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
this : ↑(mkSpanSingleton' x y H) { val := 1 • x, property := (_ : 1 • x ∈ (mkSpanSingleton' x y H).domain) } = 1 • y
⊢ ↑(mkSpanSingleton' x y H) { val := x, property := h } = y
[PROOFSTEP]
convert this
[GOAL]
case h.e'_2.h.e'_10.h.e'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
this : ↑(mkSpanSingleton' x y H) { val := 1 • x, property := (_ : 1 • x ∈ (mkSpanSingleton' x y H).domain) } = 1 • y
⊢ x = 1 • x
[PROOFSTEP]
rw [one_smul]
[GOAL]
case h.e'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
this : ↑(mkSpanSingleton' x y H) { val := 1 • x, property := (_ : 1 • x ∈ (mkSpanSingleton' x y H).domain) } = 1 • y
⊢ y = 1 • y
[PROOFSTEP]
rw [one_smul]
[GOAL]
R : Type u_1
inst✝¹¹ : Ring R
E✝ : Type u_2
inst✝¹⁰ : AddCommGroup E✝
inst✝⁹ : Module R E✝
F✝ : Type u_3
inst✝⁸ : AddCommGroup F✝
inst✝⁷ : Module R F✝
G : Type u_4
inst✝⁶ : AddCommGroup G
inst✝⁵ : Module R G
K : Type u_5
E : Type u_6
F : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup E
inst✝² : Module K E
inst✝¹ : AddCommGroup F
inst✝ : Module K F
x : E
y : F
hx : x ≠ 0
c : K
hc✝ : c • x = 0
hc : c = 0
⊢ c • y = 0
[PROOFSTEP]
rw [hc, zero_smul]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x y : E
x✝¹ : x ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }}
x✝ : y ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }}
hfx : x ∈ f.domain
hgx : x ∈ g.domain
hx : ↑f { val := x, property := hfx } = ↑g { val := x, property := hgx }
hfy : y ∈ f.domain
hgy : y ∈ g.domain
hy : ↑f { val := y, property := hfy } = ↑g { val := y, property := hgy }
⊢ ↑f { val := x + y, property := (_ : x + y ∈ f.domain) } = ↑g { val := x + y, property := (_ : x + y ∈ g.domain) }
[PROOFSTEP]
erw [f.map_add ⟨x, hfx⟩ ⟨y, hfy⟩, g.map_add ⟨x, hgx⟩ ⟨y, hgy⟩, hx, hy]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
⊢ ∀ (c : R) {x : E},
    x ∈
        {
              toAddSubsemigroup :=
                { carrier := {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }},
                  add_mem' :=
                    (_ :
                      ∀ {x y : E},
                        x ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }} →
                          y ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }} →
                            x + y ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }}) },
              zero_mem' :=
                (_ :
                  ∃ hf hg,
                    ↑f { val := 0, property := hf } = ↑g { val := 0, property := hg }) }.toAddSubsemigroup.carrier →
      c • x ∈
        {
              toAddSubsemigroup :=
                { carrier := {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }},
                  add_mem' :=
                    (_ :
                      ∀ {x y : E},
                        x ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }} →
                          y ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }} →
                            x + y ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }}) },
              zero_mem' :=
                (_ :
                  ∃ hf hg,
                    ↑f { val := 0, property := hf } = ↑g { val := 0, property := hg }) }.toAddSubsemigroup.carrier
[PROOFSTEP]
rintro c x ⟨hfx, hgx, hx⟩
[GOAL]
case intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
c : R
x : E
hfx : x ∈ f.domain
hgx : x ∈ g.domain
hx : ↑f { val := x, property := hfx } = ↑g { val := x, property := hgx }
⊢ c • x ∈
    {
          toAddSubsemigroup :=
            { carrier := {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }},
              add_mem' :=
                (_ :
                  ∀ {x y : E},
                    x ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }} →
                      y ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }} →
                        x + y ∈ {x | ∃ hf hg, ↑f { val := x, property := hf } = ↑g { val := x, property := hg }}) },
          zero_mem' :=
            (_ : ∃ hf hg, ↑f { val := 0, property := hf } = ↑g { val := 0, property := hg }) }.toAddSubsemigroup.carrier
[PROOFSTEP]
exact ⟨smul_mem _ c hfx, smul_mem _ c hgx, by erw [f.map_smul c ⟨x, hfx⟩, g.map_smul c ⟨x, hgx⟩, hx]⟩
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
c : R
x : E
hfx : x ∈ f.domain
hgx : x ∈ g.domain
hx : ↑f { val := x, property := hfx } = ↑g { val := x, property := hgx }
⊢ ↑f { val := c • x, property := (_ : c • x ∈ f.domain) } = ↑g { val := c • x, property := (_ : c • x ∈ g.domain) }
[PROOFSTEP]
erw [f.map_smul c ⟨x, hfx⟩, g.map_smul c ⟨x, hgx⟩, hx]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
⊢ ∀ (a b c : E →ₗ.[R] F), a ≤ b → a ≤ c → a ≤ b ⊓ c
[PROOFSTEP]
rintro f g h ⟨fg_le, fg_eq⟩ ⟨fh_le, fh_eq⟩
[GOAL]
case intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
⊢ f ≤ g ⊓ h
[PROOFSTEP]
exact
  ⟨fun x hx =>
    ⟨fg_le hx, fh_le hx, by
      -- Porting note: `[exact ⟨x, hx⟩, rfl, rfl]` → `[skip, exact ⟨x, hx⟩, skip] <;> rfl`refine'
            (fg_eq _).symm.trans (fh_eq _) <;>
          [skip; exact ⟨x, hx⟩; skip] <;>
        rfl⟩,
    fun x ⟨y, yg, hy⟩ h => by
    apply fg_eq
    exact h⟩
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
x : E
hx : x ∈ f.domain
⊢ ↑g { val := x, property := (_ : x ∈ g.domain) } = ↑h { val := x, property := (_ : x ∈ h.domain) }
[PROOFSTEP]
refine' (fg_eq _).symm.trans (fh_eq _) <;> [skip; exact ⟨x, hx⟩; skip]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
x : E
hx : x ∈ f.domain
⊢ ↑g { val := x, property := (_ : x ∈ g.domain) } = ↑h { val := x, property := (_ : x ∈ h.domain) }
[PROOFSTEP]
refine' (fg_eq _).symm.trans (fh_eq _)
[GOAL]
case refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
x : E
hx : x ∈ f.domain
⊢ ↑?refine'_2 = ↑{ val := x, property := (_ : x ∈ g.domain) }
[PROOFSTEP]
skip
[GOAL]
case refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
x : E
hx : x ∈ f.domain
⊢ { x // x ∈ f.domain }
[PROOFSTEP]
exact ⟨x, hx⟩
[GOAL]
case refine'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
x : E
hx : x ∈ f.domain
⊢ ↑{ val := x, property := hx } = ↑{ val := x, property := (_ : x ∈ h.domain) }
[PROOFSTEP]
skip
[GOAL]
case refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
x : E
hx : x ∈ f.domain
⊢ ↑{ val := x, property := hx } = ↑{ val := x, property := (_ : x ∈ g.domain) }
[PROOFSTEP]
rfl
[GOAL]
case refine'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h.domain }⦄, ↑x = ↑y → ↑f x = ↑h y
x : E
hx : x ∈ f.domain
⊢ ↑{ val := x, property := hx } = ↑{ val := x, property := (_ : x ∈ h.domain) }
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h✝ : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h✝.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h✝.domain }⦄, ↑x = ↑y → ↑f x = ↑h✝ y
x : { x // x ∈ f.domain }
x✝ : { x // x ∈ (g ⊓ h✝).domain }
y : E
yg : y ∈ g.domain
hy : ∃ hg, ↑g { val := y, property := yg } = ↑h✝ { val := y, property := hg }
h : ↑x = ↑{ val := y, property := (_ : ∃ hf hg, ↑g { val := y, property := hf } = ↑h✝ { val := y, property := hg }) }
⊢ ↑f x =
    ↑(g ⊓ h✝)
      { val := y, property := (_ : ∃ hf hg, ↑g { val := y, property := hf } = ↑h✝ { val := y, property := hg }) }
[PROOFSTEP]
apply fg_eq
[GOAL]
case _h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h✝ : E →ₗ.[R] F
fg_le : f.domain ≤ g.domain
fg_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
fh_le : f.domain ≤ h✝.domain
fh_eq : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ h✝.domain }⦄, ↑x = ↑y → ↑f x = ↑h✝ y
x : { x // x ∈ f.domain }
x✝ : { x // x ∈ (g ⊓ h✝).domain }
y : E
yg : y ∈ g.domain
hy : ∃ hg, ↑g { val := y, property := yg } = ↑h✝ { val := y, property := hg }
h : ↑x = ↑{ val := y, property := (_ : ∃ hf hg, ↑g { val := y, property := hf } = ↑h✝ { val := y, property := hg }) }
⊢ ↑x =
    ↑(↑(ofLe (_ : ∀ (_x : E), _x ∈ eqLocus g h✝ → _x ∈ g.domain))
        { val := y, property := (_ : ∃ hf hg, ↑g { val := y, property := hf } = ↑h✝ { val := y, property := hg }) })
[PROOFSTEP]
exact h
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ ⊥.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑⊥ x = ↑f y
[PROOFSTEP]
have hx : x = 0 := Subtype.eq ((mem_bot R).1 x.2)
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ ⊥.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
hx : x = 0
⊢ ↑⊥ x = ↑f y
[PROOFSTEP]
have hy : y = 0 := Subtype.eq (h.symm.trans (congr_arg _ hx))
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ ⊥.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
hx : x = 0
hy : y = 0
⊢ ↑⊥ x = ↑f y
[PROOFSTEP]
rw [hx, hy, map_zero, map_zero]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
⊢ ∃ fg,
    ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }) (z : { x // x ∈ f.domain ⊔ g.domain }),
      ↑x + ↑y = ↑z → ↑fg z = ↑f x + ↑g y
[PROOFSTEP]
choose x hx y hy hxy using fun z : ↥(f.domain ⊔ g.domain) => mem_sup.1 z.prop
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
⊢ ∃ fg,
    ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }) (z : { x // x ∈ f.domain ⊔ g.domain }),
      ↑x + ↑y = ↑z → ↑fg z = ↑f x + ↑g y
[PROOFSTEP]
set fg := fun z => f ⟨x z, hx z⟩ + g ⟨y z, hy z⟩
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
⊢ ∃ fg,
    ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }) (z : { x // x ∈ f.domain ⊔ g.domain }),
      ↑x + ↑y = ↑z → ↑fg z = ↑f x + ↑g y
[PROOFSTEP]
have fg_eq :
  ∀ (x' : f.domain) (y' : g.domain) (z' : ↥(f.domain ⊔ g.domain)) (_H : (x' : E) + y' = z'), fg z' = f x' + g y' :=
  by
  intro x' y' z' H
  dsimp
  rw [add_comm, ← sub_eq_sub_iff_add_eq_add, eq_comm, ← map_sub, ← map_sub]
  apply h
  simp only [← eq_sub_iff_add_eq] at hxy 
  simp only [AddSubgroupClass.coe_sub, coe_mk, coe_mk, hxy, ← sub_add, ← sub_sub, sub_self, zero_sub, ← H]
  apply neg_add_eq_sub
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
⊢ ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
[PROOFSTEP]
intro x' y' z' H
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
x' : { x // x ∈ f.domain }
y' : { x // x ∈ g.domain }
z' : { x // x ∈ f.domain ⊔ g.domain }
H : ↑x' + ↑y' = ↑z'
⊢ fg z' = ↑f x' + ↑g y'
[PROOFSTEP]
dsimp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
x' : { x // x ∈ f.domain }
y' : { x // x ∈ g.domain }
z' : { x // x ∈ f.domain ⊔ g.domain }
H : ↑x' + ↑y' = ↑z'
⊢ ↑f { val := x z', property := (_ : x z' ∈ f.domain) } + ↑g { val := y z', property := (_ : y z' ∈ g.domain) } =
    ↑f x' + ↑g y'
[PROOFSTEP]
rw [add_comm, ← sub_eq_sub_iff_add_eq_add, eq_comm, ← map_sub, ← map_sub]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
x' : { x // x ∈ f.domain }
y' : { x // x ∈ g.domain }
z' : { x // x ∈ f.domain ⊔ g.domain }
H : ↑x' + ↑y' = ↑z'
⊢ ↑f (x' - { val := x z', property := (_ : x z' ∈ f.domain) }) =
    ↑g ({ val := y z', property := (_ : y z' ∈ g.domain) } - y')
[PROOFSTEP]
apply h
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
x' : { x // x ∈ f.domain }
y' : { x // x ∈ g.domain }
z' : { x // x ∈ f.domain ⊔ g.domain }
H : ↑x' + ↑y' = ↑z'
⊢ ↑(x' - { val := x z', property := (_ : x z' ∈ f.domain) }) =
    ↑({ val := y z', property := (_ : y z' ∈ g.domain) } - y')
[PROOFSTEP]
simp only [← eq_sub_iff_add_eq] at hxy 
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
x' : { x // x ∈ f.domain }
y' : { x // x ∈ g.domain }
z' : { x // x ∈ f.domain ⊔ g.domain }
H : ↑x' + ↑y' = ↑z'
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z = ↑z - y z
⊢ ↑(x' - { val := x z', property := (_ : x z' ∈ f.domain) }) =
    ↑({ val := y z', property := (_ : y z' ∈ g.domain) } - y')
[PROOFSTEP]
simp only [AddSubgroupClass.coe_sub, coe_mk, coe_mk, hxy, ← sub_add, ← sub_sub, sub_self, zero_sub, ← H]
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
x' : { x // x ∈ f.domain }
y' : { x // x ∈ g.domain }
z' : { x // x ∈ f.domain ⊔ g.domain }
H : ↑x' + ↑y' = ↑z'
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z = ↑z - y z
⊢ -↑y' + y z' = y z' - ↑y'
[PROOFSTEP]
apply neg_add_eq_sub
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
⊢ ∃ fg,
    ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }) (z : { x // x ∈ f.domain ⊔ g.domain }),
      ↑x + ↑y = ↑z → ↑fg z = ↑f x + ↑g y
[PROOFSTEP]
refine' ⟨{ toFun := fg .. }, fg_eq⟩
[GOAL]
case refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
⊢ ∀ (x y : { x // x ∈ f.domain ⊔ g.domain }), fg (x + y) = fg x + fg y
[PROOFSTEP]
rintro ⟨z₁, hz₁⟩ ⟨z₂, hz₂⟩
[GOAL]
case refine'_1.mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
z₁ : E
hz₁ : z₁ ∈ f.domain ⊔ g.domain
z₂ : E
hz₂ : z₂ ∈ f.domain ⊔ g.domain
⊢ fg ({ val := z₁, property := hz₁ } + { val := z₂, property := hz₂ }) =
    fg { val := z₁, property := hz₁ } + fg { val := z₂, property := hz₂ }
[PROOFSTEP]
rw [← add_assoc, add_right_comm (f _), ← map_add, add_assoc, ← map_add]
[GOAL]
case refine'_1.mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
z₁ : E
hz₁ : z₁ ∈ f.domain ⊔ g.domain
z₂ : E
hz₂ : z₂ ∈ f.domain ⊔ g.domain
⊢ fg ({ val := z₁, property := hz₁ } + { val := z₂, property := hz₂ }) =
    ↑f
        ({ val := x { val := z₁, property := hz₁ }, property := (_ : x { val := z₁, property := hz₁ } ∈ f.domain) } +
          { val := x { val := z₂, property := hz₂ }, property := (_ : x { val := z₂, property := hz₂ } ∈ f.domain) }) +
      ↑g
        ({ val := y { val := z₁, property := hz₁ }, property := (_ : y { val := z₁, property := hz₁ } ∈ g.domain) } +
          { val := y { val := z₂, property := hz₂ }, property := (_ : y { val := z₂, property := hz₂ } ∈ g.domain) })
[PROOFSTEP]
apply fg_eq
[GOAL]
case refine'_1.mk.mk._H
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
z₁ : E
hz₁ : z₁ ∈ f.domain ⊔ g.domain
z₂ : E
hz₂ : z₂ ∈ f.domain ⊔ g.domain
⊢ ↑({ val := x { val := z₁, property := hz₁ }, property := (_ : x { val := z₁, property := hz₁ } ∈ f.domain) } +
          { val := x { val := z₂, property := hz₂ }, property := (_ : x { val := z₂, property := hz₂ } ∈ f.domain) }) +
      ↑({ val := y { val := z₁, property := hz₁ }, property := (_ : y { val := z₁, property := hz₁ } ∈ g.domain) } +
          { val := y { val := z₂, property := hz₂ }, property := (_ : y { val := z₂, property := hz₂ } ∈ g.domain) }) =
    ↑({ val := z₁, property := hz₁ } + { val := z₂, property := hz₂ })
[PROOFSTEP]
simp only [coe_add, coe_mk, ← add_assoc]
[GOAL]
case refine'_1.mk.mk._H
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
z₁ : E
hz₁ : z₁ ∈ f.domain ⊔ g.domain
z₂ : E
hz₂ : z₂ ∈ f.domain ⊔ g.domain
⊢ x { val := z₁, property := hz₁ } + x { val := z₂, property := hz₂ } + y { val := z₁, property := hz₁ } +
      y { val := z₂, property := hz₂ } =
    z₁ + z₂
[PROOFSTEP]
rw [add_right_comm (x _), hxy, add_assoc, hxy, coe_mk, coe_mk]
[GOAL]
case refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
⊢ ∀ (r : R) (x_1 : { x // x ∈ f.domain ⊔ g.domain }),
    AddHom.toFun { toFun := fg, map_add' := (_ : ∀ (x y : { x // x ∈ f.domain ⊔ g.domain }), fg (x + y) = fg x + fg y) }
        (r • x_1) =
      ↑(RingHom.id R) r •
        AddHom.toFun
          { toFun := fg, map_add' := (_ : ∀ (x y : { x // x ∈ f.domain ⊔ g.domain }), fg (x + y) = fg x + fg y) } x_1
[PROOFSTEP]
intro c z
[GOAL]
case refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
c : R
z : { x // x ∈ f.domain ⊔ g.domain }
⊢ AddHom.toFun { toFun := fg, map_add' := (_ : ∀ (x y : { x // x ∈ f.domain ⊔ g.domain }), fg (x + y) = fg x + fg y) }
      (c • z) =
    ↑(RingHom.id R) c •
      AddHom.toFun
        { toFun := fg, map_add' := (_ : ∀ (x y : { x // x ∈ f.domain ⊔ g.domain }), fg (x + y) = fg x + fg y) } z
[PROOFSTEP]
rw [smul_add, ← map_smul, ← map_smul]
[GOAL]
case refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
c : R
z : { x // x ∈ f.domain ⊔ g.domain }
⊢ AddHom.toFun { toFun := fg, map_add' := (_ : ∀ (x y : { x // x ∈ f.domain ⊔ g.domain }), fg (x + y) = fg x + fg y) }
      (c • z) =
    ↑f (↑(RingHom.id R) c • { val := x z, property := (_ : x z ∈ f.domain) }) +
      ↑g (↑(RingHom.id R) c • { val := y z, property := (_ : y z ∈ g.domain) })
[PROOFSTEP]
apply fg_eq
[GOAL]
case refine'_2._H
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
x : { x // x ∈ f.domain ⊔ g.domain } → E
hx : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z ∈ f.domain
y : { x // x ∈ f.domain ⊔ g.domain } → E
hy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), y z ∈ g.domain
hxy : ∀ (z : { x // x ∈ f.domain ⊔ g.domain }), x z + y z = ↑z
fg : { x // x ∈ f.domain ⊔ g.domain } → F :=
  fun z => ↑f { val := x z, property := (_ : x z ∈ f.domain) } + ↑g { val := y z, property := (_ : y z ∈ g.domain) }
fg_eq :
  ∀ (x' : { x // x ∈ f.domain }) (y' : { x // x ∈ g.domain }) (z' : { x // x ∈ f.domain ⊔ g.domain }),
    ↑x' + ↑y' = ↑z' → fg z' = ↑f x' + ↑g y'
c : R
z : { x // x ∈ f.domain ⊔ g.domain }
⊢ ↑(↑(RingHom.id R) c • { val := x z, property := (_ : x z ∈ f.domain) }) +
      ↑(↑(RingHom.id R) c • { val := y z, property := (_ : y z ∈ g.domain) }) =
    ↑(c • z)
[PROOFSTEP]
simp only [coe_smul, coe_mk, ← smul_add, hxy, RingHom.id_apply]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
⊢ f ≤ LinearPMap.sup f g h
[PROOFSTEP]
refine' ⟨le_sup_left, fun z₁ z₂ hz => _⟩
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ f.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ = ↑(LinearPMap.sup f g h) z₂
[PROOFSTEP]
rw [← add_zero (f _), ← g.map_zero]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ f.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ + ↑g 0 = ↑(LinearPMap.sup f g h) z₂
[PROOFSTEP]
refine' (sup_apply h _ _ _ _).symm
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ f.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑z₁ + ↑0 = ↑z₂
[PROOFSTEP]
simpa
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
⊢ g ≤ LinearPMap.sup f g h
[PROOFSTEP]
refine' ⟨le_sup_right, fun z₁ z₂ hz => _⟩
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ g.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑g z₁ = ↑(LinearPMap.sup f g h) z₂
[PROOFSTEP]
rw [← zero_add (g _), ← f.map_zero]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ g.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑f 0 + ↑g z₁ = ↑(LinearPMap.sup f g h) z₂
[PROOFSTEP]
refine' (sup_apply h _ _ _ _).symm
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : { x // x ∈ f.domain }) (y : { x // x ∈ g.domain }), ↑x = ↑y → ↑f x = ↑g y
z₁ : { x // x ∈ g.domain }
z₂ : { x // x ∈ (LinearPMap.sup f g h).domain }
hz : ↑z₁ = ↑z₂
⊢ ↑0 + ↑z₁ = ↑z₂
[PROOFSTEP]
simpa
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : Disjoint f.domain g.domain
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
⊢ ↑f x = ↑g y
[PROOFSTEP]
rw [disjoint_def] at h 
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : E), x ∈ f.domain → x ∈ g.domain → x = 0
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
⊢ ↑f x = ↑g y
[PROOFSTEP]
have hy : y = 0 := Subtype.eq (h y (hxy ▸ x.2) y.2)
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : E), x ∈ f.domain → x ∈ g.domain → x = 0
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
hy : y = 0
⊢ ↑f x = ↑g y
[PROOFSTEP]
have hx : x = 0 := Subtype.eq (hxy.trans <| congr_arg _ hy)
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : E), x ∈ f.domain → x ∈ g.domain → x = 0
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
hy : y = 0
hx : x = 0
⊢ ↑f x = ↑g y
[PROOFSTEP]
simp [*]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ - -f = f
[PROOFSTEP]
ext x y hxy
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ x ∈ (- -f).domain ↔ x ∈ f.domain
[PROOFSTEP]
rfl
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ (- -f).domain }
y : { x // x ∈ f.domain }
hxy : ↑x = ↑y
⊢ ↑(- -f) x = ↑f y
[PROOFSTEP]
simp only [neg_apply, neg_neg]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ (- -f).domain }
y : { x // x ∈ f.domain }
hxy : ↑x = ↑y
⊢ ↑f x = ↑f y
[PROOFSTEP]
cases x
[GOAL]
case h'.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
y : { x // x ∈ f.domain }
val✝ : E
property✝ : val✝ ∈ (- -f).domain
hxy : ↑{ val := val✝, property := property✝ } = ↑y
⊢ ↑f { val := val✝, property := property✝ } = ↑f y
[PROOFSTEP]
congr
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
⊢ f + g + h = f + (g + h)
[PROOFSTEP]
ext x y hxy
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
x : E
⊢ x ∈ (f + g + h).domain ↔ x ∈ (f + (g + h)).domain
[PROOFSTEP]
simp only [add_domain, inf_assoc]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g h : E →ₗ.[R] F
x : { x // x ∈ (f + g + h).domain }
y : { x // x ∈ (f + (g + h)).domain }
hxy : ↑x = ↑y
⊢ ↑(f + g + h) x = ↑(f + (g + h)) y
[PROOFSTEP]
simp only [add_apply, hxy, add_assoc]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ 0 + f = f
[PROOFSTEP]
ext x y hxy
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ x ∈ (0 + f).domain ↔ x ∈ f.domain
[PROOFSTEP]
simp [add_domain]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ (0 + f).domain }
y : { x // x ∈ f.domain }
hxy : ↑x = ↑y
⊢ ↑(0 + f) x = ↑f y
[PROOFSTEP]
simp only [add_apply, hxy, zero_apply, zero_add]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ f + 0 = f
[PROOFSTEP]
ext x y hxy
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ x ∈ (f + 0).domain ↔ x ∈ f.domain
[PROOFSTEP]
simp [add_domain]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ (f + 0).domain }
y : { x // x ∈ f.domain }
hxy : ↑x = ↑y
⊢ ↑(f + 0) x = ↑f y
[PROOFSTEP]
simp only [add_apply, hxy, zero_apply, add_zero]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ 0 + f = f
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
⊢ ∀ (a : E →ₗ.[R] F), a + 0 = a
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
⊢ f + g = g + f
[PROOFSTEP]
ext x y hxy
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : E
⊢ x ∈ (f + g).domain ↔ x ∈ (g + f).domain
[PROOFSTEP]
simp only [add_domain, inf_comm]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (f + g).domain }
y : { x // x ∈ (g + f).domain }
hxy : ↑x = ↑y
⊢ ↑(f + g) x = ↑(g + f) y
[PROOFSTEP]
simp only [add_apply, hxy, add_comm]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
⊢ f - g = f + -g
[PROOFSTEP]
ext x y h
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : E
⊢ x ∈ (f - g).domain ↔ x ∈ (f + -g).domain
[PROOFSTEP]
rfl
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (f - g).domain }
y : { x // x ∈ (f + -g).domain }
h : ↑x = ↑y
⊢ ↑(f - g) x = ↑(f + -g) y
[PROOFSTEP]
simp [sub_apply, add_apply, neg_apply, ← sub_eq_add_neg, h]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
⊢ -(f + g) = -g + -f
[PROOFSTEP]
ext x y h
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : E
⊢ x ∈ (-(f + g)).domain ↔ x ∈ (-g + -f).domain
[PROOFSTEP]
simp [add_domain, sub_domain, neg_domain, And.comm]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (-(f + g)).domain }
y : { x // x ∈ (-g + -f).domain }
h : ↑x = ↑y
⊢ ↑(-(f + g)) x = ↑(-g + -f) y
[PROOFSTEP]
simp [sub_apply, add_apply, neg_apply, ← sub_eq_add_neg, h]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h' : f + g = 0
⊢ -f = g
[PROOFSTEP]
ext x y h
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h' : f + g = 0
x : E
⊢ x ∈ (-f).domain ↔ x ∈ g.domain
[PROOFSTEP]
have : (0 : E →ₗ.[R] F).domain = ⊤ := zero_domain
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h' : f + g = 0
x : E
this : 0.domain = ⊤
⊢ x ∈ (-f).domain ↔ x ∈ g.domain
[PROOFSTEP]
simp only [← h', add_domain, ge_iff_le, inf_eq_top_iff] at this 
[GOAL]
case h.h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h' : f + g = 0
x : E
this : f.domain = ⊤ ∧ g.domain = ⊤
⊢ x ∈ (-f).domain ↔ x ∈ g.domain
[PROOFSTEP]
rw [neg_domain, this.1, this.2]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h' : f + g = 0
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
⊢ ↑(-f) x = ↑g y
[PROOFSTEP]
simp only [inf_coe, neg_domain, Eq.ndrec, Int.ofNat_eq_coe, neg_apply]
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h' : f + g = 0
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
⊢ -↑f x = ↑g y
[PROOFSTEP]
rw [ext_iff] at h' 
[GOAL]
case h'
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h' : ∃ _domain_eq, ∀ ⦃x : { x // x ∈ (f + g).domain }⦄ ⦃y : { x // x ∈ 0.domain }⦄, ↑x = ↑y → ↑(f + g) x = ↑0 y
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
⊢ -↑f x = ↑g y
[PROOFSTEP]
rcases h' with ⟨hdom, h'⟩
[GOAL]
case h'.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
hdom : (f + g).domain = 0.domain
h' : ∀ ⦃x : { x // x ∈ (f + g).domain }⦄ ⦃y : { x // x ∈ 0.domain }⦄, ↑x = ↑y → ↑(f + g) x = ↑0 y
⊢ -↑f x = ↑g y
[PROOFSTEP]
rw [zero_domain] at hdom 
[GOAL]
case h'.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
hdom : (f + g).domain = ⊤
h' : ∀ ⦃x : { x // x ∈ (f + g).domain }⦄ ⦃y : { x // x ∈ 0.domain }⦄, ↑x = ↑y → ↑(f + g) x = ↑0 y
⊢ -↑f x = ↑g y
[PROOFSTEP]
simp only [inf_coe, neg_domain, Eq.ndrec, Int.ofNat_eq_coe, zero_domain, top_coe, zero_apply, Subtype.forall, mem_top,
  forall_true_left, forall_eq'] at h' 
[GOAL]
case h'.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
hdom : (f + g).domain = ⊤
h' : ∀ (a : E) (b : a ∈ (f + g).domain), ↑(f + g) { val := a, property := b } = 0
⊢ -↑f x = ↑g y
[PROOFSTEP]
specialize h' x.1 (by simp [hdom])
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
hdom : (f + g).domain = ⊤
h' : ∀ (a : E) (b : a ∈ (f + g).domain), ↑(f + g) { val := a, property := b } = 0
⊢ ↑x ∈ (f + g).domain
[PROOFSTEP]
simp [hdom]
[GOAL]
case h'.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
hdom : (f + g).domain = ⊤
h' : ↑(f + g) { val := ↑x, property := (_ : ↑x ∈ (f + g).domain) } = 0
⊢ -↑f x = ↑g y
[PROOFSTEP]
simp only [inf_coe, neg_domain, Eq.ndrec, Int.ofNat_eq_coe, add_apply, Subtype.coe_eta, ← neg_eq_iff_add_eq_zero] at h' 
[GOAL]
case h'.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
x : { x // x ∈ (-f).domain }
y : { x // x ∈ g.domain }
h : ↑x = ↑y
hdom : (f + g).domain = ⊤
h' : -↑f x = ↑g { val := ↑x, property := (_ : ↑{ val := ↑x, property := (_ : ↑x ∈ (f + g).domain) } ∈ ↑g.domain) }
⊢ -↑f x = ↑g y
[PROOFSTEP]
rw [h', h]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
K : Type u_5
inst✝² : DivisionRing K
inst✝¹ : Module K E
inst✝ : Module K F
f : E →ₗ.[K] F
x : E
y : F
hx : ¬x ∈ f.domain
⊢ Disjoint f.domain (mkSpanSingleton x y (_ : x = 0 → False)).domain
[PROOFSTEP]
simp [disjoint_span_singleton]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
K : Type u_5
inst✝² : DivisionRing K
inst✝¹ : Module K E
inst✝ : Module K F
f : E →ₗ.[K] F
x : E
y : F
hx : ¬x ∈ f.domain
⊢ x ∈ f.domain → x = 0
[PROOFSTEP]
exact fun h => False.elim <| hx h
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
K : Type u_5
inst✝² : DivisionRing K
inst✝¹ : Module K E
inst✝ : Module K F
f : E →ₗ.[K] F
x : E
y : F
hx : ¬x ∈ f.domain
x' : E
hx' : x' ∈ f.domain
c : K
⊢ ↑(supSpanSingleton f x y hx)
      { val := x' + c • x,
        property := (_ : x' + c • x ∈ f.domain ⊔ (mkSpanSingleton x y (_ : x = 0 → False)).domain) } =
    ↑f { val := x', property := hx' } + c • y
[PROOFSTEP]
erw [sup_apply _ ⟨x', hx'⟩ ⟨c • x, _⟩, mkSpanSingleton'_apply]
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
K : Type u_5
inst✝² : DivisionRing K
inst✝¹ : Module K E
inst✝ : Module K F
f : E →ₗ.[K] F
x : E
y : F
hx : ¬x ∈ f.domain
x' : E
hx' : x' ∈ f.domain
c : K
⊢ c • x ∈ (mkSpanSingleton' x y (_ : ∀ (c : K), c • x = 0 → c • y = 0)).domain
[PROOFSTEP]
exact mem_span_singleton.2 ⟨c, rfl⟩
[GOAL]
case hz
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
K : Type u_5
inst✝² : DivisionRing K
inst✝¹ : Module K E
inst✝ : Module K F
f : E →ₗ.[K] F
x : E
y : F
hx : ¬x ∈ f.domain
x' : E
hx' : x' ∈ f.domain
c : K
⊢ ↑{ val := x', property := hx' } + ↑{ val := c • x, property := (_ : c • x ∈ span K {x}) } =
    ↑{ val := x' + c • x, property := (_ : x' + c • x ∈ f.domain ⊔ (mkSpanSingleton x y (_ : x = 0 → False)).domain) }
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
⊢ ∃ f, { domain := sSup (domain '' c), toFun := f } ∈ upperBounds c
[PROOFSTEP]
cases' c.eq_empty_or_nonempty with ceq cne
[GOAL]
case inl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
ceq : c = ∅
⊢ ∃ f, { domain := sSup (domain '' c), toFun := f } ∈ upperBounds c
[PROOFSTEP]
subst c
[GOAL]
case inl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
hc : DirectedOn (fun x x_1 => x ≤ x_1) ∅
⊢ ∃ f, { domain := sSup (domain '' ∅), toFun := f } ∈ upperBounds ∅
[PROOFSTEP]
simp
[GOAL]
case inr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
⊢ ∃ f, { domain := sSup (domain '' c), toFun := f } ∈ upperBounds c
[PROOFSTEP]
have hdir : DirectedOn (· ≤ ·) (domain '' c) := directedOn_image.2 (hc.mono @(domain_mono.monotone))
[GOAL]
case inr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
⊢ ∃ f, { domain := sSup (domain '' c), toFun := f } ∈ upperBounds c
[PROOFSTEP]
have P : ∀ x : ↥(sSup (domain '' c)), { p : c // (x : E) ∈ p.val.domain } :=
  by
  rintro x
  apply Classical.indefiniteDescription
  have :=
    (mem_sSup_of_directed (cne.image _) hdir).1
      x.2
        -- Porting note: + `← bex_def`
  rwa [bex_image_iff, ← bex_def, SetCoe.exists'] at this 
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
⊢ (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
[PROOFSTEP]
rintro x
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
x : { x // x ∈ sSup (domain '' c) }
⊢ { p // ↑x ∈ (↑p).domain }
[PROOFSTEP]
apply Classical.indefiniteDescription
[GOAL]
case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
x : { x // x ∈ sSup (domain '' c) }
⊢ ∃ x_1, ↑x ∈ (↑x_1).domain
[PROOFSTEP]
have :=
  (mem_sSup_of_directed (cne.image _) hdir).1
    x.2
      -- Porting note: + `← bex_def`
[GOAL]
case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
x : { x // x ∈ sSup (domain '' c) }
this : ∃ y, y ∈ domain '' c ∧ ↑x ∈ y
⊢ ∃ x_1, ↑x ∈ (↑x_1).domain
[PROOFSTEP]
rwa [bex_image_iff, ← bex_def, SetCoe.exists'] at this 
[GOAL]
case inr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
⊢ ∃ f, { domain := sSup (domain '' c), toFun := f } ∈ upperBounds c
[PROOFSTEP]
set f : ↥(sSup (domain '' c)) → F := fun x => (P x).val.val ⟨x, (P x).property⟩
[GOAL]
case inr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
⊢ ∃ f, { domain := sSup (domain '' c), toFun := f } ∈ upperBounds c
[PROOFSTEP]
have f_eq : ∀ (p : c) (x : ↥(sSup (domain '' c))) (y : p.1.1) (_hxy : (x : E) = y), f x = p.1 y :=
  by
  intro p x y hxy
  rcases hc (P x).1.1 (P x).1.2 p.1 p.2 with
    ⟨q, _hqc, hxq, hpq⟩
      -- Porting note: `refine' ..; exacts [ofLe hpq.1 y, hxy, rfl]`
          --               → `refine' .. <;> [skip; exact ofLe hpq.1 y; rfl]; exact hxy`
  refine' (hxq.2 _).trans (hpq.2 _).symm <;> [skip; exact ofLe hpq.1 y; rfl]; exact hxy
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
⊢ ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
[PROOFSTEP]
intro p x y hxy
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
p : ↑c
x : { x // x ∈ sSup (domain '' c) }
y : { x // x ∈ (↑p).domain }
hxy : ↑x = ↑y
⊢ f x = ↑↑p y
[PROOFSTEP]
rcases hc (P x).1.1 (P x).1.2 p.1 p.2 with
  ⟨q, _hqc, hxq, hpq⟩
    -- Porting note: `refine' ..; exacts [ofLe hpq.1 y, hxy, rfl]`
        --               → `refine' .. <;> [skip; exact ofLe hpq.1 y; rfl]; exact hxy`
[GOAL]
case intro.intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
p : ↑c
x : { x // x ∈ sSup (domain '' c) }
y : { x // x ∈ (↑p).domain }
hxy : ↑x = ↑y
q : E →ₗ.[R] F
_hqc : q ∈ c
hxq : ↑↑(P x) ≤ q
hpq : ↑p ≤ q
⊢ f x = ↑↑p y
[PROOFSTEP]
refine' (hxq.2 _).trans (hpq.2 _).symm <;> [skip; exact ofLe hpq.1 y; rfl]
[GOAL]
case intro.intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
p : ↑c
x : { x // x ∈ sSup (domain '' c) }
y : { x // x ∈ (↑p).domain }
hxy : ↑x = ↑y
q : E →ₗ.[R] F
_hqc : q ∈ c
hxq : ↑↑(P x) ≤ q
hpq : ↑p ≤ q
⊢ f x = ↑↑p y
[PROOFSTEP]
refine' (hxq.2 _).trans (hpq.2 _).symm
[GOAL]
case intro.intro.intro.refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
p : ↑c
x : { x // x ∈ sSup (domain '' c) }
y : { x // x ∈ (↑p).domain }
hxy : ↑x = ↑y
q : E →ₗ.[R] F
_hqc : q ∈ c
hxq : ↑↑(P x) ≤ q
hpq : ↑p ≤ q
⊢ ↑{ val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) } = ↑?intro.intro.intro.refine'_2
[PROOFSTEP]
skip
[GOAL]
case intro.intro.intro.refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
p : ↑c
x : { x // x ∈ sSup (domain '' c) }
y : { x // x ∈ (↑p).domain }
hxy : ↑x = ↑y
q : E →ₗ.[R] F
_hqc : q ∈ c
hxq : ↑↑(P x) ≤ q
hpq : ↑p ≤ q
⊢ { x // x ∈ q.domain }
[PROOFSTEP]
exact ofLe hpq.1 y
[GOAL]
case intro.intro.intro.refine'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
p : ↑c
x : { x // x ∈ sSup (domain '' c) }
y : { x // x ∈ (↑p).domain }
hxy : ↑x = ↑y
q : E →ₗ.[R] F
_hqc : q ∈ c
hxq : ↑↑(P x) ≤ q
hpq : ↑p ≤ q
⊢ ↑y = ↑(↑(ofLe (_ : (↑p).domain ≤ q.domain)) y)
[PROOFSTEP]
rfl
[GOAL]
case intro.intro.intro.refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
p : ↑c
x : { x // x ∈ sSup (domain '' c) }
y : { x // x ∈ (↑p).domain }
hxy : ↑x = ↑y
q : E →ₗ.[R] F
_hqc : q ∈ c
hxq : ↑↑(P x) ≤ q
hpq : ↑p ≤ q
⊢ ↑{ val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) } = ↑(↑(ofLe (_ : (↑p).domain ≤ q.domain)) y)
[PROOFSTEP]
exact hxy
[GOAL]
case inr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
⊢ ∃ f, { domain := sSup (domain '' c), toFun := f } ∈ upperBounds c
[PROOFSTEP]
refine' ⟨{ toFun := f .. }, _⟩
[GOAL]
case inr.refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
⊢ ∀ (x y : { x // x ∈ sSup (domain '' c) }), f (x + y) = f x + f y
[PROOFSTEP]
intro x y
[GOAL]
case inr.refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
x y : { x // x ∈ sSup (domain '' c) }
⊢ f (x + y) = f x + f y
[PROOFSTEP]
rcases hc (P x).1.1 (P x).1.2 (P y).1.1 (P y).1.2 with ⟨p, hpc, hpx, hpy⟩
[GOAL]
case inr.refine'_1.intro.intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
x y : { x // x ∈ sSup (domain '' c) }
p : E →ₗ.[R] F
hpc : p ∈ c
hpx : ↑↑(P x) ≤ p
hpy : ↑↑(P y) ≤ p
⊢ f (x + y) = f x + f y
[PROOFSTEP]
set x' := ofLe hpx.1 ⟨x, (P x).2⟩
[GOAL]
case inr.refine'_1.intro.intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
x y : { x // x ∈ sSup (domain '' c) }
p : E →ₗ.[R] F
hpc : p ∈ c
hpx : ↑↑(P x) ≤ p
hpy : ↑↑(P y) ≤ p
x' : { x // x ∈ p.domain } :=
  ↑(ofLe (_ : (↑↑(P x)).domain ≤ p.domain)) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
⊢ f (x + y) = f x + f y
[PROOFSTEP]
set y' := ofLe hpy.1 ⟨y, (P y).2⟩
[GOAL]
case inr.refine'_1.intro.intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
x y : { x // x ∈ sSup (domain '' c) }
p : E →ₗ.[R] F
hpc : p ∈ c
hpx : ↑↑(P x) ≤ p
hpy : ↑↑(P y) ≤ p
x' : { x // x ∈ p.domain } :=
  ↑(ofLe (_ : (↑↑(P x)).domain ≤ p.domain)) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
y' : { x // x ∈ p.domain } :=
  ↑(ofLe (_ : (↑↑(P y)).domain ≤ p.domain)) { val := ↑y, property := (_ : ↑y ∈ (↑↑(P y)).domain) }
⊢ f (x + y) = f x + f y
[PROOFSTEP]
rw [f_eq ⟨p, hpc⟩ x x' rfl, f_eq ⟨p, hpc⟩ y y' rfl, f_eq ⟨p, hpc⟩ (x + y) (x' + y') rfl, map_add]
[GOAL]
case inr.refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
⊢ ∀ (r : R) (x : { x // x ∈ sSup (domain '' c) }),
    AddHom.toFun { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c) }), f (x + y) = f x + f y) }
        (r • x) =
      ↑(RingHom.id R) r •
        AddHom.toFun { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c) }), f (x + y) = f x + f y) }
          x
[PROOFSTEP]
intro c x
[GOAL]
case inr.refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c✝ : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c✝
cne : Set.Nonempty c✝
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c✝)
P : (x : { x // x ∈ sSup (domain '' c✝) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c✝) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c✝) (x : { x // x ∈ sSup (domain '' c✝) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
c : R
x : { x // x ∈ sSup (domain '' c✝) }
⊢ AddHom.toFun { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c✝) }), f (x + y) = f x + f y) }
      (c • x) =
    ↑(RingHom.id R) c •
      AddHom.toFun { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c✝) }), f (x + y) = f x + f y) } x
[PROOFSTEP]
simp only [f_eq (P x).1 (c • x) (c • ⟨x, (P x).2⟩) rfl, ← map_smul, RingHom.id_apply]
[GOAL]
case inr.refine'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
⊢ { domain := sSup (domain '' c),
      toFun :=
        {
          toAddHom :=
            { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c) }), f (x + y) = f x + f y) },
          map_smul' :=
            (_ :
              ∀ (c_1 : R) (x : { x // x ∈ sSup (domain '' c) }),
                f (c_1 • x) = c_1 • ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }) } } ∈
    upperBounds c
[PROOFSTEP]
intro p hpc
[GOAL]
case inr.refine'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
p : E →ₗ.[R] F
hpc : p ∈ c
⊢ p ≤
    { domain := sSup (domain '' c),
      toFun :=
        {
          toAddHom :=
            { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c) }), f (x + y) = f x + f y) },
          map_smul' :=
            (_ :
              ∀ (c_1 : R) (x : { x // x ∈ sSup (domain '' c) }),
                f (c_1 • x) = c_1 • ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }) } }
[PROOFSTEP]
refine' ⟨le_sSup <| mem_image_of_mem domain hpc, fun x y hxy => Eq.symm _⟩
[GOAL]
case inr.refine'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
cne : Set.Nonempty c
hdir : DirectedOn (fun x x_1 => x ≤ x_1) (domain '' c)
P : (x : { x // x ∈ sSup (domain '' c) }) → { p // ↑x ∈ (↑p).domain }
f : { x // x ∈ sSup (domain '' c) } → F := fun x => ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }
f_eq : ∀ (p : ↑c) (x : { x // x ∈ sSup (domain '' c) }) (y : { x // x ∈ (↑p).domain }), ↑x = ↑y → f x = ↑↑p y
p : E →ₗ.[R] F
hpc : p ∈ c
x : { x // x ∈ p.domain }
y :
  { x //
    x ∈
      { domain := sSup (domain '' c),
          toFun :=
            {
              toAddHom :=
                { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c) }), f (x + y) = f x + f y) },
              map_smul' :=
                (_ :
                  ∀ (c_1 : R) (x : { x // x ∈ sSup (domain '' c) }),
                    f (c_1 • x) = c_1 • ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }) } }.domain }
hxy : ↑x = ↑y
⊢ ↑{ domain := sSup (domain '' c),
          toFun :=
            {
              toAddHom :=
                { toFun := f, map_add' := (_ : ∀ (x y : { x // x ∈ sSup (domain '' c) }), f (x + y) = f x + f y) },
              map_smul' :=
                (_ :
                  ∀ (c_1 : R) (x : { x // x ∈ sSup (domain '' c) }),
                    f (c_1 • x) = c_1 • ↑↑↑(P x) { val := ↑x, property := (_ : ↑x ∈ (↑↑(P x)).domain) }) } }
      y =
    ↑p x
[PROOFSTEP]
exact f_eq ⟨p, hpc⟩ _ _ hxy.symm
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : { x // x ∈ l.domain }
⊢ ↑(LinearPMap.sSup c hc) { val := ↑x, property := (_ : ↑x ∈ (LinearPMap.sSup c hc).domain) } = ↑l x
[PROOFSTEP]
symm
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : { x // x ∈ l.domain }
⊢ ↑l x = ↑(LinearPMap.sSup c hc) { val := ↑x, property := (_ : ↑x ∈ (LinearPMap.sSup c hc).domain) }
[PROOFSTEP]
apply (Classical.choose_spec (sSup_aux c hc) hl).2
[GOAL]
case _h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : { x // x ∈ l.domain }
⊢ ↑x = ↑{ val := ↑x, property := (_ : ↑x ∈ (LinearPMap.sSup c hc).domain) }
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
⊢ S ⊓ f.domain ≤ f.domain
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑(domRestrict f S) x = ↑f y
[PROOFSTEP]
have : Submodule.ofLe (by simp) x = y := by
  ext
  simp [h]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ S ⊓ f.domain ≤ f.domain
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x = y
[PROOFSTEP]
ext
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑(↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x) = ↑y
[PROOFSTEP]
simp [h]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
this : ↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x = y
⊢ ↑(domRestrict f S) x = ↑f y
[PROOFSTEP]
rw [← this]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
x : { x // x ∈ S ⊓ f.domain }
y : { x // x ∈ f.domain }
h : ↑x = ↑y
this : ↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x = y
⊢ ↑(domRestrict f S) x = ↑f (↑(Submodule.ofLe (_ : S ⊓ f.domain ≤ f.domain)) x)
[PROOFSTEP]
exact LinearPMap.mk_apply _ _ _
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
⊢ (domRestrict f S).domain ≤ f.domain
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E × F
⊢ x ∈ graph f ↔ ∃ y, (↑y, ↑f y) = x
[PROOFSTEP]
simp [graph]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E × F
⊢ x ∈ graph f ↔ ∃ y, ↑y = x.fst ∧ ↑f y = x.snd
[PROOFSTEP]
cases x
[GOAL]
case mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
fst✝ : E
snd✝ : F
⊢ (fst✝, snd✝) ∈ graph f ↔ ∃ y, ↑y = (fst✝, snd✝).fst ∧ ↑f y = (fst✝, snd✝).snd
[PROOFSTEP]
simp_rw [mem_graph_iff', Prod.mk.inj_iff]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ f.domain }
⊢ (↑x, ↑f x) ∈ graph f
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ Submodule.map (LinearMap.fst R E F) (graph f) = f.domain
[PROOFSTEP]
ext x
[GOAL]
case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ x ∈ Submodule.map (LinearMap.fst R E F) (graph f) ↔ x ∈ f.domain
[PROOFSTEP]
simp only [Submodule.mem_map, mem_graph_iff, Subtype.exists, exists_and_left, exists_eq_left, LinearMap.fst_apply,
  Prod.exists, exists_and_right, exists_eq_right]
[GOAL]
case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ (∃ x_1 h, ↑f { val := x, property := (_ : (x, x_1).fst ∈ f.domain) } = x_1) ↔ x ∈ f.domain
[PROOFSTEP]
constructor
[GOAL]
case h.mp
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ (∃ x_1 h, ↑f { val := x, property := (_ : (x, x_1).fst ∈ f.domain) } = x_1) → x ∈ f.domain
[PROOFSTEP]
intro h
[GOAL]
case h.mpr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ x ∈ f.domain → ∃ x_1 h, ↑f { val := x, property := (_ : (x, x_1).fst ∈ f.domain) } = x_1
[PROOFSTEP]
intro h
[GOAL]
case h.mp
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
h : ∃ x_1 h, ↑f { val := x, property := (_ : (x, x_1).fst ∈ f.domain) } = x_1
⊢ x ∈ f.domain
[PROOFSTEP]
rcases h with ⟨x, hx, _⟩
[GOAL]
case h.mp.intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x✝ : E
x : F
hx : x✝ ∈ f.domain
h✝ : ↑f { val := x✝, property := (_ : (x✝, x).fst ∈ f.domain) } = x
⊢ x✝ ∈ f.domain
[PROOFSTEP]
exact hx
[GOAL]
case h.mpr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
h : x ∈ f.domain
⊢ ∃ x_1 h, ↑f { val := x, property := (_ : (x, x_1).fst ∈ f.domain) } = x_1
[PROOFSTEP]
use f ⟨x, h⟩
[GOAL]
case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
h : x ∈ f.domain
⊢ ∃ h_1,
    ↑f { val := x, property := (_ : (x, ↑f { val := x, property := h }).fst ∈ f.domain) } =
      ↑f { val := x, property := h }
[PROOFSTEP]
simp only [h, exists_prop]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ Submodule.map (LinearMap.snd R E F) (graph f) = LinearMap.range f.toFun
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x✝ : F
⊢ x✝ ∈ Submodule.map (LinearMap.snd R E F) (graph f) ↔ x✝ ∈ LinearMap.range f.toFun
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
⊢ graph (z • f) = Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
ext x
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x : E × F
⊢ x ∈ graph (z • f) ↔ x ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
cases' x with x_fst x_snd
[GOAL]
case h.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
⊢ (x_fst, x_snd) ∈ graph (z • f) ↔
    (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
constructor
[GOAL]
case h.mk.mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
⊢ (x_fst, x_snd) ∈ graph (z • f) →
    (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
intro h
[GOAL]
case h.mk.mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f) →
    (x_fst, x_snd) ∈ graph (z • f)
[PROOFSTEP]
intro h
[GOAL]
case h.mk.mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
h : (x_fst, x_snd) ∈ graph (z • f)
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
rw [mem_graph_iff] at h 
[GOAL]
case h.mk.mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
h : ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(z • f) y = (x_fst, x_snd).snd
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
rcases h with ⟨y, hy, h⟩
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
y : { x // x ∈ (z • f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : ↑(z • f) y = (x_fst, x_snd).snd
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
rw [LinearPMap.smul_apply] at h 
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
y : { x // x ∈ (z • f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : z • ↑f y = (x_fst, x_snd).snd
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
[PROOFSTEP]
rw [Submodule.mem_map]
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
y : { x // x ∈ (z • f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : z • ↑f y = (x_fst, x_snd).snd
⊢ ∃ y, y ∈ graph f ∧ ↑(LinearMap.prodMap LinearMap.id (z • LinearMap.id)) y = (x_fst, x_snd)
[PROOFSTEP]
simp only [mem_graph_iff, LinearMap.prodMap_apply, LinearMap.id_coe, id.def, LinearMap.smul_apply, Prod.mk.inj_iff,
  Prod.exists, exists_exists_and_eq_and]
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
y : { x // x ∈ (z • f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : z • ↑f y = (x_fst, x_snd).snd
⊢ ∃ a a_1, ↑a_1 = a ∧ a = x_fst ∧ z • ↑f a_1 = x_snd
[PROOFSTEP]
use x_fst, y, hy
[GOAL]
case h.mk.mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
h : (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (graph f)
⊢ (x_fst, x_snd) ∈ graph (z • f)
[PROOFSTEP]
rw [Submodule.mem_map] at h 
[GOAL]
case h.mk.mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
h : ∃ y, y ∈ graph f ∧ ↑(LinearMap.prodMap LinearMap.id (z • LinearMap.id)) y = (x_fst, x_snd)
⊢ (x_fst, x_snd) ∈ graph (z • f)
[PROOFSTEP]
rcases h with ⟨x', hx', h⟩
[GOAL]
case h.mk.mpr.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
x' : E × F
hx' : x' ∈ graph f
h : ↑(LinearMap.prodMap LinearMap.id (z • LinearMap.id)) x' = (x_fst, x_snd)
⊢ (x_fst, x_snd) ∈ graph (z • f)
[PROOFSTEP]
cases x'
[GOAL]
case h.mk.mpr.intro.intro.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
hx' : (fst✝, snd✝) ∈ graph f
h : ↑(LinearMap.prodMap LinearMap.id (z • LinearMap.id)) (fst✝, snd✝) = (x_fst, x_snd)
⊢ (x_fst, x_snd) ∈ graph (z • f)
[PROOFSTEP]
simp only [LinearMap.prodMap_apply, LinearMap.id_coe, id.def, LinearMap.smul_apply, Prod.mk.inj_iff] at h 
[GOAL]
case h.mk.mpr.intro.intro.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
hx' : (fst✝, snd✝) ∈ graph f
h : fst✝ = x_fst ∧ z • snd✝ = x_snd
⊢ (x_fst, x_snd) ∈ graph (z • f)
[PROOFSTEP]
rw [mem_graph_iff] at hx' ⊢
[GOAL]
case h.mk.mpr.intro.intro.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
hx' : ∃ y, ↑y = (fst✝, snd✝).fst ∧ ↑f y = (fst✝, snd✝).snd
h : fst✝ = x_fst ∧ z • snd✝ = x_snd
⊢ ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(z • f) y = (x_fst, x_snd).snd
[PROOFSTEP]
rcases hx' with ⟨y, hy, hx'⟩
[GOAL]
case h.mk.mpr.intro.intro.mk.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
h : fst✝ = x_fst ∧ z • snd✝ = x_snd
y : { x // x ∈ f.domain }
hy : ↑y = (fst✝, snd✝).fst
hx' : ↑f y = (fst✝, snd✝).snd
⊢ ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(z • f) y = (x_fst, x_snd).snd
[PROOFSTEP]
use y
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
h : fst✝ = x_fst ∧ z • snd✝ = x_snd
y : { x // x ∈ f.domain }
hy : ↑y = (fst✝, snd✝).fst
hx' : ↑f y = (fst✝, snd✝).snd
⊢ ↑y = (x_fst, x_snd).fst ∧ ↑(z • f) y = (x_fst, x_snd).snd
[PROOFSTEP]
rw [← h.1, ← h.2]
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
z : M
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
h : fst✝ = x_fst ∧ z • snd✝ = x_snd
y : { x // x ∈ f.domain }
hy : ↑y = (fst✝, snd✝).fst
hx' : ↑f y = (fst✝, snd✝).snd
⊢ ↑y = (fst✝, z • snd✝).fst ∧ ↑(z • f) y = (fst✝, z • snd✝).snd
[PROOFSTEP]
simp [hy, hx']
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
⊢ graph (-f) = Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
ext x
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x : E × F
⊢ x ∈ graph (-f) ↔ x ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
cases' x with x_fst x_snd
[GOAL]
case h.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
⊢ (x_fst, x_snd) ∈ graph (-f) ↔
    (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
constructor
[GOAL]
case h.mk.mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
⊢ (x_fst, x_snd) ∈ graph (-f) →
    (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
intro h
[GOAL]
case h.mk.mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f) →
    (x_fst, x_snd) ∈ graph (-f)
[PROOFSTEP]
intro h
[GOAL]
case h.mk.mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
h : (x_fst, x_snd) ∈ graph (-f)
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
rw [mem_graph_iff] at h 
[GOAL]
case h.mk.mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
h : ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(-f) y = (x_fst, x_snd).snd
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
rcases h with ⟨y, hy, h⟩
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
y : { x // x ∈ (-f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : ↑(-f) y = (x_fst, x_snd).snd
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
rw [LinearPMap.neg_apply] at h 
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
y : { x // x ∈ (-f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : -↑f y = (x_fst, x_snd).snd
⊢ (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
[PROOFSTEP]
rw [Submodule.mem_map]
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
y : { x // x ∈ (-f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : -↑f y = (x_fst, x_snd).snd
⊢ ∃ y, y ∈ graph f ∧ ↑(LinearMap.prodMap LinearMap.id (-LinearMap.id)) y = (x_fst, x_snd)
[PROOFSTEP]
simp only [mem_graph_iff, LinearMap.prodMap_apply, LinearMap.id_coe, id.def, LinearMap.neg_apply, Prod.mk.inj_iff,
  Prod.exists, exists_exists_and_eq_and]
[GOAL]
case h.mk.mp.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
y : { x // x ∈ (-f).domain }
hy : ↑y = (x_fst, x_snd).fst
h : -↑f y = (x_fst, x_snd).snd
⊢ ∃ a a_1, ↑a_1 = a ∧ a = x_fst ∧ -↑f a_1 = x_snd
[PROOFSTEP]
use x_fst, y, hy
[GOAL]
case h.mk.mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
h : (x_fst, x_snd) ∈ Submodule.map (LinearMap.prodMap LinearMap.id (-LinearMap.id)) (graph f)
⊢ (x_fst, x_snd) ∈ graph (-f)
[PROOFSTEP]
rw [Submodule.mem_map] at h 
[GOAL]
case h.mk.mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
h : ∃ y, y ∈ graph f ∧ ↑(LinearMap.prodMap LinearMap.id (-LinearMap.id)) y = (x_fst, x_snd)
⊢ (x_fst, x_snd) ∈ graph (-f)
[PROOFSTEP]
rcases h with ⟨x', hx', h⟩
[GOAL]
case h.mk.mpr.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
x' : E × F
hx' : x' ∈ graph f
h : ↑(LinearMap.prodMap LinearMap.id (-LinearMap.id)) x' = (x_fst, x_snd)
⊢ (x_fst, x_snd) ∈ graph (-f)
[PROOFSTEP]
cases x'
[GOAL]
case h.mk.mpr.intro.intro.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
hx' : (fst✝, snd✝) ∈ graph f
h : ↑(LinearMap.prodMap LinearMap.id (-LinearMap.id)) (fst✝, snd✝) = (x_fst, x_snd)
⊢ (x_fst, x_snd) ∈ graph (-f)
[PROOFSTEP]
simp only [LinearMap.prodMap_apply, LinearMap.id_coe, id.def, LinearMap.neg_apply, Prod.mk.inj_iff] at h 
[GOAL]
case h.mk.mpr.intro.intro.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
hx' : (fst✝, snd✝) ∈ graph f
h : fst✝ = x_fst ∧ -snd✝ = x_snd
⊢ (x_fst, x_snd) ∈ graph (-f)
[PROOFSTEP]
rw [mem_graph_iff] at hx' ⊢
[GOAL]
case h.mk.mpr.intro.intro.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
hx' : ∃ y, ↑y = (fst✝, snd✝).fst ∧ ↑f y = (fst✝, snd✝).snd
h : fst✝ = x_fst ∧ -snd✝ = x_snd
⊢ ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(-f) y = (x_fst, x_snd).snd
[PROOFSTEP]
rcases hx' with ⟨y, hy, hx'⟩
[GOAL]
case h.mk.mpr.intro.intro.mk.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
h : fst✝ = x_fst ∧ -snd✝ = x_snd
y : { x // x ∈ f.domain }
hy : ↑y = (fst✝, snd✝).fst
hx' : ↑f y = (fst✝, snd✝).snd
⊢ ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(-f) y = (x_fst, x_snd).snd
[PROOFSTEP]
use y
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
h : fst✝ = x_fst ∧ -snd✝ = x_snd
y : { x // x ∈ f.domain }
hy : ↑y = (fst✝, snd✝).fst
hx' : ↑f y = (fst✝, snd✝).snd
⊢ ↑y = (x_fst, x_snd).fst ∧ ↑(-f) y = (x_fst, x_snd).snd
[PROOFSTEP]
rw [← h.1, ← h.2]
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x_fst : E
x_snd : F
fst✝ : E
snd✝ : F
h : fst✝ = x_fst ∧ -snd✝ = x_snd
y : { x // x ∈ f.domain }
hy : ↑y = (fst✝, snd✝).fst
hx' : ↑f y = (fst✝, snd✝).snd
⊢ ↑y = (fst✝, -snd✝).fst ∧ ↑(-f) y = (fst✝, -snd✝).snd
[PROOFSTEP]
simp [hy, hx']
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x y : E
x' y' : F
hx : (x, x') ∈ graph f
hy : (y, y') ∈ graph f
hxy : x = y
⊢ x' = y'
[PROOFSTEP]
rw [mem_graph_iff] at hx hy 
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x y : E
x' y' : F
hx : ∃ y, ↑y = (x, x').fst ∧ ↑f y = (x, x').snd
hy : ∃ y_1, ↑y_1 = (y, y').fst ∧ ↑f y_1 = (y, y').snd
hxy : x = y
⊢ x' = y'
[PROOFSTEP]
rcases hx with ⟨x'', hx1, hx2⟩
[GOAL]
case intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x y : E
x' y' : F
hy : ∃ y_1, ↑y_1 = (y, y').fst ∧ ↑f y_1 = (y, y').snd
hxy : x = y
x'' : { x // x ∈ f.domain }
hx1 : ↑x'' = (x, x').fst
hx2 : ↑f x'' = (x, x').snd
⊢ x' = y'
[PROOFSTEP]
rcases hy with ⟨y'', hy1, hy2⟩
[GOAL]
case intro.intro.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x y : E
x' y' : F
hxy : x = y
x'' : { x // x ∈ f.domain }
hx1 : ↑x'' = (x, x').fst
hx2 : ↑f x'' = (x, x').snd
y'' : { x // x ∈ f.domain }
hy1 : ↑y'' = (y, y').fst
hy2 : ↑f y'' = (y, y').snd
⊢ x' = y'
[PROOFSTEP]
simp only at hx1 hx2 hy1 hy2 
[GOAL]
case intro.intro.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x y : E
x' y' : F
hxy : x = y
x'' : { x // x ∈ f.domain }
hx1 : ↑x'' = x
hx2 : ↑f x'' = x'
y'' : { x // x ∈ f.domain }
hy1 : ↑y'' = y
hy2 : ↑f y'' = y'
⊢ x' = y'
[PROOFSTEP]
rw [← hx1, ← hy1, SetLike.coe_eq_coe] at hxy 
[GOAL]
case intro.intro.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x y : E
x' y' : F
x'' : { x // x ∈ f.domain }
hx1 : ↑x'' = x
hx2 : ↑f x'' = x'
y'' : { x // x ∈ f.domain }
hxy : x'' = y''
hy1 : ↑y'' = y
hy2 : ↑f y'' = y'
⊢ x' = y'
[PROOFSTEP]
rw [← hx2, ← hy2, hxy]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x y : E × F
hx : x ∈ graph f
hy : y ∈ graph f
hxy : x.fst = y.fst
⊢ x.snd = y.snd
[PROOFSTEP]
cases x
[GOAL]
case mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : E × F
hy : y ∈ graph f
fst✝ : E
snd✝ : F
hx : (fst✝, snd✝) ∈ graph f
hxy : (fst✝, snd✝).fst = y.fst
⊢ (fst✝, snd✝).snd = y.snd
[PROOFSTEP]
cases y
[GOAL]
case mk.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
fst✝¹ : E
snd✝¹ : F
hx : (fst✝¹, snd✝¹) ∈ graph f
fst✝ : E
snd✝ : F
hy : (fst✝, snd✝) ∈ graph f
hxy : (fst✝¹, snd✝¹).fst = (fst✝, snd✝).fst
⊢ (fst✝¹, snd✝¹).snd = (fst✝, snd✝).snd
[PROOFSTEP]
exact f.mem_graph_snd_inj hx hy hxy
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x : E
⊢ x ∈ f.domain ↔ ∃ y, (x, y) ∈ graph f
[PROOFSTEP]
constructor
[GOAL]
case mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x : E
⊢ x ∈ f.domain → ∃ y, (x, y) ∈ graph f
[PROOFSTEP]
intro h
[GOAL]
case mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x : E
⊢ (∃ y, (x, y) ∈ graph f) → x ∈ f.domain
[PROOFSTEP]
intro h
[GOAL]
case mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x : E
h : x ∈ f.domain
⊢ ∃ y, (x, y) ∈ graph f
[PROOFSTEP]
use f ⟨x, h⟩
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x : E
h : x ∈ f.domain
⊢ (x, ↑f { val := x, property := h }) ∈ graph f
[PROOFSTEP]
exact f.mem_graph ⟨x, h⟩
[GOAL]
case mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f : E →ₗ.[R] F
x : E
h : ∃ y, (x, y) ∈ graph f
⊢ x ∈ f.domain
[PROOFSTEP]
cases' h with y h
[GOAL]
case mpr.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
h : (x, y) ∈ graph f
⊢ x ∈ f.domain
[PROOFSTEP]
rw [mem_graph_iff] at h 
[GOAL]
case mpr.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
h : ∃ y_1, ↑y_1 = (x, y).fst ∧ ↑f y_1 = (x, y).snd
⊢ x ∈ f.domain
[PROOFSTEP]
cases' h with x' h
[GOAL]
case mpr.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
x' : { x // x ∈ f.domain }
h : ↑x' = (x, y).fst ∧ ↑f x' = (x, y).snd
⊢ x ∈ f.domain
[PROOFSTEP]
simp only at h 
[GOAL]
case mpr.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
x' : { x // x ∈ f.domain }
h : ↑x' = x ∧ ↑f x' = y
⊢ x ∈ f.domain
[PROOFSTEP]
rw [← h.1]
[GOAL]
case mpr.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
x' : { x // x ∈ f.domain }
h : ↑x' = x ∧ ↑f x' = y
⊢ ↑x' ∈ f.domain
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
h : (x, y) ∈ graph f
⊢ x ∈ f.domain
[PROOFSTEP]
rw [mem_domain_iff]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
h : (x, y) ∈ graph f
⊢ ∃ y, (x, y) ∈ graph f
[PROOFSTEP]
exact ⟨y, h⟩
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
⊢ y = ↑f { val := x, property := hx } ↔ (x, y) ∈ graph f
[PROOFSTEP]
rw [mem_graph_iff]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
⊢ y = ↑f { val := x, property := hx } ↔ ∃ y_1, ↑y_1 = (x, y).fst ∧ ↑f y_1 = (x, y).snd
[PROOFSTEP]
constructor
[GOAL]
case mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
⊢ y = ↑f { val := x, property := hx } → ∃ y_1, ↑y_1 = (x, y).fst ∧ ↑f y_1 = (x, y).snd
[PROOFSTEP]
intro h
[GOAL]
case mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
⊢ (∃ y_1, ↑y_1 = (x, y).fst ∧ ↑f y_1 = (x, y).snd) → y = ↑f { val := x, property := hx }
[PROOFSTEP]
intro h
[GOAL]
case mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
h : y = ↑f { val := x, property := hx }
⊢ ∃ y_1, ↑y_1 = (x, y).fst ∧ ↑f y_1 = (x, y).snd
[PROOFSTEP]
use⟨x, hx⟩
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
h : y = ↑f { val := x, property := hx }
⊢ ↑{ val := x, property := hx } = (x, y).fst ∧ ↑f { val := x, property := hx } = (x, y).snd
[PROOFSTEP]
simp [h]
[GOAL]
case mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
h : ∃ y_1, ↑y_1 = (x, y).fst ∧ ↑f y_1 = (x, y).snd
⊢ y = ↑f { val := x, property := hx }
[PROOFSTEP]
rcases h with ⟨⟨x', hx'⟩, ⟨h1, h2⟩⟩
[GOAL]
case mpr.intro.mk.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
x' : E
hx' : x' ∈ f.domain
h1 : ↑{ val := x', property := hx' } = (x, y).fst
h2 : ↑f { val := x', property := hx' } = (x, y).snd
⊢ y = ↑f { val := x, property := hx }
[PROOFSTEP]
simp only [Submodule.coe_mk] at h1 h2 
[GOAL]
case mpr.intro.mk.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
hx : x ∈ f.domain
x' : E
hx' : x' ∈ f.domain
h1 : x' = x
h2 : ↑f { val := x', property := hx' } = y
⊢ y = ↑f { val := x, property := hx }
[PROOFSTEP]
simp only [← h2, h1]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
⊢ y ∈ range ↑f ↔ ∃ x, (x, y) ∈ graph f
[PROOFSTEP]
constructor
[GOAL]
case mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
⊢ y ∈ range ↑f → ∃ x, (x, y) ∈ graph f
[PROOFSTEP]
intro h
[GOAL]
case mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
⊢ (∃ x, (x, y) ∈ graph f) → y ∈ range ↑f
[PROOFSTEP]
intro h
[GOAL]
case mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
h : y ∈ range ↑f
⊢ ∃ x, (x, y) ∈ graph f
[PROOFSTEP]
rw [Set.mem_range] at h 
[GOAL]
case mp
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
h : ∃ y_1, ↑f y_1 = y
⊢ ∃ x, (x, y) ∈ graph f
[PROOFSTEP]
rcases h with ⟨⟨x, hx⟩, h⟩
[GOAL]
case mp.intro.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x : E
hx : x ∈ f.domain
h : ↑f { val := x, property := hx } = y
⊢ ∃ x, (x, y) ∈ graph f
[PROOFSTEP]
use x
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x : E
hx : x ∈ f.domain
h : ↑f { val := x, property := hx } = y
⊢ (x, y) ∈ graph f
[PROOFSTEP]
rw [← h]
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x : E
hx : x ∈ f.domain
h : ↑f { val := x, property := hx } = y
⊢ (x, ↑f { val := x, property := hx }) ∈ graph f
[PROOFSTEP]
exact f.mem_graph ⟨x, hx⟩
[GOAL]
case mpr
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
h : ∃ x, (x, y) ∈ graph f
⊢ y ∈ range ↑f
[PROOFSTEP]
cases' h with x h
[GOAL]
case mpr.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x : E
h : (x, y) ∈ graph f
⊢ y ∈ range ↑f
[PROOFSTEP]
rw [mem_graph_iff] at h 
[GOAL]
case mpr.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x : E
h : ∃ y_1, ↑y_1 = (x, y).fst ∧ ↑f y_1 = (x, y).snd
⊢ y ∈ range ↑f
[PROOFSTEP]
cases' h with x h
[GOAL]
case mpr.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x✝ : E
x : { x // x ∈ f.domain }
h : ↑x = (x✝, y).fst ∧ ↑f x = (x✝, y).snd
⊢ y ∈ range ↑f
[PROOFSTEP]
rw [Set.mem_range]
[GOAL]
case mpr.intro.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x✝ : E
x : { x // x ∈ f.domain }
h : ↑x = (x✝, y).fst ∧ ↑f x = (x✝, y).snd
⊢ ∃ y_1, ↑f y_1 = y
[PROOFSTEP]
use x
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x✝ : E
x : { x // x ∈ f.domain }
h : ↑x = (x✝, y).fst ∧ ↑f x = (x✝, y).snd
⊢ ↑f x = y
[PROOFSTEP]
simp only at h 
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
y : F
x✝ : E
x : { x // x ∈ f.domain }
h : ↑x = x✝ ∧ ↑f x = y
⊢ ↑f x = y
[PROOFSTEP]
rw [h.2]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f = graph g
x : E
⊢ x ∈ f.domain ↔ x ∈ g.domain
[PROOFSTEP]
simp_rw [mem_domain_iff, h]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
⊢ f ≤ g
[PROOFSTEP]
constructor
[GOAL]
case left
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
⊢ f.domain ≤ g.domain
[PROOFSTEP]
intro x hx
[GOAL]
case left
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx : x ∈ f.domain
⊢ x ∈ g.domain
[PROOFSTEP]
rw [mem_domain_iff] at hx ⊢
[GOAL]
case left
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx : ∃ y, (x, y) ∈ graph f
⊢ ∃ y, (x, y) ∈ graph g
[PROOFSTEP]
cases' hx with y hx
[GOAL]
case left.intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
y : F
hx : (x, y) ∈ graph f
⊢ ∃ y, (x, y) ∈ graph g
[PROOFSTEP]
use y
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
y : F
hx : (x, y) ∈ graph f
⊢ (x, y) ∈ graph g
[PROOFSTEP]
exact h hx
[GOAL]
case right
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
⊢ ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
[PROOFSTEP]
rintro ⟨x, hx⟩ ⟨y, hy⟩ hxy
[GOAL]
case right.mk.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx : x ∈ f.domain
y : E
hy : y ∈ g.domain
hxy : ↑{ val := x, property := hx } = ↑{ val := y, property := hy }
⊢ ↑f { val := x, property := hx } = ↑g { val := y, property := hy }
[PROOFSTEP]
rw [image_iff]
[GOAL]
case right.mk.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx : x ∈ f.domain
y : E
hy : y ∈ g.domain
hxy : ↑{ val := x, property := hx } = ↑{ val := y, property := hy }
⊢ (y, ↑f { val := x, property := hx }) ∈ graph g
[PROOFSTEP]
refine' h _
[GOAL]
case right.mk.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx : x ∈ f.domain
y : E
hy : y ∈ g.domain
hxy : ↑{ val := x, property := hx } = ↑{ val := y, property := hy }
⊢ (y, ↑f { val := x, property := hx }) ∈ graph f
[PROOFSTEP]
simp only [Submodule.coe_mk] at hxy 
[GOAL]
case right.mk.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx : x ∈ f.domain
y : E
hy : y ∈ g.domain
hxy : x = y
⊢ (y, ↑f { val := x, property := hx }) ∈ graph f
[PROOFSTEP]
rw [hxy] at hx 
[GOAL]
case right.mk.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx✝ : x ∈ f.domain
y : E
hx : y ∈ f.domain
hy : y ∈ g.domain
hxy : x = y
⊢ (y, ↑f { val := x, property := hx✝ }) ∈ graph f
[PROOFSTEP]
rw [← image_iff hx]
[GOAL]
case right.mk.mk
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f ≤ graph g
x : E
hx✝ : x ∈ f.domain
y : E
hx : y ∈ f.domain
hy : y ∈ g.domain
hxy : x = y
⊢ ↑f { val := x, property := hx✝ } = ↑f { val := y, property := hx }
[PROOFSTEP]
simp [hxy]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : f ≤ g
⊢ graph f ≤ graph g
[PROOFSTEP]
intro x hx
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : f ≤ g
x : E × F
hx : x ∈ graph f
⊢ x ∈ graph g
[PROOFSTEP]
rw [mem_graph_iff] at hx ⊢
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : f ≤ g
x : E × F
hx : ∃ y, ↑y = x.fst ∧ ↑f y = x.snd
⊢ ∃ y, ↑y = x.fst ∧ ↑g y = x.snd
[PROOFSTEP]
cases' hx with y hx
[GOAL]
case intro
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : f ≤ g
x : E × F
y : { x // x ∈ f.domain }
hx : ↑y = x.fst ∧ ↑f y = x.snd
⊢ ∃ y, ↑y = x.fst ∧ ↑g y = x.snd
[PROOFSTEP]
use⟨y, h.1 y.2⟩
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : f ≤ g
x : E × F
y : { x // x ∈ f.domain }
hx : ↑y = x.fst ∧ ↑f y = x.snd
⊢ ↑{ val := ↑y, property := (_ : ↑y ∈ g.domain) } = x.fst ∧ ↑g { val := ↑y, property := (_ : ↑y ∈ g.domain) } = x.snd
[PROOFSTEP]
simp only [hx, Submodule.coe_mk, eq_self_iff_true, true_and_iff]
[GOAL]
case h
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : f ≤ g
x : E × F
y : { x // x ∈ f.domain }
hx : ↑y = x.fst ∧ ↑f y = x.snd
⊢ ↑g { val := x.fst, property := (_ : (fun x => x ∈ g.domain) x.fst) } = x.snd
[PROOFSTEP]
convert hx.2 using 1
[GOAL]
case h.e'_2
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : f ≤ g
x : E × F
y : { x // x ∈ f.domain }
hx : ↑y = x.fst ∧ ↑f y = x.snd
⊢ ↑g { val := x.fst, property := (_ : (fun x => x ∈ g.domain) x.fst) } = ↑f y
[PROOFSTEP]
refine' (h.2 _).symm
[GOAL]
case h.e'_2
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : f ≤ g
x : E × F
y : { x // x ∈ f.domain }
hx : ↑y = x.fst ∧ ↑f y = x.snd
⊢ ↑y = ↑{ val := x.fst, property := (_ : (fun x => x ∈ g.domain) x.fst) }
[PROOFSTEP]
simp only [hx.1, Submodule.coe_mk]
[GOAL]
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f = graph g
⊢ f = g
[PROOFSTEP]
refine ext (Submodule.ext fun x => ?_) (fun x y h' => ?_)
[GOAL]
case refine_1
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f = graph g
x : E
⊢ x ∈ f.domain ↔ x ∈ g.domain
case refine_2
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f = graph g
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
h' : ↑x = ↑y
⊢ ↑f x = ↑g y
[PROOFSTEP]
exact mem_domain_iff_of_eq_graph h
[GOAL]
case refine_2
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type u_5
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f g : E →ₗ.[R] F
h : graph f = graph g
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
h' : ↑x = ↑y
⊢ ↑f x = ↑g y
[PROOFSTEP]
exact (le_of_le_graph h.le).2 h'
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
⊢ ∃! b, (a, b) ∈ g
[PROOFSTEP]
refine' exists_unique_of_exists_of_unique _ _
[GOAL]
case refine'_1
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
⊢ ∃ x, (a, x) ∈ g
[PROOFSTEP]
convert ha
[GOAL]
case a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
⊢ (∃ x, (a, x) ∈ g) ↔ a ∈ map (LinearMap.fst R E F) g
[PROOFSTEP]
simp
[GOAL]
case refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
⊢ ∀ (y₁ y₂ : F), (a, y₁) ∈ g → (a, y₂) ∈ g → y₁ = y₂
[PROOFSTEP]
intro y₁ y₂ hy₁ hy₂
[GOAL]
case refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
y₁ y₂ : F
hy₁ : (a, y₁) ∈ g
hy₂ : (a, y₂) ∈ g
⊢ y₁ = y₂
[PROOFSTEP]
have hy : ((0 : E), y₁ - y₂) ∈ g := by
  convert g.sub_mem hy₁ hy₂
  exact (sub_self _).symm
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
y₁ y₂ : F
hy₁ : (a, y₁) ∈ g
hy₂ : (a, y₂) ∈ g
⊢ (0, y₁ - y₂) ∈ g
[PROOFSTEP]
convert g.sub_mem hy₁ hy₂
[GOAL]
case h.e'_4.h.e'_3
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
y₁ y₂ : F
hy₁ : (a, y₁) ∈ g
hy₂ : (a, y₂) ∈ g
⊢ 0 = ((a, y₁) - (a, y₂)).fst
[PROOFSTEP]
exact (sub_self _).symm
[GOAL]
case refine'_2
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
y₁ y₂ : F
hy₁ : (a, y₁) ∈ g
hy₂ : (a, y₂) ∈ g
hy : (0, y₁ - y₂) ∈ g
⊢ y₁ = y₂
[PROOFSTEP]
exact sub_eq_zero.mp (hg hy (by simp))
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ {x : E × F}, x ∈ g → x.fst = 0 → x.snd = 0
a : E
ha : a ∈ map (LinearMap.fst R E F) g
y₁ y₂ : F
hy₁ : (a, y₁) ∈ g
hy₂ : (a, y₂) ∈ g
hy : (0, y₁ - y₂) ∈ g
⊢ (0, y₁ - y₂).fst = 0
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
v w : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
      (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w
[PROOFSTEP]
have hadd := (g.map (LinearMap.fst R E F)).add_mem v.2 w.2
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
v w : { x // x ∈ map (LinearMap.fst R E F) g }
hadd : ↑v + ↑w ∈ map (LinearMap.fst R E F) g
⊢ (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
      (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w
[PROOFSTEP]
have hvw := valFromGraph_mem hg hadd
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
v w : { x // x ∈ map (LinearMap.fst R E F) g }
hadd : ↑v + ↑w ∈ map (LinearMap.fst R E F) g
hvw : (↑v + ↑w, valFromGraph hg hadd) ∈ g
⊢ (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
      (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w
[PROOFSTEP]
have hvw' := g.add_mem (valFromGraph_mem hg v.2) (valFromGraph_mem hg w.2)
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
v w : { x // x ∈ map (LinearMap.fst R E F) g }
hadd : ↑v + ↑w ∈ map (LinearMap.fst R E F) g
hvw : (↑v + ↑w, valFromGraph hg hadd) ∈ g
hvw' :
  (↑v, valFromGraph hg (_ : ↑v ∈ map (LinearMap.fst R E F) g)) +
      (↑w, valFromGraph hg (_ : ↑w ∈ map (LinearMap.fst R E F) g)) ∈
    g
⊢ (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
      (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w
[PROOFSTEP]
rw [Prod.mk_add_mk] at hvw' 
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
v w : { x // x ∈ map (LinearMap.fst R E F) g }
hadd : ↑v + ↑w ∈ map (LinearMap.fst R E F) g
hvw : (↑v + ↑w, valFromGraph hg hadd) ∈ g
hvw' :
  (↑v + ↑w,
      valFromGraph hg (_ : ↑v ∈ map (LinearMap.fst R E F) g) + valFromGraph hg (_ : ↑w ∈ map (LinearMap.fst R E F) g)) ∈
    g
⊢ (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
      (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w
[PROOFSTEP]
exact (existsUnique_from_graph (@hg) hadd).unique hvw hvw'
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
a : R
v : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ AddHom.toFun
      { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
        map_add' :=
          (_ :
            ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
              (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
      (a • v) =
    ↑(RingHom.id R) a •
      AddHom.toFun
        { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
          map_add' :=
            (_ :
              ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
        v
[PROOFSTEP]
have hsmul := (g.map (LinearMap.fst R E F)).smul_mem a v.2
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
a : R
v : { x // x ∈ map (LinearMap.fst R E F) g }
hsmul : a • ↑v ∈ map (LinearMap.fst R E F) g
⊢ AddHom.toFun
      { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
        map_add' :=
          (_ :
            ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
              (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
      (a • v) =
    ↑(RingHom.id R) a •
      AddHom.toFun
        { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
          map_add' :=
            (_ :
              ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
        v
[PROOFSTEP]
have hav := valFromGraph_mem hg hsmul
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
a : R
v : { x // x ∈ map (LinearMap.fst R E F) g }
hsmul : a • ↑v ∈ map (LinearMap.fst R E F) g
hav : (a • ↑v, valFromGraph hg hsmul) ∈ g
⊢ AddHom.toFun
      { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
        map_add' :=
          (_ :
            ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
              (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
      (a • v) =
    ↑(RingHom.id R) a •
      AddHom.toFun
        { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
          map_add' :=
            (_ :
              ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
        v
[PROOFSTEP]
have hav' := g.smul_mem a (valFromGraph_mem hg v.2)
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
a : R
v : { x // x ∈ map (LinearMap.fst R E F) g }
hsmul : a • ↑v ∈ map (LinearMap.fst R E F) g
hav : (a • ↑v, valFromGraph hg hsmul) ∈ g
hav' : a • (↑v, valFromGraph hg (_ : ↑v ∈ map (LinearMap.fst R E F) g)) ∈ g
⊢ AddHom.toFun
      { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
        map_add' :=
          (_ :
            ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
              (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
      (a • v) =
    ↑(RingHom.id R) a •
      AddHom.toFun
        { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
          map_add' :=
            (_ :
              ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
        v
[PROOFSTEP]
rw [Prod.smul_mk] at hav' 
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
a : R
v : { x // x ∈ map (LinearMap.fst R E F) g }
hsmul : a • ↑v ∈ map (LinearMap.fst R E F) g
hav : (a • ↑v, valFromGraph hg hsmul) ∈ g
hav' : (a • ↑v, a • valFromGraph hg (_ : ↑v ∈ map (LinearMap.fst R E F) g)) ∈ g
⊢ AddHom.toFun
      { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
        map_add' :=
          (_ :
            ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
              (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
      (a • v) =
    ↑(RingHom.id R) a •
      AddHom.toFun
        { toFun := fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g),
          map_add' :=
            (_ :
              ∀ (v w : { x // x ∈ map (LinearMap.fst R E F) g }),
                (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) (v + w) =
                  (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) v +
                    (fun x => valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) w) }
        v
[PROOFSTEP]
exact (existsUnique_from_graph (@hg) hsmul).unique hav hav'
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ ↑(toLinearPMap g) x = valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)
[PROOFSTEP]
classical
change (if hg : _ then g.toLinearPMapAux hg else 0) x = _
rw [dif_pos]
· rfl
· exact hg
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ ↑(toLinearPMap g) x = valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)
[PROOFSTEP]
change (if hg : _ then g.toLinearPMapAux hg else 0) x = _
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ ↑(if hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0 then toLinearPMapAux g hg else 0) x =
    valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)
[PROOFSTEP]
rw [dif_pos]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ ↑(toLinearPMapAux g ?hc) x = valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)
[PROOFSTEP]
rfl
[GOAL]
case hc
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
[PROOFSTEP]
exact hg
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ (↑x, ↑(toLinearPMap g) x) ∈ g
[PROOFSTEP]
rw [toLinearPMap_apply_aux hg]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : { x // x ∈ map (LinearMap.fst R E F) g }
⊢ (↑x, valFromGraph hg (_ : ↑x ∈ map (LinearMap.fst R E F) g)) ∈ g
[PROOFSTEP]
exact valFromGraph_mem hg x.2
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
⊢ LinearPMap.graph (toLinearPMap g) = g
[PROOFSTEP]
ext x
[GOAL]
case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
⊢ x ∈ LinearPMap.graph (toLinearPMap g) ↔ x ∈ g
[PROOFSTEP]
constructor
[GOAL]
case h.mp
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
⊢ x ∈ LinearPMap.graph (toLinearPMap g) → x ∈ g
[PROOFSTEP]
intro hx
[GOAL]
case h.mpr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
⊢ x ∈ g → x ∈ LinearPMap.graph (toLinearPMap g)
[PROOFSTEP]
intro hx
[GOAL]
case h.mp
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
hx : x ∈ LinearPMap.graph (toLinearPMap g)
⊢ x ∈ g
[PROOFSTEP]
rw [LinearPMap.mem_graph_iff] at hx 
[GOAL]
case h.mp
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
hx : ∃ y, ↑y = x.fst ∧ ↑(toLinearPMap g) y = x.snd
⊢ x ∈ g
[PROOFSTEP]
rcases hx with ⟨y, hx1, hx2⟩
[GOAL]
case h.mp.intro.intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
y : { x // x ∈ (toLinearPMap g).domain }
hx1 : ↑y = x.fst
hx2 : ↑(toLinearPMap g) y = x.snd
⊢ x ∈ g
[PROOFSTEP]
convert g.mem_graph_toLinearPMap hg y using 1
[GOAL]
case h.e'_4
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
y : { x // x ∈ (toLinearPMap g).domain }
hx1 : ↑y = x.fst
hx2 : ↑(toLinearPMap g) y = x.snd
⊢ x = (↑y, ↑(toLinearPMap g) y)
[PROOFSTEP]
exact Prod.ext hx1.symm hx2.symm
[GOAL]
case h.mpr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
hx : x ∈ g
⊢ x ∈ LinearPMap.graph (toLinearPMap g)
[PROOFSTEP]
rw [LinearPMap.mem_graph_iff]
[GOAL]
case h.mpr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x : E × F
hx : x ∈ g
⊢ ∃ y, ↑y = x.fst ∧ ↑(toLinearPMap g) y = x.snd
[PROOFSTEP]
cases' x with x_fst x_snd
[GOAL]
case h.mpr.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x_fst : E
x_snd : F
hx : (x_fst, x_snd) ∈ g
⊢ ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(toLinearPMap g) y = (x_fst, x_snd).snd
[PROOFSTEP]
have hx_fst : x_fst ∈ g.map (LinearMap.fst R E F) :=
  by
  simp only [mem_map, LinearMap.fst_apply, Prod.exists, exists_and_right, exists_eq_right]
  exact ⟨x_snd, hx⟩
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x_fst : E
x_snd : F
hx : (x_fst, x_snd) ∈ g
⊢ x_fst ∈ map (LinearMap.fst R E F) g
[PROOFSTEP]
simp only [mem_map, LinearMap.fst_apply, Prod.exists, exists_and_right, exists_eq_right]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x_fst : E
x_snd : F
hx : (x_fst, x_snd) ∈ g
⊢ ∃ x, (x_fst, x) ∈ g
[PROOFSTEP]
exact ⟨x_snd, hx⟩
[GOAL]
case h.mpr.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x_fst : E
x_snd : F
hx : (x_fst, x_snd) ∈ g
hx_fst : x_fst ∈ map (LinearMap.fst R E F) g
⊢ ∃ y, ↑y = (x_fst, x_snd).fst ∧ ↑(toLinearPMap g) y = (x_fst, x_snd).snd
[PROOFSTEP]
refine' ⟨⟨x_fst, hx_fst⟩, Subtype.coe_mk x_fst hx_fst, _⟩
[GOAL]
case h.mpr.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x_fst : E
x_snd : F
hx : (x_fst, x_snd) ∈ g
hx_fst : x_fst ∈ map (LinearMap.fst R E F) g
⊢ ↑(toLinearPMap g) { val := x_fst, property := hx_fst } = (x_fst, x_snd).snd
[PROOFSTEP]
rw [toLinearPMap_apply_aux hg]
[GOAL]
case h.mpr.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
x_fst : E
x_snd : F
hx : (x_fst, x_snd) ∈ g
hx_fst : x_fst ∈ map (LinearMap.fst R E F) g
⊢ valFromGraph hg (_ : ↑{ val := x_fst, property := hx_fst } ∈ map (LinearMap.fst R E F) g) = (x_fst, x_snd).snd
[PROOFSTEP]
exact (existsUnique_from_graph (@hg) hx_fst).unique (valFromGraph_mem hg hx_fst) hx
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ (x : E × F), x ∈ g → x.fst = 0 → x.snd = 0
⊢ LinearMap.range (toLinearPMap g).toFun = map (LinearMap.snd R E F) g
[PROOFSTEP]
rwa [← LinearPMap.graph_map_snd_eq_range, toLinearPMap_graph_eq]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ (inverse f).domain = LinearMap.range f.toFun
[PROOFSTEP]
rw [inverse, Submodule.toLinearPMap_domain, ← graph_map_snd_eq_range, ← LinearEquiv.fst_comp_prodComm,
  Submodule.map_comp]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ Submodule.map (LinearMap.fst R F E) (Submodule.map (LinearEquiv.prodComm R E F) (graph f)) =
    Submodule.map (LinearMap.fst R F E) (Submodule.map (↑(LinearEquiv.prodComm R E F)) (graph f))
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
x : F × E
hv : x ∈ Submodule.map (LinearEquiv.prodComm R E F) (graph f)
hv' : x.fst = 0
⊢ x.snd = 0
[PROOFSTEP]
simp only [Submodule.mem_map, mem_graph_iff, Subtype.exists, exists_and_left, exists_eq_left,
  LinearEquiv.prodComm_apply, Prod.exists, Prod.swap_prod_mk] at hv 
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
x : F × E
hv' : x.fst = 0
hv : ∃ a b, (∃ h, ↑f { val := a, property := (_ : (a, b).fst ∈ f.domain) } = b) ∧ (b, a) = x
⊢ x.snd = 0
[PROOFSTEP]
rcases hv with ⟨a, b, ⟨ha, h1⟩, ⟨h2, h3⟩⟩
[GOAL]
case intro.intro.intro.intro.refl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
a : E
b : F
ha : a ∈ f.domain
h1 : ↑f { val := a, property := (_ : (a, b).fst ∈ f.domain) } = b
hv' : (b, a).fst = 0
⊢ (b, a).snd = 0
[PROOFSTEP]
simp only at hv' ⊢
[GOAL]
case intro.intro.intro.intro.refl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
a : E
b : F
ha : a ∈ f.domain
h1 : ↑f { val := a, property := (_ : (a, b).fst ∈ f.domain) } = b
hv' : b = 0
⊢ a = 0
[PROOFSTEP]
rw [hv'] at h1 
[GOAL]
case intro.intro.intro.intro.refl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
a : E
b : F
ha : a ∈ f.domain
h1 : ↑f { val := a, property := (_ : (a, 0).fst ∈ f.domain) } = 0
hv' : b = 0
⊢ a = 0
[PROOFSTEP]
rw [LinearMap.ker_eq_bot'] at hf 
[GOAL]
case intro.intro.intro.intro.refl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : ∀ (m : { x // x ∈ f.domain }), ↑f.toFun m = 0 → m = 0
a : E
b : F
ha : a ∈ f.domain
h1 : ↑f { val := a, property := (_ : (a, 0).fst ∈ f.domain) } = 0
hv' : b = 0
⊢ a = 0
[PROOFSTEP]
specialize hf ⟨a, ha⟩ h1
[GOAL]
case intro.intro.intro.intro.refl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
a : E
b : F
ha : a ∈ f.domain
h1 : ↑f { val := a, property := (_ : (a, 0).fst ∈ f.domain) } = 0
hv' : b = 0
hf : { val := a, property := ha } = 0
⊢ a = 0
[PROOFSTEP]
simp only [Submodule.mk_eq_zero] at hf 
[GOAL]
case intro.intro.intro.intro.refl
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
a : E
b : F
ha : a ∈ f.domain
h1 : ↑f { val := a, property := (_ : (a, 0).fst ∈ f.domain) } = 0
hv' : b = 0
hf : a = 0
⊢ a = 0
[PROOFSTEP]
exact hf
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
⊢ graph (inverse f) = Submodule.map (LinearEquiv.prodComm R E F) (graph f)
[PROOFSTEP]
rw [inverse, Submodule.toLinearPMap_graph_eq _ (mem_inverse_graph_snd_eq_zero hf)]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
⊢ LinearMap.range (inverse f).toFun = f.domain
[PROOFSTEP]
rw [inverse, Submodule.toLinearPMap_range _ (mem_inverse_graph_snd_eq_zero hf), ← graph_map_fst_eq_domain, ←
  LinearEquiv.snd_comp_prodComm, Submodule.map_comp]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
⊢ Submodule.map (LinearMap.snd R F E) (Submodule.map (LinearEquiv.prodComm R E F) (graph f)) =
    Submodule.map (LinearMap.snd R F E) (Submodule.map (↑(LinearEquiv.prodComm R E F)) (graph f))
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
x : { x // x ∈ f.domain }
⊢ (↑f x, ↑x) ∈ graph (inverse f)
[PROOFSTEP]
simp only [inverse_graph hf, Submodule.mem_map, mem_graph_iff, Subtype.exists, exists_and_left, exists_eq_left,
  LinearEquiv.prodComm_apply, Prod.exists, Prod.swap_prod_mk, Prod.mk.injEq]
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
x : { x // x ∈ f.domain }
⊢ ∃ a b, (∃ h, ↑f { val := a, property := (_ : (a, b).fst ∈ f.domain) } = b) ∧ b = ↑f x ∧ a = ↑x
[PROOFSTEP]
exact ⟨(x : E), f x, ⟨x.2, Eq.refl _⟩, Eq.refl _, Eq.refl _⟩
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
y : { x // x ∈ (inverse f).domain }
x : { x // x ∈ f.domain }
hxy : ↑f x = ↑y
⊢ ↑(inverse f) y = ↑x
[PROOFSTEP]
have := mem_inverse_graph hf x
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
y : { x // x ∈ (inverse f).domain }
x : { x // x ∈ f.domain }
hxy : ↑f x = ↑y
this : (↑f x, ↑x) ∈ graph (inverse f)
⊢ ↑(inverse f) y = ↑x
[PROOFSTEP]
simp only [mem_graph_iff, Subtype.exists, exists_and_left, exists_eq_left] at this 
[GOAL]
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
y : { x // x ∈ (inverse f).domain }
x : { x // x ∈ f.domain }
hxy : ↑f x = ↑y
this : ∃ x_1, ↑(inverse f) { val := ↑f x, property := (_ : ↑f x ∈ (inverse f).domain) } = ↑x
⊢ ↑(inverse f) y = ↑x
[PROOFSTEP]
rcases this with ⟨hx, h⟩
[GOAL]
case intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
y : { x // x ∈ (inverse f).domain }
x : { x // x ∈ f.domain }
hxy : ↑f x = ↑y
hx : ↑f x ∈ (inverse f).domain
h : ↑(inverse f) { val := ↑f x, property := (_ : ↑f x ∈ (inverse f).domain) } = ↑x
⊢ ↑(inverse f) y = ↑x
[PROOFSTEP]
rw [← h]
[GOAL]
case intro
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
y : { x // x ∈ (inverse f).domain }
x : { x // x ∈ f.domain }
hxy : ↑f x = ↑y
hx : ↑f x ∈ (inverse f).domain
h : ↑(inverse f) { val := ↑f x, property := (_ : ↑f x ∈ (inverse f).domain) } = ↑x
⊢ ↑(inverse f) y = ↑(inverse f) { val := ↑f x, property := (_ : ↑f x ∈ (inverse f).domain) }
[PROOFSTEP]
congr
[GOAL]
case intro.e_a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
y : { x // x ∈ (inverse f).domain }
x : { x // x ∈ f.domain }
hxy : ↑f x = ↑y
hx : ↑f x ∈ (inverse f).domain
h : ↑(inverse f) { val := ↑f x, property := (_ : ↑f x ∈ (inverse f).domain) } = ↑x
⊢ y = { val := ↑f x, property := (_ : ↑f x ∈ (inverse f).domain) }
[PROOFSTEP]
simp only [hxy, Subtype.coe_eta]
