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

tactic: cases' l with x l
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
hn : n < l.length
⊢ l.prev (l.nthLe n hn) ⋯ = l.nthLe ((n + (l.length - 1)) % l.length) ⋯
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
h : [].Nodup
hn : n < [].length
⊢ [].prev ([].nthLe n hn) ⋯ = [].nthLe ((n + ([].length - 1)) % [].length) ⋯

case cons
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
n : ℕ
x : α
l : List α
h : (x :: l).Nodup
hn : n < (x :: l).length
⊢ (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯

tactic: induction' l with y l hl generalizing n x
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
n : ℕ
x : α
l : List α
h : (x :: l).Nodup
hn : n < (x :: l).length
⊢ (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
state_after: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x✝ : α
n : ℕ
x : α
h : [x].Nodup
hn : n < [x].length
⊢ [x].prev ([x].nthLe n hn) ⋯ = [x].nthLe ((n + ([x].length - 1)) % [x].length) ⋯

case cons.cons
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
n : ℕ
x : α
h : (x :: y :: l).Nodup
hn : n < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe n hn) ⋯ =
    (x :: y :: l).nthLe ((n + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯

tactic: simp at hn
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
h : [].Nodup
hn : n < [].length
⊢ [].prev ([].nthLe n hn) ⋯ = [].nthLe ((n + ([].length - 1)) % [].length) ⋯
state_after: no goals

tactic: simp
state_before: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x✝ : α
n : ℕ
x : α
h : [x].Nodup
hn : n < [x].length
⊢ [x].prev ([x].nthLe n hn) ⋯ = [x].nthLe ((n + ([x].length - 1)) % [x].length) ⋯
state_after: no goals

tactic: rcases n with (_ | _ | n)
state_before: case cons.cons
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
n : ℕ
x : α
h : (x :: y :: l).Nodup
hn : n < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe n hn) ⋯ =
    (x :: y :: l).nthLe ((n + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
state_after: case cons.cons.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
hn : 0 < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe 0 hn) ⋯ =
    (x :: y :: l).nthLe ((0 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯

case cons.cons.succ.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
hn : 0 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (0 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((0 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯

case cons.cons.succ.succ
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (n + 1 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯

tactic: simp [Nat.add_succ_sub_one, add_zero, List.prev_cons_cons_eq, Nat.zero_eq, List.length,
  List.nthLe, Nat.succ_add_sub_one, zero_add, getLast_eq_get,
  Nat.mod_eq_of_lt (Nat.succ_lt_succ l.length.lt_succ_self)]
state_before: case cons.cons.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
hn : 0 < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe 0 hn) ⋯ =
    (x :: y :: l).nthLe ((0 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
state_after: no goals

tactic: simp only [mem_cons, nodup_cons] at h
state_before: case cons.cons.succ.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
hn : 0 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (0 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((0 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
state_after: case cons.cons.succ.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
hn : 0 + 1 < (x :: y :: l).length
h : ¬(x = y ∨ x ∈ l) ∧ y ∉ l ∧ l.Nodup
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (0 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((0 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯

tactic: push_neg at h
state_before: case cons.cons.succ.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
hn : 0 + 1 < (x :: y :: l).length
h : ¬(x = y ∨ x ∈ l) ∧ y ∉ l ∧ l.Nodup
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (0 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((0 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
state_after: case cons.cons.succ.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
hn : 0 + 1 < (x :: y :: l).length
h : (x ≠ y ∧ x ∉ l) ∧ y ∉ l ∧ l.Nodup
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (0 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((0 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯

tactic: simp only [List.prev_cons_cons_of_ne _ _ _ _ h.left.left.symm, Nat.zero_eq, List.length,
  List.nthLe, add_comm, eq_self_iff_true, Nat.succ_add_sub_one, Nat.mod_self, zero_add,
  List.get]
state_before: case cons.cons.succ.zero
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
hn : 0 + 1 < (x :: y :: l).length
h : (x ≠ y ∧ x ∉ l) ∧ y ∉ l ∧ l.Nodup
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (0 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((0 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
state_after: no goals

tactic: rw [prev_ne_cons_cons]
state_before: case cons.cons.succ.succ
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).prev ((x :: y :: l).nthLe (n + 1 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
state_after: case cons.cons.succ.succ
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (y :: l).prev ((x :: y :: l).nthLe (n + 1 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯

case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).nthLe (n + 1 + 1) hn ≠ x

case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).nthLe (n + 1 + 1) hn ≠ y

tactic: convert hl n.succ y h.of_cons (Nat.le_of_succ_le_succ hn) using 1
state_before: case cons.cons.succ.succ
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (y :: l).prev ((x :: y :: l).nthLe (n + 1 + 1) hn) ⋯ =
    (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯
state_after: case h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯ =
    (y :: l).nthLe ((n.succ + ((y :: l).length - 1)) % (y :: l).length) ⋯

tactic: have : ∀ k hk, (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) (Nat.succ_lt_succ hk) := by
  intros
  simp [List.nthLe]
state_before: case h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯ =
    (y :: l).nthLe ((n.succ + ((y :: l).length - 1)) % (y :: l).length) ⋯
state_after: case h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯ =
    (y :: l).nthLe ((n.succ + ((y :: l).length - 1)) % (y :: l).length) ⋯

tactic: rw [this]
state_before: case h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯ =
    (y :: l).nthLe ((n.succ + ((y :: l).length - 1)) % (y :: l).length) ⋯
state_after: case h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯ =
    (x :: y :: l).nthLe ((n.succ + ((y :: l).length - 1)) % (y :: l).length + 1) ⋯

tactic: congr
state_before: case h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (x :: y :: l).nthLe ((n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length) ⋯ =
    (x :: y :: l).nthLe ((n.succ + ((y :: l).length - 1)) % (y :: l).length + 1) ⋯
state_after: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length =
    (n.succ + ((y :: l).length - 1)) % (y :: l).length + 1

tactic: simp only [Nat.add_succ_sub_one, add_zero, length]
state_before: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (n + 1 + 1 + ((x :: y :: l).length - 1)) % (x :: y :: l).length =
    (n.succ + ((y :: l).length - 1)) % (y :: l).length + 1
state_after: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (n + 1 + 1 + (l.length + 1)) % (l.length + 1 + 1) = (n.succ + l.length) % (l.length + 1) + 1

tactic: simp only [length, Nat.succ_lt_succ_iff] at hn
state_before: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
⊢ (n + 1 + 1 + (l.length + 1)) % (l.length + 1 + 1) = (n.succ + l.length) % (l.length + 1) + 1
state_after: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
hn : n < l.length
⊢ (n + 1 + 1 + (l.length + 1)) % (l.length + 1 + 1) = (n.succ + l.length) % (l.length + 1) + 1

tactic: set k := l.length
state_before: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
hn : n < l.length
⊢ (n + 1 + 1 + (l.length + 1)) % (l.length + 1 + 1) = (n.succ + l.length) % (l.length + 1) + 1
state_after: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
k : ℕ := l.length
hn : n < k
⊢ (n + 1 + 1 + (k + 1)) % (k + 1 + 1) = (n.succ + k) % (k + 1) + 1

tactic: rw [Nat.succ_add, ← Nat.add_succ, Nat.add_mod_right, Nat.succ_add, ← Nat.add_succ _ k,
  Nat.add_mod_right, Nat.mod_eq_of_lt, Nat.mod_eq_of_lt]
state_before: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
k : ℕ := l.length
hn : n < k
⊢ (n + 1 + 1 + (k + 1)) % (k + 1 + 1) = (n.succ + k) % (k + 1) + 1
state_after: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
k : ℕ := l.length
hn : n < k
⊢ n < k.succ

case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
k : ℕ := l.length
hn : n < k
⊢ n + 1 < (k + 1).succ

tactic: intros
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
k✝ : ℕ
hk✝ : k✝ < (y :: l).length
⊢ (y :: l).nthLe k✝ hk✝ = (x :: y :: l).nthLe (k✝ + 1) ⋯

tactic: simp [List.nthLe]
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
k✝ : ℕ
hk✝ : k✝ < (y :: l).length
⊢ (y :: l).nthLe k✝ hk✝ = (x :: y :: l).nthLe (k✝ + 1) ⋯
state_after: no goals

tactic: exact Nat.lt_succ_of_lt hn
state_before: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
k : ℕ := l.length
hn : n < k
⊢ n < k.succ
state_after: no goals

tactic: exact Nat.succ_lt_succ (Nat.lt_succ_of_lt hn)
state_before: case h.e'_3.e_n
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
this : ∀ (k : ℕ) (hk : k < (y :: l).length), (y :: l).nthLe k hk = (x :: y :: l).nthLe (k + 1) ⋯
k : ℕ := l.length
hn : n < k
⊢ n + 1 < (k + 1).succ
state_after: no goals

tactic: intro H
state_before: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).nthLe (n + 1 + 1) hn ≠ x
state_after: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ False

tactic: suffices n.succ.succ = 0 by simpa
state_before: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ False
state_after: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ n.succ.succ = 0

tactic: rw [nodup_iff_nthLe_inj] at h
state_before: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ n.succ.succ = 0
state_after: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ n.succ.succ = 0

tactic: refine h _ _ hn Nat.succ_pos' ?_
state_before: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ n.succ.succ = 0
state_after: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ (x :: y :: l).nthLe n.succ.succ hn = (x :: y :: l).nthLe 0 ⋯

tactic: simpa using H
state_before: case cons.cons.succ.succ.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
⊢ (x :: y :: l).nthLe n.succ.succ hn = (x :: y :: l).nthLe 0 ⋯
state_after: no goals

tactic: simpa
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = x
this : n.succ.succ = 0
⊢ False
state_after: no goals

tactic: intro H
state_before: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
⊢ (x :: y :: l).nthLe (n + 1 + 1) hn ≠ y
state_after: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ False

tactic: suffices n.succ.succ = 1 by simpa
state_before: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ False
state_after: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ n.succ.succ = 1

tactic: rw [nodup_iff_nthLe_inj] at h
state_before: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ n.succ.succ = 1
state_after: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ n.succ.succ = 1

tactic: refine h _ _ hn (Nat.succ_lt_succ Nat.succ_pos') ?_
state_before: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ n.succ.succ = 1
state_after: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ (x :: y :: l).nthLe n.succ.succ hn = (x :: y :: l).nthLe 1 ⋯

tactic: simpa using H
state_before: case cons.cons.succ.succ.hz
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (x :: y :: l).length) (h₂ : j < (x :: y :: l).length),
    (x :: y :: l).nthLe i h₁ = (x :: y :: l).nthLe j h₂ → i = j
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
⊢ (x :: y :: l).nthLe n.succ.succ hn = (x :: y :: l).nthLe 1 ⋯
state_after: no goals

tactic: simpa
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ y : α
l : List α
hl :
  ∀ (n : ℕ) (x : α),
    (x :: l).Nodup →
      ∀ (hn : n < (x :: l).length),
        (x :: l).prev ((x :: l).nthLe n hn) ⋯ = (x :: l).nthLe ((n + ((x :: l).length - 1)) % (x :: l).length) ⋯
x : α
h : (x :: y :: l).Nodup
n : ℕ
hn : n + 1 + 1 < (x :: y :: l).length
H : (x :: y :: l).nthLe (n + 1 + 1) hn = y
this : n.succ.succ = 1
⊢ False
state_after: no goals