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

tactic: cases' c.eq_empty_or_nonempty with ceq cne
state_before: R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: 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
  rwa [bex_image_iff, ← bex_def, SetCoe.exists'] at this
state_before: case inr
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: set f : ↥(sSup (domain '' c)) → F := fun x => (P x).val.val ⟨x, (P x).property⟩
state_before: case inr
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: 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⟩
  refine' (hxq.2 _).trans (hpq.2 _).symm <;> [skip; exact ofLe hpq.1 y; rfl]; exact hxy
state_before: case inr
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

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

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

tactic: simp
state_before: case inl
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
inst✝¹ : AddCommGroup G
inst✝ : Module R G
hc : DirectedOn (fun x x_1 => x ≤ x_1) ∅
⊢ ∃ f, { domain := sSup (domain '' ∅), toFun := f } ∈ upperBounds ∅

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

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

tactic: have := (mem_sSup_of_directed (cne.image _) hdir).1 x.2
state_before: case h
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: rwa [bex_image_iff, ← bex_def, SetCoe.exists'] at this
state_before: case h
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

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

tactic: rcases hc (P x).1.1 (P x).1.2 p.1 p.2 with ⟨q, _hqc, hxq, hpq⟩
state_before: R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: refine' (hxq.2 _).trans (hpq.2 _).symm <;> [skip; exact ofLe hpq.1 y; rfl]
state_before: case intro.intro.intro
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: exact hxy
state_before: case intro.intro.intro.refine'_1
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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)

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

tactic: rcases hc (P x).1.1 (P x).1.2 (P y).1.1 (P y).1.2 with ⟨p, hpc, hpx, hpy⟩
state_before: case inr.refine'_1
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: set x' := ofLe hpx.1 ⟨x, (P x).2⟩
state_before: case inr.refine'_1.intro.intro.intro
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: set y' := ofLe hpy.1 ⟨y, (P y).2⟩
state_before: case inr.refine'_1.intro.intro.intro
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: 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]
state_before: case inr.refine'_1.intro.intro.intro
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: intro c x
state_before: case inr.refine'_2
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: simp only [f_eq (P x).1 (c • x) (c • ⟨x, (P x).2⟩) rfl, ← map_smul, RingHom.id_apply]
state_before: case inr.refine'_2
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: intro p hpc
state_before: case inr.refine'_3
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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

tactic: refine' ⟨le_sSup <| mem_image_of_mem domain hpc, fun x y hxy => Eq.symm _⟩
state_before: case inr.refine'_3
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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) }) } }

tactic: exact f_eq ⟨p, hpc⟩ _ _ hxy.symm
state_before: case inr.refine'_3
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.369211
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