-- Mathlib/Combinatorics/Colex.lean
/-- If `s ≤ t` in colex and `#s ≤ #t`, then `s \ {a} ≤ t \ {min t}` for any `a ∈ s`. -/
lemma erase_le_erase_min' (hst : toColex s ≤ toColex t) (hcard : #s ≤ #t) (ha : a ∈ s) :
    toColex (s.erase a) ≤
      toColex (t.erase <| min' t <| card_pos.1 <| (card_pos.2 ⟨a, ha⟩).trans_le hcard)

Proof state:
case inr.intro.intro.intro.inr.inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
haw : a < w
hmw : m < w
b : α
hbs : b ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
hbt : b = m ∨ b ∉ t
⊢ b < w

Tactic:
obtain rfl | hbt := hbt

Result:
case inr.intro.intro.intro.inr.inr.inl
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
haw : a < w
hmw : m < w
hbs : m ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
⊢ m < w

case inr.intro.intro.intro.inr.inr.inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
haw : a < w
hmw : m < w
b : α
hbs : b ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
hbt : b ∉ t
⊢ b < w

Proof state:
case inr.intro.intro.intro.inr.inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
haw : a < w
hmw : m < w
b : α
hbs : b ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
hbt : b ∉ t.erase m
⊢ b < w

Tactic:
rw [mem_erase, not_and_or, not_ne_iff] at hbt

Result:
case inr.intro.intro.intro.inr.inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
haw : a < w
hmw : m < w
b : α
hbs : b ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
hbt : b = m ∨ b ∉ t
⊢ b < w

Proof state:
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
hcard : #s ≤ #t
ha : a ∈ s
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase (t.min' ⋯) }

Tactic:
generalize_proofs ht

Result:
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase (t.min' ht) }

Proof state:
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
hwt : m ∈ t
hws : m ∉ s
hw : ∀ ⦃a : α⦄, m < a → (a ∈ s ↔ a ∈ t)
haw : a < m
⊢ t.erase m ⊆ s.erase a

Tactic:
rintro b hb

Result:
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
hwt : m ∈ t
hws : m ∉ s
hw : ∀ ⦃a : α⦄, m < a → (a ∈ s ↔ a ∈ t)
haw : a < m
b : α
hb : b ∈ t.erase m
⊢ b ∈ s.erase a

Proof state:
case inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }

Tactic:
replace hst := hst.lt_of_ne <| toColex_inj.not.2 h'

Result:
case inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
hst : { ofColex := s } < { ofColex := t }
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }

Proof state:
case inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
hst : { ofColex := s } < { ofColex := t }
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }

Tactic:
simp only [lt_iff_exists_filter_lt, mem_sdiff, filter_inj, and_assoc] at hst

Result:
case inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
hst : ∃ w ∈ t, w ∉ s ∧ ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }

Proof state:
case inl
α : Type u_1
inst✝ : LinearOrder α
s : Finset α
a : α
ha : a ∈ s
hst : { ofColex := s } ≤ { ofColex := s }
hcard : #s ≤ #s
ht : s.Nonempty
m : α := s.min' ht
⊢ { ofColex := s.erase a } ≤ { ofColex := s.erase m }

Tactic:
exact (erase_le_erase ha <| min'_mem _ _).2 <| min'_le _ _ <| ha

Result:
no goals

Proof state:
case inr.intro.intro.intro
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }

Tactic:
obtain hwa | haw := (ne_of_mem_of_not_mem ha hws).symm.lt_or_lt

Result:
case inr.intro.intro.intro.inl
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
hwa : w < a
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }

case inr.intro.intro.intro.inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
haw : a < w
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }

Proof state:
case inr.intro.intro.intro.inl.inr
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
hwa : w < a
hma : m < a
b : α
hbs : b ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
hbt : b ∉ t
hab : a ≤ b
⊢ False

Tactic:
exact hbt <| (hw <| hwa.trans_le hab).1 <| mem_of_mem_erase hbs

Result:
no goals

Proof state:
case inr.intro.intro.intro.inl
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
hwa : w < a
hma : m < a
b : α
hbs : b ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
hbt : b ∉ { ofColex := { val := t.val.erase m, nodup := ⋯ } }.ofColex
⊢ b < a

Tactic:
change b ∉ t.erase m at hbt

Result:
case inr.intro.intro.intro.inl
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
h' : s ≠ t
w : α
hwt : w ∈ t
hws : w ∉ s
hw : ∀ ⦃a : α⦄, w < a → (a ∈ s ↔ a ∈ t)
hwa : w < a
hma : m < a
b : α
hbs : b ∈ { ofColex := { val := s.val.erase a, nodup := ⋯ } }.ofColex
hbt : b ∉ t.erase m
⊢ b < a

Proof state:
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase (t.min' ht) }

Tactic:
set m := min' t ht

Result:
α : Type u_1
inst✝ : LinearOrder α
s t : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
hcard : #s ≤ #t
ha : a ∈ s
ht : t.Nonempty
m : α := t.min' ht
⊢ { ofColex := s.erase a } ≤ { ofColex := t.erase m }