ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Multiset.rel_bind
theorem rel_bind {r : α → β → Prop} {p : γ → δ → Prop} {s t} {f : α → Multiset γ}
    {g : β → Multiset δ} (h : (r ⇒ Rel p) f g) (hst : Rel r s t) :
    Rel p (s.bind f) (t.bind g) 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} {δ : Type u_3} {r : α → β → Prop} {p : γ → δ → Prop} {s : Multiset α} {t : Multiset β} {f : α → Multiset γ} {g : β → Multiset δ} (h : (r ⇒ Multiset.Rel p) f g) (hst : Multiset.Rel r s t)
Goal: Multiset.Rel p (s.bind f) (t.bind g)
-- Multiset.count_sum
theorem count_sum [DecidableEq α] {m : Multiset β} {f : β → Multiset α} {a : α} :
    count a (map f m).sum = sum (m.map fun b => count a <| f b) 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] {m : Multiset β} {f : β → Multiset α} {a : α}
Goal: Multiset.count a (Multiset.map f m).sum = (Multiset.map (fun b => Multiset.count a (f b)) m).sum
-- Multiset.count_bind
theorem count_bind [DecidableEq α] {m : Multiset β} {f : β → Multiset α} {a : α} :
    count a (bind m f) = sum (m.map fun b => count a <| f b) 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] {m : Multiset β} {f : β → Multiset α} {a : α}
Goal: Multiset.count a (m.bind f) = (Multiset.map (fun b => Multiset.count a (f b)) m).sum
-- Multiset.le_bind
theorem le_bind {α β : Type*} {f : α → Multiset β} (S : Multiset α) {x : α} (hx : x ∈ S) :
    f x ≤ S.bind f 
Arguments: {α : Type u_4} {β : Type u_5} {f : α → Multiset β} (S : Multiset α) {x : α} (hx : x ∈ S)
Goal: f x ≤ S.bind f
-- Multiset.attach_bind_coe
theorem attach_bind_coe (s : Multiset α) (f : α → Multiset β) :
    (s.attach.bind fun i => f i) = s.bind f 
Arguments: {α : Type u_1} {β : Type v} (s : Multiset α) (f : α → Multiset β)
Goal: (s.attach.bind fun i => f ↑i) = s.bind f
-- Multiset.nodup_bind
@[simp] lemma nodup_bind :
    Nodup (bind s f) ↔ (∀ a ∈ s, Nodup (f a)) ∧ s.Pairwise fun a b => Disjoint (f a) (f b) 
Arguments: {α : Type u_1} {β : Type v} {s : Multiset α} {f : α → Multiset β}
Goal: (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Multiset.Pairwise (fun a b => (f a).Disjoint (f b)) s
-- Multiset.dedup_bind_dedup
@[simp]
lemma dedup_bind_dedup [DecidableEq α] [DecidableEq β] (s : Multiset α) (f : α → Multiset β) :
    (s.dedup.bind f).dedup = (s.bind f).dedup 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] [DecidableEq β] (s : Multiset α) (f : α → Multiset β)
Goal: (s.dedup.bind f).dedup = (s.bind f).dedup
-- Multiset.coe_product
@[simp]
theorem coe_product (l₁ : List α) (l₂ : List β) :
    (l₁ : Multiset α) ×ˢ (l₂ : Multiset β) = (l₁ ×ˢ l₂) 
Arguments: {α : Type u_1} {β : Type v} (l₁ : List α) (l₂ : List β)
Goal: ↑l₁ ×ˢ ↑l₂ = ↑(l₁ ×ˢ l₂)
-- Multiset.zero_product
@[simp]
theorem zero_product : (0 : Multiset α) ×ˢ t = 0 
Arguments: {α : Type u_1} {β : Type v} (t : Multiset β)
Goal: 0 ×ˢ t = 0
-- Multiset.cons_product
@[simp]
theorem cons_product : (a ::ₘ s) ×ˢ t = map (Prod.mk a) t + s ×ˢ t 
Arguments: {α : Type u_1} {β : Type v} (a : α) (s : Multiset α) (t : Multiset β)
Goal: (a ::ₘ s) ×ˢ t = Multiset.map (Prod.mk a) t + s ×ˢ t
-- Multiset.product_zero
@[simp]
theorem product_zero : s ×ˢ (0 : Multiset β) = 0 
Arguments: {α : Type u_1} {β : Type v} (s : Multiset α)
Goal: s ×ˢ 0 = 0
-- Multiset.product_cons
@[simp]
theorem product_cons : s ×ˢ (b ::ₘ t) = (s.map fun a => (a, b)) + s ×ˢ t 
Arguments: {α : Type u_1} {β : Type v} (b : β) (s : Multiset α) (t : Multiset β)
Goal: s ×ˢ (b ::ₘ t) = Multiset.map (fun a => (a, b)) s + s ×ˢ t
-- Multiset.product_singleton
@[simp]
theorem product_singleton : ({a} : Multiset α) ×ˢ ({b} : Multiset β) = {(a, b)} 
Arguments: {α : Type u_1} {β : Type v} (a : α) (b : β)
Goal: {a} ×ˢ {b} = {(a, b)}
-- Multiset.add_product
@[simp]
theorem add_product (s t : Multiset α) (u : Multiset β) : (s + t) ×ˢ u = s ×ˢ u + t ×ˢ u 
Arguments: {α : Type u_1} {β : Type v} (s t : Multiset α) (u : Multiset β)
Goal: (s + t) ×ˢ u = s ×ˢ u + t ×ˢ u
-- Multiset.product_add
@[simp]
theorem product_add (s : Multiset α) : ∀ t u : Multiset β, s ×ˢ (t + u) = s ×ˢ t + s ×ˢ u 
Arguments: {α : Type u_1} {β : Type v} (s : Multiset α) (t u : Multiset β)
Goal: s ×ˢ (t + u) = s ×ˢ t + s ×ˢ u
-- Multiset.card_product
@[simp]
theorem card_product : card (s ×ˢ t) = card s * card t 
Arguments: {α : Type u_1} {β : Type v} (s : Multiset α) (t : Multiset β)
Goal: Multiset.card (s ×ˢ t) = Multiset.card s * Multiset.card t
-- Multiset.mem_product
@[simp] lemma mem_product : ∀ {p : α × β}, p ∈ @product α β s t ↔ p.1 ∈ s ∧ p.2 ∈ t
  
Arguments: {α : Type u_1} {β : Type v} {s : Multiset α} {t : Multiset β} {p : α × β}
Goal: p ∈ s.product t ↔ p.1 ∈ s ∧ p.2 ∈ t
-- Multiset.Nodup.product
protected theorem Nodup.product : Nodup s → Nodup t → Nodup (s ×ˢ t) 
Arguments: {α : Type u_1} {β : Type v} {s : Multiset α} {t : Multiset β}
Goal: s.Nodup → t.Nodup → (s ×ˢ t).Nodup
-- Multiset.coe_sigma
@[simp]
theorem coe_sigma (l₁ : List α) (l₂ : ∀ a, List (σ a)) :
    (@Multiset.sigma α σ l₁ fun a => l₂ a) = l₁.sigma l₂ 
Arguments: {α : Type u_1} {σ : α → Type u_4} (l₁ : List α) (l₂ : (a : α) → List (σ a))
Goal: ((↑l₁).sigma fun a => ↑(l₂ a)) = ↑(l₁.sigma l₂)
-- Multiset.zero_sigma
@[simp]
theorem zero_sigma : @Multiset.sigma α σ 0 t = 0 
Arguments: {α : Type u_1} {σ : α → Type u_4} (t : (a : α) → Multiset (σ a))
Goal: Multiset.sigma 0 t = 0
-- Multiset.cons_sigma
@[simp]
theorem cons_sigma : (a ::ₘ s).sigma t = (t a).map (Sigma.mk a) + s.sigma t 
Arguments: {α : Type u_1} {σ : α → Type u_4} (a : α) (s : Multiset α) (t : (a : α) → Multiset (σ a))
Goal: (a ::ₘ s).sigma t = Multiset.map (Sigma.mk a) (t a) + s.sigma t
-- Multiset.sigma_singleton
@[simp]
theorem sigma_singleton (b : α → β) :
    (({a} : Multiset α).sigma fun a => ({b a} : Multiset β)) = {⟨a, b a⟩} 
Arguments: {α : Type u_1} {β : Type v} (a : α) (b : α → β)
Goal: ({a}.sigma fun a => {b a}) = {⟨a, b a⟩}
-- Multiset.add_sigma
@[simp]
theorem add_sigma (s t : Multiset α) (u : ∀ a, Multiset (σ a)) :
    (s + t).sigma u = s.sigma u + t.sigma u 
Arguments: {α : Type u_1} {σ : α → Type u_4} (s t : Multiset α) (u : (a : α) → Multiset (σ a))
Goal: (s + t).sigma u = s.sigma u + t.sigma u
-- Multiset.sigma_add
@[simp]
theorem sigma_add :
    ∀ t u : ∀ a, Multiset (σ a), (s.sigma fun a => t a + u a) = s.sigma t + s.sigma u 
Arguments: {α : Type u_1} {σ : α → Type u_4} (s : Multiset α) (t u : (a : α) → Multiset (σ a))
Goal: (s.sigma fun a => t a + u a) = s.sigma t + s.sigma u
-- Multiset.card_sigma
@[simp]
theorem card_sigma : card (s.sigma t) = sum (map (fun a => card (t a)) s) 
Arguments: {α : Type u_1} {σ : α → Type u_4} (s : Multiset α) (t : (a : α) → Multiset (σ a))
Goal: Multiset.card (s.sigma t) = (Multiset.map (fun a => Multiset.card (t a)) s).sum
-- Multiset.mem_sigma
@[simp] lemma mem_sigma : ∀ {p : Σa, σ a}, p ∈ @Multiset.sigma α σ s t ↔ p.1 ∈ s ∧ p.2 ∈ t p.1
  
Arguments: {α : Type u_1} {σ : α → Type u_4} {s : Multiset α} {t : (a : α) → Multiset (σ a)} {p : (a : α) × σ a}
Goal: p ∈ s.sigma t ↔ p.fst ∈ s ∧ p.snd ∈ t p.fst
-- Multiset.Nodup.sigma
protected theorem Nodup.sigma {σ : α → Type*} {t : ∀ a, Multiset (σ a)} :
    Nodup s → (∀ a, Nodup (t a)) → Nodup (s.sigma t) 
Arguments: {α : Type u_1} {s : Multiset α} {σ : α → Type u_5} {t : (a : α) → Multiset (σ a)}
Goal: s.Nodup → (∀ (a : α), (t a).Nodup) → (s.sigma t).Nodup
-- Multiset.coe_dedup
@[simp]
theorem coe_dedup (l : List α) : @dedup α _ l = l.dedup 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: (↑l).dedup = ↑l.dedup
-- Multiset.dedup_zero
@[simp]
theorem dedup_zero : @dedup α _ 0 = 0 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Multiset.dedup 0 = 0
-- Multiset.mem_dedup
@[simp]
theorem mem_dedup {a : α} {s : Multiset α} : a ∈ dedup s ↔ a ∈ s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: a ∈ s.dedup ↔ a ∈ s
-- Multiset.dedup_cons_of_mem
@[simp]
theorem dedup_cons_of_mem {a : α} {s : Multiset α} : a ∈ s → dedup (a ::ₘ s) = dedup s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: a ∈ s → (a ::ₘ s).dedup = s.dedup
-- Multiset.dedup_cons_of_not_mem
@[simp]
theorem dedup_cons_of_not_mem {a : α} {s : Multiset α} : a ∉ s → dedup (a ::ₘ s) = a ::ₘ dedup s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: a ∉ s → (a ::ₘ s).dedup = a ::ₘ s.dedup
-- Multiset.dedup_le
theorem dedup_le (s : Multiset α) : dedup s ≤ s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: s.dedup ≤ s
-- Multiset.dedup_subset
theorem dedup_subset (s : Multiset α) : dedup s ⊆ s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: s.dedup ⊆ s
-- Multiset.subset_dedup
theorem subset_dedup (s : Multiset α) : s ⊆ dedup s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: s ⊆ s.dedup
-- Multiset.dedup_subset'
@[simp]
theorem dedup_subset' {s t : Multiset α} : dedup s ⊆ t ↔ s ⊆ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s.dedup ⊆ t ↔ s ⊆ t
-- Multiset.subset_dedup'
@[simp]
theorem subset_dedup' {s t : Multiset α} : s ⊆ dedup t ↔ s ⊆ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s ⊆ t.dedup ↔ s ⊆ t
-- Multiset.nodup_dedup
@[simp]
theorem nodup_dedup (s : Multiset α) : Nodup (dedup s) 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: s.dedup.Nodup
-- Multiset.dedup_eq_self
theorem dedup_eq_self {s : Multiset α} : dedup s = s ↔ Nodup s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α}
Goal: s.dedup = s ↔ s.Nodup
-- Multiset.count_dedup
theorem count_dedup (m : Multiset α) (a : α) : m.dedup.count a = if a ∈ m then 1 else 0 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α) (a : α)
Goal: Multiset.count a m.dedup = if a ∈ m then 1 else 0
-- Multiset.dedup_idem
@[simp]
theorem dedup_idem {m : Multiset α} : m.dedup.dedup = m.dedup 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α}
Goal: m.dedup.dedup = m.dedup
-- Multiset.dedup_eq_zero
theorem dedup_eq_zero {s : Multiset α} : dedup s = 0 ↔ s = 0 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α}
Goal: s.dedup = 0 ↔ s = 0
-- Multiset.dedup_singleton
@[simp]
theorem dedup_singleton {a : α} : dedup ({a} : Multiset α) = {a} 
Arguments: {α : Type u_1} [DecidableEq α] {a : α}
Goal: {a}.dedup = {a}
-- Multiset.le_dedup
theorem le_dedup {s t : Multiset α} : s ≤ dedup t ↔ s ≤ t ∧ Nodup s 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s ≤ t.dedup ↔ s ≤ t ∧ s.Nodup
-- Multiset.le_dedup_self
theorem le_dedup_self {s : Multiset α} : s ≤ dedup s ↔ Nodup s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α}
Goal: s ≤ s.dedup ↔ s.Nodup
-- Multiset.dedup_ext
theorem dedup_ext {s t : Multiset α} : dedup s = dedup t ↔ ∀ a, a ∈ s ↔ a ∈ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s.dedup = t.dedup ↔ ∀ (a : α), a ∈ s ↔ a ∈ t
-- Multiset.dedup_map_of_injective
theorem dedup_map_of_injective [DecidableEq β] {f : α → β} (hf : Function.Injective f)
    (s : Multiset α) :
    (s.map f).dedup = s.dedup.map f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (s : Multiset α)
Goal: (Multiset.map f s).dedup = Multiset.map f s.dedup
-- Multiset.dedup_map_dedup_eq
theorem dedup_map_dedup_eq [DecidableEq β] (f : α → β) (s : Multiset α) :
    dedup (map f (dedup s)) = dedup (map f s) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Multiset α)
Goal: (Multiset.map f s.dedup).dedup = (Multiset.map f s).dedup
-- Multiset.dedup_nsmul
@[simp]
theorem dedup_nsmul {s : Multiset α} {n : ℕ} (h0 : n ≠ 0) : (n • s).dedup = s.dedup 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} {n : ℕ} (h0 : n ≠ 0)
Goal: (n • s).dedup = s.dedup
-- Multiset.Nodup.le_dedup_iff_le
theorem Nodup.le_dedup_iff_le {s t : Multiset α} (hno : s.Nodup) : s ≤ t.dedup ↔ s ≤ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (hno : s.Nodup)
Goal: s ≤ t.dedup ↔ s ≤ t
-- Multiset.Subset.dedup_add_right
theorem Subset.dedup_add_right {s t : Multiset α} (h : s ⊆ t) :
    dedup (s + t) = dedup t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s ⊆ t)
Goal: (s + t).dedup = t.dedup
-- Multiset.Subset.dedup_add_left
theorem Subset.dedup_add_left {s t : Multiset α} (h : t ⊆ s) :
    dedup (s + t) = dedup s 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : t ⊆ s)
Goal: (s + t).dedup = s.dedup
-- Multiset.Disjoint.dedup_add
theorem Disjoint.dedup_add {s t : Multiset α} (h : Disjoint s t) :
    dedup (s + t) = dedup s + dedup t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s.Disjoint t)
Goal: (s + t).dedup = s.dedup + t.dedup
-- List.Subset.dedup_append_left
theorem _root_.List.Subset.dedup_append_left {s t : List α} (h : t ⊆ s) :
    List.dedup (s ++ t) ~ List.dedup s 
Arguments: {α : Type u_1} [DecidableEq α] {s t : List α} (h : t ⊆ s)
Goal: (s ++ t).dedup.Perm s.dedup
-- Multiset.Nodup.le_nsmul_iff_le
theorem Multiset.Nodup.le_nsmul_iff_le {α : Type*} {s t : Multiset α} {n : ℕ} (h : s.Nodup)
    (hn : n ≠ 0) : s ≤ n • t ↔ s ≤ t 
Arguments: {α : Type u_1} {s t : Multiset α} {n : ℕ} (h : s.Nodup) (hn : n ≠ 0)
Goal: s ≤ n • t ↔ s ≤ t
-- Set.restrict_eq
theorem restrict_eq (f : α → β) (s : Set α) : s.restrict f = f ∘ Subtype.val 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α)
Goal: s.restrict f = f ∘ Subtype.val
-- Set.restrict_apply
@[simp]
theorem restrict_apply (f : α → β) (s : Set α) (x : s) : s.restrict f x = f x 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α) (x : ↑s)
Goal: s.restrict f x = f ↑x
-- Set.restrict_eq_iff
theorem restrict_eq_iff {f : ∀ a, π a} {s : Set α} {g : ∀ a : s, π a} :
    restrict s f = g ↔ ∀ (a) (ha : a ∈ s), f a = g ⟨a, ha⟩ 
Arguments: {α : Type u_1} {π : α → Type u_5} {f : (a : α) → π a} {s : Set α} {g : (a : ↑s) → π ↑a}
Goal: s.restrict f = g ↔ ∀ (a : α) (ha : a ∈ s), f a = g ⟨a, ha⟩
-- Set.eq_restrict_iff
theorem eq_restrict_iff {s : Set α} {f : ∀ a : s, π a} {g : ∀ a, π a} :
    f = restrict s g ↔ ∀ (a) (ha : a ∈ s), f ⟨a, ha⟩ = g a 
Arguments: {α : Type u_1} {π : α → Type u_5} {s : Set α} {f : (a : ↑s) → π ↑a} {g : (a : α) → π a}
Goal: f = s.restrict g ↔ ∀ (a : α) (ha : a ∈ s), f ⟨a, ha⟩ = g a
-- Set.range_restrict
@[simp]
theorem range_restrict (f : α → β) (s : Set α) : Set.range (s.restrict f) = f '' s 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α)
Goal: Set.range (s.restrict f) = f '' s
-- Set.image_restrict
theorem image_restrict (f : α → β) (s t : Set α) :
    s.restrict f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (s t : Set α)
Goal: s.restrict f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s)
-- Set.restrict_dite
@[simp]
theorem restrict_dite {s : Set α} [∀ x, Decidable (x ∈ s)] (f : ∀ a ∈ s, β)
    (g : ∀ a ∉ s, β) :
    (s.restrict fun a => if h : a ∈ s then f a h else g a h) = (fun a : s => f a a.2) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} [(x : α) → Decidable (x ∈ s)] (f : (a : α) → a ∈ s → β) (g : (a : α) → a ∉ s → β)
Goal: (s.restrict fun a => if h : a ∈ s then f a h else g a h) = fun a => f ↑a ⋯
-- Set.restrict_dite_compl
@[simp]
theorem restrict_dite_compl {s : Set α} [∀ x, Decidable (x ∈ s)] (f : ∀ a ∈ s, β)
    (g : ∀ a ∉ s, β) :
    (sᶜ.restrict fun a => if h : a ∈ s then f a h else g a h) = (fun a : (sᶜ : Set α) => g a a.2) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} [(x : α) → Decidable (x ∈ s)] (f : (a : α) → a ∈ s → β) (g : (a : α) → a ∉ s → β)
Goal: (sᶜ.restrict fun a => if h : a ∈ s then f a h else g a h) = fun a => g ↑a ⋯
-- Set.restrict_ite
@[simp]
theorem restrict_ite (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    (s.restrict fun a => if a ∈ s then f a else g a) = s.restrict f 
Arguments: {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [(x : α) → Decidable (x ∈ s)]
Goal: (s.restrict fun a => if a ∈ s then f a else g a) = s.restrict f
-- Set.restrict_ite_compl
@[simp]
theorem restrict_ite_compl (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    (sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g 
Arguments: {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [(x : α) → Decidable (x ∈ s)]
Goal: (sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g
-- Set.restrict_piecewise
@[simp]
theorem restrict_piecewise (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    s.restrict (piecewise s f g) = s.restrict f 
Arguments: {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [(x : α) → Decidable (x ∈ s)]
Goal: s.restrict (s.piecewise f g) = s.restrict f
-- Set.restrict_piecewise_compl
@[simp]
theorem restrict_piecewise_compl (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    sᶜ.restrict (piecewise s f g) = sᶜ.restrict g 
Arguments: {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [(x : α) → Decidable (x ∈ s)]
Goal: sᶜ.restrict (s.piecewise f g) = sᶜ.restrict g
-- Set.restrict_extend_range
theorem restrict_extend_range (f : α → β) (g : α → γ) (g' : β → γ) :
    (range f).restrict (extend f g g') = fun x => g x.coe_prop.choose 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : α → γ) (g' : β → γ)
Goal: (Set.range f).restrict (Function.extend f g g') = fun x => g (Exists.choose ⋯)
-- Set.restrict_extend_compl_range
@[simp]
theorem restrict_extend_compl_range (f : α → β) (g : α → γ) (g' : β → γ) :
    (range f)ᶜ.restrict (extend f g g') = g' ∘ Subtype.val 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : α → γ) (g' : β → γ)
Goal: (Set.range f)ᶜ.restrict (Function.extend f g g') = g' ∘ Subtype.val
-- Set.range_extend_subset
theorem range_extend_subset (f : α → β) (g : α → γ) (g' : β → γ) :
    range (extend f g g') ⊆ range g ∪ g' '' (range f)ᶜ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : α → γ) (g' : β → γ)
Goal: Set.range (Function.extend f g g') ⊆ Set.range g ∪ g' '' (Set.range f)ᶜ
-- Set.range_extend
theorem range_extend {f : α → β} (hf : Injective f) (g : α → γ) (g' : β → γ) :
    range (extend f g g') = range g ∪ g' '' (range f)ᶜ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} (hf : Function.Injective f) (g : α → γ) (g' : β → γ)
Goal: Set.range (Function.extend f g g') = Set.range g ∪ g' '' (Set.range f)ᶜ
-- Set.val_codRestrict_apply
@[simp]
theorem val_codRestrict_apply (f : ι → α) (s : Set α) (h : ∀ x, f x ∈ s) (x : ι) :
    (codRestrict f s h x : α) = f x 
Arguments: {α : Type u_1} {ι : Sort u_4} (f : ι → α) (s : Set α) (h : ∀ (x : ι), f x ∈ s) (x : ι)
Goal: ↑(Set.codRestrict f s h x) = f x
-- Set.restrict_comp_codRestrict
@[simp]
theorem restrict_comp_codRestrict {f : ι → α} {g : α → β} {b : Set α} (h : ∀ x, f x ∈ b) :
    b.restrict g ∘ b.codRestrict f h = g ∘ f 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : ι → α} {g : α → β} {b : Set α} (h : ∀ (x : ι), f x ∈ b)
Goal: b.restrict g ∘ Set.codRestrict f b h = g ∘ f
-- Set.injective_codRestrict
@[simp]
theorem injective_codRestrict {f : ι → α} {s : Set α} (h : ∀ x, f x ∈ s) :
    Injective (codRestrict f s h) ↔ Injective f 
Arguments: {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α} (h : ∀ (x : ι), f x ∈ s)
Goal: Function.Injective (Set.codRestrict f s h) ↔ Function.Injective f
-- Set.eqOn_empty
@[simp]
theorem eqOn_empty (f₁ f₂ : α → β) : EqOn f₁ f₂ ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (f₁ f₂ : α → β)
Goal: Set.EqOn f₁ f₂ ∅
-- Set.eqOn_singleton
@[simp]
theorem eqOn_singleton : Set.EqOn f₁ f₂ {a} ↔ f₁ a = f₂ a 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : α → β} {a : α}
Goal: Set.EqOn f₁ f₂ {a} ↔ f₁ a = f₂ a
-- Set.eqOn_univ
@[simp]
theorem eqOn_univ (f₁ f₂ : α → β) : EqOn f₁ f₂ univ ↔ f₁ = f₂ 
Arguments: {α : Type u_1} {β : Type u_2} (f₁ f₂ : α → β)
Goal: Set.EqOn f₁ f₂ Set.univ ↔ f₁ = f₂
-- Set.restrict_eq_restrict_iff
@[simp]
theorem restrict_eq_restrict_iff : restrict s f₁ = restrict s f₂ ↔ EqOn f₁ f₂ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β}
Goal: s.restrict f₁ = s.restrict f₂ ↔ Set.EqOn f₁ f₂ s
-- Set.EqOn.symm
@[symm]
theorem EqOn.symm (h : EqOn f₁ f₂ s) : EqOn f₂ f₁ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} (h : Set.EqOn f₁ f₂ s)
Goal: Set.EqOn f₂ f₁ s
-- Set.eqOn_comm
theorem eqOn_comm : EqOn f₁ f₂ s ↔ EqOn f₂ f₁ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β}
Goal: Set.EqOn f₁ f₂ s ↔ Set.EqOn f₂ f₁ s
-- Set.eqOn_refl
theorem eqOn_refl (f : α → β) (s : Set α) : EqOn f f s 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α)
Goal: Set.EqOn f f s
-- Set.EqOn.trans
theorem EqOn.trans (h₁ : EqOn f₁ f₂ s) (h₂ : EqOn f₂ f₃ s) : EqOn f₁ f₃ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ f₃ : α → β} (h₁ : Set.EqOn f₁ f₂ s) (h₂ : Set.EqOn f₂ f₃ s)
Goal: Set.EqOn f₁ f₃ s
-- Set.EqOn.image_eq
theorem EqOn.image_eq (heq : EqOn f₁ f₂ s) : f₁ '' s = f₂ '' s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} (heq : Set.EqOn f₁ f₂ s)
Goal: f₁ '' s = f₂ '' s
-- Set.EqOn.image_eq_self
theorem EqOn.image_eq_self {f : α → α} (h : Set.EqOn f id s) : f '' s = s 
Arguments: {α : Type u_1} {s : Set α} {f : α → α} (h : Set.EqOn f id s)
Goal: f '' s = s
-- Set.EqOn.inter_preimage_eq
theorem EqOn.inter_preimage_eq (heq : EqOn f₁ f₂ s) (t : Set β) : s ∩ f₁ ⁻¹' t = s ∩ f₂ ⁻¹' t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} (heq : Set.EqOn f₁ f₂ s) (t : Set β)
Goal: s ∩ f₁ ⁻¹' t = s ∩ f₂ ⁻¹' t
-- Set.EqOn.mono
theorem EqOn.mono (hs : s₁ ⊆ s₂) (hf : EqOn f₁ f₂ s₂) : EqOn f₁ f₂ s₁ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {f₁ f₂ : α → β} (hs : s₁ ⊆ s₂) (hf : Set.EqOn f₁ f₂ s₂)
Goal: Set.EqOn f₁ f₂ s₁
-- Set.eqOn_union
@[simp]
theorem eqOn_union : EqOn f₁ f₂ (s₁ ∪ s₂) ↔ EqOn f₁ f₂ s₁ ∧ EqOn f₁ f₂ s₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {f₁ f₂ : α → β}
Goal: Set.EqOn f₁ f₂ (s₁ ∪ s₂) ↔ Set.EqOn f₁ f₂ s₁ ∧ Set.EqOn f₁ f₂ s₂
-- Set.EqOn.union
theorem EqOn.union (h₁ : EqOn f₁ f₂ s₁) (h₂ : EqOn f₁ f₂ s₂) : EqOn f₁ f₂ (s₁ ∪ s₂) 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {f₁ f₂ : α → β} (h₁ : Set.EqOn f₁ f₂ s₁) (h₂ : Set.EqOn f₁ f₂ s₂)
Goal: Set.EqOn f₁ f₂ (s₁ ∪ s₂)
-- Set.EqOn.comp_left
theorem EqOn.comp_left (h : s.EqOn f₁ f₂) : s.EqOn (g ∘ f₁) (g ∘ f₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {f₁ f₂ : α → β} {g : β → γ} (h : Set.EqOn f₁ f₂ s)
Goal: Set.EqOn (g ∘ f₁) (g ∘ f₂) s
-- Set.eqOn_range
@[simp]
theorem eqOn_range {ι : Sort*} {f : ι → α} {g₁ g₂ : α → β} :
    EqOn g₁ g₂ (range f) ↔ g₁ ∘ f = g₂ ∘ f 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_6} {f : ι → α} {g₁ g₂ : α → β}
Goal: Set.EqOn g₁ g₂ (Set.range f) ↔ g₁ ∘ f = g₂ ∘ f
-- MonotoneOn.congr
theorem _root_.MonotoneOn.congr (h₁ : MonotoneOn f₁ s) (h : s.EqOn f₁ f₂) : MonotoneOn f₂ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} [Preorder α] [Preorder β] (h₁ : MonotoneOn f₁ s) (h : Set.EqOn f₁ f₂ s)
Goal: MonotoneOn f₂ s
-- AntitoneOn.congr
theorem _root_.AntitoneOn.congr (h₁ : AntitoneOn f₁ s) (h : s.EqOn f₁ f₂) : AntitoneOn f₂ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} [Preorder α] [Preorder β] (h₁ : AntitoneOn f₁ s) (h : Set.EqOn f₁ f₂ s)
Goal: AntitoneOn f₂ s
-- StrictMonoOn.congr
theorem _root_.StrictMonoOn.congr (h₁ : StrictMonoOn f₁ s) (h : s.EqOn f₁ f₂) :
    StrictMonoOn f₂ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} [Preorder α] [Preorder β] (h₁ : StrictMonoOn f₁ s) (h : Set.EqOn f₁ f₂ s)
Goal: StrictMonoOn f₂ s
-- StrictAntiOn.congr
theorem _root_.StrictAntiOn.congr (h₁ : StrictAntiOn f₁ s) (h : s.EqOn f₁ f₂) : StrictAntiOn f₂ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} [Preorder α] [Preorder β] (h₁ : StrictAntiOn f₁ s) (h : Set.EqOn f₁ f₂ s)
Goal: StrictAntiOn f₂ s
-- Set.EqOn.congr_monotoneOn
theorem EqOn.congr_monotoneOn (h : s.EqOn f₁ f₂) : MonotoneOn f₁ s ↔ MonotoneOn f₂ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} [Preorder α] [Preorder β] (h : Set.EqOn f₁ f₂ s)
Goal: MonotoneOn f₁ s ↔ MonotoneOn f₂ s
-- Set.EqOn.congr_antitoneOn
theorem EqOn.congr_antitoneOn (h : s.EqOn f₁ f₂) : AntitoneOn f₁ s ↔ AntitoneOn f₂ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {f₁ f₂ : α → β} [Preorder α] [Preorder β] (h : Set.EqOn f₁ f₂ s)
Goal: AntitoneOn f₁ s ↔ AntitoneOn f₂ s