Theorem: Equiv.Perm.prod_prodExtendRight
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (a : α), a ∈ l
⊢ List.prod (List.map (fun a => prodExtendRight a (σ a)) l) = prodCongrRight σ

tactic: suffices a ∈ l ∧ (l.map fun a => prodExtendRight a (σ a)).prod (a, b) = (a, σ a b) ∨
    a ∉ l ∧ (l.map fun a => prodExtendRight a (σ a)).prod (a, b) = (a, b) by
  obtain ⟨_, prod_eq⟩ := Or.resolve_right this (not_and.mpr fun h _ => h (mem_l a))
  rw [prod_eq, prodCongrRight_apply]
state_before: case H.mk
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (a : α), a ∈ l
a : α
b : β
⊢ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = ↑(prodCongrRight σ) (a, b)

tactic: clear mem_l
state_before: case H.mk
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (a : α), a ∈ l
a : α
b : β
⊢ a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)

tactic: induction' l with a' l ih
state_before: case H.mk
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl : List.Nodup l
a : α
b : β
⊢ a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)

tactic: rw [List.map_cons, List.prod_cons, mul_apply]
state_before: case H.mk.cons
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
⊢ a ∈ a' :: l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) (a' :: l))) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ a' :: l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) (a' :: l))) (a, b) = (a, b)

tactic: rcases ih (List.nodup_cons.mp hl).2 with (⟨mem_l, prod_eq⟩ | ⟨not_mem_l, prod_eq⟩) <;>
  rw [prod_eq]
state_before: case H.mk.cons
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
⊢ a ∈ a' :: l ∧
      ↑(prodExtendRight a' (σ a')) (↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b)) =
        (a, ↑(σ a) b) ∨
    ¬a ∈ a' :: l ∧
      ↑(prodExtendRight a' (σ a')) (↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b)) = (a, b)

tactic: by_cases ha' : a = a'
state_before: case H.mk.cons.inr.intro
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
not_mem_l : ¬a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
⊢ a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, b) = (a, b)

tactic: obtain ⟨_, prod_eq⟩ := Or.resolve_right this (not_and.mpr fun h _ => h (mem_l a))
state_before: α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (a : α), a ∈ l
a : α
b : β
this :
  a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
⊢ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = ↑(prodCongrRight σ) (a, b)

tactic: rw [prod_eq, prodCongrRight_apply]
state_before: case intro
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl : List.Nodup l
mem_l : ∀ (a : α), a ∈ l
a : α
b : β
this :
  a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
left✝ : a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b)
⊢ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = ↑(prodCongrRight σ) (a, b)

tactic: refine' Or.inr ⟨List.not_mem_nil _, _⟩
state_before: case H.mk.nil
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl✝ : List.Nodup l
a : α
b : β
hl : List.Nodup []
⊢ a ∈ [] ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) [])) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ [] ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) [])) (a, b) = (a, b)

tactic: rw [List.map_nil, List.prod_nil, one_apply]
state_before: case H.mk.nil
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l : List α
hl✝ : List.Nodup l
a : α
b : β
hl : List.Nodup []
⊢ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) [])) (a, b) = (a, b)

tactic: refine' Or.inl ⟨List.mem_cons_of_mem _ mem_l, _⟩
state_before: case H.mk.cons.inl.intro
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
mem_l : a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b)
⊢ a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, ↑(σ a) b) = (a, ↑(σ a) b) ∨
    ¬a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, ↑(σ a) b) = (a, b)

tactic: rw [prodExtendRight_apply_ne _ fun h : a = a' => (List.nodup_cons.mp hl).1 (h ▸ mem_l)]
state_before: case H.mk.cons.inl.intro
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
mem_l : a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b)
⊢ ↑(prodExtendRight a' (σ a')) (a, ↑(σ a) b) = (a, ↑(σ a) b)

tactic: rw [← ha'] at *
state_before: case pos
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
not_mem_l : ¬a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
ha' : a = a'
⊢ a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, b) = (a, b)

tactic: refine' Or.inl ⟨l.mem_cons_self a, _⟩
state_before: case pos
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
not_mem_l : ¬a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
ha' : a = a
⊢ a ∈ a :: l ∧ ↑(prodExtendRight a (σ a)) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ a :: l ∧ ↑(prodExtendRight a (σ a)) (a, b) = (a, b)

tactic: rw [prodExtendRight_apply_eq]
state_before: case pos
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
not_mem_l : ¬a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
ha' : a = a
⊢ ↑(prodExtendRight a (σ a)) (a, b) = (a, ↑(σ a) b)

tactic: refine' Or.inr ⟨fun h => not_or_of_not ha' not_mem_l ((List.mem_cons).mp h), _⟩
state_before: case neg
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
not_mem_l : ¬a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
ha' : ¬a = a'
⊢ a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, b) = (a, ↑(σ a) b) ∨
    ¬a ∈ a' :: l ∧ ↑(prodExtendRight a' (σ a')) (a, b) = (a, b)

tactic: rw [prodExtendRight_apply_ne _ ha']
state_before: case neg
α✝ : Type u
β : Type v
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
l✝ : List α
hl✝ : List.Nodup l✝
a : α
b : β
a' : α
l : List α
ih :
  List.Nodup l →
    a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, ↑(σ a) b) ∨
      ¬a ∈ l ∧ ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
hl : List.Nodup (a' :: l)
not_mem_l : ¬a ∈ l
prod_eq : ↑(List.prod (List.map (fun a => prodExtendRight a (σ a)) l)) (a, b) = (a, b)
ha' : ¬a = a'
⊢ ↑(prodExtendRight a' (σ a')) (a, b) = (a, b)