Theorem: LinearPMap.sup_aux
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: choose x hx y hy hxy using fun z : ↥(f.domain ⊔ g.domain) => mem_sup.1 z.prop
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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

tactic: set fg := fun z => f ⟨x z, hx z⟩ + g ⟨y z, hy z⟩
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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

tactic: 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
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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

tactic: refine' ⟨{ toFun := fg.. }, fg_eq⟩
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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

tactic: intro x' y' z' H
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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'

tactic: dsimp
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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'

tactic: rw [add_comm, ← sub_eq_sub_iff_add_eq_add, eq_comm, ← map_sub, ← map_sub]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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'

tactic: apply h
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.162242
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')

tactic: simp only [← eq_sub_iff_add_eq] at hxy
state_before: 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.162242
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')

tactic: simp only [AddSubgroupClass.coe_sub, coe_mk, coe_mk, hxy, ← sub_add, ← sub_sub, sub_self,
  zero_sub, ← H]
state_before: 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.162242
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')

tactic: apply neg_add_eq_sub
state_before: 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.162242
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'

tactic: rintro ⟨z₁, hz₁⟩ ⟨z₂, hz₂⟩
state_before: 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.162242
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

tactic: rw [← add_assoc, add_right_comm (f _), ← map_add, add_assoc, ← map_add]
state_before: 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.162242
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₂ }

tactic: apply fg_eq
state_before: 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.162242
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) })

tactic: simp only [coe_add, coe_mk, ← add_assoc]
state_before: 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.162242
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₂ })

tactic: rw [add_right_comm (x _), hxy, add_assoc, hxy, coe_mk, coe_mk]
state_before: 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.162242
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₂

tactic: intro c z
state_before: 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.162242
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

tactic: rw [smul_add, ← map_smul, ← map_smul]
state_before: 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.162242
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

tactic: apply fg_eq
state_before: 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.162242
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) })

tactic: simp only [coe_smul, coe_mk, ← smul_add, hxy, RingHom.id_apply]
state_before: 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.162242
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)