Theorem: Finset.prod_sum
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: induction' s using Finset.induction with a s ha ih
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
s : Finset α
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
⊢ ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))

tactic: rw [pi_empty, sum_singleton]
state_before: case empty
α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
⊢ ∏ a in ∅, ∑ b in t a, f a b = ∑ p in pi ∅ t, ∏ x in attach ∅, f (↑x) (p ↑x (_ : ↑x ∈ ∅))

tactic: rfl
state_before: case empty
α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
⊢ ∏ a in ∅, ∑ b in t a, f a b = ∏ x in attach ∅, f (↑x) (Pi.empty (fun a => δ a) ↑x (_ : ↑x ∈ ∅))

tactic: have h₁ : ∀ x ∈ t a, ∀ y ∈ t a, x ≠ y →
  Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t)) := by
  intro x _ y _ h
  simp only [disjoint_iff_ne, mem_image]
  rintro _ ⟨p₂, _, eq₂⟩ _ ⟨p₃, _, eq₃⟩ eq
  have : Pi.cons s a x p₂ a (mem_insert_self _ _) = Pi.cons s a y p₃ a (mem_insert_self _ _) :=
    by rw [eq₂, eq₃, eq]
  rw [Pi.cons_same, Pi.cons_same] at this
  exact h this
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
⊢ ∏ a in insert a s, ∑ b in t a, f a b =
    ∑ p in pi (insert a s) t, ∏ x in attach (insert a s), f (↑x) (p ↑x (_ : ↑x ∈ insert a s))

tactic: rw [prod_insert ha, pi_insert ha, ih, sum_mul, sum_biUnion h₁]
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
⊢ ∏ a in insert a s, ∑ b in t a, f a b =
    ∑ p in pi (insert a s) t, ∏ x in attach (insert a s), f (↑x) (p ↑x (_ : ↑x ∈ insert a s))

tactic: refine' sum_congr rfl fun b _ => _
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
⊢ ∑ x in t a, f a x * ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s)) =
    ∑ x in t a, ∑ i in image (Pi.cons s a x) (pi s t), ∏ x in attach (insert a s), f (↑x) (i ↑x (_ : ↑x ∈ insert a s))

tactic: have h₂ : ∀ p₁ ∈ pi s t, ∀ p₂ ∈ pi s t, Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂ :=
  fun p₁ _ p₂ _ eq => Pi.cons_injective ha eq
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝ : b ∈ t a
⊢ f a b * ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s)) =
    ∑ i in image (Pi.cons s a b) (pi s t), ∏ x in attach (insert a s), f (↑x) (i ↑x (_ : ↑x ∈ insert a s))

tactic: rw [sum_image h₂, mul_sum]
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
⊢ f a b * ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s)) =
    ∑ i in image (Pi.cons s a b) (pi s t), ∏ x in attach (insert a s), f (↑x) (i ↑x (_ : ↑x ∈ insert a s))

tactic: refine' sum_congr rfl fun g _ => _
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
⊢ ∑ x in pi s t, f a b * ∏ x_1 in attach s, f (↑x_1) (x ↑x_1 (_ : ↑x_1 ∈ s)) =
    ∑ x in pi s t, ∏ x_1 in attach (insert a s), f (↑x_1) (Pi.cons s a b x ↑x_1 (_ : ↑x_1 ∈ insert a s))

tactic: rw [attach_insert, prod_insert, prod_image]
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
⊢ f a b * ∏ x in attach s, f (↑x) (g ↑x (_ : ↑x ∈ s)) =
    ∏ x in attach (insert a s), f (↑x) (Pi.cons s a b g ↑x (_ : ↑x ∈ insert a s))

tactic: intro x _ y _ h
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
⊢ ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))

tactic: simp only [disjoint_iff_ne, mem_image]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝² : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
x : δ a
a✝¹ : x ∈ t a
y : δ a
a✝ : y ∈ t a
h : x ≠ y
⊢ Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))

tactic: rintro _ ⟨p₂, _, eq₂⟩ _ ⟨p₃, _, eq₃⟩ eq
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝² : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
x : δ a
a✝¹ : x ∈ t a
y : δ a
a✝ : y ∈ t a
h : x ≠ y
⊢ ∀ (a_1 : (a' : α) → a' ∈ insert a s → δ a'),
    (∃ a_2, a_2 ∈ pi s t ∧ Pi.cons s a x a_2 = a_1) →
      ∀ (b : (a' : α) → a' ∈ insert a s → δ a'), (∃ a_3, a_3 ∈ pi s t ∧ Pi.cons s a y a_3 = b) → a_1 ≠ b

tactic: have : Pi.cons s a x p₂ a (mem_insert_self _ _) = Pi.cons s a y p₃ a (mem_insert_self _ _) :=
  by rw [eq₂, eq₃, eq]
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝³ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
x : δ a
a✝² : x ∈ t a
y : δ a
a✝¹ : y ∈ t a
h : x ≠ y
a✝ : (a' : α) → a' ∈ insert a s → δ a'
p₂ : (a : α) → a ∈ s → δ a
left✝¹ : p₂ ∈ pi s t
eq₂ : Pi.cons s a x p₂ = a✝
b✝ : (a' : α) → a' ∈ insert a s → δ a'
p₃ : (a : α) → a ∈ s → δ a
left✝ : p₃ ∈ pi s t
eq₃ : Pi.cons s a y p₃ = b✝
eq : a✝ = b✝
⊢ False

tactic: rw [Pi.cons_same, Pi.cons_same] at this
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝³ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
x : δ a
a✝² : x ∈ t a
y : δ a
a✝¹ : y ∈ t a
h : x ≠ y
a✝ : (a' : α) → a' ∈ insert a s → δ a'
p₂ : (a : α) → a ∈ s → δ a
left✝¹ : p₂ ∈ pi s t
eq₂ : Pi.cons s a x p₂ = a✝
b✝ : (a' : α) → a' ∈ insert a s → δ a'
p₃ : (a : α) → a ∈ s → δ a
left✝ : p₃ ∈ pi s t
eq₃ : Pi.cons s a y p₃ = b✝
eq : a✝ = b✝
this : Pi.cons s a x p₂ a (_ : a ∈ insert a s) = Pi.cons s a y p₃ a (_ : a ∈ insert a s)
⊢ False

tactic: exact h this
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝³ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
x : δ a
a✝² : x ∈ t a
y : δ a
a✝¹ : y ∈ t a
h : x ≠ y
a✝ : (a' : α) → a' ∈ insert a s → δ a'
p₂ : (a : α) → a ∈ s → δ a
left✝¹ : p₂ ∈ pi s t
eq₂ : Pi.cons s a x p₂ = a✝
b✝ : (a' : α) → a' ∈ insert a s → δ a'
p₃ : (a : α) → a ∈ s → δ a
left✝ : p₃ ∈ pi s t
eq₃ : Pi.cons s a y p₃ = b✝
eq : a✝ = b✝
this : x = y
⊢ False

tactic: rw [eq₂, eq₃, eq]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝³ : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
x : δ a
a✝² : x ∈ t a
y : δ a
a✝¹ : y ∈ t a
h : x ≠ y
a✝ : (a' : α) → a' ∈ insert a s → δ a'
p₂ : (a : α) → a ∈ s → δ a
left✝¹ : p₂ ∈ pi s t
eq₂ : Pi.cons s a x p₂ = a✝
b✝ : (a' : α) → a' ∈ insert a s → δ a'
p₃ : (a : α) → a ∈ s → δ a
left✝ : p₃ ∈ pi s t
eq₃ : Pi.cons s a y p₃ = b✝
eq : a✝ = b✝
⊢ Pi.cons s a x p₂ a (_ : a ∈ insert a s) = Pi.cons s a y p₃ a (_ : a ∈ insert a s)

tactic: simp only [Pi.cons_same]
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
⊢ f a b * ∏ x in attach s, f (↑x) (g ↑x (_ : ↑x ∈ s)) =
    f (↑{ val := a, property := (_ : a ∈ insert a s) })
        (Pi.cons s a b g ↑{ val := a, property := (_ : a ∈ insert a s) }
          (_ : ↑{ val := a, property := (_ : a ∈ insert a s) } ∈ insert a s)) *
      ∏ x in attach s,
        f (↑{ val := ↑x, property := (_ : ↑x ∈ insert a s) })
          (Pi.cons s a b g ↑{ val := ↑x, property := (_ : ↑x ∈ insert a s) }
            (_ : ↑{ val := ↑x, property := (_ : ↑x ∈ insert a s) } ∈ insert a s))

tactic: congr with ⟨v, hv⟩
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
⊢ f a b * ∏ x in attach s, f (↑x) (g ↑x (_ : ↑x ∈ s)) =
    f a b *
      ∏ x in attach s,
        f (↑x)
          (Pi.cons s a b g ↑{ val := ↑x, property := (_ : ↑x ∈ insert a s) }
            (_ : ↑{ val := ↑x, property := (_ : ↑x ∈ insert a s) } ∈ insert a s))

tactic: congr
state_before: case insert.e_a.e_f.h.mk
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
v : α
hv : v ∈ s
⊢ f (↑{ val := v, property := hv }) (g ↑{ val := v, property := hv } (_ : ↑{ val := v, property := hv } ∈ s)) =
    f (↑{ val := v, property := hv })
      (Pi.cons s a b g
        ↑{ val := ↑{ val := v, property := hv }, property := (_ : ↑{ val := v, property := hv } ∈ insert a s) }
        (_ :
          ↑{ val := ↑{ val := v, property := hv }, property := (_ : ↑{ val := v, property := hv } ∈ insert a s) } ∈
            insert a s))

tactic: exact (Pi.cons_ne (by rintro rfl; exact ha hv)).symm
state_before: case insert.e_a.e_f.h.mk.e_a
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
v : α
hv : v ∈ s
⊢ g ↑{ val := v, property := hv } (_ : ↑{ val := v, property := hv } ∈ s) =
    Pi.cons s a b g
      ↑{ val := ↑{ val := v, property := hv }, property := (_ : ↑{ val := v, property := hv } ∈ insert a s) }
      (_ :
        ↑{ val := ↑{ val := v, property := hv }, property := (_ : ↑{ val := v, property := hv } ∈ insert a s) } ∈
          insert a s)

tactic: rintro rfl
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
v : α
hv : v ∈ s
⊢ a ≠ ↑{ val := v, property := hv }

tactic: exact ha hv
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
hv : a ∈ s
⊢ False

tactic: exact fun _ _ _ _ => Subtype.eq ∘ Subtype.mk.inj
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
⊢ ∀ (x : { x // x ∈ s }),
    x ∈ attach s →
      ∀ (y : { x // x ∈ s }),
        y ∈ attach s →
          { val := ↑x, property := (_ : ↑x ∈ insert a s) } = { val := ↑y, property := (_ : ↑y ∈ insert a s) } → x = y

tactic: simpa only [mem_image, mem_attach, Subtype.mk.injEq, true_and,
  Subtype.exists, exists_prop, exists_eq_right] using ha
state_before: case insert
α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b✝ : β
f✝ g✝ : α → β
inst✝² : CommSemiring β
δ : α → Type u_1
inst✝¹ : DecidableEq α
inst✝ : (a : α) → DecidableEq (δ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a → β
a : α
s : Finset α
ha : ¬a ∈ s
ih : ∏ a in s, ∑ b in t a, f a b = ∑ p in pi s t, ∏ x in attach s, f (↑x) (p ↑x (_ : ↑x ∈ s))
h₁ :
  ∀ (x : δ a),
    x ∈ t a → ∀ (y : δ a), y ∈ t a → x ≠ y → Disjoint (image (Pi.cons s a x) (pi s t)) (image (Pi.cons s a y) (pi s t))
b : δ a
x✝¹ : b ∈ t a
h₂ :
  ∀ (p₁ : (a : α) → a ∈ s → δ a),
    p₁ ∈ pi s t → ∀ (p₂ : (a : α) → a ∈ s → δ a), p₂ ∈ pi s t → Pi.cons s a b p₁ = Pi.cons s a b p₂ → p₁ = p₂
g : (a : α) → a ∈ s → δ a
x✝ : g ∈ pi s t
⊢ ¬{ val := a, property := (_ : a ∈ insert a s) } ∈
      image (fun x => { val := ↑x, property := (_ : ↑x ∈ insert a s) }) (attach s)