Theorem: List.nodup_permutations'Aux_iff
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
⊢ (permutations'Aux x s).Nodup ↔ x ∉ s
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h : (permutations'Aux x s).Nodup
⊢ x ∉ s
tactic: refine ⟨fun h => ?_, nodup_permutations'Aux_of_not_mem _ _⟩
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h : (permutations'Aux x s).Nodup
⊢ x ∉ s
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h : (permutations'Aux x s).Nodup
H : x ∈ s
⊢ False
tactic: intro H
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h : (permutations'Aux x s).Nodup
H : x ∈ s
⊢ False
state_after: case intro.intro
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h : (permutations'Aux x s).Nodup
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ False
tactic: obtain ⟨k, hk, hk'⟩ := nthLe_of_mem H
state_before: case intro.intro
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h : (permutations'Aux x s).Nodup
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ False
state_after: case intro.intro
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ False
tactic: rw [nodup_iff_nthLe_inj] at h
state_before: case intro.intro
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ False
state_after: case intro.intro.refine_1
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ k < (permutations'Aux x s).length

case intro.intro.refine_2
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ k + 1 < (permutations'Aux x s).length

case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ (permutations'Aux x s).nthLe k ?intro.intro.refine_1 = (permutations'Aux x s).nthLe (k + 1) ?intro.intro.refine_2
tactic: refine k.succ_ne_self.symm $ h k (k + 1) ?_ ?_ ?_
state_before: case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ (permutations'Aux x s).nthLe k ⋯ = (permutations'Aux x s).nthLe (k + 1) ⋯
state_after: case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ insertNth k x s = insertNth (k + 1) x s
tactic: rw [nthLe_permutations'Aux, nthLe_permutations'Aux]
state_before: case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
⊢ insertNth k x s = insertNth (k + 1) x s
state_after: case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
hl : (insertNth k x s).length = (insertNth (k + 1) x s).length
⊢ insertNth k x s = insertNth (k + 1) x s
tactic: have hl : length (insertNth k x s) = length (insertNth (k + 1) x s) := by
    rw [length_insertNth _ _ hk.le, length_insertNth _ _ (Nat.succ_le_of_lt hk)]
state_before: case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
hl : (insertNth k x s).length = (insertNth (k + 1) x s).length
⊢ insertNth k x s = insertNth (k + 1) x s
state_after: case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
hl : (insertNth k x s).length = (insertNth (k + 1) x s).length
n : ℕ
hn : n < (insertNth k x s).length
hn' : n < (insertNth (k + 1) x s).length
⊢ (insertNth k x s).nthLe n hn = (insertNth (k + 1) x s).nthLe n hn'
tactic: refine ext_nthLe hl fun n hn hn' => ?_
state_before: case intro.intro.refine_3
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
hl : (insertNth k x s).length = (insertNth (k + 1) x s).length
n : ℕ
hn : n < (insertNth k x s).length
hn' : n < (insertNth (k + 1) x s).length
⊢ (insertNth k x s).nthLe n hn = (insertNth (k + 1) x s).nthLe n hn'
state_after: case intro.intro.refine_3.inl
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H✝ : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
hl : (insertNth k x s).length = (insertNth (k + 1) x s).length
n : ℕ
hn : n < (insertNth k x s).length
hn' : n < (insertNth (k + 1) x s).length
H : n < k
⊢ (insertNth k x s).nthLe n hn = (insertNth (k + 1) x s).nthLe n hn'

case intro.intro.refine_3.inr.inl
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H : x ∈ s
n : ℕ
hk : n < s.length
hk' : s.nthLe n hk = x
hl : (insertNth n x s).length = (insertNth (n + 1) x s).length
hn : n < (insertNth n x s).length
hn' : n < (insertNth (n + 1) x s).length
⊢ (insertNth n x s).nthLe n hn = (insertNth (n + 1) x s).nthLe n hn'

case intro.intro.refine_3.inr.inr
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
h :
  ∀ (i j : ℕ) (h₁ : i < (permutations'Aux x s).length) (h₂ : j < (permutations'Aux x s).length),
    (permutations'Aux x s).nthLe i h₁ = (permutations'Aux x s).nthLe j h₂ → i = j
H✝ : x ∈ s
k : ℕ
hk : k < s.length
hk' : s.nthLe k hk = x
hl : (insertNth k x s).length = (insertNth (k + 1) x s).length
n : ℕ
hn : n < (insertNth k x s).length
hn' : n < (insertNth (k + 1) x s).length
H : k < n
⊢ (insertNth k x s).nthLe n hn = (insertNth (k + 1) x s).nthLe n hn'
tactic: rcases lt_trichotomy n k with (H | rfl | H)