Theorem: List.prev_reverse_eq_next
File: Mathlib/Data/List/Cycle.lean

tactic: obtain ⟨k, hk, rfl⟩ := nthLe_of_mem hx
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : l.Nodup
x : α
hx : x ∈ l
⊢ l.reverse.prev x ⋯ = l.next x hx
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = l.next (l.nthLe k hk) hx

tactic: have lpos : 0 < l.length := k.zero_le.trans_lt hk
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = l.next (l.nthLe k hk) hx
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = l.next (l.nthLe k hk) hx

tactic: have key : l.length - 1 - k < l.length := by omega
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = l.next (l.nthLe k hk) hx
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = l.next (l.nthLe k hk) hx

tactic: rw [← nthLe_pmap l.next (fun _ h => h) (by simpa using hk)]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = l.next (l.nthLe k hk) hx
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = (pmap l.next l ⋯).nthLe k ⋯

tactic: simp_rw [← nthLe_reverse l k (key.trans_le (by simp)), pmap_next_eq_rotate_one _ h]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev (l.nthLe k hk) ⋯ = (pmap l.next l ⋯).nthLe k ⋯
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev (l.reverse.nthLe (l.length - 1 - k) ⋯) ⋯ = (l.rotate 1).nthLe k ⋯

tactic: rw [← nthLe_pmap l.reverse.prev fun _ h => h]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev (l.reverse.nthLe (l.length - 1 - k) ⋯) ⋯ = (l.rotate 1).nthLe k ⋯
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (pmap l.reverse.prev l.reverse ⋯).nthLe (l.length - 1 - k) ?intro.intro = (l.rotate 1).nthLe k ⋯

case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.length - 1 - k < (pmap l.reverse.prev l.reverse ⋯).length

tactic: omega
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
⊢ l.length - 1 - k < l.length
state_after: no goals

tactic: simpa using hk
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ k < (pmap l.next l ⋯).length
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.length ≤ l.reverse.length
state_after: no goals

tactic: simp_rw [pmap_prev_eq_rotate_length_sub_one _ (nodup_reverse.mpr h), rotate_reverse,
  length_reverse, Nat.mod_eq_of_lt (Nat.sub_lt lpos Nat.succ_pos'),
  Nat.sub_sub_self (Nat.succ_le_of_lt lpos)]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (pmap l.reverse.prev l.reverse ⋯).nthLe (l.length - 1 - k) ?intro.intro = (l.rotate 1).nthLe k ⋯
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (l.rotate (Nat.succ 0)).reverse.nthLe (l.length - 1 - k) ⋯ = (l.rotate 1).nthLe k ⋯

tactic: rw [← nthLe_reverse]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (l.rotate (Nat.succ 0)).reverse.nthLe (l.length - 1 - k) ⋯ = (l.rotate 1).nthLe k ⋯
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (l.rotate (Nat.succ 0)).reverse.reverse.nthLe ((l.rotate (Nat.succ 0)).reverse.length - 1 - (l.length - 1 - k))
      ?intro.intro.h1 =
    (l.rotate 1).nthLe k ⋯

case intro.intro.h1
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (l.rotate (Nat.succ 0)).reverse.length - 1 - (l.length - 1 - k) < (l.rotate (Nat.succ 0)).reverse.reverse.length

tactic: simp [Nat.sub_sub_self (Nat.le_sub_one_of_lt hk)]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (l.rotate (Nat.succ 0)).reverse.reverse.nthLe ((l.rotate (Nat.succ 0)).reverse.length - 1 - (l.length - 1 - k))
      ?intro.intro.h1 =
    (l.rotate 1).nthLe k ⋯
state_after: no goals

tactic: simpa using (Nat.sub_le _ _).trans_lt (Nat.sub_lt lpos Nat.succ_pos')
state_before: case intro.intro.h1
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ (l.rotate (Nat.succ 0)).reverse.length - 1 - (l.length - 1 - k) < (l.rotate (Nat.succ 0)).reverse.reverse.length
state_after: no goals

tactic: simpa
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l.nthLe k hk ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.length - 1 - k < (pmap l.reverse.prev l.reverse ⋯).length
state_after: no goals