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

tactic: rw [(permutations_perm_permutations' s).nodup_iff]
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
hs : s.Nodup
⊢ s.permutations.Nodup
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
hs : s.Nodup
⊢ s.permutations'.Nodup

tactic: induction' hs with x l h h' IH
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
hs : s.Nodup
⊢ s.permutations'.Nodup
state_after: case nil
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
⊢ [].permutations'.Nodup

case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ (x :: l).permutations'.Nodup

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
⊢ [].permutations'.Nodup
state_after: no goals

tactic: rw [permutations']
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ (x :: l).permutations'.Nodup
state_after: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ (l.permutations'.bind (permutations'Aux x)).Nodup

tactic: rw [nodup_bind]
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ (l.permutations'.bind (permutations'Aux x)).Nodup
state_after: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ (∀ x_1 ∈ l.permutations', (permutations'Aux x x_1).Nodup) ∧
    Pairwise (fun a b => (permutations'Aux x a).Disjoint (permutations'Aux x b)) l.permutations'

tactic: constructor
state_before: case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ (∀ x_1 ∈ l.permutations', (permutations'Aux x x_1).Nodup) ∧
    Pairwise (fun a b => (permutations'Aux x a).Disjoint (permutations'Aux x b)) l.permutations'
state_after: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ ∀ x_1 ∈ l.permutations', (permutations'Aux x x_1).Nodup

case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ Pairwise (fun a b => (permutations'Aux x a).Disjoint (permutations'Aux x b)) l.permutations'

tactic: intro ys hy
state_before: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ ∀ x_1 ∈ l.permutations', (permutations'Aux x x_1).Nodup
state_after: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
ys : List α
hy : ys ∈ l.permutations'
⊢ (permutations'Aux x ys).Nodup

tactic: rw [mem_permutations'] at hy
state_before: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
ys : List α
hy : ys ∈ l.permutations'
⊢ (permutations'Aux x ys).Nodup
state_after: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
ys : List α
hy : ys ~ l
⊢ (permutations'Aux x ys).Nodup

tactic: rw [nodup_permutations'Aux_iff, hy.mem_iff]
state_before: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
ys : List α
hy : ys ~ l
⊢ (permutations'Aux x ys).Nodup
state_after: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
ys : List α
hy : ys ~ l
⊢ x ∉ l

tactic: exact fun H => h x H rfl
state_before: case cons.left
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
ys : List α
hy : ys ~ l
⊢ x ∉ l
state_after: no goals

tactic: refine IH.pairwise_of_forall_ne fun as ha bs hb H => ?_
state_before: case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
⊢ Pairwise (fun a b => (permutations'Aux x a).Disjoint (permutations'Aux x b)) l.permutations'
state_after: case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
⊢ (permutations'Aux x as).Disjoint (permutations'Aux x bs)

tactic: rw [disjoint_iff_ne]
state_before: case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
⊢ (permutations'Aux x as).Disjoint (permutations'Aux x bs)
state_after: case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
⊢ ∀ a ∈ permutations'Aux x as, ∀ b ∈ permutations'Aux x bs, a ≠ b

tactic: rintro a ha' b hb' rfl
state_before: case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
⊢ ∀ a ∈ permutations'Aux x as, ∀ b ∈ permutations'Aux x bs, a ≠ b
state_after: case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
⊢ False

tactic: obtain ⟨⟨n, hn⟩, hn'⟩ := get_of_mem ha'
state_before: case cons.right
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
⊢ False
state_after: case cons.right.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
⊢ False

tactic: obtain ⟨⟨m, hm⟩, hm'⟩ := get_of_mem hb'
state_before: case cons.right.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
⊢ False
state_after: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
m : ℕ
hm : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm⟩ = a
⊢ False

tactic: rw [mem_permutations'] at ha hb
state_before: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ∈ l.permutations'
bs : List α
hb : bs ∈ l.permutations'
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
m : ℕ
hm : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm⟩ = a
⊢ False
state_after: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
m : ℕ
hm : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm⟩ = a
⊢ False

tactic: have hl : as.length = bs.length := (ha.trans hb.symm).length_eq
state_before: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
m : ℕ
hm : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm⟩ = a
⊢ False
state_after: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
m : ℕ
hm : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm⟩ = a
hl : as.length = bs.length
⊢ False

tactic: simp only [Nat.lt_succ_iff, length_permutations'Aux] at hn hm
state_before: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn⟩ = a
m : ℕ
hm : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm⟩ = a
hl : as.length = bs.length
⊢ False
state_after: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn✝⟩ = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm✝⟩ = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
⊢ False

tactic: rw [← nthLe, nthLe_permutations'Aux] at hn' hm'
state_before: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : (permutations'Aux x as).get ⟨n, hn✝⟩ = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : (permutations'Aux x bs).get ⟨m, hm✝⟩ = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
⊢ False
state_after: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
⊢ False

tactic: have hx :
  nthLe (insertNth n x as) m (by rwa [length_insertNth _ _ hn, Nat.lt_succ_iff, hl]) = x := by
  simp [hn', ← hm', hm]
state_before: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
⊢ False
state_after: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
⊢ False

tactic: have hx' :
  nthLe (insertNth m x bs) n (by rwa [length_insertNth _ _ hm, Nat.lt_succ_iff, ← hl]) =
    x := by
  simp [hm', ← hn', hn]
state_before: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
⊢ False
state_after: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
⊢ False

tactic: rcases lt_trichotomy n m with (ht | ht | ht)
state_before: case cons.right.intro.mk.intro.mk
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
⊢ False
state_after: case cons.right.intro.mk.intro.mk.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n < m
⊢ False

case cons.right.intro.mk.intro.mk.inr.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n = m
⊢ False

case cons.right.intro.mk.intro.mk.inr.inr
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : m < n
⊢ False

tactic: rwa [length_insertNth _ _ hn, Nat.lt_succ_iff, hl]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
⊢ m < (insertNth n x as).length
state_after: no goals

tactic: simp [hn', ← hm', hm]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
⊢ (insertNth n x as).nthLe m ⋯ = x
state_after: no goals

tactic: rwa [length_insertNth _ _ hm, Nat.lt_succ_iff, ← hl]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
⊢ n < (insertNth m x bs).length
state_after: no goals

tactic: simp [hm', ← hn', hn]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
⊢ (insertNth m x bs).nthLe n ⋯ = x
state_after: no goals

tactic: suffices x ∈ bs by exact h x (hb.subset this) rfl
state_before: case cons.right.intro.mk.intro.mk.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n < m
⊢ False
state_after: case cons.right.intro.mk.intro.mk.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n < m
⊢ x ∈ bs

tactic: rw [← hx', nthLe_insertNth_of_lt _ _ _ _ ht (ht.trans_le hm)]
state_before: case cons.right.intro.mk.intro.mk.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n < m
⊢ x ∈ bs
state_after: case cons.right.intro.mk.intro.mk.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n < m
⊢ bs.nthLe n ⋯ ∈ bs

tactic: exact nthLe_mem _ _ _
state_before: case cons.right.intro.mk.intro.mk.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n < m
⊢ bs.nthLe n ⋯ ∈ bs
state_after: no goals

tactic: exact h x (hb.subset this) rfl
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n < m
this : x ∈ bs
⊢ False
state_after: no goals

tactic: simp only [ht] at hm' hn'
state_before: case cons.right.intro.mk.intro.mk.inr.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n = m
⊢ False
state_after: case cons.right.intro.mk.intro.mk.inr.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n = m
hn' : insertNth m x as = a
⊢ False

tactic: rw [← hm'] at hn'
state_before: case cons.right.intro.mk.intro.mk.inr.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n = m
hn' : insertNth m x as = a
⊢ False
state_after: case cons.right.intro.mk.intro.mk.inr.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n = m
hn' : insertNth m x as = insertNth m x bs
⊢ False

tactic: exact H (insertNth_injective _ _ hn')
state_before: case cons.right.intro.mk.intro.mk.inr.inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : n = m
hn' : insertNth m x as = insertNth m x bs
⊢ False
state_after: no goals

tactic: suffices x ∈ as by exact h x (ha.subset this) rfl
state_before: case cons.right.intro.mk.intro.mk.inr.inr
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : m < n
⊢ False
state_after: case cons.right.intro.mk.intro.mk.inr.inr
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : m < n
⊢ x ∈ as

tactic: rw [← hx, nthLe_insertNth_of_lt _ _ _ _ ht (ht.trans_le hn)]
state_before: case cons.right.intro.mk.intro.mk.inr.inr
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : m < n
⊢ x ∈ as
state_after: case cons.right.intro.mk.intro.mk.inr.inr
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : m < n
⊢ as.nthLe m ⋯ ∈ as

tactic: exact nthLe_mem _ _ _
state_before: case cons.right.intro.mk.intro.mk.inr.inr
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : m < n
⊢ as.nthLe m ⋯ ∈ as
state_after: no goals

tactic: exact h x (ha.subset this) rfl
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
s : List α
x : α
l : List α
h : ∀ a' ∈ l, x ≠ a'
h' : Pairwise (fun x x_1 => x ≠ x_1) l
IH : l.permutations'.Nodup
as : List α
ha : as ~ l
bs : List α
hb : bs ~ l
H : as ≠ bs
a : List α
ha' : a ∈ permutations'Aux x as
hb' : a ∈ permutations'Aux x bs
n : ℕ
hn✝ : n < (permutations'Aux x as).length
hn' : insertNth n x as = a
m : ℕ
hm✝ : m < (permutations'Aux x bs).length
hm' : insertNth m x bs = a
hl : as.length = bs.length
hn : n ≤ as.length
hm : m ≤ bs.length
hx : (insertNth n x as).nthLe m ⋯ = x
hx' : (insertNth m x bs).nthLe n ⋯ = x
ht : m < n
this : x ∈ as
⊢ False
state_after: no goals