Theorem: nodup_permsOfList
File: Mathlib/Data/Fintype/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x✝ : [].Nodup
⊢ (permsOfList []).Nodup
state_after: no goals
tactic: simp [permsOfList]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
⊢ (permsOfList (a :: l)).Nodup
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
⊢ (permsOfList (a :: l)).Nodup
tactic: have hl' : l.Nodup := hl.of_cons
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
⊢ (permsOfList (a :: l)).Nodup
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
⊢ (permsOfList (a :: l)).Nodup
tactic: have hln' : (permsOfList l).Nodup := nodup_permsOfList hl'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
⊢ (permsOfList (a :: l)).Nodup
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ (permsOfList (a :: l)).Nodup
tactic: have hmeml : ∀ {f : Perm α}, f ∈ permsOfList l → f a = a := fun {f} hf =>
      not_not.1 (mt (mem_of_mem_permsOfList hf _) (nodup_cons.1 hl).1)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ (permsOfList (a :: l)).Nodup
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ (permsOfList l).Nodup ∧
    ((∀ x ∈ l, (List.map (fun f => Equiv.swap a x * f) (permsOfList l)).Nodup) ∧
        ∀ (i j : Fin l.length),
          i < j →
            (List.map (fun f => Equiv.swap a (l.get i) * f) (permsOfList l)).Disjoint
              (List.map (fun f => Equiv.swap a (l.get j) * f) (permsOfList l))) ∧
      (permsOfList l).Disjoint (l.bind fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l))
tactic: rw [permsOfList, List.nodup_append, List.nodup_bind, pairwise_iff_get]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ (permsOfList l).Nodup ∧
    ((∀ x ∈ l, (List.map (fun f => Equiv.swap a x * f) (permsOfList l)).Nodup) ∧
        ∀ (i j : Fin l.length),
          i < j →
            (List.map (fun f => Equiv.swap a (l.get i) * f) (permsOfList l)).Disjoint
              (List.map (fun f => Equiv.swap a (l.get j) * f) (permsOfList l))) ∧
      (permsOfList l).Disjoint (l.bind fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l))
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ (permsOfList l).Nodup

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ ∀ x ∈ l, (List.map (fun f => Equiv.swap a x * f) (permsOfList l)).Nodup

case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ ∀ (i j : Fin l.length),
    i < j →
      (List.map (fun f => Equiv.swap a (l.get i) * f) (permsOfList l)).Disjoint
        (List.map (fun f => Equiv.swap a (l.get j) * f) (permsOfList l))

case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
⊢ (permsOfList l).Disjoint (l.bind fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l))
tactic: refine ⟨?_, ⟨⟨?_,?_ ⟩, ?_⟩⟩