Theorem: Finset.noncommProd_union_of_disjoint
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: obtain ⟨sl, sl', rfl⟩ := exists_list_nodup_eq s
state_before: F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
s t : Finset α
h : Disjoint s t
f : α → β
comm : Set.Pairwise {x | x ∈ s ∪ t} fun a b => Commute (f a) (f b)
⊢ noncommProd (s ∪ t) f comm =
    noncommProd s f (_ : Set.Pairwise ↑s fun a b => Commute (f a) (f b)) *
      noncommProd t f (_ : Set.Pairwise ↑t fun a b => Commute (f a) (f b))

tactic: obtain ⟨tl, tl', rfl⟩ := exists_list_nodup_eq t
state_before: case intro.intro
F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
t : Finset α
f : α → β
sl : List α
sl' : List.Nodup sl
h : Disjoint (List.toFinset sl) t
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ t} fun a b => Commute (f a) (f b)
⊢ noncommProd (List.toFinset sl ∪ t) f comm =
    noncommProd (List.toFinset sl) f (_ : Set.Pairwise ↑(List.toFinset sl) fun a b => Commute (f a) (f b)) *
      noncommProd t f (_ : Set.Pairwise ↑t fun a b => Commute (f a) (f b))

tactic: rw [List.disjoint_toFinset_iff_disjoint] at h
state_before: case intro.intro.intro.intro
F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : Disjoint (List.toFinset sl) (List.toFinset tl)
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
⊢ noncommProd (List.toFinset sl ∪ List.toFinset tl) f comm =
    noncommProd (List.toFinset sl) f (_ : Set.Pairwise ↑(List.toFinset sl) fun a b => Commute (f a) (f b)) *
      noncommProd (List.toFinset tl) f (_ : Set.Pairwise ↑(List.toFinset tl) fun a b => Commute (f a) (f b))

tactic: calc noncommProd (List.toFinset sl ∪ List.toFinset tl) f comm
   = noncommProd ⟨↑(sl ++ tl), Multiset.coe_nodup.2 (sl'.append tl' h)⟩ f
      (by convert comm; simp [Set.ext_iff]) := noncommProd_congr (by ext; simp) (by simp) _
 _ =  noncommProd (List.toFinset sl) f (comm.mono <| coe_subset.2 <| subset_union_left _ _) *
      noncommProd (List.toFinset tl) f (comm.mono <| coe_subset.2 <| subset_union_right _ _) :=
  by simp [noncommProd, List.dedup_eq_self.2 sl', List.dedup_eq_self.2 tl', h]
state_before: case intro.intro.intro.intro
F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : List.Disjoint sl tl
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
⊢ noncommProd (List.toFinset sl ∪ List.toFinset tl) f comm =
    noncommProd (List.toFinset sl) f (_ : Set.Pairwise ↑(List.toFinset sl) fun a b => Commute (f a) (f b)) *
      noncommProd (List.toFinset tl) f (_ : Set.Pairwise ↑(List.toFinset tl) fun a b => Commute (f a) (f b))

tactic: convert comm
state_before: F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : List.Disjoint sl tl
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
⊢ Set.Pairwise ↑{ val := ↑(sl ++ tl), nodup := (_ : Multiset.Nodup ↑(sl ++ tl)) } fun a b => Commute (f a) (f b)

tactic: simp [Set.ext_iff]
state_before: case h.e'_2
F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : List.Disjoint sl tl
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
⊢ ↑{ val := ↑(sl ++ tl), nodup := (_ : Multiset.Nodup ↑(sl ++ tl)) } = {x | x ∈ List.toFinset sl ∪ List.toFinset tl}

tactic: ext
state_before: F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : List.Disjoint sl tl
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
⊢ List.toFinset sl ∪ List.toFinset tl = { val := ↑(sl ++ tl), nodup := (_ : Multiset.Nodup ↑(sl ++ tl)) }

tactic: simp
state_before: case a
F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : List.Disjoint sl tl
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
a✝ : α
⊢ a✝ ∈ List.toFinset sl ∪ List.toFinset tl ↔ a✝ ∈ { val := ↑(sl ++ tl), nodup := (_ : Multiset.Nodup ↑(sl ++ tl)) }

tactic: simp
state_before: F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : List.Disjoint sl tl
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
⊢ ∀ (x : α), x ∈ { val := ↑(sl ++ tl), nodup := (_ : Multiset.Nodup ↑(sl ++ tl)) } → f x = f x

tactic: simp [noncommProd, List.dedup_eq_self.2 sl', List.dedup_eq_self.2 tl', h]
state_before: F : Type ?u.199818
ι : Type ?u.199821
α : Type u_1
β : Type u_2
γ : Type ?u.199830
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
f : α → β
sl : List α
sl' : List.Nodup sl
tl : List α
tl' : List.Nodup tl
h : List.Disjoint sl tl
comm : Set.Pairwise {x | x ∈ List.toFinset sl ∪ List.toFinset tl} fun a b => Commute (f a) (f b)
⊢ noncommProd { val := ↑(sl ++ tl), nodup := (_ : Multiset.Nodup ↑(sl ++ tl)) } f
      (_ :
        Set.Pairwise ↑{ val := ↑(sl ++ tl), nodup := (_ : Multiset.Nodup ↑(sl ++ tl)) } fun a b =>
          Commute (f a) (f b)) =
    noncommProd (List.toFinset sl) f (_ : Set.Pairwise ↑(List.toFinset sl) fun a b => Commute (f a) (f b)) *
      noncommProd (List.toFinset tl) f (_ : Set.Pairwise ↑(List.toFinset tl) fun a b => Commute (f a) (f b))