Theorem: Finset.pi_insert
File: Mathlib/Data/Finset/Pi.lean

tactic: apply eq_of_veq
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ (insert a s).pi t = (t a).biUnion fun b => image (Pi.cons s a b) (s.pi t)
state_after: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((insert a s).pi t).val = ((t a).biUnion fun b => image (Pi.cons s a b) (s.pi t)).val

tactic: rw [← (pi (insert a s) t).2.dedup]
state_before: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((insert a s).pi t).val = ((t a).biUnion fun b => image (Pi.cons s a b) (s.pi t)).val
state_after: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((insert a s).pi t).val.dedup = ((t a).biUnion fun b => image (Pi.cons s a b) (s.pi t)).val

tactic: refine
  (fun s' (h : s' = a ::ₘ s.1) =>
      (?_ :
        dedup (Multiset.pi s' fun a => (t a).1) =
          dedup
            ((t a).1.bind fun b =>
              dedup <|
                (Multiset.pi s.1 fun a : α => (t a).val).map fun f a' h' =>
                  Multiset.Pi.cons s.1 a b f a' (h ▸ h'))))
    _ (insert_val_of_not_mem ha)
state_before: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((insert a s).pi t).val.dedup = ((t a).biUnion fun b => image (Pi.cons s a b) (s.pi t)).val
state_after: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
s' : Multiset α
h : s' = a ::ₘ s.val
⊢ (s'.pi fun a => (t a).val).dedup =
    ((t a).val.bind fun b =>
        (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup).dedup

tactic: subst s'
state_before: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
s' : Multiset α
h : s' = a ::ₘ s.val
⊢ (s'.pi fun a => (t a).val).dedup =
    ((t a).val.bind fun b =>
        (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup).dedup
state_after: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((a ::ₘ s.val).pi fun a => (t a).val).dedup =
    ((t a).val.bind fun b =>
        (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup).dedup

tactic: rw [pi_cons]
state_before: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((a ::ₘ s.val).pi fun a => (t a).val).dedup =
    ((t a).val.bind fun b =>
        (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup).dedup
state_after: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((t a).val.bind fun b => Multiset.map (Multiset.Pi.cons s.val a b) (s.val.pi fun a => (t a).val)).dedup =
    ((t a).val.bind fun b =>
        (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup).dedup

tactic: congr
state_before: case a
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ ((t a).val.bind fun b => Multiset.map (Multiset.Pi.cons s.val a b) (s.val.pi fun a => (t a).val)).dedup =
    ((t a).val.bind fun b =>
        (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup).dedup
state_after: case a.e_s.e_f
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ (fun b => Multiset.map (Multiset.Pi.cons s.val a b) (s.val.pi fun a => (t a).val)) = fun b =>
    (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup

tactic: funext b
state_before: case a.e_s.e_f
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
⊢ (fun b => Multiset.map (Multiset.Pi.cons s.val a b) (s.val.pi fun a => (t a).val)) = fun b =>
    (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup
state_after: case a.e_s.e_f.h
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
b : β a
⊢ Multiset.map (Multiset.Pi.cons s.val a b) (s.val.pi fun a => (t a).val) =
    (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup

tactic: exact ((pi s t).nodup.map <| Multiset.Pi.cons_injective ha).dedup.symm
state_before: case a.e_s.e_f.h
α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝¹ : DecidableEq α
s✝ : Finset α
t✝ : (a : α) → Finset (β a)
inst✝ : (a : α) → DecidableEq (β a)
s : Finset α
t : (a : α) → Finset (β a)
a : α
ha : a ∉ s
b : β a
⊢ Multiset.map (Multiset.Pi.cons s.val a b) (s.val.pi fun a => (t a).val) =
    (Multiset.map (fun f a' h' => Multiset.Pi.cons s.val a b f a' ⋯) (s.val.pi fun a => (t a).val)).dedup
state_after: no goals