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
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
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
⊢ Chain' R []
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
x✝ : ℕ
h : x✝ < [].length - 1
⊢ R ([].get ⟨x✝, ⋯⟩) ([].get ⟨x✝ + 1, ⋯⟩)
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 : α
x✝ : ℕ
h : x✝ < [a].length - 1
⊢ R ([a].get ⟨x✝, ⋯⟩) ([a].get ⟨x✝ + 1, ⋯⟩)
state_after: no goals

tactic: rw [← and_forall_succ, chain'_cons, chain'_iff_get]
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) ↔
    ∀ (i : ℕ) (h : i < (a :: b :: t).length - 1), R ((a :: b :: t).get ⟨i, ⋯⟩) ((a :: 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 ∧ ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)) ↔
    (∀ (h : 0 < (a :: b :: t).length - 1), R ((a :: b :: t).get ⟨0, ⋯⟩) ((a :: b :: t).get ⟨0 + 1, ⋯⟩)) ∧
      ∀ (n : ℕ) (h : n + 1 < (a :: b :: t).length - 1),
        R ((a :: b :: t).get ⟨n + 1, ⋯⟩) ((a :: b :: t).get ⟨n + 1 + 1, ⋯⟩)

tactic: simp only [length_cons, get_cons_succ, Fin.zero_eta, get_cons_zero, Nat.zero_add, Fin.mk_one,
  get_cons_cons_one, succ_sub_succ_eq_sub, Nat.le_zero, Nat.add_eq_zero_iff, and_false,
  Nat.sub_zero, Nat.add_pos_iff_pos_or_pos, Nat.zero_lt_one, or_true, forall_true_left,
  and_congr_right_iff]
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ (R a b ∧ ∀ (i : ℕ) (h : i < (b :: t).length - 1), R ((b :: t).get ⟨i, ⋯⟩) ((b :: t).get ⟨i + 1, ⋯⟩)) ↔
    (∀ (h : 0 < (a :: b :: t).length - 1), R ((a :: b :: t).get ⟨0, ⋯⟩) ((a :: b :: t).get ⟨0 + 1, ⋯⟩)) ∧
      ∀ (n : ℕ) (h : n + 1 < (a :: b :: t).length - 1),
        R ((a :: b :: t).get ⟨n + 1, ⋯⟩) ((a :: b :: t).get ⟨n + 1 + 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 →
    ((∀ (i : ℕ) (h : i < t.length), R ((b :: t).get ⟨i, ⋯⟩) (t.get ⟨i, ⋯⟩)) ↔
      ∀ (n : ℕ) (h : n + 1 < t.length + 1), R ((b :: t).get ⟨n, ⋯⟩) (t.get ⟨n, ⋯⟩))

tactic: dsimp [succ_sub_one]
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ R a b →
    ((∀ (i : ℕ) (h : i < t.length), R ((b :: t).get ⟨i, ⋯⟩) (t.get ⟨i, ⋯⟩)) ↔
      ∀ (n : ℕ) (h : n + 1 < t.length + 1), R ((b :: t).get ⟨n, ⋯⟩) (t.get ⟨n, ⋯⟩))
state_after: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ R a b →
    ((∀ (i : ℕ) (h : i < t.length), R (b :: t)[i] t[i]) ↔ ∀ (n : ℕ) (h : n + 1 < t.length + 1), R (b :: t)[n] t[n])

tactic: exact fun _ => ⟨fun h i hi => h i (Nat.lt_of_succ_lt_succ hi),
                fun h i hi => h i (Nat.succ_lt_succ hi)⟩
state_before: α : Type u
β : Type v
R✝ r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ : α
R : α → α → Prop
a b : α
t : List α
⊢ R a b →
    ((∀ (i : ℕ) (h : i < t.length), R (b :: t)[i] t[i]) ↔ ∀ (n : ℕ) (h : n + 1 < t.length + 1), R (b :: t)[n] t[n])
state_after: no goals