ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PProd.forall'
theorem forall' {p : α → β → Prop} : (∀ x : PProd α β, p x.1 x.2) ↔ ∀ a b, p a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → β → Prop}
Goal: (∀ (x : PProd α β), p x.fst x.snd) ↔ ∀ (a : α) (b : β), p a b
-- PProd.exists'
theorem exists' {p : α → β → Prop} : (∃ x : PProd α β, p x.1 x.2) ↔ ∃ a b, p a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → β → Prop}
Goal: (∃ x, p x.fst x.snd) ↔ ∃ a b, p a b
-- Function.Injective.pprod_map
theorem Function.Injective.pprod_map {f : α → β} {g : γ → δ} (hf : Injective f) (hg : Injective g) :
    Injective (fun x ↦ ⟨f x.1, g x.2⟩ : PProd α γ → PProd β δ) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {f : α → β} {g : γ → δ} (hf : Function.Injective f) (hg : Function.Injective g)
Goal: Function.Injective fun x => ⟨f x.fst, g x.snd⟩
-- Set.IsPWO.smul
@[to_additive]
theorem IsPWO.smul [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P]
    {s : Set G} {t : Set P} (hs : s.IsPWO) (ht : t.IsPWO) : IsPWO (s • t) 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} (hs : s.IsPWO) (ht : t.IsPWO)
Goal: (s • t).IsPWO
-- Set.IsPWO.vadd
@[to_additive]
theorem IsPWO.smul [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P]
    {s : Set G} {t : Set P} (hs : s.IsPWO) (ht : t.IsPWO) : IsPWO (s • t) 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} (hs : s.IsPWO) (ht : t.IsPWO)
Goal: (s +ᵥ t).IsPWO
-- Set.IsWF.vadd
@[to_additive]
theorem IsWF.smul [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G}
    {t : Set P} (hs : s.IsWF) (ht : t.IsWF) : IsWF (s • t) 
Arguments: {G : Type u_1} {P : Type u_2} [LinearOrder G] [LinearOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF)
Goal: (s +ᵥ t).IsWF
-- Set.IsWF.smul
@[to_additive]
theorem IsWF.smul [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G}
    {t : Set P} (hs : s.IsWF) (ht : t.IsWF) : IsWF (s • t) 
Arguments: {G : Type u_1} {P : Type u_2} [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF)
Goal: (s • t).IsWF
-- Set.IsWF.min_vadd
@[to_additive]
theorem IsWF.min_smul [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P]
    {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty) (htn : t.Nonempty) :
    (hs.smul ht).min (hsn.smul htn) = hs.min hsn • ht.min htn 
Arguments: {G : Type u_1} {P : Type u_2} [LinearOrder G] [LinearOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty) (htn : t.Nonempty)
Goal: ⋯.min ⋯ = hs.min hsn +ᵥ ht.min htn
-- Set.IsWF.min_smul
@[to_additive]
theorem IsWF.min_smul [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P]
    {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty) (htn : t.Nonempty) :
    (hs.smul ht).min (hsn.smul htn) = hs.min hsn • ht.min htn 
Arguments: {G : Type u_1} {P : Type u_2} [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty) (htn : t.Nonempty)
Goal: ⋯.min ⋯ = hs.min hsn • ht.min htn
-- Finset.mem_smulAntidiagonal
@[to_additive (attr := simp)]
theorem mem_smulAntidiagonal :
    x ∈ SMulAntidiagonal hs ht a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 • x.2 = a 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} (hs : s.IsPWO) (ht : t.IsPWO) (a : P) {x : G × P}
Goal: x ∈ Finset.SMulAntidiagonal hs ht a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 • x.2 = a
-- Finset.mem_vaddAntidiagonal
@[to_additive (attr := simp)]
theorem mem_smulAntidiagonal :
    x ∈ SMulAntidiagonal hs ht a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 • x.2 = a 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} (hs : s.IsPWO) (ht : t.IsPWO) (a : P) {x : G × P}
Goal: x ∈ Finset.VAddAntidiagonal hs ht a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 +ᵥ x.2 = a
-- Finset.smulAntidiagonal_mono_left
@[to_additive]
theorem smulAntidiagonal_mono_left {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : u ⊆ s) :
    SMulAntidiagonal hu ht a ⊆ SMulAntidiagonal hs ht a 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} {u : Set G} {hu : u.IsPWO} {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : u ⊆ s)
Goal: Finset.SMulAntidiagonal hu ht a ⊆ Finset.SMulAntidiagonal hs ht a
-- Finset.vaddAntidiagonal_mono_left
@[to_additive]
theorem smulAntidiagonal_mono_left {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : u ⊆ s) :
    SMulAntidiagonal hu ht a ⊆ SMulAntidiagonal hs ht a 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} {u : Set G} {hu : u.IsPWO} {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : u ⊆ s)
Goal: Finset.VAddAntidiagonal hu ht a ⊆ Finset.VAddAntidiagonal hs ht a
-- Finset.smulAntidiagonal_mono_right
@[to_additive]
theorem smulAntidiagonal_mono_right {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : v ⊆ t) :
    SMulAntidiagonal hs hv a ⊆ SMulAntidiagonal hs ht a 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t v : Set P} {hv : v.IsPWO} {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : v ⊆ t)
Goal: Finset.SMulAntidiagonal hs hv a ⊆ Finset.SMulAntidiagonal hs ht a
-- Finset.vaddAntidiagonal_mono_right
@[to_additive]
theorem smulAntidiagonal_mono_right {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : v ⊆ t) :
    SMulAntidiagonal hs hv a ⊆ SMulAntidiagonal hs ht a 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t v : Set P} {hv : v.IsPWO} {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : v ⊆ t)
Goal: Finset.VAddAntidiagonal hs hv a ⊆ Finset.VAddAntidiagonal hs ht a
-- Finset.support_smulAntidiagonal_subset_smul
@[to_additive]
theorem support_smulAntidiagonal_subset_smul {hs : s.IsPWO} {ht : t.IsPWO} :
    { a | (SMulAntidiagonal hs ht a).Nonempty } ⊆ (s • t) 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} {hs : s.IsPWO} {ht : t.IsPWO}
Goal: {a | (Finset.SMulAntidiagonal hs ht a).Nonempty} ⊆ s • t
-- Finset.support_vaddAntidiagonal_subset_vadd
@[to_additive]
theorem support_smulAntidiagonal_subset_smul {hs : s.IsPWO} {ht : t.IsPWO} :
    { a | (SMulAntidiagonal hs ht a).Nonempty } ⊆ (s • t) 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} {hs : s.IsPWO} {ht : t.IsPWO}
Goal: {a | (Finset.VAddAntidiagonal hs ht a).Nonempty} ⊆ s +ᵥ t
-- Finset.isPWO_support_smulAntidiagonal
@[to_additive]
theorem isPWO_support_smulAntidiagonal {hs : s.IsPWO} {ht : t.IsPWO} :
    { a | (SMulAntidiagonal hs ht a).Nonempty }.IsPWO 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} {hs : s.IsPWO} {ht : t.IsPWO}
Goal: {a | (Finset.SMulAntidiagonal hs ht a).Nonempty}.IsPWO
-- Finset.isPWO_support_vaddAntidiagonal
@[to_additive]
theorem isPWO_support_smulAntidiagonal {hs : s.IsPWO} {ht : t.IsPWO} :
    { a | (SMulAntidiagonal hs ht a).Nonempty }.IsPWO 
Arguments: {G : Type u_1} {P : Type u_2} [PartialOrder G] [PartialOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} {hs : s.IsPWO} {ht : t.IsPWO}
Goal: {a | (Finset.VAddAntidiagonal hs ht a).Nonempty}.IsPWO
-- Finset.smulAntidiagonal_min_smul_min
@[to_additive]
theorem smulAntidiagonal_min_smul_min [LinearOrder G] [LinearOrder P] [SMul G P]
    [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hns : s.Nonempty)
    (hnt : t.Nonempty) :
    SMulAntidiagonal hs.isPWO ht.isPWO (hs.min hns • ht.min hnt) = {(hs.min hns, ht.min hnt)} 
Arguments: {G : Type u_1} {P : Type u_2} [LinearOrder G] [LinearOrder P] [SMul G P] [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hns : s.Nonempty) (hnt : t.Nonempty)
Goal: Finset.SMulAntidiagonal ⋯ ⋯ (hs.min hns • ht.min hnt) = {(hs.min hns, ht.min hnt)}
-- Finset.vaddAntidiagonal_min_vadd_min
@[to_additive]
theorem smulAntidiagonal_min_smul_min [LinearOrder G] [LinearOrder P] [SMul G P]
    [IsOrderedCancelSMul G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hns : s.Nonempty)
    (hnt : t.Nonempty) :
    SMulAntidiagonal hs.isPWO ht.isPWO (hs.min hns • ht.min hnt) = {(hs.min hns, ht.min hnt)} 
Arguments: {G : Type u_1} {P : Type u_2} [LinearOrder G] [LinearOrder P] [VAdd G P] [IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} (hs : s.IsWF) (ht : t.IsWF) (hns : s.Nonempty) (hnt : t.Nonempty)
Goal: Finset.VAddAntidiagonal ⋯ ⋯ (hs.min hns +ᵥ ht.min hnt) = {(hs.min hns, ht.min hnt)}
-- Sigma.card_Icc
theorem card_Icc : (Icc a b).card = if h : a.1 = b.1 then (Icc (h.rec a.2) b.2).card else 0 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) × α i)
Goal: (Finset.Icc a b).card = if h : a.fst = b.fst then (Finset.Icc (h ▸ a.snd) b.snd).card else 0
-- Sigma.card_Ico
theorem card_Ico : (Ico a b).card = if h : a.1 = b.1 then (Ico (h.rec a.2) b.2).card else 0 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) × α i)
Goal: (Finset.Ico a b).card = if h : a.fst = b.fst then (Finset.Ico (h ▸ a.snd) b.snd).card else 0
-- Sigma.card_Ioc
theorem card_Ioc : (Ioc a b).card = if h : a.1 = b.1 then (Ioc (h.rec a.2) b.2).card else 0 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) × α i)
Goal: (Finset.Ioc a b).card = if h : a.fst = b.fst then (Finset.Ioc (h ▸ a.snd) b.snd).card else 0
-- Sigma.card_Ioo
theorem card_Ioo : (Ioo a b).card = if h : a.1 = b.1 then (Ioo (h.rec a.2) b.2).card else 0 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) × α i)
Goal: (Finset.Ioo a b).card = if h : a.fst = b.fst then (Finset.Ioo (h ▸ a.snd) b.snd).card else 0
-- Sigma.Icc_mk_mk
@[simp]
theorem Icc_mk_mk : Icc (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Icc a b).map (Embedding.sigmaMk i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (i : ι) (a b : α i)
Goal: Finset.Icc ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Icc a b)
-- Sigma.Ico_mk_mk
@[simp]
theorem Ico_mk_mk : Ico (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Ico a b).map (Embedding.sigmaMk i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (i : ι) (a b : α i)
Goal: Finset.Ico ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Ico a b)
-- Sigma.Ioc_mk_mk
@[simp]
theorem Ioc_mk_mk : Ioc (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Ioc a b).map (Embedding.sigmaMk i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (i : ι) (a b : α i)
Goal: Finset.Ioc ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Ioc a b)
-- Sigma.Ioo_mk_mk
@[simp]
theorem Ioo_mk_mk : Ioo (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Ioo a b).map (Embedding.sigmaMk i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [DecidableEq ι] [(i : ι) → Preorder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (i : ι) (a b : α i)
Goal: Finset.Ioo ⟨i, a⟩ ⟨i, b⟩ = Finset.map (Function.Embedding.sigmaMk i) (Finset.Ioo a b)
-- Prod.Lex.le_iff
theorem le_iff [LT α] [LE β] (a b : α × β) :
    toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LE β] (a b : α × β)
Goal: toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2
-- Prod.Lex.lt_iff
theorem lt_iff [LT α] [LT β] (a b : α × β) :
    toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] (a b : α × β)
Goal: toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2
-- Prod.Lex.monotone_fst
theorem monotone_fst [Preorder α] [LE β] (t c : α ×ₗ β) (h : t ≤ c) :
    (ofLex t).1 ≤ (ofLex c).1 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [LE β] (t c : Lex (α × β)) (h : t ≤ c)
Goal: (ofLex t).1 ≤ (ofLex c).1
-- Prod.Lex.toLex_mono
theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) 
Arguments: {α : Type u_1} {β : Type u_2} [PartialOrder α] [Preorder β]
Goal: Monotone ⇑toLex
-- Prod.Lex.toLex_strictMono
theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) 
Arguments: {α : Type u_1} {β : Type u_2} [PartialOrder α] [Preorder β]
Goal: StrictMono ⇑toLex
-- Finset.sym2_val
@[simps]
protected def sym2 (s : Finset α) : Finset (Sym2 α) 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s.sym2.val = s.val.sym2
-- Finset.mk_mem_sym2_iff
theorem mk_mem_sym2_iff : s(a, b) ∈ s.sym2 ↔ a ∈ s ∧ b ∈ s 
Arguments: {α : Type u_1} {s : Finset α} {a b : α}
Goal: s(a, b) ∈ s.sym2 ↔ a ∈ s ∧ b ∈ s
-- Finset.mem_sym2_iff
@[simp]
theorem mem_sym2_iff {m : Sym2 α} : m ∈ s.sym2 ↔ ∀ a ∈ m, a ∈ s 
Arguments: {α : Type u_1} {s : Finset α} {m : Sym2 α}
Goal: m ∈ s.sym2 ↔ ∀ a ∈ m, a ∈ s
-- Finset.sym2_cons
theorem sym2_cons (a : α) (s : Finset α) (ha : a ∉ s) :
    (s.cons a ha).sym2 = ((s.cons a ha).map <| Sym2.mkEmbedding a).disjUnion s.sym2 (by
      simp [Finset.disjoint_left, ha]) 
Arguments: {α : Type u_1} (a : α) (s : Finset α) (ha : a ∉ s)
Goal: (Finset.cons a s ha).sym2 = (Finset.map (Sym2.mkEmbedding a) (Finset.cons a s ha)).disjUnion s.sym2 ⋯
-- Finset.sym2_insert
theorem sym2_insert [DecidableEq α] (a : α) (s : Finset α) :
    (insert a s).sym2 = ((insert a s).image fun b => s(a, b)) ∪ s.sym2 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Finset α)
Goal: (insert a s).sym2 = Finset.image (fun b => s(a, b)) (insert a s) ∪ s.sym2
-- Finset.sym2_map
theorem sym2_map (f : α ↪ β) (s : Finset α) : (s.map f).sym2 = s.sym2.map (.sym2Map f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) (s : Finset α)
Goal: (Finset.map f s).sym2 = Finset.map f.sym2Map s.sym2
-- Finset.sym2_image
theorem sym2_image [DecidableEq β] (f : α → β) (s : Finset α) :
    (s.image f).sym2 = s.sym2.image (Sym2.map f) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (f : α → β) (s : Finset α)
Goal: (Finset.image f s).sym2 = Finset.image (Sym2.map f) s.sym2
-- Finset.sym2_univ
@[simp]
theorem sym2_univ [Fintype α] (inst : Fintype (Sym2 α) := Sym2.instFintype) :
    (univ : Finset α).sym2 = univ 
Arguments: {α : Type u_1} [Fintype α] (inst : Fintype (Sym2 α) := Sym2.instFintype)
Goal: Finset.univ.sym2 = Finset.univ
-- Finset.sym2_mono
@[simp, mono]
theorem sym2_mono (h : s ⊆ t) : s.sym2 ⊆ t.sym2 
Arguments: {α : Type u_1} {s t : Finset α} (h : s ⊆ t)
Goal: s.sym2 ⊆ t.sym2
-- Finset.monotone_sym2
theorem monotone_sym2 : Monotone (Finset.sym2 : Finset α → _) 
Arguments: {α : Type u_1}
Goal: Monotone Finset.sym2
-- Finset.injective_sym2
theorem injective_sym2 : Function.Injective (Finset.sym2 : Finset α → _) 
Arguments: {α : Type u_1}
Goal: Function.Injective Finset.sym2
-- Finset.strictMono_sym2
theorem strictMono_sym2 : StrictMono (Finset.sym2 : Finset α → _) 
Arguments: {α : Type u_1}
Goal: StrictMono Finset.sym2
-- Finset.sym2_toFinset
theorem sym2_toFinset [DecidableEq α] (m : Multiset α) :
    m.toFinset.sym2 = m.sym2.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: m.toFinset.sym2 = m.sym2.toFinset
-- Finset.sym2_empty
@[simp]
theorem sym2_empty : (∅ : Finset α).sym2 = ∅ 
Arguments: {α : Type u_1}
Goal: ∅.sym2 = ∅
-- Finset.sym2_eq_empty
@[simp]
theorem sym2_eq_empty : s.sym2 = ∅ ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.sym2 = ∅ ↔ s = ∅
-- Finset.sym2_nonempty
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem sym2_nonempty : s.sym2.Nonempty ↔ s.Nonempty 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.sym2.Nonempty ↔ s.Nonempty
-- Finset.sym2_singleton
@[simp]
theorem sym2_singleton (a : α) : ({a} : Finset α).sym2 = {Sym2.diag a} 
Arguments: {α : Type u_1} (a : α)
Goal: {a}.sym2 = {Sym2.diag a}
-- Finset.card_sym2
theorem card_sym2 (s : Finset α) : s.sym2.card = Nat.choose (s.card + 1) 2 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s.sym2.card = (s.card + 1).choose 2
-- Finset.sym2_eq_image
theorem sym2_eq_image : s.sym2 = (s ×ˢ s).image Sym2.mk 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α}
Goal: s.sym2 = Finset.image Sym2.mk (s ×ˢ s)
-- Finset.isDiag_mk_of_mem_diag
theorem isDiag_mk_of_mem_diag {a : α × α} (h : a ∈ s.diag) : (Sym2.mk a).IsDiag 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {a : α × α} (h : a ∈ s.diag)
Goal: (Sym2.mk a).IsDiag
-- Finset.not_isDiag_mk_of_mem_offDiag
theorem not_isDiag_mk_of_mem_offDiag {a : α × α} (h : a ∈ s.offDiag) :
    ¬ (Sym2.mk a).IsDiag 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {a : α × α} (h : a ∈ s.offDiag)
Goal: ¬(Sym2.mk a).IsDiag
-- Finset.diag_mem_sym2_mem_iff
@[simp]
theorem diag_mem_sym2_mem_iff : (∀ b, b ∈ Sym2.diag a → b ∈ s) ↔ a ∈ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: (∀ b ∈ Sym2.diag a, b ∈ s) ↔ a ∈ s
-- Finset.diag_mem_sym2_iff
theorem diag_mem_sym2_iff : Sym2.diag a ∈ s.sym2 ↔ a ∈ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: Sym2.diag a ∈ s.sym2 ↔ a ∈ s
-- Finset.image_diag_union_image_offDiag
theorem image_diag_union_image_offDiag :
    s.diag.image Sym2.mk ∪ s.offDiag.image Sym2.mk = s.sym2 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α}
Goal: Finset.image Sym2.mk s.diag ∪ Finset.image Sym2.mk s.offDiag = s.sym2
-- Finset.sym_zero
@[simp]
theorem sym_zero : s.sym 0 = {∅} 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α}
Goal: s.sym 0 = {∅}
-- Finset.sym_succ
@[simp]
theorem sym_succ : s.sym (n + 1) = s.sup fun a ↦ (s.sym n).image <| Sym.cons a 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {n : ℕ}
Goal: s.sym (n + 1) = s.sup fun a => Finset.image (Sym.cons a) (s.sym n)
-- Finset.mem_sym_iff
@[simp]
theorem mem_sym_iff {m : Sym α n} : m ∈ s.sym n ↔ ∀ a ∈ m, a ∈ s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {n : ℕ} {m : Sym α n}
Goal: m ∈ s.sym n ↔ ∀ a ∈ m, a ∈ s
-- Finset.sym_empty
@[simp]
theorem sym_empty (n : ℕ) : (∅ : Finset α).sym (n + 1) = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] (n : ℕ)
Goal: ∅.sym (n + 1) = ∅
-- Finset.replicate_mem_sym
theorem replicate_mem_sym (ha : a ∈ s) (n : ℕ) : Sym.replicate n a ∈ s.sym n 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {a : α} (ha : a ∈ s) (n : ℕ)
Goal: Sym.replicate n a ∈ s.sym n
-- Finset.Nonempty.sym
protected theorem Nonempty.sym (h : s.Nonempty) (n : ℕ) : (s.sym n).Nonempty 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} (h : s.Nonempty) (n : ℕ)
Goal: (s.sym n).Nonempty
-- Finset.sym_singleton
@[simp]
theorem sym_singleton (a : α) (n : ℕ) : ({a} : Finset α).sym n = {Sym.replicate n a} 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (n : ℕ)
Goal: {a}.sym n = {Sym.replicate n a}
-- Finset.eq_empty_of_sym_eq_empty
theorem eq_empty_of_sym_eq_empty (h : s.sym n = ∅) : s = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {n : ℕ} (h : s.sym n = ∅)
Goal: s = ∅
-- Finset.sym_eq_empty
@[simp]
theorem sym_eq_empty : s.sym n = ∅ ↔ n ≠ 0 ∧ s = ∅ 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {n : ℕ}
Goal: s.sym n = ∅ ↔ n ≠ 0 ∧ s = ∅
-- Finset.sym_nonempty
@[simp]
theorem sym_nonempty : (s.sym n).Nonempty ↔ n = 0 ∨ s.Nonempty 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {n : ℕ}
Goal: (s.sym n).Nonempty ↔ n = 0 ∨ s.Nonempty
-- Finset.sym_univ
@[simp]
theorem sym_univ [Fintype α] (n : ℕ) : (univ : Finset α).sym n = univ 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (n : ℕ)
Goal: Finset.univ.sym n = Finset.univ
-- Finset.sym_mono
@[simp]
theorem sym_mono (h : s ⊆ t) (n : ℕ) : s.sym n ⊆ t.sym n 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : s ⊆ t) (n : ℕ)
Goal: s.sym n ⊆ t.sym n
-- Finset.sym_inter
@[simp]
theorem sym_inter (s t : Finset α) (n : ℕ) : (s ∩ t).sym n = s.sym n ∩ t.sym n 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α) (n : ℕ)
Goal: (s ∩ t).sym n = s.sym n ∩ t.sym n
-- Finset.sym_union
@[simp]
theorem sym_union (s t : Finset α) (n : ℕ) : s.sym n ∪ t.sym n ⊆ (s ∪ t).sym n 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α) (n : ℕ)
Goal: s.sym n ∪ t.sym n ⊆ (s ∪ t).sym n
-- Finset.sym_fill_mem
theorem sym_fill_mem (a : α) {i : Fin (n + 1)} {m : Sym α (n - i)} (h : m ∈ s.sym (n - i)) :
    m.fill a i ∈ (insert a s).sym n 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {n : ℕ} (a : α) {i : Fin (n + 1)} {m : Sym α (n - ↑i)} (h : m ∈ s.sym (n - ↑i))
Goal: Sym.fill a i m ∈ (insert a s).sym n
-- Finset.sym_filterNe_mem
theorem sym_filterNe_mem {m : Sym α n} (a : α) (h : m ∈ s.sym n) :
    (m.filterNe a).2 ∈ (Finset.erase s a).sym (n - (m.filterNe a).1) 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {n : ℕ} {m : Sym α n} (a : α) (h : m ∈ s.sym n)
Goal: (Sym.filterNe a m).snd ∈ (s.erase a).sym (n - ↑(Sym.filterNe a m).fst)
-- Finset.symInsertEquiv_symm_apply_coe
@[simps]
def symInsertEquiv (h : a ∉ s) : (insert a s).sym n ≃ Σi : Fin (n + 1), s.sym (n - i) 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {a : α} {n : ℕ} (h : a ∉ s) (m : (i : Fin (n + 1)) × { x // x ∈ s.sym (n - ↑i) })
Goal: ↑((Finset.symInsertEquiv h).symm m) = Sym.fill a m.fst ↑m.snd
-- Finset.symInsertEquiv_apply_fst
@[simps]
def symInsertEquiv (h : a ∉ s) : (insert a s).sym n ≃ Σi : Fin (n + 1), s.sym (n - i) 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {a : α} {n : ℕ} (h : a ∉ s) (m : { x // x ∈ (insert a s).sym n })
Goal: ((Finset.symInsertEquiv h) m).fst = (Sym.filterNe a ↑m).fst
-- Finset.symInsertEquiv_apply_snd_coe
@[simps]
def symInsertEquiv (h : a ∉ s) : (insert a s).sym n ≃ Σi : Fin (n + 1), s.sym (n - i) 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {a : α} {n : ℕ} (h : a ∉ s) (m : { x // x ∈ (insert a s).sym n })
Goal: ↑((Finset.symInsertEquiv h) m).snd = (Sym.filterNe a ↑m).snd
-- Sigma.lex_iff
theorem lex_iff : Lex r s a b ↔ r a.1 b.1 ∨ ∃ h : a.1 = b.1, s b.1 (h.rec a.2) b.2 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} {a b : (i : ι) × α i}
Goal: Sigma.Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd
-- Sigma.Lex.mono
theorem Lex.mono (hr : ∀ a b, r₁ a b → r₂ a b) (hs : ∀ i a b, s₁ i a b → s₂ i a b) {a b : Σ i, α i}
    (h : Lex r₁ s₁ a b) : Lex r₂ s₂ a b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {r₁ r₂ : ι → ι → Prop} {s₁ s₂ : (i : ι) → α i → α i → Prop} (hr : ∀ (a b : ι), r₁ a b → r₂ a b) (hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b) {a b : (i : ι) × α i} (h : Sigma.Lex r₁ s₁ a b)
Goal: Sigma.Lex r₂ s₂ a b
-- Sigma.Lex.mono_left
theorem Lex.mono_left (hr : ∀ a b, r₁ a b → r₂ a b) {a b : Σ i, α i} (h : Lex r₁ s a b) :
    Lex r₂ s a b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {r₁ r₂ : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hr : ∀ (a b : ι), r₁ a b → r₂ a b) {a b : (i : ι) × α i} (h : Sigma.Lex r₁ s a b)
Goal: Sigma.Lex r₂ s a b
-- Sigma.Lex.mono_right
theorem Lex.mono_right (hs : ∀ i a b, s₁ i a b → s₂ i a b) {a b : Σ i, α i} (h : Lex r s₁ a b) :
    Lex r s₂ a b 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {r : ι → ι → Prop} {s₁ s₂ : (i : ι) → α i → α i → Prop} (hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b) {a b : (i : ι) × α i} (h : Sigma.Lex r s₁ a b)
Goal: Sigma.Lex r s₂ a b
-- Sigma.lex_swap
theorem lex_swap : Lex (Function.swap r) s a b ↔ Lex r (fun i => Function.swap (s i)) b a 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} {a b : (i : ι) × α i}
Goal: Sigma.Lex (Function.swap r) s a b ↔ Sigma.Lex r (fun i => Function.swap (s i)) b a