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

tactic: simpa using i.2
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
x✝ : [].Nodup
i : Fin [].length
⊢ [].next ([].get i) ⋯ = [].get ⟨(↑i + 1) % [].length, ⋯⟩
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x head✝ : α
x✝¹ : [head✝].Nodup
x✝ : Fin [head✝].length
⊢ [head✝].next ([head✝].get x✝) ⋯ = [head✝].get ⟨(↑x✝ + 1) % [head✝].length, ⋯⟩
state_after: no goals

tactic: have h₁ : get (x :: y :: l) { val := 0, isLt := h0 } = x := by simp
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
_h : (x :: y :: l).Nodup
h0 : 0 < (x :: y :: l).length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨0, h0⟩) ⋯ = (x :: y :: l).get ⟨(↑⟨0, h0⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
_h : (x :: y :: l).Nodup
h0 : 0 < (x :: y :: l).length
h₁ : (x :: y :: l).get ⟨0, h0⟩ = x
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨0, h0⟩) ⋯ = (x :: y :: l).get ⟨(↑⟨0, h0⟩ + 1) % (x :: y :: l).length, ⋯⟩

tactic: rw [next_cons_cons_eq' _ _ _ _ _ h₁]
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
_h : (x :: y :: l).Nodup
h0 : 0 < (x :: y :: l).length
h₁ : (x :: y :: l).get ⟨0, h0⟩ = x
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨0, h0⟩) ⋯ = (x :: y :: l).get ⟨(↑⟨0, h0⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
_h : (x :: y :: l).Nodup
h0 : 0 < (x :: y :: l).length
h₁ : (x :: y :: l).get ⟨0, h0⟩ = x
⊢ y = (x :: y :: l).get ⟨(↑⟨0, h0⟩ + 1) % (x :: y :: l).length, ⋯⟩

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
_h : (x :: y :: l).Nodup
h0 : 0 < (x :: y :: l).length
h₁ : (x :: y :: l).get ⟨0, h0⟩ = x
⊢ y = (x :: y :: l).get ⟨(↑⟨0, h0⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
_h : (x :: y :: l).Nodup
h0 : 0 < (x :: y :: l).length
⊢ (x :: y :: l).get ⟨0, h0⟩ = x
state_after: no goals

tactic: have hx' : (x :: y :: l).get ⟨i+1, hi⟩ ≠ x := by
  intro H
  suffices (i + 1 : ℕ) = 0 by simpa
  rw [nodup_iff_injective_get] at hn
  refine Fin.val_eq_of_eq (@hn ⟨i + 1, hi⟩ ⟨0, by simp⟩ ?_)
  simpa using H
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩

tactic: have hi' : i ≤ l.length := Nat.le_of_lt_succ (Nat.succ_lt_succ_iff.1 hi)
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi' : i ≤ l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩

tactic: rcases hi'.eq_or_lt with (hi' | hi')
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi' : i ≤ l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: case inl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i = l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩

case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩

tactic: intro H
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ False

tactic: suffices (i + 1 : ℕ) = 0 by simpa
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ False
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ i + 1 = 0

tactic: rw [nodup_iff_injective_get] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ i + 1 = 0
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : Function.Injective (x :: y :: l).get
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ i + 1 = 0

tactic: refine Fin.val_eq_of_eq (@hn ⟨i + 1, hi⟩ ⟨0, by simp⟩ ?_)
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : Function.Injective (x :: y :: l).get
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ i + 1 = 0
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : Function.Injective (x :: y :: l).get
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨0, ⋯⟩

tactic: simpa using H
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : Function.Injective (x :: y :: l).get
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨0, ⋯⟩
state_after: no goals

tactic: simpa
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
this : i + 1 = 0
⊢ False
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : Function.Injective (x :: y :: l).get
i : ℕ
hi : i + 1 < (x :: y :: l).length
H : (x :: y :: l).get ⟨i + 1, hi⟩ = x
⊢ 0 < (x :: y :: l).length
state_after: no goals

tactic: subst hi'
state_before: case inl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i = l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: case inl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨l.length + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨l.length + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩

tactic: rw [next_getLast_cons]
state_before: case inl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨l.length + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨l.length + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: case inl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ x = (x :: y :: l).get ⟨(↑⟨l.length + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩

case inl.h
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).get ⟨l.length + 1, hi⟩ ∈ y :: l

case inl.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x

case inl.hx
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).get ⟨l.length + 1, hi⟩ = (x :: y :: l).getLast ⋯

case inl.hl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (y :: l).Nodup

tactic: simp [hi', get]
state_before: case inl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ x = (x :: y :: l).get ⟨(↑⟨l.length + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: no goals

tactic: rw [get_cons_succ]
state_before: case inl.h
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).get ⟨l.length + 1, hi⟩ ∈ y :: l
state_after: case inl.h
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (y :: l).get ⟨l.length, ⋯⟩ ∈ y :: l

tactic: exact get_mem _ _ _
state_before: case inl.h
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (y :: l).get ⟨l.length, ⋯⟩ ∈ y :: l
state_after: no goals

tactic: exact hx'
state_before: case inl.hy
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
state_after: no goals

tactic: simp [getLast_eq_get]
state_before: case inl.hx
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (x :: y :: l).get ⟨l.length + 1, hi⟩ = (x :: y :: l).getLast ⋯
state_after: no goals

tactic: exact hn.of_cons
state_before: case inl.hl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
hi : l.length + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨l.length + 1, hi⟩ ≠ x
hi' : l.length ≤ l.length
⊢ (y :: l).Nodup
state_after: no goals

tactic: rw [next_ne_head_ne_getLast _ _ _ _ _ hx']
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ =
    (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ = (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩

case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ ≠ (x :: y :: l).getLast ⋯

α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ ∈ y :: l

tactic: simp only [get_cons_succ]
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).next ((x :: y :: l).get ⟨i + 1, hi⟩) ⋯ = (x :: y :: l).get ⟨(↑⟨i + 1, hi⟩ + 1) % (x :: y :: l).length, ⋯⟩
state_after: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).next ((y :: l).get ⟨i, ⋯⟩) ⋯ = (x :: y :: l).get ⟨(i + 1 + 1) % (x :: y :: l).length, ⋯⟩

tactic: rw [next_get (y::l), ← get_cons_succ (a := x)]
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).next ((y :: l).get ⟨i, ⋯⟩) ⋯ = (x :: y :: l).get ⟨(i + 1 + 1) % (x :: y :: l).length, ⋯⟩
state_after: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨(↑⟨i, ⋯⟩ + 1) % (y :: l).length + 1, ?m.38840⟩ =
    (x :: y :: l).get ⟨(i + 1 + 1) % (x :: y :: l).length, ⋯⟩

α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (↑⟨i, ⋯⟩ + 1) % (y :: l).length + 1 < (x :: y :: l).length

case inr._h
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).Nodup

tactic: congr
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨(↑⟨i, ⋯⟩ + 1) % (y :: l).length + 1, ?m.38840⟩ =
    (x :: y :: l).get ⟨(i + 1 + 1) % (x :: y :: l).length, ⋯⟩
state_after: case inr.e_a.e_val
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (↑⟨i, ⋯⟩ + 1) % (y :: l).length + 1 = (i + 1 + 1) % (x :: y :: l).length

tactic: dsimp
state_before: case inr.e_a.e_val
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (↑⟨i, ⋯⟩ + 1) % (y :: l).length + 1 = (i + 1 + 1) % (x :: y :: l).length
state_after: case inr.e_a.e_val
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (i + 1) % (l.length + 1) + 1 = (i + 1 + 1) % (l.length + 1 + 1)

tactic: rw [Nat.mod_eq_of_lt (Nat.succ_lt_succ_iff.2 hi'),
  Nat.mod_eq_of_lt (Nat.succ_lt_succ_iff.2 (Nat.succ_lt_succ_iff.2 hi'))]
state_before: case inr.e_a.e_val
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (i + 1) % (l.length + 1) + 1 = (i + 1 + 1) % (l.length + 1 + 1)
state_after: no goals

tactic: simp [Nat.mod_eq_of_lt (Nat.succ_lt_succ_iff.2 hi'), hi']
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (↑⟨i, ⋯⟩ + 1) % (y :: l).length + 1 < (x :: y :: l).length
state_after: no goals

tactic: exact hn.of_cons
state_before: case inr._h
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).Nodup
state_after: no goals

tactic: rw [getLast_eq_get]
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ ≠ (x :: y :: l).getLast ⋯
state_after: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ ≠ (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩

tactic: intro h
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ ≠ (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩
state_after: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
h : (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩
⊢ False

tactic: have := nodup_iff_injective_get.1 hn h
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
h : (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩
⊢ False
state_after: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
h : (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩
this : ⟨i + 1, hi⟩ = ⟨(x :: y :: l).length - 1, ⋯⟩
⊢ False

tactic: simp at this
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
h : (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩
this : ⟨i + 1, hi⟩ = ⟨(x :: y :: l).length - 1, ⋯⟩
⊢ False
state_after: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
h : (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩
this : i = l.length
⊢ False

tactic: simp [this] at hi'
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
h : (x :: y :: l).get ⟨i + 1, hi⟩ = (x :: y :: l).get ⟨(x :: y :: l).length - 1, ⋯⟩
this : i = l.length
⊢ False
state_after: no goals

tactic: rw [get_cons_succ]
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (x :: y :: l).get ⟨i + 1, hi⟩ ∈ y :: l
state_after: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).get ⟨i, ⋯⟩ ∈ y :: l

tactic: exact get_mem _ _ _
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
hn : (x :: y :: l).Nodup
i : ℕ
hi : i + 1 < (x :: y :: l).length
hx' : (x :: y :: l).get ⟨i + 1, hi⟩ ≠ x
hi'✝ : i ≤ l.length
hi' : i < l.length
⊢ (y :: l).get ⟨i, ⋯⟩ ∈ y :: l
state_after: no goals