ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PFun.dom_toSubtype
@[simp]
theorem dom_toSubtype (p : β → Prop) (f : α → β) : (toSubtype p f).Dom = { a | p (f a) } 
Arguments: {α : Type u_1} {β : Type u_2} (p : β → Prop) (f : α → β)
Goal: (PFun.toSubtype p f).Dom = {a | p (f a)}
-- PFun.toSubtype_apply
@[simp]
theorem toSubtype_apply (p : β → Prop) (f : α → β) (a : α) :
    toSubtype p f a = ⟨p (f a), Subtype.mk _⟩ 
Arguments: {α : Type u_1} {β : Type u_2} (p : β → Prop) (f : α → β) (a : α)
Goal: PFun.toSubtype p f a = { Dom := p (f a), get := Subtype.mk (f a) }
-- PFun.dom_toSubtype_apply_iff
theorem dom_toSubtype_apply_iff {p : β → Prop} {f : α → β} {a : α} :
    (toSubtype p f a).Dom ↔ p (f a) 
Arguments: {α : Type u_1} {β : Type u_2} {p : β → Prop} {f : α → β} {a : α}
Goal: (PFun.toSubtype p f a).Dom ↔ p (f a)
-- PFun.mem_toSubtype_iff
theorem mem_toSubtype_iff {p : β → Prop} {f : α → β} {a : α} {b : Subtype p} :
    b ∈ toSubtype p f a ↔ ↑b = f a 
Arguments: {α : Type u_1} {β : Type u_2} {p : β → Prop} {f : α → β} {a : α} {b : Subtype p}
Goal: b ∈ PFun.toSubtype p f a ↔ ↑b = f a
-- PFun.coe_id
@[simp]
theorem coe_id (α : Type*) : ((id : α → α) : α →. α) = PFun.id α 
Arguments: (α : Type u_7)
Goal: ↑id = PFun.id α
-- PFun.id_apply
@[simp]
theorem id_apply (a : α) : PFun.id α a = Part.some a 
Arguments: {α : Type u_1} (a : α)
Goal: PFun.id α a = Part.some a
-- PFun.comp_apply
@[simp]
theorem comp_apply (f : β →. γ) (g : α →. β) (a : α) : f.comp g a = (g a).bind f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β →. γ) (g : α →. β) (a : α)
Goal: f.comp g a = (g a).bind f
-- PFun.id_comp
@[simp]
theorem id_comp (f : α →. β) : (PFun.id β).comp f = f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α →. β)
Goal: (PFun.id β).comp f = f
-- PFun.comp_id
@[simp]
theorem comp_id (f : α →. β) : f.comp (PFun.id α) = f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α →. β)
Goal: f.comp (PFun.id α) = f
-- PFun.dom_comp
@[simp]
theorem dom_comp (f : β →. γ) (g : α →. β) : (f.comp g).Dom = g.preimage f.Dom 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β →. γ) (g : α →. β)
Goal: (f.comp g).Dom = g.preimage f.Dom
-- PFun.preimage_comp
@[simp]
theorem preimage_comp (f : β →. γ) (g : α →. β) (s : Set γ) :
    (f.comp g).preimage s = g.preimage (f.preimage s) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β →. γ) (g : α →. β) (s : Set γ)
Goal: (f.comp g).preimage s = g.preimage (f.preimage s)
-- PFun.Part.bind_comp
@[simp]
theorem Part.bind_comp (f : β →. γ) (g : α →. β) (a : Part α) :
    a.bind (f.comp g) = (a.bind g).bind f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β →. γ) (g : α →. β) (a : Part α)
Goal: a.bind (f.comp g) = (a.bind g).bind f
-- PFun.comp_assoc
@[simp]
theorem comp_assoc (f : γ →. δ) (g : β →. γ) (h : α →. β) : (f.comp g).comp h = f.comp (g.comp h) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : γ →. δ) (g : β →. γ) (h : α →. β)
Goal: (f.comp g).comp h = f.comp (g.comp h)
-- PFun.coe_comp
theorem coe_comp (g : β → γ) (f : α → β) : ((g ∘ f : α → γ) : α →. γ) = (g : β →. γ).comp f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β)
Goal: ↑(g ∘ f) = (↑g).comp ↑f
-- PFun.dom_prodLift
@[simp]
theorem dom_prodLift (f : α →. β) (g : α →. γ) :
    (f.prodLift g).Dom = { x | (f x).Dom ∧ (g x).Dom } 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α →. β) (g : α →. γ)
Goal: (f.prodLift g).Dom = {x | (f x).Dom ∧ (g x).Dom}
-- PFun.get_prodLift
theorem get_prodLift (f : α →. β) (g : α →. γ) (x : α) (h) :
    (f.prodLift g x).get h = ((f x).get h.1, (g x).get h.2) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α →. β) (g : α →. γ) (x : α) (h : (f.prodLift g x).Dom)
Goal: (f.prodLift g x).get h = ((f x).get ⋯, (g x).get ⋯)
-- PFun.prodLift_apply
@[simp]
theorem prodLift_apply (f : α →. β) (g : α →. γ) (x : α) :
    f.prodLift g x = ⟨(f x).Dom ∧ (g x).Dom, fun h => ((f x).get h.1, (g x).get h.2)⟩ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α →. β) (g : α →. γ) (x : α)
Goal: f.prodLift g x = { Dom := (f x).Dom ∧ (g x).Dom, get := fun h => ((f x).get ⋯, (g x).get ⋯) }
-- PFun.mem_prodLift
theorem mem_prodLift {f : α →. β} {g : α →. γ} {x : α} {y : β × γ} :
    y ∈ f.prodLift g x ↔ y.1 ∈ f x ∧ y.2 ∈ g x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α →. β} {g : α →. γ} {x : α} {y : β × γ}
Goal: y ∈ f.prodLift g x ↔ y.1 ∈ f x ∧ y.2 ∈ g x
-- PFun.dom_prodMap
@[simp]
theorem dom_prodMap (f : α →. γ) (g : β →. δ) :
    (f.prodMap g).Dom = { x | (f x.1).Dom ∧ (g x.2).Dom } 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α →. γ) (g : β →. δ)
Goal: (f.prodMap g).Dom = {x | (f x.1).Dom ∧ (g x.2).Dom}
-- PFun.get_prodMap
theorem get_prodMap (f : α →. γ) (g : β →. δ) (x : α × β) (h) :
    (f.prodMap g x).get h = ((f x.1).get h.1, (g x.2).get h.2) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α →. γ) (g : β →. δ) (x : α × β) (h : (f.prodMap g x).Dom)
Goal: (f.prodMap g x).get h = ((f x.1).get ⋯, (g x.2).get ⋯)
-- PFun.prodMap_apply
@[simp]
theorem prodMap_apply (f : α →. γ) (g : β →. δ) (x : α × β) :
    f.prodMap g x = ⟨(f x.1).Dom ∧ (g x.2).Dom, fun h => ((f x.1).get h.1, (g x.2).get h.2)⟩ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α →. γ) (g : β →. δ) (x : α × β)
Goal: f.prodMap g x = { Dom := (f x.1).Dom ∧ (g x.2).Dom, get := fun h => ((f x.1).get ⋯, (g x.2).get ⋯) }
-- PFun.mem_prodMap
theorem mem_prodMap {f : α →. γ} {g : β →. δ} {x : α × β} {y : γ × δ} :
    y ∈ f.prodMap g x ↔ y.1 ∈ f x.1 ∧ y.2 ∈ g x.2 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α →. γ} {g : β →. δ} {x : α × β} {y : γ × δ}
Goal: y ∈ f.prodMap g x ↔ y.1 ∈ f x.1 ∧ y.2 ∈ g x.2
-- PFun.prodLift_fst_comp_snd_comp
@[simp]
theorem prodLift_fst_comp_snd_comp (f : α →. γ) (g : β →. δ) :
    prodLift (f.comp ((Prod.fst : α × β → α) : α × β →. α))
        (g.comp ((Prod.snd : α × β → β) : α × β →. β)) =
      prodMap f g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α →. γ) (g : β →. δ)
Goal: (f.comp ↑Prod.fst).prodLift (g.comp ↑Prod.snd) = f.prodMap g
-- PFun.prodMap_id_id
@[simp]
theorem prodMap_id_id : (PFun.id α).prodMap (PFun.id β) = PFun.id _ 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: (PFun.id α).prodMap (PFun.id β) = PFun.id (α × β)
-- PFun.prodMap_comp_comp
@[simp]
theorem prodMap_comp_comp (f₁ : α →. β) (f₂ : β →. γ) (g₁ : δ →. ε) (g₂ : ε →. ι) :
    (f₂.comp f₁).prodMap (g₂.comp g₁) = (f₂.prodMap g₂).comp (f₁.prodMap g₁) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} {ι : Type u_6} (f₁ : α →. β) (f₂ : β →. γ) (g₁ : δ →. ε) (g₂ : ε →. ι)
Goal: (f₂.comp f₁).prodMap (g₂.comp g₁) = (f₂.prodMap g₂).comp (f₁.prodMap g₁)
-- Sym2.Rel.symm
@[symm]
theorem Rel.symm {x y : α × α} : Rel α x y → Rel α y x 
Arguments: {α : Type u_1} {x y : α × α}
Goal: Sym2.Rel α x y → Sym2.Rel α y x
-- Sym2.Rel.trans
@[trans]
theorem Rel.trans {x y z : α × α} (a : Rel α x y) (b : Rel α y z) : Rel α x z 
Arguments: {α : Type u_1} {x y z : α × α} (a : Sym2.Rel α x y) (b : Sym2.Rel α y z)
Goal: Sym2.Rel α x z
-- Sym2.Rel.is_equivalence
theorem Rel.is_equivalence : Equivalence (Rel α) 
Arguments: {α : Type u_1}
Goal: Equivalence (Sym2.Rel α)
-- Sym2.rel_iff'
@[simp]
theorem rel_iff' {p q : α × α} : Rel α p q ↔ p = q ∨ p = q.swap 
Arguments: {α : Type u_1} {p q : α × α}
Goal: Sym2.Rel α p q ↔ p = q ∨ p = q.swap
-- Sym2.rel_iff
theorem rel_iff {x y z w : α} : Rel α (x, y) (z, w) ↔ x = z ∧ y = w ∨ x = w ∧ y = z 
Arguments: {α : Type u_1} {x y z w : α}
Goal: Sym2.Rel α (x, y) (z, w) ↔ x = z ∧ y = w ∨ x = w ∧ y = z
-- Sym2.sound
protected theorem sound {p p' : α × α} (h : Sym2.Rel α p p') : Sym2.mk p = Sym2.mk p' 
Arguments: {α : Type u_1} {p p' : α × α} (h : Sym2.Rel α p p')
Goal: Sym2.mk p = Sym2.mk p'
-- Sym2.exact
protected theorem exact {p p' : α × α} (h : Sym2.mk p = Sym2.mk p') : Sym2.Rel α p p' 
Arguments: {α : Type u_1} {p p' : α × α} (h : Sym2.mk p = Sym2.mk p')
Goal: Sym2.Rel α p p'
-- Sym2.eq
@[simp]
protected theorem eq {p p' : α × α} : Sym2.mk p = Sym2.mk p' ↔ Sym2.Rel α p p' 
Arguments: {α : Type u_1} {p p' : α × α}
Goal: Sym2.mk p = Sym2.mk p' ↔ Sym2.Rel α p p'
-- Sym2.ind
@[elab_as_elim, cases_eliminator, induction_eliminator]
protected theorem ind {f : Sym2 α → Prop} (h : ∀ x y, f s(x, y)) : ∀ i, f i 
Arguments: {α : Type u_1} {f : Sym2 α → Prop} (h : ∀ (x y : α), f s(x, y)) (i : Sym2 α)
Goal: f i
-- Sym2.inductionOn
@[elab_as_elim]
protected theorem inductionOn {f : Sym2 α → Prop} (i : Sym2 α) (hf : ∀ x y, f s(x, y)) : f i 
Arguments: {α : Type u_1} {f : Sym2 α → Prop} (i : Sym2 α) (hf : ∀ (x y : α), f s(x, y))
Goal: f i
-- Sym2.inductionOn₂
@[elab_as_elim]
protected theorem inductionOn₂ {f : Sym2 α → Sym2 β → Prop} (i : Sym2 α) (j : Sym2 β)
    (hf : ∀ a₁ a₂ b₁ b₂, f s(a₁, a₂) s(b₁, b₂)) : f i j 
Arguments: {α : Type u_1} {β : Type u_2} {f : Sym2 α → Sym2 β → Prop} (i : Sym2 α) (j : Sym2 β) (hf : ∀ (a₁ a₂ : α) (b₁ b₂ : β), f s(a₁, a₂) s(b₁, b₂))
Goal: f i j
-- Sym2.exists
protected theorem «exists» {α : Sort _} {f : Sym2 α → Prop} :
    (∃ x : Sym2 α, f x) ↔ ∃ x y, f s(x, y) 
Arguments: {α : Type u_4} {f : Sym2 α → Prop}
Goal: (∃ x, f x) ↔ ∃ x y, f s(x, y)
-- Sym2.forall
protected theorem «forall» {α : Sort _} {f : Sym2 α → Prop} :
    (∀ x : Sym2 α, f x) ↔ ∀ x y, f s(x, y) 
Arguments: {α : Type u_4} {f : Sym2 α → Prop}
Goal: (∀ (x : Sym2 α), f x) ↔ ∀ (x y : α), f s(x, y)
-- Sym2.eq_swap
theorem eq_swap {a b : α} : s(a, b) = s(b, a) 
Arguments: {α : Type u_1} {a b : α}
Goal: s(a, b) = s(b, a)
-- Sym2.mk_prod_swap_eq
@[simp]
theorem mk_prod_swap_eq {p : α × α} : Sym2.mk p.swap = Sym2.mk p 
Arguments: {α : Type u_1} {p : α × α}
Goal: Sym2.mk p.swap = Sym2.mk p
-- Sym2.congr_right
theorem congr_right {a b c : α} : s(a, b) = s(a, c) ↔ b = c 
Arguments: {α : Type u_1} {a b c : α}
Goal: s(a, b) = s(a, c) ↔ b = c
-- Sym2.congr_left
theorem congr_left {a b c : α} : s(b, a) = s(c, a) ↔ b = c 
Arguments: {α : Type u_1} {a b c : α}
Goal: s(b, a) = s(c, a) ↔ b = c
-- Sym2.eq_iff
theorem eq_iff {x y z w : α} : s(x, y) = s(z, w) ↔ x = z ∧ y = w ∨ x = w ∧ y = z 
Arguments: {α : Type u_1} {x y z w : α}
Goal: s(x, y) = s(z, w) ↔ x = z ∧ y = w ∨ x = w ∧ y = z
-- Sym2.mk_eq_mk_iff
theorem mk_eq_mk_iff {p q : α × α} : Sym2.mk p = Sym2.mk q ↔ p = q ∨ p = q.swap 
Arguments: {α : Type u_1} {p q : α × α}
Goal: Sym2.mk p = Sym2.mk q ↔ p = q ∨ p = q.swap
-- Sym2.lift_mk
@[simp]
theorem lift_mk (f : { f : α → α → β // ∀ a₁ a₂, f a₁ a₂ = f a₂ a₁ }) (a₁ a₂ : α) :
    lift f s(a₁, a₂) = (f : α → α → β) a₁ a₂ 
Arguments: {α : Type u_1} {β : Type u_2} (f : { f // ∀ (a₁ a₂ : α), f a₁ a₂ = f a₂ a₁ }) (a₁ a₂ : α)
Goal: Sym2.lift f s(a₁, a₂) = ↑f a₁ a₂
-- Sym2.coe_lift_symm_apply
@[simp]
theorem coe_lift_symm_apply (F : Sym2 α → β) (a₁ a₂ : α) :
    (lift.symm F : α → α → β) a₁ a₂ = F s(a₁, a₂) 
Arguments: {α : Type u_1} {β : Type u_2} (F : Sym2 α → β) (a₁ a₂ : α)
Goal: ↑(Sym2.lift.symm F) a₁ a₂ = F s(a₁, a₂)
-- Sym2.lift₂_mk
@[simp]
theorem lift₂_mk
    (f :
    { f : α → α → β → β → γ //
      ∀ a₁ a₂ b₁ b₂, f a₁ a₂ b₁ b₂ = f a₂ a₁ b₁ b₂ ∧ f a₁ a₂ b₁ b₂ = f a₁ a₂ b₂ b₁ })
    (a₁ a₂ : α) (b₁ b₂ : β) : lift₂ f s(a₁, a₂) s(b₁, b₂) = (f : α → α → β → β → γ) a₁ a₂ b₁ b₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : { f // ∀ (a₁ a₂ : α) (b₁ b₂ : β), f a₁ a₂ b₁ b₂ = f a₂ a₁ b₁ b₂ ∧ f a₁ a₂ b₁ b₂ = f a₁ a₂ b₂ b₁ }) (a₁ a₂ : α) (b₁ b₂ : β)
Goal: Sym2.lift₂ f s(a₁, a₂) s(b₁, b₂) = ↑f a₁ a₂ b₁ b₂
-- Sym2.coe_lift₂_symm_apply
@[simp]
theorem coe_lift₂_symm_apply (F : Sym2 α → Sym2 β → γ) (a₁ a₂ : α) (b₁ b₂ : β) :
    (lift₂.symm F : α → α → β → β → γ) a₁ a₂ b₁ b₂ = F s(a₁, a₂) s(b₁, b₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (F : Sym2 α → Sym2 β → γ) (a₁ a₂ : α) (b₁ b₂ : β)
Goal: ↑(Sym2.lift₂.symm F) a₁ a₂ b₁ b₂ = F s(a₁, a₂) s(b₁, b₂)
-- Sym2.map_id
@[simp]
theorem map_id : map (@id α) = id 
Arguments: {α : Type u_1}
Goal: Sym2.map id = id
-- Sym2.map_comp
theorem map_comp {g : β → γ} {f : α → β} : Sym2.map (g ∘ f) = Sym2.map g ∘ Sym2.map f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {g : β → γ} {f : α → β}
Goal: Sym2.map (g ∘ f) = Sym2.map g ∘ Sym2.map f
-- Sym2.map_map
theorem map_map {g : β → γ} {f : α → β} (x : Sym2 α) : map g (map f x) = map (g ∘ f) x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {g : β → γ} {f : α → β} (x : Sym2 α)
Goal: Sym2.map g (Sym2.map f x) = Sym2.map (g ∘ f) x
-- Sym2.map_pair_eq
@[simp]
theorem map_pair_eq (f : α → β) (x y : α) : map f s(x, y) = s(f x, f y) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x y : α)
Goal: Sym2.map f s(x, y) = s(f x, f y)
-- Sym2.map.injective
theorem map.injective {f : α → β} (hinj : Injective f) : Injective (map f) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} (hinj : Function.Injective f)
Goal: Function.Injective (Sym2.map f)
-- Sym2.mkEmbedding_apply
@[simps]
def mkEmbedding (a : α) : α ↪ Sym2 α 
Arguments: {α : Type u_1} (a b : α)
Goal: (Sym2.mkEmbedding a) b = s(a, b)
-- Function.Embedding.sym2Map_apply
@[simps]
def _root_.Function.Embedding.sym2Map (f : α ↪ β) : Sym2 α ↪ Sym2 β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β)
Goal: ∀ (a : Sym2 α), f.sym2Map a = Sym2.map (⇑f) a
-- Sym2.mem_iff'
@[aesop norm (rule_sets := [Sym2])]
theorem mem_iff' {a b c : α} : Sym2.Mem a s(b, c) ↔ a = b ∨ a = c 
Arguments: {α : Type u_1} {a b c : α}
Goal: Sym2.Mem a s(b, c) ↔ a = b ∨ a = c
-- Sym2.mem_iff_mem
@[simp]
theorem mem_iff_mem {x : α} {z : Sym2 α} : Sym2.Mem x z ↔ x ∈ z 
Arguments: {α : Type u_1} {x : α} {z : Sym2 α}
Goal: Sym2.Mem x z ↔ x ∈ z
-- Sym2.mem_iff_exists
theorem mem_iff_exists {x : α} {z : Sym2 α} : x ∈ z ↔ ∃ y : α, z = s(x, y) 
Arguments: {α : Type u_1} {x : α} {z : Sym2 α}
Goal: x ∈ z ↔ ∃ y, z = s(x, y)
-- Sym2.ext
@[ext]
theorem ext {p q : Sym2 α} (h : ∀ x, x ∈ p ↔ x ∈ q) : p = q 
Arguments: {α : Type u_1} {p q : Sym2 α} (h : ∀ (x : α), x ∈ p ↔ x ∈ q)
Goal: p = q
-- Sym2.mem_mk_left
theorem mem_mk_left (x y : α) : x ∈ s(x, y) 
Arguments: {α : Type u_1} (x y : α)
Goal: x ∈ s(x, y)
-- Sym2.mem_mk_right
theorem mem_mk_right (x y : α) : y ∈ s(x, y) 
Arguments: {α : Type u_1} (x y : α)
Goal: y ∈ s(x, y)
-- Sym2.mem_iff
@[simp, aesop norm (rule_sets := [Sym2])]
theorem mem_iff {a b c : α} : a ∈ s(b, c) ↔ a = b ∨ a = c 
Arguments: {α : Type u_1} {a b c : α}
Goal: a ∈ s(b, c) ↔ a = b ∨ a = c
-- Sym2.out_fst_mem
theorem out_fst_mem (e : Sym2 α) : e.out.1 ∈ e 
Arguments: {α : Type u_1} (e : Sym2 α)
Goal: (Quot.out e).1 ∈ e
-- Sym2.out_snd_mem
theorem out_snd_mem (e : Sym2 α) : e.out.2 ∈ e 
Arguments: {α : Type u_1} (e : Sym2 α)
Goal: (Quot.out e).2 ∈ e
-- Sym2.ball
theorem ball {p : α → Prop} {a b : α} : (∀ c ∈ s(a, b), p c) ↔ p a ∧ p b 
Arguments: {α : Type u_1} {p : α → Prop} {a b : α}
Goal: (∀ c ∈ s(a, b), p c) ↔ p a ∧ p b
-- Sym2.other_spec
@[simp]
theorem other_spec {a : α} {z : Sym2 α} (h : a ∈ z) : s(a, Mem.other h) = z 
Arguments: {α : Type u_1} {a : α} {z : Sym2 α} (h : a ∈ z)
Goal: s(a, Sym2.Mem.other h) = z
-- Sym2.other_mem
theorem other_mem {a : α} {z : Sym2 α} (h : a ∈ z) : Mem.other h ∈ z 
Arguments: {α : Type u_1} {a : α} {z : Sym2 α} (h : a ∈ z)
Goal: Sym2.Mem.other h ∈ z
-- Sym2.mem_and_mem_iff
theorem mem_and_mem_iff {x y : α} {z : Sym2 α} (hne : x ≠ y) : x ∈ z ∧ y ∈ z ↔ z = s(x, y) 
Arguments: {α : Type u_1} {x y : α} {z : Sym2 α} (hne : x ≠ y)
Goal: x ∈ z ∧ y ∈ z ↔ z = s(x, y)
-- Sym2.eq_of_ne_mem
theorem eq_of_ne_mem {x y : α} {z z' : Sym2 α} (h : x ≠ y) (h1 : x ∈ z) (h2 : y ∈ z) (h3 : x ∈ z')
    (h4 : y ∈ z') : z = z' 
Arguments: {α : Type u_1} {x y : α} {z z' : Sym2 α} (h : x ≠ y) (h1 : x ∈ z) (h2 : y ∈ z) (h3 : x ∈ z') (h4 : y ∈ z')
Goal: z = z'
-- Sym2.mem_map
@[simp]
theorem mem_map {f : α → β} {b : β} {z : Sym2 α} : b ∈ Sym2.map f z ↔ ∃ a, a ∈ z ∧ f a = b 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {z : Sym2 α}
Goal: b ∈ Sym2.map f z ↔ ∃ a ∈ z, f a = b
-- Sym2.map_congr
@[congr]
theorem map_congr {f g : α → β} {s : Sym2 α} (h : ∀ x ∈ s, f x = g x) : map f s = map g s 
Arguments: {α : Type u_1} {β : Type u_2} {f g : α → β} {s : Sym2 α} (h : ∀ x ∈ s, f x = g x)
Goal: Sym2.map f s = Sym2.map g s
-- Sym2.map_id'
@[simp]
theorem map_id' : (map fun x : α => x) = id 
Arguments: {α : Type u_1}
Goal: (Sym2.map fun x => x) = id
-- Sym2.diag_injective
theorem diag_injective : Function.Injective (Sym2.diag : α → Sym2 α) 
Arguments: {α : Type u_1}
Goal: Function.Injective Sym2.diag
-- Sym2.mk_isDiag_iff
theorem mk_isDiag_iff {x y : α} : IsDiag s(x, y) ↔ x = y 
Arguments: {α : Type u_1} {x y : α}
Goal: s(x, y).IsDiag ↔ x = y
-- Sym2.isDiag_iff_proj_eq
@[simp]
theorem isDiag_iff_proj_eq (z : α × α) : IsDiag (Sym2.mk z) ↔ z.1 = z.2 
Arguments: {α : Type u_1} (z : α × α)
Goal: (Sym2.mk z).IsDiag ↔ z.1 = z.2
-- Sym2.IsDiag.map
protected lemma IsDiag.map : e.IsDiag → (e.map f).IsDiag 
Arguments: {α : Type u_1} {β : Type u_2} {e : Sym2 α} {f : α → β}
Goal: e.IsDiag → (Sym2.map f e).IsDiag
-- Sym2.isDiag_map
lemma isDiag_map (hf : Injective f) : (e.map f).IsDiag ↔ e.IsDiag 
Arguments: {α : Type u_1} {β : Type u_2} {e : Sym2 α} {f : α → β} (hf : Function.Injective f)
Goal: (Sym2.map f e).IsDiag ↔ e.IsDiag
-- Sym2.diag_isDiag
@[simp]
theorem diag_isDiag (a : α) : IsDiag (diag a) 
Arguments: {α : Type u_1} (a : α)
Goal: (Sym2.diag a).IsDiag
-- Sym2.IsDiag.mem_range_diag
theorem IsDiag.mem_range_diag {z : Sym2 α} : IsDiag z → z ∈ Set.range (@diag α) 
Arguments: {α : Type u_1} {z : Sym2 α}
Goal: z.IsDiag → z ∈ Set.range Sym2.diag
-- Sym2.isDiag_iff_mem_range_diag
theorem isDiag_iff_mem_range_diag (z : Sym2 α) : IsDiag z ↔ z ∈ Set.range (@diag α) 
Arguments: {α : Type u_1} (z : Sym2 α)
Goal: z.IsDiag ↔ z ∈ Set.range Sym2.diag
-- Sym2.other_ne
theorem other_ne {a : α} {z : Sym2 α} (hd : ¬IsDiag z) (h : a ∈ z) : Mem.other h ≠ a 
Arguments: {α : Type u_1} {a : α} {z : Sym2 α} (hd : ¬z.IsDiag) (h : a ∈ z)
Goal: Sym2.Mem.other h ≠ a
-- Sym2.fromRel_proj_prop
@[simp]
theorem fromRel_proj_prop {sym : Symmetric r} {z : α × α} : Sym2.mk z ∈ fromRel sym ↔ r z.1 z.2 
Arguments: {α : Type u_1} {r : α → α → Prop} {sym : Symmetric r} {z : α × α}
Goal: Sym2.mk z ∈ Sym2.fromRel sym ↔ r z.1 z.2
-- Sym2.fromRel_prop
theorem fromRel_prop {sym : Symmetric r} {a b : α} : s(a, b) ∈ fromRel sym ↔ r a b 
Arguments: {α : Type u_1} {r : α → α → Prop} {sym : Symmetric r} {a b : α}
Goal: s(a, b) ∈ Sym2.fromRel sym ↔ r a b
-- Sym2.fromRel_bot
theorem fromRel_bot : fromRel (fun (x y : α) z => z : Symmetric ⊥) = ∅ 
Arguments: {α : Type u_1}
Goal: Sym2.fromRel ⋯ = ∅
-- Sym2.fromRel_top
theorem fromRel_top : fromRel (fun (x y : α) z => z : Symmetric ⊤) = Set.univ 
Arguments: {α : Type u_1}
Goal: Sym2.fromRel ⋯ = Set.univ
-- Sym2.fromRel_ne
theorem fromRel_ne : fromRel (fun (x y : α) z => z.symm : Symmetric Ne) = {z | ¬IsDiag z} 
Arguments: {α : Type u_1}
Goal: Sym2.fromRel ⋯ = {z | ¬z.IsDiag}
-- Sym2.fromRel_irreflexive
theorem fromRel_irreflexive {sym : Symmetric r} :
    Irreflexive r ↔ ∀ {z}, z ∈ fromRel sym → ¬IsDiag z 
Arguments: {α : Type u_1} {r : α → α → Prop} {sym : Symmetric r}
Goal: Irreflexive r ↔ ∀ {z : Sym2 α}, z ∈ Sym2.fromRel sym → ¬z.IsDiag
-- Sym2.mem_fromRel_irrefl_other_ne
theorem mem_fromRel_irrefl_other_ne {sym : Symmetric r} (irrefl : Irreflexive r) {a : α}
    {z : Sym2 α} (hz : z ∈ fromRel sym) (h : a ∈ z) : Mem.other h ≠ a 
Arguments: {α : Type u_1} {r : α → α → Prop} {sym : Symmetric r} (irrefl : Irreflexive r) {a : α} {z : Sym2 α} (hz : z ∈ Sym2.fromRel sym) (h : a ∈ z)
Goal: Sym2.Mem.other h ≠ a
-- Sym2.toRel_prop
@[simp]
theorem toRel_prop (s : Set (Sym2 α)) (x y : α) : ToRel s x y ↔ s(x, y) ∈ s 
Arguments: {α : Type u_1} (s : Set (Sym2 α)) (x y : α)
Goal: Sym2.ToRel s x y ↔ s(x, y) ∈ s
-- Sym2.toRel_symmetric
theorem toRel_symmetric (s : Set (Sym2 α)) : Symmetric (ToRel s) 
Arguments: {α : Type u_1} (s : Set (Sym2 α))
Goal: Symmetric (Sym2.ToRel s)
-- Sym2.toRel_fromRel
theorem toRel_fromRel (sym : Symmetric r) : ToRel (fromRel sym) = r 
Arguments: {α : Type u_1} {r : α → α → Prop} (sym : Symmetric r)
Goal: Sym2.ToRel (Sym2.fromRel sym) = r
-- Sym2.fromRel_toRel
theorem fromRel_toRel (s : Set (Sym2 α)) : fromRel (toRel_symmetric s) = s 
Arguments: {α : Type u_1} (s : Set (Sym2 α))
Goal: Sym2.fromRel ⋯ = s
-- _private.Mathlib.Data.Sym.Sym2.0.Sym2.perm_card_two_iff
private theorem perm_card_two_iff {a₁ b₁ a₂ b₂ : α} :
    [a₁, b₁].Perm [a₂, b₂] ↔ a₁ = a₂ ∧ b₁ = b₂ ∨ a₁ = b₂ ∧ b₁ = a₂ 
Arguments: {α : Type u_1} {a₁ b₁ a₂ b₂ : α}
Goal: [a₁, b₁].Perm [a₂, b₂] ↔ a₁ = a₂ ∧ b₁ = b₂ ∨ a₁ = b₂ ∧ b₁ = a₂
-- Sym2.other_spec'
@[simp]
theorem other_spec' [DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z) : s(a, Mem.other' h) = z 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z)
Goal: s(a, Sym2.Mem.other' h) = z
-- Sym2.other_eq_other'
@[simp]
theorem other_eq_other' [DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z) :
    Mem.other h = Mem.other' h 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z)
Goal: Sym2.Mem.other h = Sym2.Mem.other' h
-- Sym2.other_mem'
theorem other_mem' [DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z) : Mem.other' h ∈ z 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {z : Sym2 α} (h : a ∈ z)
Goal: Sym2.Mem.other' h ∈ z
-- Sym2.other_invol'
theorem other_invol' [DecidableEq α] {a : α} {z : Sym2 α} (ha : a ∈ z) (hb : Mem.other' ha ∈ z) :
    Mem.other' hb = a 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {z : Sym2 α} (ha : a ∈ z) (hb : Sym2.Mem.other' ha ∈ z)
Goal: Sym2.Mem.other' hb = a
-- Sym2.other_invol
theorem other_invol {a : α} {z : Sym2 α} (ha : a ∈ z) (hb : Mem.other ha ∈ z) :
    Mem.other hb = a 
Arguments: {α : Type u_1} {a : α} {z : Sym2 α} (ha : a ∈ z) (hb : Sym2.Mem.other ha ∈ z)
Goal: Sym2.Mem.other hb = a
-- Sym2.filter_image_mk_isDiag
theorem filter_image_mk_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Sym2.mk).filter IsDiag = s.diag.image Sym2.mk 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: Finset.filter Sym2.IsDiag (Finset.image Sym2.mk (s ×ˢ s)) = Finset.image Sym2.mk s.diag
-- Sym2.filter_image_mk_not_isDiag
theorem filter_image_mk_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Sym2.mk).filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Sym2.mk 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: Finset.filter (fun a => ¬a.IsDiag) (Finset.image Sym2.mk (s ×ˢ s)) = Finset.image Sym2.mk s.offDiag
-- PFunctor.map_eq_map
@[simp]
theorem map_eq_map {α β : Type v} (f : α → β) (x : P α) : f <$> x = P.map f x 
Arguments: (P : PFunctor.{u}) {α β : Type v} (f : α → β) (x : ↑P α)
Goal: f <$> x = P.map f x
-- PFunctor.map_eq
@[simp]
protected theorem map_eq (f : α → β) (a : P.A) (g : P.B a → α) :
    P.map f ⟨a, g⟩ = ⟨a, f ∘ g⟩ 
Arguments: (P : PFunctor.{u}) {α : Type v₁} {β : Type v₂} (f : α → β) (a : P.A) (g : P.B a → α)
Goal: P.map f ⟨a, g⟩ = ⟨a, f ∘ g⟩
-- PFunctor.id_map
@[simp]
protected theorem id_map : ∀ x : P α, P.map id x = x 
Arguments: (P : PFunctor.{u}) {α : Type v₁} (x : ↑P α)
Goal: P.map id x = x
-- PFunctor.map_map
@[simp]
protected theorem map_map (f : α → β) (g : β → γ) :
    ∀ x : P α, P.map g (P.map f x) = P.map (g ∘ f) x 
Arguments: (P : PFunctor.{u}) {α : Type v₁} {β : Type v₂} {γ : Type v₃} (f : α → β) (g : β → γ) (x : ↑P α)
Goal: P.map g (P.map f x) = P.map (g ∘ f) x
-- PFunctor.W.dest_mk
@[simp]
theorem W.dest_mk (p : P (W P)) : W.dest (W.mk p) = p 
Arguments: {P : PFunctor.{u}} (p : ↑P P.W)
Goal: (PFunctor.W.mk p).dest = p
-- PFunctor.W.mk_dest
@[simp]
theorem W.mk_dest (p : W P) : W.mk (W.dest p) = p 
Arguments: {P : PFunctor.{u}} (p : P.W)
Goal: PFunctor.W.mk p.dest = p
-- PFunctor.fst_map
@[simp]
theorem fst_map (x : P α) (f : α → β) : (P.map f x).1 = x.1 
Arguments: {P : PFunctor.{u}} {α : Type v₁} {β : Type v₂} (x : ↑P α) (f : α → β)
Goal: (P.map f x).fst = x.fst
-- PFunctor.iget_map
@[simp]
theorem iget_map [DecidableEq P.A] [Inhabited α] [Inhabited β] (x : P α)
    (f : α → β) (i : P.Idx) (h : i.1 = x.1) : (P.map f x).iget i = f (x.iget i) 
Arguments: {P : PFunctor.{u}} {α : Type v₁} {β : Type v₂} [DecidableEq P.A] [Inhabited α] [Inhabited β] (x : ↑P α) (f : α → β) (i : P.Idx) (h : i.fst = x.fst)
Goal: (P.map f x).iget i = f (x.iget i)