ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.fold_hom
theorem fold_hom {op' : γ → γ → γ} [Std.Commutative op'] [Std.Associative op'] {m : β → γ}
    (hm : ∀ x y, m (op x y) = op' (m x) (m y)) :
    (s.fold op' (m b) fun x => m (f x)) = m (s.fold op b f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {b : β} {s : Finset α} {op' : γ → γ → γ} [Std.Commutative op'] [Std.Associative op'] {m : β → γ} (hm : ∀ (x y : β), m (op x y) = op' (m x) (m y))
Goal: Finset.fold op' (m b) (fun x => m (f x)) s = m (Finset.fold op b f s)
-- Finset.fold_disjUnion
theorem fold_disjUnion {s₁ s₂ : Finset α} {b₁ b₂ : β} (h) :
    (s₁.disjUnion s₂ h).fold op (b₁ * b₂) f = s₁.fold op b₁ f * s₂.fold op b₂ f 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {s₁ s₂ : Finset α} {b₁ b₂ : β} (h : Disjoint s₁ s₂)
Goal: Finset.fold op (op b₁ b₂) f (s₁.disjUnion s₂ h) = op (Finset.fold op b₁ f s₁) (Finset.fold op b₂ f s₂)
-- Finset.fold_disjiUnion
theorem fold_disjiUnion {ι : Type*} {s : Finset ι} {t : ι → Finset α} {b : ι → β} {b₀ : β} (h) :
    (s.disjiUnion t h).fold op (s.fold op b₀ b) f = s.fold op b₀ fun i => (t i).fold op (b i) f 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {ι : Type u_4} {s : Finset ι} {t : ι → Finset α} {b : ι → β} {b₀ : β} (h : (↑s).PairwiseDisjoint t)
Goal: Finset.fold op (Finset.fold op b₀ b s) f (s.disjiUnion t h) =
  Finset.fold op b₀ (fun i => Finset.fold op (b i) f (t i)) s
-- Finset.fold_union_inter
theorem fold_union_inter [DecidableEq α] {s₁ s₂ : Finset α} {b₁ b₂ : β} :
    ((s₁ ∪ s₂).fold op b₁ f * (s₁ ∩ s₂).fold op b₂ f) = s₁.fold op b₂ f * s₂.fold op b₁ f 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} [DecidableEq α] {s₁ s₂ : Finset α} {b₁ b₂ : β}
Goal: op (Finset.fold op b₁ f (s₁ ∪ s₂)) (Finset.fold op b₂ f (s₁ ∩ s₂)) =
  op (Finset.fold op b₂ f s₁) (Finset.fold op b₁ f s₂)
-- Finset.fold_insert_idem
@[simp]
theorem fold_insert_idem [DecidableEq α] [hi : Std.IdempotentOp op] :
    (insert a s).fold op b f = f a * s.fold op b f 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {b : β} {s : Finset α} {a : α} [DecidableEq α] [hi : Std.IdempotentOp op]
Goal: Finset.fold op b f (insert a s) = op (f a) (Finset.fold op b f s)
-- Finset.fold_image_idem
theorem fold_image_idem [DecidableEq α] {g : γ → α} {s : Finset γ} [hi : Std.IdempotentOp op] :
    (image g s).fold op b f = s.fold op b (f ∘ g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {b : β} [DecidableEq α] {g : γ → α} {s : Finset γ} [hi : Std.IdempotentOp op]
Goal: Finset.fold op b f (Finset.image g s) = Finset.fold op b (f ∘ g) s
-- Finset.fold_ite'
theorem fold_ite' {g : α → β} (hb : op b b = b) (p : α → Prop) [DecidablePred p] :
    Finset.fold op b (fun i => ite (p i) (f i) (g i)) s =
      op (Finset.fold op b f (s.filter p)) (Finset.fold op b g (s.filter fun i => ¬p i)) 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {b : β} {s : Finset α} {g : α → β} (hb : op b b = b) (p : α → Prop) [DecidablePred p]
Goal: Finset.fold op b (fun i => if p i then f i else g i) s =
  op (Finset.fold op b f (Finset.filter p s)) (Finset.fold op b g (Finset.filter (fun i => ¬p i) s))
-- Finset.fold_ite
theorem fold_ite [Std.IdempotentOp op] {g : α → β} (p : α → Prop) [DecidablePred p] :
    Finset.fold op b (fun i => ite (p i) (f i) (g i)) s =
      op (Finset.fold op b f (s.filter p)) (Finset.fold op b g (s.filter fun i => ¬p i)) 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {b : β} {s : Finset α} [Std.IdempotentOp op] {g : α → β} (p : α → Prop) [DecidablePred p]
Goal: Finset.fold op b (fun i => if p i then f i else g i) s =
  op (Finset.fold op b f (Finset.filter p s)) (Finset.fold op b g (Finset.filter (fun i => ¬p i) s))
-- Finset.fold_op_rel_iff_and
theorem fold_op_rel_iff_and {r : β → β → Prop} (hr : ∀ {x y z}, r x (op y z) ↔ r x y ∧ r x z)
    {c : β} : r c (s.fold op b f) ↔ r c b ∧ ∀ x ∈ s, r c (f x) 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {b : β} {s : Finset α} {r : β → β → Prop} (hr : ∀ {x y z : β}, r x (op y z) ↔ r x y ∧ r x z) {c : β}
Goal: r c (Finset.fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x)
-- Finset.fold_op_rel_iff_or
theorem fold_op_rel_iff_or {r : β → β → Prop} (hr : ∀ {x y z}, r x (op y z) ↔ r x y ∨ r x z)
    {c : β} : r c (s.fold op b f) ↔ r c b ∨ ∃ x ∈ s, r c (f x) 
Arguments: {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {f : α → β} {b : β} {s : Finset α} {r : β → β → Prop} (hr : ∀ {x y z : β}, r x (op y z) ↔ r x y ∨ r x z) {c : β}
Goal: r c (Finset.fold op b f s) ↔ r c b ∨ ∃ x ∈ s, r c (f x)
-- Finset.fold_union_empty_singleton
@[simp]
theorem fold_union_empty_singleton [DecidableEq α] (s : Finset α) :
    Finset.fold (· ∪ ·) ∅ singleton s = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: Finset.fold (fun x x_1 => x ∪ x_1) ∅ singleton s = s
-- Finset.fold_sup_bot_singleton
theorem fold_sup_bot_singleton [DecidableEq α] (s : Finset α) :
    Finset.fold (· ⊔ ·) ⊥ singleton s = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: Finset.fold (fun x x_1 => x ⊔ x_1) ⊥ singleton s = s
-- Finset.le_fold_min
theorem le_fold_min : c ≤ s.fold min b f ↔ c ≤ b ∧ ∀ x ∈ s, c ≤ f x 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: c ≤ Finset.fold min b f s ↔ c ≤ b ∧ ∀ x ∈ s, c ≤ f x
-- Finset.fold_min_le
theorem fold_min_le : s.fold min b f ≤ c ↔ b ≤ c ∨ ∃ x ∈ s, f x ≤ c 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: Finset.fold min b f s ≤ c ↔ b ≤ c ∨ ∃ x ∈ s, f x ≤ c
-- Finset.lt_fold_min
theorem lt_fold_min : c < s.fold min b f ↔ c < b ∧ ∀ x ∈ s, c < f x 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: c < Finset.fold min b f s ↔ c < b ∧ ∀ x ∈ s, c < f x
-- Finset.fold_min_lt
theorem fold_min_lt : s.fold min b f < c ↔ b < c ∨ ∃ x ∈ s, f x < c 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: Finset.fold min b f s < c ↔ b < c ∨ ∃ x ∈ s, f x < c
-- Finset.fold_max_le
theorem fold_max_le : s.fold max b f ≤ c ↔ b ≤ c ∧ ∀ x ∈ s, f x ≤ c 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: Finset.fold max b f s ≤ c ↔ b ≤ c ∧ ∀ x ∈ s, f x ≤ c
-- Finset.le_fold_max
theorem le_fold_max : c ≤ s.fold max b f ↔ c ≤ b ∨ ∃ x ∈ s, c ≤ f x 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: c ≤ Finset.fold max b f s ↔ c ≤ b ∨ ∃ x ∈ s, c ≤ f x
-- Finset.fold_max_lt
theorem fold_max_lt : s.fold max b f < c ↔ b < c ∧ ∀ x ∈ s, f x < c 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: Finset.fold max b f s < c ↔ b < c ∧ ∀ x ∈ s, f x < c
-- Finset.lt_fold_max
theorem lt_fold_max : c < s.fold max b f ↔ c < b ∨ ∃ x ∈ s, c < f x 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Finset α} [LinearOrder β] (c : β)
Goal: c < Finset.fold max b f s ↔ c < b ∨ ∃ x ∈ s, c < f x
-- Finset.fold_max_add
theorem fold_max_add [Add β] [CovariantClass β β (Function.swap (· + ·)) (· ≤ ·)] (n : WithBot β)
    (s : Finset α) : (s.fold max ⊥ fun x : α => ↑(f x) + n) = s.fold max ⊥ ((↑) ∘ f) + n 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} [LinearOrder β] [Add β] [CovariantClass β β (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (n : WithBot β) (s : Finset α)
Goal: Finset.fold max ⊥ (fun x => ↑(f x) + n) s = Finset.fold max ⊥ (WithBot.some ∘ f) s + n
-- Finset.disjiUnion_val
@[simp]
lemma disjiUnion_val (s : Finset α) (t : α → Finset β) (h) :
    (s.disjiUnion t h).1 = s.1.bind fun a ↦ (t a).1 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : α → Finset β) (h : (↑s).PairwiseDisjoint t)
Goal: (s.disjiUnion t h).val = s.val.bind fun a => (t a).val
-- Finset.disjiUnion_empty
@[simp] lemma disjiUnion_empty (t : α → Finset β) : disjiUnion ∅ t (by simp) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (t : α → Finset β)
Goal: ∅.disjiUnion t ⋯ = ∅
-- Finset.mem_disjiUnion
@[simp] lemma mem_disjiUnion {b : β} {h} : b ∈ s.disjiUnion t h ↔ ∃ a ∈ s, b ∈ t a 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} {b : β} {h : (↑s).PairwiseDisjoint t}
Goal: b ∈ s.disjiUnion t h ↔ ∃ a ∈ s, b ∈ t a
-- Finset.coe_disjiUnion
@[simp, norm_cast]
lemma coe_disjiUnion {h} : (s.disjiUnion t h : Set β) = ⋃ x ∈ (s : Set α), t x 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} {h : (↑s).PairwiseDisjoint t}
Goal: ↑(s.disjiUnion t h) = ⋃ x ∈ ↑s, ↑(t x)
-- Finset.disjiUnion_cons
@[simp] lemma disjiUnion_cons (a : α) (s : Finset α) (ha : a ∉ s) (f : α → Finset β) (H) :
    disjiUnion (cons a s ha) f H =
    (f a).disjUnion ((s.disjiUnion f) fun _ hb _ hc ↦ H (mem_cons_of_mem hb) (mem_cons_of_mem hc))
      (disjoint_left.2 fun _ hb h ↦
        let ⟨_, hc, h⟩ := mem_disjiUnion.mp h
        disjoint_left.mp
          (H (mem_cons_self a s) (mem_cons_of_mem hc) (ne_of_mem_of_not_mem hc ha).symm) hb h) 
Arguments: {α : Type u_1} {β : Type u_2} (a : α) (s : Finset α) (ha : a ∉ s) (f : α → Finset β) (H : (↑(Finset.cons a s ha)).PairwiseDisjoint f)
Goal: (Finset.cons a s ha).disjiUnion f H = (f a).disjUnion (s.disjiUnion f ⋯) ⋯
-- Finset.singleton_disjiUnion
@[simp] lemma singleton_disjiUnion (a : α) {h} : Finset.disjiUnion {a} t h = t a 
Arguments: {α : Type u_1} {β : Type u_2} {t : α → Finset β} (a : α) {h : (↑{a}).PairwiseDisjoint t}
Goal: {a}.disjiUnion t h = t a
-- Finset.disjiUnion_disjiUnion
lemma disjiUnion_disjiUnion (s : Finset α) (f : α → Finset β) (g : β → Finset γ) (h1 h2) :
    (s.disjiUnion f h1).disjiUnion g h2 =
      s.attach.disjiUnion
        (fun a ↦ ((f a).disjiUnion g) fun b hb c hc ↦
            h2 (mem_disjiUnion.mpr ⟨_, a.prop, hb⟩) (mem_disjiUnion.mpr ⟨_, a.prop, hc⟩))
        fun a _ b _ hab ↦
        disjoint_left.mpr fun x hxa hxb ↦ by
          obtain ⟨xa, hfa, hga⟩ := mem_disjiUnion.mp hxa
          obtain ⟨xb, hfb, hgb⟩ := mem_disjiUnion.mp hxb
          refine disjoint_left.mp
            (h2 (mem_disjiUnion.mpr ⟨_, a.prop, hfa⟩) (mem_disjiUnion.mpr ⟨_, b.prop, hfb⟩) ?_) hga
            hgb
          rintro rfl
          exact disjoint_left.mp (h1 a.prop b.prop <| Subtype.coe_injective.ne hab) hfa hfb 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (s : Finset α) (f : α → Finset β) (g : β → Finset γ) (h1 : (↑s).PairwiseDisjoint f) (h2 : (↑(s.disjiUnion f h1)).PairwiseDisjoint g)
Goal: (s.disjiUnion f h1).disjiUnion g h2 = s.attach.disjiUnion (fun a => (f ↑a).disjiUnion g ⋯) ⋯
-- _private.Mathlib.Data.Finset.Union.0.Finset.pairwiseDisjoint_fibers
private lemma pairwiseDisjoint_fibers : Set.PairwiseDisjoint ↑t fun a ↦ s.filter (f · = a) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β}
Goal: (↑t).PairwiseDisjoint fun a => Finset.filter (fun x => f x = a) s
-- Finset.disjiUnion_filter_eq
@[simp, nolint simpNF] lemma disjiUnion_filter_eq (s : Finset α) (t : Finset β) (f : α → β) :
    t.disjiUnion (fun a ↦ s.filter (f · = a)) pairwiseDisjoint_fibers =
      s.filter fun c ↦ f c ∈ t 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (t : Finset β) (f : α → β)
Goal: t.disjiUnion (fun a => Finset.filter (fun x => f x = a) s) ⋯ = Finset.filter (fun c => f c ∈ t) s
-- Finset.disjiUnion_filter_eq_of_maps_to
lemma disjiUnion_filter_eq_of_maps_to (h : ∀ x ∈ s, f x ∈ t) :
    t.disjiUnion (fun a ↦ s.filter (f · = a)) pairwiseDisjoint_fibers = s 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β} (h : ∀ x ∈ s, f x ∈ t)
Goal: t.disjiUnion (fun a => Finset.filter (fun x => f x = a) s) ⋯ = s
-- Finset.biUnion_val
@[simp] lemma biUnion_val (s : Finset α) (t : α → Finset β) :
    (s.biUnion t).1 = (s.1.bind fun a ↦ (t a).1).dedup 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (t : α → Finset β)
Goal: (s.biUnion t).val = (s.val.bind fun a => (t a).val).dedup
-- Finset.biUnion_empty
@[simp] lemma biUnion_empty : Finset.biUnion ∅ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {t : α → Finset β} [DecidableEq β]
Goal: ∅.biUnion t = ∅
-- Finset.mem_biUnion
@[simp] lemma mem_biUnion {b : β} : b ∈ s.biUnion t ↔ ∃ a ∈ s, b ∈ t a 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β] {b : β}
Goal: b ∈ s.biUnion t ↔ ∃ a ∈ s, b ∈ t a
-- Finset.coe_biUnion
@[simp, norm_cast]
lemma coe_biUnion : (s.biUnion t : Set β) = ⋃ x ∈ (s : Set α), t x 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β]
Goal: ↑(s.biUnion t) = ⋃ x ∈ ↑s, ↑(t x)
-- Finset.biUnion_insert
@[simp]
lemma biUnion_insert [DecidableEq α] {a : α} : (insert a s).biUnion t = t a ∪ s.biUnion t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β] [DecidableEq α] {a : α}
Goal: (insert a s).biUnion t = t a ∪ s.biUnion t
-- Finset.biUnion_congr
lemma biUnion_congr (hs : s₁ = s₂) (ht : ∀ a ∈ s₁, t₁ a = t₂ a) : s₁.biUnion t₁ = s₂.biUnion t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : α → Finset β} [DecidableEq β] (hs : s₁ = s₂) (ht : ∀ a ∈ s₁, t₁ a = t₂ a)
Goal: s₁.biUnion t₁ = s₂.biUnion t₂
-- Finset.disjiUnion_eq_biUnion
@[simp]
lemma disjiUnion_eq_biUnion (s : Finset α) (f : α → Finset β) (hf) :
    s.disjiUnion f hf = s.biUnion f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (f : α → Finset β) (hf : (↑s).PairwiseDisjoint f)
Goal: s.disjiUnion f hf = s.biUnion f
-- Finset.biUnion_subset
lemma biUnion_subset {s' : Finset β} : s.biUnion t ⊆ s' ↔ ∀ x ∈ s, t x ⊆ s' 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β] {s' : Finset β}
Goal: s.biUnion t ⊆ s' ↔ ∀ x ∈ s, t x ⊆ s'
-- Finset.singleton_biUnion
@[simp]
lemma singleton_biUnion {a : α} : Finset.biUnion {a} t = t a 
Arguments: {α : Type u_1} {β : Type u_2} {t : α → Finset β} [DecidableEq β] {a : α}
Goal: {a}.biUnion t = t a
-- Finset.biUnion_inter
lemma biUnion_inter (s : Finset α) (f : α → Finset β) (t : Finset β) :
    s.biUnion f ∩ t = s.biUnion fun x ↦ f x ∩ t 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (f : α → Finset β) (t : Finset β)
Goal: s.biUnion f ∩ t = s.biUnion fun x => f x ∩ t
-- Finset.inter_biUnion
lemma inter_biUnion (t : Finset β) (s : Finset α) (f : α → Finset β) :
    t ∩ s.biUnion f = s.biUnion fun x ↦ t ∩ f x 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (t : Finset β) (s : Finset α) (f : α → Finset β)
Goal: t ∩ s.biUnion f = s.biUnion fun x => t ∩ f x
-- Finset.biUnion_biUnion
lemma biUnion_biUnion [DecidableEq γ] (s : Finset α) (f : α → Finset β) (g : β → Finset γ) :
    (s.biUnion f).biUnion g = s.biUnion fun a ↦ (f a).biUnion g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [DecidableEq β] [DecidableEq γ] (s : Finset α) (f : α → Finset β) (g : β → Finset γ)
Goal: (s.biUnion f).biUnion g = s.biUnion fun a => (f a).biUnion g
-- Finset.bind_toFinset
lemma bind_toFinset [DecidableEq α] (s : Multiset α) (t : α → Multiset β) :
    (s.bind t).toFinset = s.toFinset.biUnion fun a ↦ (t a).toFinset 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] [DecidableEq α] (s : Multiset α) (t : α → Multiset β)
Goal: (s.bind t).toFinset = s.toFinset.biUnion fun a => (t a).toFinset
-- Finset.biUnion_mono
lemma biUnion_mono (h : ∀ a ∈ s, t₁ a ⊆ t₂ a) : s.biUnion t₁ ⊆ s.biUnion t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t₁ t₂ : α → Finset β} [DecidableEq β] (h : ∀ a ∈ s, t₁ a ⊆ t₂ a)
Goal: s.biUnion t₁ ⊆ s.biUnion t₂
-- Finset.biUnion_subset_biUnion_of_subset_left
lemma biUnion_subset_biUnion_of_subset_left (t : α → Finset β) (h : s₁ ⊆ s₂) :
    s₁.biUnion t ⊆ s₂.biUnion t 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} [DecidableEq β] (t : α → Finset β) (h : s₁ ⊆ s₂)
Goal: s₁.biUnion t ⊆ s₂.biUnion t
-- Finset.subset_biUnion_of_mem
lemma subset_biUnion_of_mem (u : α → Finset β) {x : α} (xs : x ∈ s) : u x ⊆ s.biUnion u 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} [DecidableEq β] (u : α → Finset β) {x : α} (xs : x ∈ s)
Goal: u x ⊆ s.biUnion u
-- Finset.biUnion_subset_iff_forall_subset
@[simp]
lemma biUnion_subset_iff_forall_subset {α β : Type*} [DecidableEq β] {s : Finset α}
    {t : Finset β} {f : α → Finset β} : s.biUnion f ⊆ t ↔ ∀ x ∈ s, f x ⊆ t 
Arguments: {α : Type u_4} {β : Type u_5} [DecidableEq β] {s : Finset α} {t : Finset β} {f : α → Finset β}
Goal: s.biUnion f ⊆ t ↔ ∀ x ∈ s, f x ⊆ t
-- Finset.biUnion_singleton_eq_self
@[simp]
lemma biUnion_singleton_eq_self [DecidableEq α] : s.biUnion (singleton : α → Finset α) = s 
Arguments: {α : Type u_1} {s : Finset α} [DecidableEq α]
Goal: s.biUnion singleton = s
-- Finset.filter_biUnion
lemma filter_biUnion (s : Finset α) (f : α → Finset β) (p : β → Prop) [DecidablePred p] :
    (s.biUnion f).filter p = s.biUnion fun a ↦ (f a).filter p 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (f : α → Finset β) (p : β → Prop) [DecidablePred p]
Goal: Finset.filter p (s.biUnion f) = s.biUnion fun a => Finset.filter p (f a)
-- Finset.biUnion_filter_eq_of_maps_to
lemma biUnion_filter_eq_of_maps_to [DecidableEq α] {s : Finset α} {t : Finset β} {f : α → β}
    (h : ∀ x ∈ s, f x ∈ t) : (t.biUnion fun a ↦ s.filter fun c ↦ f c = a) = s 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] [DecidableEq α] {s : Finset α} {t : Finset β} {f : α → β} (h : ∀ x ∈ s, f x ∈ t)
Goal: (t.biUnion fun a => Finset.filter (fun c => f c = a) s) = s
-- Finset.erase_biUnion
lemma erase_biUnion (f : α → Finset β) (s : Finset α) (b : β) :
    (s.biUnion f).erase b = s.biUnion fun x ↦ (f x).erase b 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (f : α → Finset β) (s : Finset α) (b : β)
Goal: (s.biUnion f).erase b = s.biUnion fun x => (f x).erase b
-- Finset.biUnion_nonempty
@[simp]
lemma biUnion_nonempty : (s.biUnion t).Nonempty ↔ ∃ x ∈ s, (t x).Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β]
Goal: (s.biUnion t).Nonempty ↔ ∃ x ∈ s, (t x).Nonempty
-- Finset.Nonempty.biUnion
lemma Nonempty.biUnion (hs : s.Nonempty) (ht : ∀ x ∈ s, (t x).Nonempty) :
    (s.biUnion t).Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β] (hs : s.Nonempty) (ht : ∀ x ∈ s, (t x).Nonempty)
Goal: (s.biUnion t).Nonempty
-- Finset.disjoint_biUnion_left
lemma disjoint_biUnion_left (s : Finset α) (f : α → Finset β) (t : Finset β) :
    Disjoint (s.biUnion f) t ↔ ∀ i ∈ s, Disjoint (f i) t 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (f : α → Finset β) (t : Finset β)
Goal: Disjoint (s.biUnion f) t ↔ ∀ i ∈ s, Disjoint (f i) t
-- Finset.disjoint_biUnion_right
lemma disjoint_biUnion_right (s : Finset β) (t : Finset α) (f : α → Finset β) :
    Disjoint s (t.biUnion f) ↔ ∀ i ∈ t, Disjoint s (f i) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset β) (t : Finset α) (f : α → Finset β)
Goal: Disjoint s (t.biUnion f) ↔ ∀ i ∈ t, Disjoint s (f i)
-- Finset.induction_on_pi_of_choice
theorem induction_on_pi_of_choice (r : ∀ i, α i → Finset (α i) → Prop)
    (H_ex : ∀ (i) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x))
    {p : (∀ i, Finset (α i)) → Prop} (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step :
      ∀ (g : ∀ i, Finset (α i)) (i : ι) (x : α i),
        r i x (g i) → p g → p (update g i (insert x (g i)))) :
    p f 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Finite ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] (r : (i : ι) → α i → Finset (α i) → Prop) (H_ex : ∀ (i : ι) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x)) {p : ((i : ι) → Finset (α i)) → Prop} (f : (i : ι) → Finset (α i)) (h0 : p fun x => ∅) (step : ∀ (g : (i : ι) → Finset (α i)) (i : ι) (x : α i), r i x (g i) → p g → p (Function.update g i (insert x (g i))))
Goal: p f
-- Finset.induction_on_pi
theorem induction_on_pi {p : (∀ i, Finset (α i)) → Prop} (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step : ∀ (g : ∀ i, Finset (α i)) (i : ι), ∀ x ∉ g i, p g → p (update g i (insert x (g i)))) :
    p f 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Finite ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] {p : ((i : ι) → Finset (α i)) → Prop} (f : (i : ι) → Finset (α i)) (h0 : p fun x => ∅) (step : ∀ (g : (i : ι) → Finset (α i)) (i : ι), ∀ x ∉ g i, p g → p (Function.update g i (insert x (g i))))
Goal: p f
-- Finset.induction_on_pi_max
theorem induction_on_pi_max [∀ i, LinearOrder (α i)] {p : (∀ i, Finset (α i)) → Prop}
    (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step :
      ∀ (g : ∀ i, Finset (α i)) (i : ι) (x : α i),
        (∀ y ∈ g i, y < x) → p g → p (update g i (insert x (g i)))) :
    p f 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Finite ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → LinearOrder (α i)] {p : ((i : ι) → Finset (α i)) → Prop} (f : (i : ι) → Finset (α i)) (h0 : p fun x => ∅) (step :
  ∀ (g : (i : ι) → Finset (α i)) (i : ι) (x : α i), (∀ y ∈ g i, y < x) → p g → p (Function.update g i (insert x (g i))))
Goal: p f
-- Finset.induction_on_pi_min
theorem induction_on_pi_min [∀ i, LinearOrder (α i)] {p : (∀ i, Finset (α i)) → Prop}
    (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step :
      ∀ (g : ∀ i, Finset (α i)) (i : ι) (x : α i),
        (∀ y ∈ g i, x < y) → p g → p (update g i (insert x (g i)))) :
    p f 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Finite ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → LinearOrder (α i)] {p : ((i : ι) → Finset (α i)) → Prop} (f : (i : ι) → Finset (α i)) (h0 : p fun x => ∅) (step :
  ∀ (g : (i : ι) → Finset (α i)) (i : ι) (x : α i), (∀ y ∈ g i, x < y) → p g → p (Function.update g i (insert x (g i))))
Goal: p f
-- Function.updateFinset_def
theorem updateFinset_def {s : Finset ι} {y} :
    updateFinset x s y = fun i ↦ if hi : i ∈ s then y ⟨i, hi⟩ else x i 
Arguments: {ι : Type u_1} {π : ι → Sort u_2} {x : (i : ι) → π i} [DecidableEq ι] {s : Finset ι} {y : (i : { x // x ∈ s }) → π ↑i}
Goal: Function.updateFinset x s y = fun i => if hi : i ∈ s then y ⟨i, hi⟩ else x i
-- Function.updateFinset_empty
@[simp] theorem updateFinset_empty {y} : updateFinset x ∅ y = x 
Arguments: {ι : Type u_1} {π : ι → Sort u_2} {x : (i : ι) → π i} [DecidableEq ι] {y : (i : { x // x ∈ ∅ }) → π ↑i}
Goal: Function.updateFinset x ∅ y = x
-- Function.updateFinset_singleton
theorem updateFinset_singleton {i y} :
    updateFinset x {i} y = Function.update x i (y ⟨i, mem_singleton_self i⟩) 
Arguments: {ι : Type u_1} {π : ι → Sort u_2} {x : (i : ι) → π i} [DecidableEq ι] {i : ι} {y : (i_1 : { x // x ∈ {i} }) → π ↑i_1}
Goal: Function.updateFinset x {i} y = Function.update x i (y ⟨i, ⋯⟩)
-- Function.update_eq_updateFinset
theorem update_eq_updateFinset {i y} :
    Function.update x i y = updateFinset x {i} (uniqueElim y) 
Arguments: {ι : Type u_1} {π : ι → Sort u_2} {x : (i : ι) → π i} [DecidableEq ι] {i : ι} {y : π i}
Goal: Function.update x i y = Function.updateFinset x {i} (uniqueElim y)
-- Function.updateFinset_updateFinset
theorem updateFinset_updateFinset {s t : Finset ι} (hst : Disjoint s t)
    {y : ∀ i : ↥s, π i} {z : ∀ i : ↥t, π i} :
    updateFinset (updateFinset x s y) t z =
    updateFinset x (s ∪ t) (Equiv.piFinsetUnion π hst ⟨y, z⟩) 
Arguments: {ι : Type u_1} {π : ι → Type u_2} {x : (i : ι) → π i} [DecidableEq ι] {s t : Finset ι} (hst : Disjoint s t) {y : (i : { x // x ∈ s }) → π ↑i} {z : (i : { x // x ∈ t }) → π ↑i}
Goal: Function.updateFinset (Function.updateFinset x s y) t z =
  Function.updateFinset x (s ∪ t) ((Equiv.piFinsetUnion π hst) (y, z))