Theorem: Order.PartialIso.exists_across
File: Mathlib/Order/CountableDenseLinearOrder.lean

tactic: by_cases h : ∃ b, (a, b) ∈ f.val
state_before: α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
⊢ ∃ b, ∀ (p : α × β), p ∈ ↑f → cmp p.fst a = cmp p.snd 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
state_before: case neg
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
⊢ ∃ b, ∀ (p : α × β), p ∈ ↑f → cmp p.fst a = cmp p.snd b

tactic: cases' exists_between_finsets _ _ this with b hb
state_before: case neg
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
⊢ ∃ b, ∀ (p : α × β), p ∈ ↑f → cmp p.fst a = cmp p.snd b

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

tactic: rintro ⟨p1, p2⟩ hp
state_before: case neg.intro
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
⊢ ∀ (p : α × β), p ∈ ↑f → cmp p.fst a = cmp p.snd b

tactic: have : p1 ≠ a := fun he ↦ h ⟨p2, he ▸ hp⟩
state_before: case neg.intro.mk
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
⊢ cmp (p1, p2).fst a = cmp (p1, p2).snd b

tactic: cases' lt_or_gt_of_ne this with hl hr
state_before: case neg.intro.mk
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝ :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this : p1 ≠ a
⊢ cmp (p1, p2).fst a = cmp (p1, p2).snd b

tactic: cases' h with b hb
state_before: case pos
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ∃ b, (a, b) ∈ ↑f
⊢ ∃ b, ∀ (p : α × β), p ∈ ↑f → cmp p.fst a = cmp p.snd b

tactic: exact ⟨b, fun p hp ↦ f.prop _ hp _ hb⟩
state_before: case pos.intro
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
b : β
hb : (a, b) ∈ ↑f
⊢ ∃ b, ∀ (p : α × β), p ∈ ↑f → cmp p.fst a = cmp p.snd b

tactic: intro x hx y hy
state_before: α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
⊢ ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y

tactic: rw [Finset.mem_image] at hx hy
state_before: α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
x : β
hx : x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f)
y : β
hy : y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f)
⊢ x < y

tactic: rcases hx with ⟨p, hp1, rfl⟩
state_before: α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
x : β
hx : ∃ a_1, a_1 ∈ Finset.filter (fun p => p.fst < a) ↑f ∧ a_1.snd = x
y : β
hy : ∃ a_1, a_1 ∈ Finset.filter (fun p => a < p.fst) ↑f ∧ a_1.snd = y
⊢ x < y

tactic: rcases hy with ⟨q, hq1, rfl⟩
state_before: case intro.intro
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
y : β
hy : ∃ a_1, a_1 ∈ Finset.filter (fun p => a < p.fst) ↑f ∧ a_1.snd = y
p : α × β
hp1 : p ∈ Finset.filter (fun p => p.fst < a) ↑f
⊢ p.snd < y

tactic: rw [Finset.mem_filter] at hp1 hq1
state_before: case intro.intro.intro.intro
α : Type u_2
β : Type u_1
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.fst < a) ↑f
q : α × β
hq1 : q ∈ Finset.filter (fun p => a < p.fst) ↑f
⊢ p.snd < q.snd

tactic: rw [← lt_iff_lt_of_cmp_eq_cmp (f.prop _ hp1.1 _ hq1.1)]
state_before: case intro.intro.intro.intro
α : Type u_2
β : Type u_1
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.fst < a
q : α × β
hq1 : q ∈ ↑f ∧ a < q.fst
⊢ p.snd < q.snd

tactic: exact lt_trans hp1.right hq1.right
state_before: case intro.intro.intro.intro
α : Type u_2
β : Type u_1
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.fst < a
q : α × β
hq1 : q ∈ ↑f ∧ a < q.fst
⊢ p.fst < q.fst

tactic: have : p1 < a ∧ p2 < b :=
  ⟨hl, hb.1 _ (Finset.mem_image.mpr ⟨(p1, p2), Finset.mem_filter.mpr ⟨hp, hl⟩, rfl⟩)⟩
state_before: case neg.intro.mk.inl
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝ :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this : p1 ≠ a
hl : p1 < a
⊢ cmp (p1, p2).fst a = cmp (p1, p2).snd b

tactic: rw [← cmp_eq_lt_iff, ← cmp_eq_lt_iff] at this
state_before: case neg.intro.mk.inl
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝¹ :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this✝ : p1 ≠ a
hl : p1 < a
this : p1 < a ∧ p2 < b
⊢ cmp (p1, p2).fst a = cmp (p1, p2).snd b

tactic: exact this.1.trans this.2.symm
state_before: case neg.intro.mk.inl
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝¹ :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this✝ : p1 ≠ a
hl : p1 < a
this : cmp p1 a = Ordering.lt ∧ cmp p2 b = Ordering.lt
⊢ cmp (p1, p2).fst a = cmp (p1, p2).snd b

tactic: have : a < p1 ∧ b < p2 :=
  ⟨hr, hb.2 _ (Finset.mem_image.mpr ⟨(p1, p2), Finset.mem_filter.mpr ⟨hp, hr⟩, rfl⟩)⟩
state_before: case neg.intro.mk.inr
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝ :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this : p1 ≠ a
hr : p1 > a
⊢ cmp (p1, p2).fst a = cmp (p1, p2).snd b

tactic: rw [← cmp_eq_gt_iff, ← cmp_eq_gt_iff] at this
state_before: case neg.intro.mk.inr
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝¹ :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → b < y
p1 : α
p2 : β
hp : (p1, p2) ∈ ↑f
this✝ : p1 ≠ a
hr : p1 > a
this : a < p1 ∧ b < p2
⊢ cmp (p1, p2).fst a = cmp (p1, p2).snd b

tactic: exact this.1.trans this.2.symm
state_before: case neg.intro.mk.inr
α : Type u_2
β : Type u_1
inst✝⁵ : LinearOrder α
inst✝⁴ : LinearOrder β
inst✝³ : DenselyOrdered β
inst✝² : NoMinOrder β
inst✝¹ : NoMaxOrder β
inst✝ : Nonempty β
f : PartialIso α β
a : α
h : ¬∃ b, (a, b) ∈ ↑f
this✝¹ :
  ∀ (x : β),
    x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) →
      ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑f) → x < y
b : β
hb :
  (∀ (x : β), x ∈ Finset.image Prod.snd (Finset.filter (fun p => p.fst < a) ↑f) → x < b) ∧
    ∀ (y : β), y ∈ Finset.image Prod.snd (Finset.filter (fun p => a < p.fst) ↑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).fst a = cmp (p1, p2).snd b