Theorem: List.chain_iff_get
File: Mathlib/Data/List/Chain.lean

tactic: omega
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b : α
R : α → α → Prop
a : α
l : List α
i : ℕ
h : i < l.length - 1
⊢ i < l.length
state_after: no goals

tactic: omega
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b : α
R : α → α → Prop
a : α
l : List α
i : ℕ
h : i < l.length - 1
⊢ i + 1 < l.length
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b : α
R : α → α → Prop
a : α
⊢ Chain R a []
state_after: no goals

tactic: simp at h
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b : α
R : α → α → Prop
a : α
h : 0 < [].length
⊢ R a ([].get ⟨0, h⟩)
state_after: no goals

tactic: simp at h
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b : α
R : α → α → Prop
a : α
x✝ : ℕ
h : x✝ < [].length - 1
⊢ R ([].get ⟨x✝, ⋯⟩) ([].get ⟨x✝ + 1, ⋯⟩)
state_after: no goals

tactic: rw [chain_cons, @chain_iff_get _ _ t]
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ Chain R a (b :: t) ↔
    (∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
state_after: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ (R a b ∧
      (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧
        ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)) ↔
    (∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)

tactic: constructor
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ (R a b ∧
      (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧
        ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)) ↔
    (∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
state_after: case mp
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ (R a b ∧
      (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧
        ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)) →
    (∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)

case mpr
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ ((∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)) →
    R a b ∧
      (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)

tactic: rintro ⟨h0, h⟩
state_before: case mpr
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ ((∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)) →
    R a b ∧
      (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
state_after: case mpr.intro
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ R a b ∧
    (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)

tactic: constructor
state_before: case mpr.intro
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ R a b ∧
    (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
state_after: case mpr.intro.left
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ R a b

case mpr.intro.right
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)

tactic: constructor
state_before: case mpr.intro.right
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
state_after: case mpr.intro.right.left
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ ∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)

case mpr.intro.right.right
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)

tactic: intro i w
state_before: case mpr.intro.right.right
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
state_after: case mpr.intro.right.right
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
i : ℕ
w : i < t.length - 1
⊢ R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)

tactic: exact h (i+1) (by simp only [length_cons]; omega)
state_before: case mpr.intro.right.right
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
i : ℕ
w : i < t.length - 1
⊢ R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
state_after: no goals

tactic: rintro ⟨R, ⟨h0, h⟩⟩
state_before: case mp
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ (R a b ∧
      (∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)) ∧
        ∀ (i : ℕ) (h : i < t.length - 1), R (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)) →
    (∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
state_after: case mp.intro.intro
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
⊢ (∀ (h : 0 < (b :: t).length), R✝ a ((b :: t).get ⟨0, h⟩)) ∧
    ∀ (i : ℕ) (h : i < (b :: t).length - 1), R✝ ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)

tactic: constructor
state_before: case mp.intro.intro
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
⊢ (∀ (h : 0 < (b :: t).length), R✝ a ((b :: t).get ⟨0, h⟩)) ∧
    ∀ (i : ℕ) (h : i < (b :: t).length - 1), R✝ ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
state_after: case mp.intro.intro.left
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
⊢ ∀ (h : 0 < (b :: t).length), R✝ a ((b :: t).get ⟨0, h⟩)

case mp.intro.intro.right
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
⊢ ∀ (i : ℕ) (h : i < (b :: t).length - 1), R✝ ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)

tactic: intro i w
state_before: case mp.intro.intro.right
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
⊢ ∀ (i : ℕ) (h : i < (b :: t).length - 1), R✝ ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
state_after: case mp.intro.intro.right
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
i : ℕ
w : i < (b :: t).length - 1
⊢ R✝ ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)

tactic: cases' i with i
state_before: case mp.intro.intro.right
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
i : ℕ
w : i < (b :: t).length - 1
⊢ R✝ ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
state_after: case mp.intro.intro.right.zero
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
w : 0 < (b :: t).length - 1
⊢ R✝ ((b :: t).get ⟨0, ⋯⟩) ((b :: t).get ⟨0 + 1, ⋯⟩)

case mp.intro.intro.right.succ
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
i : ℕ
w : i + 1 < (b :: t).length - 1
⊢ R✝ ((b :: t).get ⟨i + 1, ⋯⟩) ((b :: t).get ⟨i + 1 + 1, ⋯⟩)

tactic: intro _
state_before: case mp.intro.intro.left
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
⊢ ∀ (h : 0 < (b :: t).length), R✝ a ((b :: t).get ⟨0, h⟩)
state_after: case mp.intro.intro.left
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
h✝ : 0 < (b :: t).length
⊢ R✝ a ((b :: t).get ⟨0, h✝⟩)

tactic: exact R
state_before: case mp.intro.intro.left
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
h✝ : 0 < (b :: t).length
⊢ R✝ a ((b :: t).get ⟨0, h✝⟩)
state_after: no goals

tactic: apply h0
state_before: case mp.intro.intro.right.zero
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
w : 0 < (b :: t).length - 1
⊢ R✝ ((b :: t).get ⟨0, ⋯⟩) ((b :: t).get ⟨0 + 1, ⋯⟩)
state_after: no goals

tactic: exact h i (by simp only [length_cons] at w; omega)
state_before: case mp.intro.intro.right.succ
α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
i : ℕ
w : i + 1 < (b :: t).length - 1
⊢ R✝ ((b :: t).get ⟨i + 1, ⋯⟩) ((b :: t).get ⟨i + 1 + 1, ⋯⟩)
state_after: no goals

tactic: simp only [length_cons] at w
state_before: α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
i : ℕ
w : i + 1 < (b :: t).length - 1
⊢ i < t.length - 1
state_after: α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
i : ℕ
w : i + 1 < t.length + 1 - 1
⊢ i < t.length - 1

tactic: omega
state_before: α : Type u
β : Type v
R✝¹ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R✝ : α → α → Prop
a b : α
t : List α
R : R✝ a b
h0 : ∀ (h : 0 < t.length), R✝ b (t.get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < t.length - 1), R✝ (t.get ⟨i, ⋯⟩) (t.get ⟨i + 1, ⋯⟩)
i : ℕ
w : i + 1 < t.length + 1 - 1
⊢ i < t.length - 1
state_after: no goals

tactic: apply h0
state_before: case mpr.intro.left
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ R a b
state_after: case mpr.intro.left
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ 0 < (b :: t).length

tactic: simp
state_before: case mpr.intro.left
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ 0 < (b :: t).length
state_after: no goals

tactic: apply h 0
state_before: case mpr.intro.right.left
α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
⊢ ∀ (h : 0 < t.length), R b (t.get ⟨0, h⟩)
state_after: no goals

tactic: simp only [length_cons]
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
i : ℕ
w : i < t.length - 1
⊢ i + 1 < (b :: t).length - 1
state_after: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
i : ℕ
w : i < t.length - 1
⊢ i + 1 < t.length + 1 - 1

tactic: omega
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
h0 : ∀ (h : 0 < (b :: t).length), R a ((b :: t).get ⟨0, h⟩)
h : ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)
i : ℕ
w : i < t.length - 1
⊢ i + 1 < t.length + 1 - 1
state_after: no goals