ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.strictAnti_iff_forall_lt_insert
lemma strictAnti_iff_forall_lt_insert : StrictAnti f ↔ ∀ s ⦃a⦄, a ∉ s → f (insert a s) < f s 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β} [DecidableEq α]
Goal: StrictAnti f ↔ ∀ (s : Finset α) ⦃a : α⦄, a ∉ s → f (insert a s) < f s
-- Part.mem_toFinset
@[simp]
theorem mem_toFinset {o : Part α} [Decidable o.Dom] {x : α} : x ∈ o.toFinset ↔ x ∈ o 
Arguments: {α : Type u_1} {o : Part α} [Decidable o.Dom] {x : α}
Goal: x ∈ o.toFinset ↔ x ∈ o
-- Part.toFinset_none
@[simp]
theorem toFinset_none [Decidable (none : Part α).Dom] : none.toFinset = (∅ : Finset α) 
Arguments: {α : Type u_1} [Decidable Part.none.Dom]
Goal: Part.none.toFinset = ∅
-- Part.toFinset_some
@[simp]
theorem toFinset_some {a : α} [Decidable (some a).Dom] : (some a).toFinset = {a} 
Arguments: {α : Type u_1} {a : α} [Decidable (Part.some a).Dom]
Goal: (Part.some a).toFinset = {a}
-- Part.coe_toFinset
@[simp]
theorem coe_toFinset (o : Part α) [Decidable o.Dom] : (o.toFinset : Set α) = { x | x ∈ o } 
Arguments: {α : Type u_1} (o : Part α) [Decidable o.Dom]
Goal: ↑o.toFinset = {x | x ∈ o}
-- Finset.mem_pimage
@[simp]
theorem mem_pimage : b ∈ s.pimage f ↔ ∃ a ∈ s, b ∈ f a 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom] {s : Finset α} {b : β}
Goal: b ∈ Finset.pimage f s ↔ ∃ a ∈ s, b ∈ f a
-- Finset.coe_pimage
@[simp, norm_cast]
theorem coe_pimage : (s.pimage f : Set β) = f.image s 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom] {s : Finset α}
Goal: ↑(Finset.pimage f s) = f.image ↑s
-- Finset.pimage_some
@[simp]
theorem pimage_some (s : Finset α) (f : α → β) [∀ x, Decidable (Part.some <| f x).Dom] :
    (s.pimage fun x => Part.some (f x)) = s.image f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (s : Finset α) (f : α → β) [(x : α) → Decidable (Part.some (f x)).Dom]
Goal: Finset.pimage (fun x => Part.some (f x)) s = Finset.image f s
-- Finset.pimage_congr
theorem pimage_congr (h₁ : s = t) (h₂ : ∀ x ∈ t, f x = g x) : s.pimage f = t.pimage g 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f g : α →. β} [(x : α) → Decidable (f x).Dom] [(x : α) → Decidable (g x).Dom] {s t : Finset α} (h₁ : s = t) (h₂ : ∀ x ∈ t, f x = g x)
Goal: Finset.pimage f s = Finset.pimage g t
-- Finset.pimage_eq_image_filter
theorem pimage_eq_image_filter : s.pimage f =
    (filter (fun x => (f x).Dom) s).attach.image
      fun x : { x // x ∈ filter (fun x => (f x).Dom) s } =>
        (f x).get (mem_filter.mp x.coe_prop).2 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom] {s : Finset α}
Goal: Finset.pimage f s = Finset.image (fun x => (f ↑x).get ⋯) (Finset.filter (fun x => (f x).Dom) s).attach
-- Finset.pimage_union
theorem pimage_union [DecidableEq α] : (s ∪ t).pimage f = s.pimage f ∪ t.pimage f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom] {s t : Finset α} [DecidableEq α]
Goal: Finset.pimage f (s ∪ t) = Finset.pimage f s ∪ Finset.pimage f t
-- Finset.pimage_empty
@[simp]
theorem pimage_empty : pimage f ∅ = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom]
Goal: Finset.pimage f ∅ = ∅
-- Finset.pimage_subset
theorem pimage_subset {t : Finset β} : s.pimage f ⊆ t ↔ ∀ x ∈ s, ∀ y ∈ f x, y ∈ t 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom] {s : Finset α} {t : Finset β}
Goal: Finset.pimage f s ⊆ t ↔ ∀ x ∈ s, ∀ y ∈ f x, y ∈ t
-- Finset.pimage_mono
@[mono]
theorem pimage_mono (h : s ⊆ t) : s.pimage f ⊆ t.pimage f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom] {s t : Finset α} (h : s ⊆ t)
Goal: Finset.pimage f s ⊆ Finset.pimage f t
-- Finset.pimage_inter
theorem pimage_inter [DecidableEq α] : (s ∩ t).pimage f ⊆ s.pimage f ∩ t.pimage f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] {f : α →. β} [(x : α) → Decidable (f x).Dom] {s t : Finset α} [DecidableEq α]
Goal: Finset.pimage f (s ∩ t) ⊆ Finset.pimage f s ∩ Finset.pimage f t
-- Finset.product_val
@[simp]
theorem product_val : (s ×ˢ t).1 = s.1 ×ˢ t.1 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}
Goal: (s ×ˢ t).val = s.val ×ˢ t.val
-- Finset.mem_product
@[simp]
theorem mem_product {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {p : α × β}
Goal: p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t
-- Finset.mk_mem_product
theorem mk_mem_product (ha : a ∈ s) (hb : b ∈ t) : (a, b) ∈ s ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {a : α} {b : β} (ha : a ∈ s) (hb : b ∈ t)
Goal: (a, b) ∈ s ×ˢ t
-- Finset.coe_product
@[simp, norm_cast]
theorem coe_product (s : Finset α) (t : Finset β) :
    (↑(s ×ˢ t) : Set (α × β)) = (s : Set α) ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β)
Goal: ↑(s ×ˢ t) = ↑s ×ˢ ↑t
-- Finset.subset_product_image_fst
theorem subset_product_image_fst [DecidableEq α] : (s ×ˢ t).image Prod.fst ⊆ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} [DecidableEq α]
Goal: Finset.image Prod.fst (s ×ˢ t) ⊆ s
-- Finset.subset_product_image_snd
theorem subset_product_image_snd [DecidableEq β] : (s ×ˢ t).image Prod.snd ⊆ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} [DecidableEq β]
Goal: Finset.image Prod.snd (s ×ˢ t) ⊆ t
-- Finset.product_image_fst
theorem product_image_fst [DecidableEq α] (ht : t.Nonempty) : (s ×ˢ t).image Prod.fst = s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} [DecidableEq α] (ht : t.Nonempty)
Goal: Finset.image Prod.fst (s ×ˢ t) = s
-- Finset.product_image_snd
theorem product_image_snd [DecidableEq β] (ht : s.Nonempty) : (s ×ˢ t).image Prod.snd = t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} [DecidableEq β] (ht : s.Nonempty)
Goal: Finset.image Prod.snd (s ×ˢ t) = t
-- Finset.subset_product
theorem subset_product [DecidableEq α] [DecidableEq β] {s : Finset (α × β)} :
    s ⊆ s.image Prod.fst ×ˢ s.image Prod.snd 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] {s : Finset (α × β)}
Goal: s ⊆ Finset.image Prod.fst s ×ˢ Finset.image Prod.snd s
-- Finset.product_subset_product
@[gcongr]
theorem product_subset_product (hs : s ⊆ s') (ht : t ⊆ t') : s ×ˢ t ⊆ s' ×ˢ t' 
Arguments: {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t t' : Finset β} (hs : s ⊆ s') (ht : t ⊆ t')
Goal: s ×ˢ t ⊆ s' ×ˢ t'
-- Finset.product_subset_product_left
@[gcongr]
theorem product_subset_product_left (hs : s ⊆ s') : s ×ˢ t ⊆ s' ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t : Finset β} (hs : s ⊆ s')
Goal: s ×ˢ t ⊆ s' ×ˢ t
-- Finset.product_subset_product_right
@[gcongr]
theorem product_subset_product_right (ht : t ⊆ t') : s ×ˢ t ⊆ s ×ˢ t' 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} (ht : t ⊆ t')
Goal: s ×ˢ t ⊆ s ×ˢ t'
-- Finset.map_swap_product
theorem map_swap_product (s : Finset α) (t : Finset β) :
    (t ×ˢ s).map ⟨Prod.swap, Prod.swap_injective⟩ = s ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β)
Goal: Finset.map { toFun := Prod.swap, inj' := ⋯ } (t ×ˢ s) = s ×ˢ t
-- Finset.image_swap_product
@[simp]
theorem image_swap_product [DecidableEq (α × β)] (s : Finset α) (t : Finset β) :
    (t ×ˢ s).image Prod.swap = s ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq (α × β)] (s : Finset α) (t : Finset β)
Goal: Finset.image Prod.swap (t ×ˢ s) = s ×ˢ t
-- Finset.product_eq_biUnion
theorem product_eq_biUnion [DecidableEq (α × β)] (s : Finset α) (t : Finset β) :
    s ×ˢ t = s.biUnion fun a => t.image fun b => (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq (α × β)] (s : Finset α) (t : Finset β)
Goal: s ×ˢ t = s.biUnion fun a => Finset.image (fun b => (a, b)) t
-- Finset.product_eq_biUnion_right
theorem product_eq_biUnion_right [DecidableEq (α × β)] (s : Finset α) (t : Finset β) :
    s ×ˢ t = t.biUnion fun b => s.image fun a => (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq (α × β)] (s : Finset α) (t : Finset β)
Goal: s ×ˢ t = t.biUnion fun b => Finset.image (fun a => (a, b)) s
-- Finset.product_biUnion
@[simp]
theorem product_biUnion [DecidableEq γ] (s : Finset α) (t : Finset β) (f : α × β → Finset γ) :
    (s ×ˢ t).biUnion f = s.biUnion fun a => t.biUnion fun b => f (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [DecidableEq γ] (s : Finset α) (t : Finset β) (f : α × β → Finset γ)
Goal: (s ×ˢ t).biUnion f = s.biUnion fun a => t.biUnion fun b => f (a, b)
-- Finset.card_product
@[simp]
theorem card_product (s : Finset α) (t : Finset β) : card (s ×ˢ t) = card s * card t 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β)
Goal: (s ×ˢ t).card = s.card * t.card
-- Finset.nontrivial_prod_iff
lemma nontrivial_prod_iff : (s ×ˢ t).Nontrivial ↔
    s.Nonempty ∧ t.Nonempty ∧ (s.Nontrivial ∨ t.Nontrivial) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}
Goal: (s ×ˢ t).Nontrivial ↔ s.Nonempty ∧ t.Nonempty ∧ (s.Nontrivial ∨ t.Nontrivial)
-- Finset.filter_product
theorem filter_product (p : α → Prop) (q : β → Prop) [DecidablePred p] [DecidablePred q] :
    ((s ×ˢ t).filter fun x : α × β => p x.1 ∧ q x.2) = s.filter p ×ˢ t.filter q 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (p : α → Prop) (q : β → Prop) [DecidablePred p] [DecidablePred q]
Goal: Finset.filter (fun x => p x.1 ∧ q x.2) (s ×ˢ t) = Finset.filter p s ×ˢ Finset.filter q t
-- Finset.filter_product_left
theorem filter_product_left (p : α → Prop) [DecidablePred p] :
    ((s ×ˢ t).filter fun x : α × β => p x.1) = s.filter p ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (p : α → Prop) [DecidablePred p]
Goal: Finset.filter (fun x => p x.1) (s ×ˢ t) = Finset.filter p s ×ˢ t
-- Finset.filter_product_right
theorem filter_product_right (q : β → Prop) [DecidablePred q] :
    ((s ×ˢ t).filter fun x : α × β => q x.2) = s ×ˢ t.filter q 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (q : β → Prop) [DecidablePred q]
Goal: Finset.filter (fun x => q x.2) (s ×ˢ t) = s ×ˢ Finset.filter q t
-- Finset.filter_product_card
theorem filter_product_card (s : Finset α) (t : Finset β) (p : α → Prop) (q : β → Prop)
    [DecidablePred p] [DecidablePred q] :
    ((s ×ˢ t).filter fun x : α × β => (p x.1) = (q x.2)).card =
      (s.filter p).card * (t.filter q).card +
        (s.filter (¬ p ·)).card * (t.filter (¬ q ·)).card 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β) (p : α → Prop) (q : β → Prop) [DecidablePred p] [DecidablePred q]
Goal: (Finset.filter (fun x => p x.1 = q x.2) (s ×ˢ t)).card =
  (Finset.filter p s).card * (Finset.filter q t).card +
    (Finset.filter (fun x => ¬p x) s).card * (Finset.filter (fun x => ¬q x) t).card
-- Finset.empty_product
@[simp]
theorem empty_product (t : Finset β) : (∅ : Finset α) ×ˢ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (t : Finset β)
Goal: ∅ ×ˢ t = ∅
-- Finset.product_empty
@[simp]
theorem product_empty (s : Finset α) : s ×ˢ (∅ : Finset β) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (s : Finset α)
Goal: s ×ˢ ∅ = ∅
-- Finset.Nonempty.product
theorem Nonempty.product (hs : s.Nonempty) (ht : t.Nonempty) : (s ×ˢ t).Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (hs : s.Nonempty) (ht : t.Nonempty)
Goal: (s ×ˢ t).Nonempty
-- Finset.Nonempty.fst
theorem Nonempty.fst (h : (s ×ˢ t).Nonempty) : s.Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (h : (s ×ˢ t).Nonempty)
Goal: s.Nonempty
-- Finset.Nonempty.snd
theorem Nonempty.snd (h : (s ×ˢ t).Nonempty) : t.Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (h : (s ×ˢ t).Nonempty)
Goal: t.Nonempty
-- Finset.nonempty_product
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_product : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}
Goal: (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Finset.product_eq_empty
@[simp]
theorem product_eq_empty {s : Finset α} {t : Finset β} : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}
Goal: s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅
-- Finset.singleton_product
@[simp]
theorem singleton_product {a : α} :
    ({a} : Finset α) ×ˢ t = t.map ⟨Prod.mk a, Prod.mk.inj_left _⟩ 
Arguments: {α : Type u_1} {β : Type u_2} {t : Finset β} {a : α}
Goal: {a} ×ˢ t = Finset.map { toFun := Prod.mk a, inj' := ⋯ } t
-- Finset.product_singleton
@[simp]
theorem product_singleton {b : β} : s ×ˢ {b} = s.map ⟨fun i => (i, b), Prod.mk.inj_right _⟩ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {b : β}
Goal: s ×ˢ {b} = Finset.map { toFun := fun i => (i, b), inj' := ⋯ } s
-- Finset.singleton_product_singleton
theorem singleton_product_singleton {a : α} {b : β} :
    ({a} ×ˢ {b} : Finset _) = {(a, b)} 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β}
Goal: {a} ×ˢ {b} = {(a, b)}
-- Finset.union_product
@[simp]
theorem union_product [DecidableEq α] [DecidableEq β] : (s ∪ s') ×ˢ t = s ×ˢ t ∪ s' ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t : Finset β} [DecidableEq α] [DecidableEq β]
Goal: (s ∪ s') ×ˢ t = s ×ˢ t ∪ s' ×ˢ t
-- Finset.product_union
@[simp]
theorem product_union [DecidableEq α] [DecidableEq β] : s ×ˢ (t ∪ t') = s ×ˢ t ∪ s ×ˢ t' 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} [DecidableEq α] [DecidableEq β]
Goal: s ×ˢ (t ∪ t') = s ×ˢ t ∪ s ×ˢ t'
-- Finset.inter_product
theorem inter_product [DecidableEq α] [DecidableEq β] : (s ∩ s') ×ˢ t = s ×ˢ t ∩ s' ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t : Finset β} [DecidableEq α] [DecidableEq β]
Goal: (s ∩ s') ×ˢ t = s ×ˢ t ∩ s' ×ˢ t
-- Finset.product_inter
theorem product_inter [DecidableEq α] [DecidableEq β] : s ×ˢ (t ∩ t') = s ×ˢ t ∩ s ×ˢ t' 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} [DecidableEq α] [DecidableEq β]
Goal: s ×ˢ (t ∩ t') = s ×ˢ t ∩ s ×ˢ t'
-- Finset.product_inter_product
theorem product_inter_product [DecidableEq α] [DecidableEq β] :
    s ×ˢ t ∩ s' ×ˢ t' = (s ∩ s') ×ˢ (t ∩ t') 
Arguments: {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t t' : Finset β} [DecidableEq α] [DecidableEq β]
Goal: s ×ˢ t ∩ s' ×ˢ t' = (s ∩ s') ×ˢ (t ∩ t')
-- Finset.disjoint_product
theorem disjoint_product : Disjoint (s ×ˢ t) (s' ×ˢ t') ↔ Disjoint s s' ∨ Disjoint t t' 
Arguments: {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t t' : Finset β}
Goal: Disjoint (s ×ˢ t) (s' ×ˢ t') ↔ Disjoint s s' ∨ Disjoint t t'
-- Finset.disjUnion_product
@[simp]
theorem disjUnion_product (hs : Disjoint s s') :
    s.disjUnion s' hs ×ˢ t = (s ×ˢ t).disjUnion (s' ×ˢ t) (disjoint_product.mpr <| Or.inl hs) 
Arguments: {α : Type u_1} {β : Type u_2} {s s' : Finset α} {t : Finset β} (hs : Disjoint s s')
Goal: s.disjUnion s' hs ×ˢ t = (s ×ˢ t).disjUnion (s' ×ˢ t) ⋯
-- Finset.product_disjUnion
@[simp]
theorem product_disjUnion (ht : Disjoint t t') :
    s ×ˢ t.disjUnion t' ht = (s ×ˢ t).disjUnion (s ×ˢ t') (disjoint_product.mpr <| Or.inr ht) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} (ht : Disjoint t t')
Goal: s ×ˢ t.disjUnion t' ht = (s ×ˢ t).disjUnion (s ×ˢ t') ⋯
-- Finset.mem_diag
@[simp]
theorem mem_diag : x ∈ s.diag ↔ x.1 ∈ s ∧ x.1 = x.2 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {x : α × α}
Goal: x ∈ s.diag ↔ x.1 ∈ s ∧ x.1 = x.2
-- Finset.mem_offDiag
@[simp]
theorem mem_offDiag : x ∈ s.offDiag ↔ x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {x : α × α}
Goal: x ∈ s.offDiag ↔ x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2
-- Finset.coe_offDiag
@[simp, norm_cast]
theorem coe_offDiag : (s.offDiag : Set (α × α)) = (s : Set α).offDiag 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: ↑s.offDiag = (↑s).offDiag
-- Finset.diag_card
@[simp]
theorem diag_card : (diag s).card = s.card 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s.diag.card = s.card
-- Finset.offDiag_card
@[simp]
theorem offDiag_card : (offDiag s).card = s.card * s.card - s.card 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s.offDiag.card = s.card * s.card - s.card
-- Finset.diag_mono
@[mono]
theorem diag_mono : Monotone (diag : Finset α → Finset (α × α)) 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Monotone Finset.diag
-- Finset.offDiag_mono
@[mono]
theorem offDiag_mono : Monotone (offDiag : Finset α → Finset (α × α)) 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Monotone Finset.offDiag
-- Finset.diag_empty
@[simp]
theorem diag_empty : (∅ : Finset α).diag = ∅ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: ∅.diag = ∅
-- Finset.offDiag_empty
@[simp]
theorem offDiag_empty : (∅ : Finset α).offDiag = ∅ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: ∅.offDiag = ∅
-- Finset.diag_union_offDiag
@[simp]
theorem diag_union_offDiag : s.diag ∪ s.offDiag = s ×ˢ s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s.diag ∪ s.offDiag = s ×ˢ s
-- Finset.disjoint_diag_offDiag
@[simp]
theorem disjoint_diag_offDiag : Disjoint s.diag s.offDiag 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: Disjoint s.diag s.offDiag
-- Finset.product_sdiff_diag
theorem product_sdiff_diag : s ×ˢ s \ s.diag = s.offDiag 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s ×ˢ s \ s.diag = s.offDiag
-- Finset.product_sdiff_offDiag
theorem product_sdiff_offDiag : s ×ˢ s \ s.offDiag = s.diag 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s ×ˢ s \ s.offDiag = s.diag
-- Finset.diag_inter
theorem diag_inter : (s ∩ t).diag = s.diag ∩ t.diag 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α)
Goal: (s ∩ t).diag = s.diag ∩ t.diag
-- Finset.offDiag_inter
theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α)
Goal: (s ∩ t).offDiag = s.offDiag ∩ t.offDiag
-- Finset.diag_union
theorem diag_union : (s ∪ t).diag = s.diag ∪ t.diag 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α)
Goal: (s ∪ t).diag = s.diag ∪ t.diag
-- Finset.offDiag_union
theorem offDiag_union (h : Disjoint s t) :
    (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : Disjoint s t)
Goal: (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s
-- Finset.offDiag_singleton
@[simp]
theorem offDiag_singleton : ({a} : Finset α).offDiag = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: {a}.offDiag = ∅
-- Finset.diag_singleton
theorem diag_singleton : ({a} : Finset α).diag = {(a, a)} 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: {a}.diag = {(a, a)}
-- Finset.diag_insert
theorem diag_insert : (insert a s).diag = insert (a, a) s.diag 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} (a : α)
Goal: (insert a s).diag = insert (a, a) s.diag
-- Finset.offDiag_insert
theorem offDiag_insert (has : a ∉ s) : (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a} 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} (a : α) (has : a ∉ s)
Goal: (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a}
-- Finset.offDiag_filter_lt_eq_filter_le
theorem offDiag_filter_lt_eq_filter_le {ι}
    [PartialOrder ι] [DecidableEq ι]
    [DecidableRel (LE.le (α := ι))] [DecidableRel (LT.lt (α := ι))]
    (s : Finset ι) :
    s.offDiag.filter (fun i => i.1 < i.2) = s.offDiag.filter (fun i => i.1 ≤ i.2) 
Arguments: {ι : Type u_4} [PartialOrder ι] [DecidableEq ι] [DecidableRel LE.le] [DecidableRel LT.lt] (s : Finset ι)
Goal: Finset.filter (fun i => i.1 < i.2) s.offDiag = Finset.filter (fun i => i.1 ≤ i.2) s.offDiag
-- Multiset.covBy_cons
@[simp] lemma covBy_cons (s : Multiset α) (a : α) : s ⋖ a ::ₘ s 
Arguments: {α : Type u_1} (s : Multiset α) (a : α)
Goal: s ⋖ a ::ₘ s
-- CovBy.exists_multiset_cons
lemma _root_.CovBy.exists_multiset_cons (h : s ⋖ t) : ∃ a, a ::ₘ s = t 
Arguments: {α : Type u_1} {s t : Multiset α} (h : s ⋖ t)
Goal: ∃ a, a ::ₘ s = t
-- Multiset.covBy_iff
lemma covBy_iff : s ⋖ t ↔ ∃ a, a ::ₘ s = t 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s ⋖ t ↔ ∃ a, a ::ₘ s = t
-- CovBy.card_multiset
lemma _root_.CovBy.card_multiset (h : s ⋖ t) : card s ⋖ card t 
Arguments: {α : Type u_1} {s t : Multiset α} (h : s ⋖ t)
Goal: Multiset.card s ⋖ Multiset.card t
-- Multiset.isAtom_iff
lemma isAtom_iff : IsAtom s ↔ ∃ a, s = {a} 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: IsAtom s ↔ ∃ a, s = {a}
-- Multiset.isAtom_singleton
@[simp] lemma isAtom_singleton (a : α) : IsAtom ({a} : Multiset α) 
Arguments: {α : Type u_1} (a : α)
Goal: IsAtom {a}
-- Multiset.grade_eq
@[simp] lemma grade_eq (m : Multiset α) : grade ℕ m = card m 
Arguments: {α : Type u_1} (m : Multiset α)
Goal: grade ℕ m = Multiset.card m
-- Finset.ordConnected_range_val
lemma ordConnected_range_val : Set.OrdConnected (Set.range val : Set <| Multiset α) 
Arguments: {α : Type u_1}
Goal: (Set.range Finset.val).OrdConnected
-- Finset.ordConnected_range_coe
lemma ordConnected_range_coe : Set.OrdConnected (Set.range ((↑) : Finset α → Set α)) 
Arguments: {α : Type u_1}
Goal: (Set.range Finset.toSet).OrdConnected
-- Finset.val_wcovBy_val
@[simp] lemma val_wcovBy_val : s.1 ⩿ t.1 ↔ s ⩿ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s.val ⩿ t.val ↔ s ⩿ t
-- Finset.val_covBy_val
@[simp] lemma val_covBy_val : s.1 ⋖ t.1 ↔ s ⋖ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s.val ⋖ t.val ↔ s ⋖ t
-- Finset.coe_wcovBy_coe
@[simp] lemma coe_wcovBy_coe : (s : Set α) ⩿ t ↔ s ⩿ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: ↑s ⩿ ↑t ↔ s ⩿ t
-- Finset.coe_covBy_coe
@[simp] lemma coe_covBy_coe : (s : Set α) ⋖ t ↔ s ⋖ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: ↑s ⋖ ↑t ↔ s ⋖ t
-- Finset.covBy_cons
@[simp] lemma covBy_cons (ha : a ∉ s) : s ⋖ s.cons a ha 
Arguments: {α : Type u_1} {s : Finset α} {a : α} (ha : a ∉ s)
Goal: s ⋖ Finset.cons a s ha
-- CovBy.exists_finset_cons
lemma _root_.CovBy.exists_finset_cons (h : s ⋖ t) : ∃ a, ∃ ha : a ∉ s, s.cons a ha = t 
Arguments: {α : Type u_1} {s t : Finset α} (h : s ⋖ t)
Goal: ∃ a, ∃ (ha : a ∉ s), Finset.cons a s ha = t
-- Finset.covBy_iff_exists_cons
lemma covBy_iff_exists_cons : s ⋖ t ↔ ∃ a, ∃ ha : a ∉ s, s.cons a ha = t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s ⋖ t ↔ ∃ a, ∃ (ha : a ∉ s), Finset.cons a s ha = t
-- CovBy.card_finset
lemma _root_.CovBy.card_finset (h : s ⋖ t) : s.card ⋖ t.card 
Arguments: {α : Type u_1} {s t : Finset α} (h : s ⋖ t)
Goal: s.card ⋖ t.card
-- Finset.wcovBy_insert
@[simp] lemma wcovBy_insert (s : Finset α) (a : α) : s ⩿ insert a s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) (a : α)
Goal: s ⩿ insert a s
-- Finset.erase_wcovBy
@[simp] lemma erase_wcovBy (s : Finset α) (a : α) : s.erase a ⩿ s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) (a : α)
Goal: s.erase a ⩿ s
-- Finset.covBy_insert
lemma covBy_insert (ha : a ∉ s) : s ⋖ insert a s 
Arguments: {α : Type u_1} {s : Finset α} {a : α} [DecidableEq α] (ha : a ∉ s)
Goal: s ⋖ insert a s
-- Finset.erase_covBy
@[simp] lemma erase_covBy (ha : a ∈ s) : s.erase a ⋖ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α} [DecidableEq α] (ha : a ∈ s)
Goal: s.erase a ⋖ s
-- CovBy.exists_finset_insert
lemma _root_.CovBy.exists_finset_insert (h : s ⋖ t) : ∃ a ∉ s, insert a s = t 
Arguments: {α : Type u_1} {s t : Finset α} [DecidableEq α] (h : s ⋖ t)
Goal: ∃ a ∉ s, insert a s = t
-- CovBy.exists_finset_erase
lemma _root_.CovBy.exists_finset_erase (h : s ⋖ t) : ∃ a ∈ t, t.erase a = s 
Arguments: {α : Type u_1} {s t : Finset α} [DecidableEq α] (h : s ⋖ t)
Goal: ∃ a ∈ t, t.erase a = s
-- Finset.covBy_iff_exists_insert
lemma covBy_iff_exists_insert : s ⋖ t ↔ ∃ a ∉ s, insert a s = t 
Arguments: {α : Type u_1} {s t : Finset α} [DecidableEq α]
Goal: s ⋖ t ↔ ∃ a ∉ s, insert a s = t
-- Finset.covBy_iff_card_sdiff_eq_one
lemma covBy_iff_card_sdiff_eq_one : t ⋖ s ↔ t ⊆ s ∧ (s \ t).card = 1 
Arguments: {α : Type u_1} {s t : Finset α} [DecidableEq α]
Goal: t ⋖ s ↔ t ⊆ s ∧ (s \ t).card = 1