-- Mathlib/Order/CountableDenseLinearOrder.lean
theorem exists_across [DenselyOrdered β] [NoMinOrder β] [NoMaxOrder β] [Nonempty β]
    (f : PartialIso α β) (a : α) :
    ∃ b : β, ∀ p ∈ f.val, cmp (Prod.fst p) a = cmp (Prod.snd p) b

Proof state:
case h.mk.inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝¹ :
  ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y
b : β
hb :
  (∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f), x < b) ∧
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this✝ : p1 ≠ a
hr : p1 > a
this : a < p1 ∧ b < p2
⊢ cmp (p1, p2).1 a = cmp (p1, p2).2 b

Tactic:
rw [← cmp_eq_gt_iff, ← cmp_eq_gt_iff] at this

Result:
case h.mk.inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝¹ :
  ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y
b : β
hb :
  (∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f), x < b) ∧
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this✝ : p1 ≠ a
hr : p1 > a
this : cmp p1 a = Ordering.gt ∧ cmp p2 b = Ordering.gt
⊢ cmp (p1, p2).1 a = cmp (p1, p2).2 b

Proof state:
case pos.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
b : β
hb : (a, b) ∈ ↑f
⊢ ∃ b, ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b

Tactic:
exact ⟨b, fun p hp ↦ f.prop _ hp _ hb⟩

Result:
no goals

Proof state:
case neg.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y
b : β
hb :
  (∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f), x < b) ∧
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), b < y
⊢ ∃ b, ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b

Tactic:
use b

Result:
case h
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y
b : β
hb :
  (∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f), x < b) ∧
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), b < y
⊢ ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b

Proof state:
case h
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y
b : β
hb :
  (∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f), x < b) ∧
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), b < y
⊢ ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b

Tactic:
rintro ⟨p1, p2⟩ hp

Result:
case h.mk
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y
b : β
hb :
  (∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f), x < b) ∧
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
⊢ cmp (p1, p2).1 a = cmp (p1, p2).2 b

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
⊢ ∃ b, ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b

Tactic:
have :
  ∀ x ∈ (f.val.filter fun p : α × β ↦ p.fst < a).image Prod.snd,
    ∀ y ∈ (f.val.filter fun p : α × β ↦ a < p.fst).image Prod.snd, x < y := by
  intro x hx y hy
  rw [Finset.mem_image] at hx hy
  rcases hx with ⟨p, hp1, rfl⟩
  rcases hy with ⟨q, hq1, rfl⟩
  rw [Finset.mem_filter] at hp1 hq1
  rw [← lt_iff_lt_of_cmp_eq_cmp (f.prop _ hp1.1 _ hq1.1)]
  exact lt_trans hp1.right hq1.right

Result:
case neg
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.1 < a) ↑f),
    ∀ y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.1) ↑f), x < y
⊢ ∃ b, ∀ p ∈ ↑f, cmp p.1 a = cmp p.2 b

Proof state:
case intro.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
y : β
hy : ∃ a_1 ∈ Finset.filter (fun p => a < p.1) ↑f, a_1.2 = y
p : α × β
hp1 : p ∈ Finset.filter (fun p => p.1 < a) ↑f
⊢ p.2 < y

Tactic:
rcases hy with ⟨q, hq1, rfl⟩

Result:
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
p : α × β
hp1 : p ∈ Finset.filter (fun p => p.1 < a) ↑f
q : α × β
hq1 : q ∈ Finset.filter (fun p => a < p.1) ↑f
⊢ p.2 < q.2

Proof state:
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
p : α × β
hp1 : p ∈ ↑f ∧ p.1 < a
q : α × β
hq1 : q ∈ ↑f ∧ a < q.1
⊢ p.2 < q.2

Tactic:
rw [← lt_iff_lt_of_cmp_eq_cmp (f.prop _ hp1.1 _ hq1.1)]

Result:
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
p : α × β
hp1 : p ∈ ↑f ∧ p.1 < a
q : α × β
hq1 : q ∈ ↑f ∧ a < q.1
⊢ p.1 < q.1

Proof state:
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
p : α × β
hp1 : p ∈ Finset.filter (fun p => p.1 < a) ↑f
q : α × β
hq1 : q ∈ Finset.filter (fun p => a < p.1) ↑f
⊢ p.2 < q.2

Tactic:
rw [Finset.mem_filter] at hp1 hq1

Result:
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
p : α × β
hp1 : p ∈ ↑f ∧ p.1 < a
q : α × β
hq1 : q ∈ ↑f ∧ a < q.1
⊢ p.2 < q.2