Theorem: Ordinal.add_le_of_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: intro l
state_before: case H.H
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
⊢ ¬c < type r + type s

tactic: intro x
state_before: case H.H
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
⊢ ∀ (x : β), Sum.Lex r s (Sum.inr x) (enum (Sum.Lex r s) c l)

tactic: rw [← typein_lt_typein (Sum.Lex r s), typein_enum]
state_before: case H.H
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
⊢ Sum.Lex r s (Sum.inr x) (enum (Sum.Lex r s) c l)

tactic: have := H _ (h.2 _ (typein_lt_type s x))
state_before: case H.H
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
⊢ typein (Sum.Lex r s) (Sum.inr x) < c

tactic: rw [add_succ, succ_le_iff] at this
state_before: case H.H
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + succ (typein s x) ≤ c
⊢ typein (Sum.Lex r s) (Sum.inr x) < c

tactic: refine'
  (RelEmbedding.ofMonotone (fun a => _) fun a b => _).ordinal_type_le.trans_lt this
state_before: case H.H
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + typein s x < c
⊢ typein (Sum.Lex r s) (Sum.inr x) < c

tactic: revert this
state_before: α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
this : ∀ (x : β), Sum.Lex r s (Sum.inr x) (enum (Sum.Lex r s) c l)
⊢ False

tactic: cases' enum _ _ l with x x <;> intro this
state_before: α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
⊢ (∀ (x : β), Sum.Lex r s (Sum.inr x) (enum (Sum.Lex r s) c l)) → False

tactic: cases this (enum s 0 h.pos)
state_before: case inl
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : α
this : ∀ (x_1 : β), Sum.Lex r s (Sum.inr x_1) (Sum.inl x)
⊢ False

tactic: exact irrefl _ (this _)
state_before: case inr
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : ∀ (x_1 : β), Sum.Lex r s (Sum.inr x_1) (Sum.inr x)
⊢ False

tactic: rcases a with ⟨a | b, h⟩
state_before: case H.H.refine'_1
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + typein s x < c
a : ↑{b | Sum.Lex r s b (Sum.inr x)}
⊢ α ⊕ ↑{b | s b x}

tactic: exact Sum.inl a
state_before: case H.H.refine'_1.mk.inl
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h✝ : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + typein s x < c
a : α
h : Sum.inl a ∈ {b | Sum.Lex r s b (Sum.inr x)}
⊢ α ⊕ ↑{b | s b x}

tactic: exact Sum.inr ⟨b, by cases h; assumption⟩
state_before: case H.H.refine'_1.mk.inr
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h✝ : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + typein s x < c
b : β
h : Sum.inr b ∈ {b | Sum.Lex r s b (Sum.inr x)}
⊢ α ⊕ ↑{b | s b x}

tactic: cases h
state_before: α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h✝ : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + typein s x < c
b : β
h : Sum.inr b ∈ {b | Sum.Lex r s b (Sum.inr x)}
⊢ b ∈ {b | s b x}

tactic: assumption
state_before: case inr
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + typein s x < c
b : β
h✝ : s b x
⊢ b ∈ {b | s b x}

tactic: rcases a with ⟨a | a, h₁⟩ <;> rcases b with ⟨b | b, h₂⟩ <;> cases h₁ <;> cases h₂ <;>
  rintro ⟨⟩ <;> constructor <;> assumption
state_before: case H.H.refine'_2
α✝ : Type ?u.120549
β✝ : Type ?u.120552
γ : Type ?u.120555
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r + b' ≤ c
l : c < type r + type s
x : β
this : type r + typein s x < c
a b : ↑{b | Sum.Lex r s b (Sum.inr x)}
⊢ Subrel (Sum.Lex r s) {b | Sum.Lex r s b (Sum.inr x)} a b →
    Sum.Lex r (Subrel s {b | s b x})
      ((fun a =>
          Subtype.casesOn a fun val h =>
            Sum.casesOn (motive := fun x_1 => x_1 ∈ {b | Sum.Lex r s b (Sum.inr x)} → α ⊕ ↑{b | s b x}) val
              (fun a h => Sum.inl a) (fun b h => Sum.inr { val := b, property := (_ : b ∈ {b | s b x}) }) h)
        a)
      ((fun a =>
          Subtype.casesOn a fun val h =>
            Sum.casesOn (motive := fun x_1 => x_1 ∈ {b | Sum.Lex r s b (Sum.inr x)} → α ⊕ ↑{b | s b x}) val
              (fun a h => Sum.inl a) (fun b h => Sum.inr { val := b, property := (_ : b ∈ {b | s b x}) }) h)
        b)