ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Part.left_dom_of_mod_dom
theorem left_dom_of_mod_dom [Mod α] {a b : Part α} (hab : Dom (a % b)) : a.Dom 
Arguments: {α : Type u_1} [Mod α] {a b : Part α} (hab : (a % b).Dom)
Goal: a.Dom
-- Part.right_dom_of_mod_dom
theorem right_dom_of_mod_dom [Mod α] {a b : Part α} (hab : Dom (a % b)) : b.Dom 
Arguments: {α : Type u_1} [Mod α] {a b : Part α} (hab : (a % b).Dom)
Goal: b.Dom
-- Part.mod_get_eq
@[simp]
theorem mod_get_eq [Mod α] (a b : Part α) (hab : Dom (a % b)) :
    (a % b).get hab = a.get (left_dom_of_mod_dom hab) % b.get (right_dom_of_mod_dom hab) 
Arguments: {α : Type u_1} [Mod α] (a b : Part α) (hab : (a % b).Dom)
Goal: (a % b).get hab = a.get ⋯ % b.get ⋯
-- Part.some_mod_some
theorem some_mod_some [Mod α] (a b : α) : some a % some b = some (a % b) 
Arguments: {α : Type u_1} [Mod α] (a b : α)
Goal: Part.some a % Part.some b = Part.some (a % b)
-- Part.append_mem_append
theorem append_mem_append [Append α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma ++ mb ∈ a ++ b 
Arguments: {α : Type u_1} [Append α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma ++ mb ∈ a ++ b
-- Part.left_dom_of_append_dom
theorem left_dom_of_append_dom [Append α] {a b : Part α} (hab : Dom (a ++ b)) : a.Dom 
Arguments: {α : Type u_1} [Append α] {a b : Part α} (hab : (a ++ b).Dom)
Goal: a.Dom
-- Part.right_dom_of_append_dom
theorem right_dom_of_append_dom [Append α] {a b : Part α} (hab : Dom (a ++ b)) : b.Dom 
Arguments: {α : Type u_1} [Append α] {a b : Part α} (hab : (a ++ b).Dom)
Goal: b.Dom
-- Part.append_get_eq
@[simp]
theorem append_get_eq [Append α] (a b : Part α) (hab : Dom (a ++ b)) : (a ++ b).get hab =
    a.get (left_dom_of_append_dom hab) ++ b.get (right_dom_of_append_dom hab) 
Arguments: {α : Type u_1} [Append α] (a b : Part α) (hab : (a ++ b).Dom)
Goal: (a ++ b).get hab = a.get ⋯ ++ b.get ⋯
-- Part.some_append_some
theorem some_append_some [Append α] (a b : α) : some a ++ some b = some (a ++ b) 
Arguments: {α : Type u_1} [Append α] (a b : α)
Goal: Part.some a ++ Part.some b = Part.some (a ++ b)
-- Part.inter_mem_inter
theorem inter_mem_inter [Inter α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma ∩ mb ∈ a ∩ b 
Arguments: {α : Type u_1} [Inter α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma ∩ mb ∈ a ∩ b
-- Part.left_dom_of_inter_dom
theorem left_dom_of_inter_dom [Inter α] {a b : Part α} (hab : Dom (a ∩ b)) : a.Dom 
Arguments: {α : Type u_1} [Inter α] {a b : Part α} (hab : (a ∩ b).Dom)
Goal: a.Dom
-- Part.right_dom_of_inter_dom
theorem right_dom_of_inter_dom [Inter α] {a b : Part α} (hab : Dom (a ∩ b)) : b.Dom 
Arguments: {α : Type u_1} [Inter α] {a b : Part α} (hab : (a ∩ b).Dom)
Goal: b.Dom
-- Part.inter_get_eq
@[simp]
theorem inter_get_eq [Inter α] (a b : Part α) (hab : Dom (a ∩ b)) :
    (a ∩ b).get hab = a.get (left_dom_of_inter_dom hab) ∩ b.get (right_dom_of_inter_dom hab) 
Arguments: {α : Type u_1} [Inter α] (a b : Part α) (hab : (a ∩ b).Dom)
Goal: (a ∩ b).get hab = a.get ⋯ ∩ b.get ⋯
-- Part.some_inter_some
theorem some_inter_some [Inter α] (a b : α) : some a ∩ some b = some (a ∩ b) 
Arguments: {α : Type u_1} [Inter α] (a b : α)
Goal: Part.some a ∩ Part.some b = Part.some (a ∩ b)
-- Part.union_mem_union
theorem union_mem_union [Union α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma ∪ mb ∈ a ∪ b 
Arguments: {α : Type u_1} [Union α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma ∪ mb ∈ a ∪ b
-- Part.left_dom_of_union_dom
theorem left_dom_of_union_dom [Union α] {a b : Part α} (hab : Dom (a ∪ b)) : a.Dom 
Arguments: {α : Type u_1} [Union α] {a b : Part α} (hab : (a ∪ b).Dom)
Goal: a.Dom
-- Part.right_dom_of_union_dom
theorem right_dom_of_union_dom [Union α] {a b : Part α} (hab : Dom (a ∪ b)) : b.Dom 
Arguments: {α : Type u_1} [Union α] {a b : Part α} (hab : (a ∪ b).Dom)
Goal: b.Dom
-- Part.union_get_eq
@[simp]
theorem union_get_eq [Union α] (a b : Part α) (hab : Dom (a ∪ b)) :
    (a ∪ b).get hab = a.get (left_dom_of_union_dom hab) ∪ b.get (right_dom_of_union_dom hab) 
Arguments: {α : Type u_1} [Union α] (a b : Part α) (hab : (a ∪ b).Dom)
Goal: (a ∪ b).get hab = a.get ⋯ ∪ b.get ⋯
-- Part.some_union_some
theorem some_union_some [Union α] (a b : α) : some a ∪ some b = some (a ∪ b) 
Arguments: {α : Type u_1} [Union α] (a b : α)
Goal: Part.some a ∪ Part.some b = Part.some (a ∪ b)
-- Part.sdiff_mem_sdiff
theorem sdiff_mem_sdiff [SDiff α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma \ mb ∈ a \ b 
Arguments: {α : Type u_1} [SDiff α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b)
Goal: ma \ mb ∈ a \ b
-- Part.left_dom_of_sdiff_dom
theorem left_dom_of_sdiff_dom [SDiff α] {a b : Part α} (hab : Dom (a \ b)) : a.Dom 
Arguments: {α : Type u_1} [SDiff α] {a b : Part α} (hab : (a \ b).Dom)
Goal: a.Dom
-- Part.right_dom_of_sdiff_dom
theorem right_dom_of_sdiff_dom [SDiff α] {a b : Part α} (hab : Dom (a \ b)) : b.Dom 
Arguments: {α : Type u_1} [SDiff α] {a b : Part α} (hab : (a \ b).Dom)
Goal: b.Dom
-- Part.sdiff_get_eq
@[simp]
theorem sdiff_get_eq [SDiff α] (a b : Part α) (hab : Dom (a \ b)) :
    (a \ b).get hab = a.get (left_dom_of_sdiff_dom hab) \ b.get (right_dom_of_sdiff_dom hab) 
Arguments: {α : Type u_1} [SDiff α] (a b : Part α) (hab : (a \ b).Dom)
Goal: (a \ b).get hab = a.get ⋯ \ b.get ⋯
-- Part.some_sdiff_some
theorem some_sdiff_some [SDiff α] (a b : α) : some a \ some b = some (a \ b) 
Arguments: {α : Type u_1} [SDiff α] (a b : α)
Goal: Part.some a \ Part.some b = Part.some (a \ b)
-- PEquiv.inv
structure PEquiv (α : Type u) (β : Type v) where
    toFun : α → Option β
    invFun : β → Option α
    inv : ∀ (a : α) (b : β), a ∈ invFun b ↔ b ∈ toFun a
Arguments: {α : Type u} {β : Type v} (self : α ≃. β) (a : α) (b : β)
Goal: a ∈ self.invFun b ↔ b ∈ self.toFun a
-- PEquiv.coe_mk
@[simp] theorem coe_mk (f₁ : α → Option β) (f₂ h) : (mk f₁ f₂ h : α → Option β) = f₁ 
Arguments: {α : Type u} {β : Type v} (f₁ : α → Option β) (f₂ : β → Option α) (h : ∀ (a : α) (b : β), a ∈ f₂ b ↔ b ∈ f₁ a)
Goal: ⇑{ toFun := f₁, invFun := f₂, inv := h } = f₁
-- PEquiv.coe_mk_apply
theorem coe_mk_apply (f₁ : α → Option β) (f₂ : β → Option α) (h) (x : α) :
    (PEquiv.mk f₁ f₂ h : α → Option β) x = f₁ x 
Arguments: {α : Type u} {β : Type v} (f₁ : α → Option β) (f₂ : β → Option α) (h : ∀ (a : α) (b : β), a ∈ f₂ b ↔ b ∈ f₁ a) (x : α)
Goal: { toFun := f₁, invFun := f₂, inv := h } x = f₁ x
-- PEquiv.ext
@[ext] theorem ext {f g : α ≃. β} (h : ∀ x, f x = g x) : f = g 
Arguments: {α : Type u} {β : Type v} {f g : α ≃. β} (h : ∀ (x : α), f x = g x)
Goal: f = g
-- PEquiv.ext_iff
theorem ext_iff {f g : α ≃. β} : f = g ↔ ∀ x, f x = g x 
Arguments: {α : Type u} {β : Type v} {f g : α ≃. β}
Goal: f = g ↔ ∀ (x : α), f x = g x
-- PEquiv.mem_iff_mem
theorem mem_iff_mem (f : α ≃. β) : ∀ {a : α} {b : β}, a ∈ f.symm b ↔ b ∈ f a 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β) {a : α} {b : β}
Goal: a ∈ f.symm b ↔ b ∈ f a
-- PEquiv.eq_some_iff
theorem eq_some_iff (f : α ≃. β) : ∀ {a : α} {b : β}, f.symm b = some a ↔ f a = some b 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β) {a : α} {b : β}
Goal: f.symm b = some a ↔ f a = some b
-- PEquiv.refl_apply
@[simp]
theorem refl_apply (a : α) : PEquiv.refl α a = some a 
Arguments: {α : Type u} (a : α)
Goal: (PEquiv.refl α) a = some a
-- PEquiv.symm_refl
@[simp]
theorem symm_refl : (PEquiv.refl α).symm = PEquiv.refl α 
Arguments: {α : Type u}
Goal: (PEquiv.refl α).symm = PEquiv.refl α
-- PEquiv.symm_symm
@[simp]
theorem symm_symm (f : α ≃. β) : f.symm.symm = f 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β)
Goal: f.symm.symm = f
-- PEquiv.symm_bijective
theorem symm_bijective : Function.Bijective (PEquiv.symm : (α ≃. β) → β ≃. α) 
Arguments: {α : Type u} {β : Type v}
Goal: Function.Bijective PEquiv.symm
-- PEquiv.symm_injective
theorem symm_injective : Function.Injective (@PEquiv.symm α β) 
Arguments: {α : Type u} {β : Type v}
Goal: Function.Injective PEquiv.symm
-- PEquiv.trans_assoc
theorem trans_assoc (f : α ≃. β) (g : β ≃. γ) (h : γ ≃. δ) :
    (f.trans g).trans h = f.trans (g.trans h) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} (f : α ≃. β) (g : β ≃. γ) (h : γ ≃. δ)
Goal: (f.trans g).trans h = f.trans (g.trans h)
-- PEquiv.mem_trans
theorem mem_trans (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ) :
    c ∈ f.trans g a ↔ ∃ b, b ∈ f a ∧ c ∈ g b 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ)
Goal: c ∈ (f.trans g) a ↔ ∃ b ∈ f a, c ∈ g b
-- PEquiv.trans_eq_some
theorem trans_eq_some (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ) :
    f.trans g a = some c ↔ ∃ b, f a = some b ∧ g b = some c 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ)
Goal: (f.trans g) a = some c ↔ ∃ b, f a = some b ∧ g b = some c
-- PEquiv.trans_eq_none
theorem trans_eq_none (f : α ≃. β) (g : β ≃. γ) (a : α) :
    f.trans g a = none ↔ ∀ b c, b ∉ f a ∨ c ∉ g b 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α ≃. β) (g : β ≃. γ) (a : α)
Goal: (f.trans g) a = none ↔ ∀ (b : β) (c : γ), b ∉ f a ∨ c ∉ g b
-- PEquiv.refl_trans
@[simp]
theorem refl_trans (f : α ≃. β) : (PEquiv.refl α).trans f = f 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β)
Goal: (PEquiv.refl α).trans f = f
-- PEquiv.trans_refl
@[simp]
theorem trans_refl (f : α ≃. β) : f.trans (PEquiv.refl β) = f 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β)
Goal: f.trans (PEquiv.refl β) = f
-- PEquiv.inj
protected theorem inj (f : α ≃. β) {a₁ a₂ : α} {b : β} (h₁ : b ∈ f a₁) (h₂ : b ∈ f a₂) :
    a₁ = a₂ 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β) {a₁ a₂ : α} {b : β} (h₁ : b ∈ f a₁) (h₂ : b ∈ f a₂)
Goal: a₁ = a₂
-- PEquiv.injective_of_forall_ne_isSome
theorem injective_of_forall_ne_isSome (f : α ≃. β) (a₂ : α)
    (h : ∀ a₁ : α, a₁ ≠ a₂ → isSome (f a₁)) : Injective f 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β) (a₂ : α) (h : ∀ (a₁ : α), a₁ ≠ a₂ → (f a₁).isSome = true)
Goal: Function.Injective ⇑f
-- PEquiv.injective_of_forall_isSome
theorem injective_of_forall_isSome {f : α ≃. β} (h : ∀ a : α, isSome (f a)) : Injective f 
Arguments: {α : Type u} {β : Type v} {f : α ≃. β} (h : ∀ (a : α), (f a).isSome = true)
Goal: Function.Injective ⇑f
-- PEquiv.mem_ofSet_self_iff
theorem mem_ofSet_self_iff {s : Set α} [DecidablePred (· ∈ s)] {a : α} : a ∈ ofSet s a ↔ a ∈ s 
Arguments: {α : Type u} {s : Set α} [DecidablePred fun x => x ∈ s] {a : α}
Goal: a ∈ (PEquiv.ofSet s) a ↔ a ∈ s
-- PEquiv.mem_ofSet_iff
theorem mem_ofSet_iff {s : Set α} [DecidablePred (· ∈ s)] {a b : α} :
    a ∈ ofSet s b ↔ a = b ∧ a ∈ s 
Arguments: {α : Type u} {s : Set α} [DecidablePred fun x => x ∈ s] {a b : α}
Goal: a ∈ (PEquiv.ofSet s) b ↔ a = b ∧ a ∈ s
-- PEquiv.ofSet_eq_some_iff
@[simp]
theorem ofSet_eq_some_iff {s : Set α} {_ : DecidablePred (· ∈ s)} {a b : α} :
    ofSet s b = some a ↔ a = b ∧ a ∈ s 
Arguments: {α : Type u} {s : Set α}
Goal: ∀ {x : DecidablePred fun x => x ∈ s} {a b : α}, (PEquiv.ofSet s) b = some a ↔ a = b ∧ a ∈ s
-- PEquiv.ofSet_eq_some_self_iff
theorem ofSet_eq_some_self_iff {s : Set α} {_ : DecidablePred (· ∈ s)} {a : α} :
    ofSet s a = some a ↔ a ∈ s 
Arguments: {α : Type u} {s : Set α}
Goal: ∀ {x : DecidablePred fun x => x ∈ s} {a : α}, (PEquiv.ofSet s) a = some a ↔ a ∈ s
-- PEquiv.ofSet_symm
@[simp]
theorem ofSet_symm : (ofSet s).symm = ofSet s 
Arguments: {α : Type u} (s : Set α) [DecidablePred fun x => x ∈ s]
Goal: (PEquiv.ofSet s).symm = PEquiv.ofSet s
-- PEquiv.ofSet_univ
@[simp]
theorem ofSet_univ : ofSet Set.univ = PEquiv.refl α 
Arguments: {α : Type u}
Goal: PEquiv.ofSet Set.univ = PEquiv.refl α
-- PEquiv.ofSet_eq_refl
@[simp]
theorem ofSet_eq_refl {s : Set α} [DecidablePred (· ∈ s)] :
    ofSet s = PEquiv.refl α ↔ s = Set.univ 
Arguments: {α : Type u} {s : Set α} [DecidablePred fun x => x ∈ s]
Goal: PEquiv.ofSet s = PEquiv.refl α ↔ s = Set.univ
-- PEquiv.symm_trans_rev
theorem symm_trans_rev (f : α ≃. β) (g : β ≃. γ) : (f.trans g).symm = g.symm.trans f.symm 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α ≃. β) (g : β ≃. γ)
Goal: (f.trans g).symm = g.symm.trans f.symm
-- PEquiv.self_trans_symm
theorem self_trans_symm (f : α ≃. β) : f.trans f.symm = ofSet { a | (f a).isSome } 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β)
Goal: f.trans f.symm = PEquiv.ofSet {a | (f a).isSome = true}
-- PEquiv.symm_trans_self
theorem symm_trans_self (f : α ≃. β) : f.symm.trans f = ofSet { b | (f.symm b).isSome } 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β)
Goal: f.symm.trans f = PEquiv.ofSet {b | (f.symm b).isSome = true}
-- PEquiv.trans_symm_eq_iff_forall_isSome
theorem trans_symm_eq_iff_forall_isSome {f : α ≃. β} :
    f.trans f.symm = PEquiv.refl α ↔ ∀ a, isSome (f a) 
Arguments: {α : Type u} {β : Type v} {f : α ≃. β}
Goal: f.trans f.symm = PEquiv.refl α ↔ ∀ (a : α), (f a).isSome = true
-- PEquiv.bot_apply
@[simp]
theorem bot_apply (a : α) : (⊥ : α ≃. β) a = none 
Arguments: {α : Type u} {β : Type v} (a : α)
Goal: ⊥ a = none
-- PEquiv.symm_bot
@[simp]
theorem symm_bot : (⊥ : α ≃. β).symm = ⊥ 
Arguments: {α : Type u} {β : Type v}
Goal: ⊥.symm = ⊥
-- PEquiv.trans_bot
@[simp]
theorem trans_bot (f : α ≃. β) : f.trans (⊥ : β ≃. γ) = ⊥ 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α ≃. β)
Goal: f.trans ⊥ = ⊥
-- PEquiv.bot_trans
@[simp]
theorem bot_trans (f : β ≃. γ) : (⊥ : α ≃. β).trans f = ⊥ 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : β ≃. γ)
Goal: ⊥.trans f = ⊥
-- PEquiv.isSome_symm_get
theorem isSome_symm_get (f : α ≃. β) {a : α} (h : isSome (f a)) :
    isSome (f.symm (Option.get _ h)) 
Arguments: {α : Type u} {β : Type v} (f : α ≃. β) {a : α} (h : (f a).isSome = true)
Goal: (f.symm ((f a).get h)).isSome = true
-- PEquiv.mem_single
theorem mem_single (a : α) (b : β) : b ∈ single a b a 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] (a : α) (b : β)
Goal: b ∈ (PEquiv.single a b) a
-- PEquiv.mem_single_iff
theorem mem_single_iff (a₁ a₂ : α) (b₁ b₂ : β) : b₁ ∈ single a₂ b₂ a₁ ↔ a₁ = a₂ ∧ b₁ = b₂ 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] (a₁ a₂ : α) (b₁ b₂ : β)
Goal: b₁ ∈ (PEquiv.single a₂ b₂) a₁ ↔ a₁ = a₂ ∧ b₁ = b₂
-- PEquiv.symm_single
@[simp]
theorem symm_single (a : α) (b : β) : (single a b).symm = single b a 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] (a : α) (b : β)
Goal: (PEquiv.single a b).symm = PEquiv.single b a
-- PEquiv.single_apply
@[simp]
theorem single_apply (a : α) (b : β) : single a b a = some b 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] (a : α) (b : β)
Goal: (PEquiv.single a b) a = some b
-- PEquiv.single_apply_of_ne
theorem single_apply_of_ne {a₁ a₂ : α} (h : a₁ ≠ a₂) (b : β) : single a₁ b a₂ = none 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] {a₁ a₂ : α} (h : a₁ ≠ a₂) (b : β)
Goal: (PEquiv.single a₁ b) a₂ = none
-- PEquiv.single_trans_of_mem
theorem single_trans_of_mem (a : α) {b : β} {c : γ} {f : β ≃. γ} (h : c ∈ f b) :
    (single a b).trans f = single a c 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [DecidableEq α] [DecidableEq β] [DecidableEq γ] (a : α) {b : β} {c : γ} {f : β ≃. γ} (h : c ∈ f b)
Goal: (PEquiv.single a b).trans f = PEquiv.single a c
-- PEquiv.trans_single_of_mem
theorem trans_single_of_mem {a : α} {b : β} (c : γ) {f : α ≃. β} (h : b ∈ f a) :
    f.trans (single b c) = single a c 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [DecidableEq α] [DecidableEq β] [DecidableEq γ] {a : α} {b : β} (c : γ) {f : α ≃. β} (h : b ∈ f a)
Goal: f.trans (PEquiv.single b c) = PEquiv.single a c
-- PEquiv.single_trans_single
@[simp]
theorem single_trans_single (a : α) (b : β) (c : γ) :
    (single a b).trans (single b c) = single a c 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [DecidableEq α] [DecidableEq β] [DecidableEq γ] (a : α) (b : β) (c : γ)
Goal: (PEquiv.single a b).trans (PEquiv.single b c) = PEquiv.single a c
-- PEquiv.single_subsingleton_eq_refl
@[simp]
theorem single_subsingleton_eq_refl [Subsingleton α] (a b : α) : single a b = PEquiv.refl α 
Arguments: {α : Type u} [DecidableEq α] [Subsingleton α] (a b : α)
Goal: PEquiv.single a b = PEquiv.refl α
-- PEquiv.trans_single_of_eq_none
theorem trans_single_of_eq_none {b : β} (c : γ) {f : δ ≃. β} (h : f.symm b = none) :
    f.trans (single b c) = ⊥ 
Arguments: {β : Type v} {γ : Type w} {δ : Type x} [DecidableEq β] [DecidableEq γ] {b : β} (c : γ) {f : δ ≃. β} (h : f.symm b = none)
Goal: f.trans (PEquiv.single b c) = ⊥
-- PEquiv.single_trans_of_eq_none
theorem single_trans_of_eq_none (a : α) {b : β} {f : β ≃. δ} (h : f b = none) :
    (single a b).trans f = ⊥ 
Arguments: {α : Type u} {β : Type v} {δ : Type x} [DecidableEq α] [DecidableEq β] (a : α) {b : β} {f : β ≃. δ} (h : f b = none)
Goal: (PEquiv.single a b).trans f = ⊥
-- PEquiv.single_trans_single_of_ne
theorem single_trans_single_of_ne {b₁ b₂ : β} (h : b₁ ≠ b₂) (a : α) (c : γ) :
    (single a b₁).trans (single b₂ c) = ⊥ 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [DecidableEq α] [DecidableEq β] [DecidableEq γ] {b₁ b₂ : β} (h : b₁ ≠ b₂) (a : α) (c : γ)
Goal: (PEquiv.single a b₁).trans (PEquiv.single b₂ c) = ⊥
-- PEquiv.le_def
theorem le_def {f g : α ≃. β} : f ≤ g ↔ ∀ (a : α) (b : β), b ∈ f a → b ∈ g a 
Arguments: {α : Type u} {β : Type v} {f g : α ≃. β}
Goal: f ≤ g ↔ ∀ (a : α), ∀ b ∈ f a, b ∈ g a
-- Equiv.toPEquiv_refl
@[simp]
theorem toPEquiv_refl : (Equiv.refl α).toPEquiv = PEquiv.refl α 
Arguments: {α : Type u_1}
Goal: (Equiv.refl α).toPEquiv = PEquiv.refl α
-- Equiv.toPEquiv_trans
theorem toPEquiv_trans (f : α ≃ β) (g : β ≃ γ) :
    (f.trans g).toPEquiv = f.toPEquiv.trans g.toPEquiv 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α ≃ β) (g : β ≃ γ)
Goal: (f.trans g).toPEquiv = f.toPEquiv.trans g.toPEquiv
-- Equiv.toPEquiv_symm
theorem toPEquiv_symm (f : α ≃ β) : f.symm.toPEquiv = f.toPEquiv.symm 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ≃ β)
Goal: f.symm.toPEquiv = f.toPEquiv.symm
-- Equiv.toPEquiv_apply
theorem toPEquiv_apply (f : α ≃ β) (x : α) : f.toPEquiv x = some (f x) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ≃ β) (x : α)
Goal: f.toPEquiv x = some (f x)
-- Set.mem_prod_list_ofFn
@[to_additive]
theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i ↦ (f i : α)).prod = a 
Arguments: {α : Type u_2} [Monoid α] {n : ℕ} {a : α} {s : Fin n → Set α}
Goal: a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
-- Set.mem_sum_list_ofFn
@[to_additive]
theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i ↦ (f i : α)).prod = a 
Arguments: {α : Type u_2} [AddMonoid α] {n : ℕ} {a : α} {s : Fin n → Set α}
Goal: a ∈ (List.ofFn s).sum ↔ ∃ f, (List.ofFn fun i => ↑(f i)).sum = a
-- Set.mem_list_prod
@[to_additive]
theorem mem_list_prod {l : List (Set α)} {a : α} :
    a ∈ l.prod ↔
      ∃ l' : List (Σs : Set α, ↥s),
        List.prod (l'.map fun x ↦ (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l 
Arguments: {α : Type u_2} [Monoid α] {l : List (Set α)} {a : α}
Goal: a ∈ l.prod ↔ ∃ l', (List.map (fun x => ↑x.snd) l').prod = a ∧ List.map Sigma.fst l' = l
-- Set.mem_list_sum
@[to_additive]
theorem mem_list_prod {l : List (Set α)} {a : α} :
    a ∈ l.prod ↔
      ∃ l' : List (Σs : Set α, ↥s),
        List.prod (l'.map fun x ↦ (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l 
Arguments: {α : Type u_2} [AddMonoid α] {l : List (Set α)} {a : α}
Goal: a ∈ l.sum ↔ ∃ l', (List.map (fun x => ↑x.snd) l').sum = a ∧ List.map Sigma.fst l' = l
-- Set.mem_pow
@[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i ↦ (f i : α)).prod = a 
Arguments: {α : Type u_2} [Monoid α] {s : Set α} {a : α} {n : ℕ}
Goal: a ∈ s ^ n ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
-- Set.mem_nsmul
@[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i ↦ (f i : α)).prod = a 
Arguments: {α : Type u_2} [AddMonoid α] {s : Set α} {a : α} {n : ℕ}
Goal: a ∈ n • s ↔ ∃ f, (List.ofFn fun i => ↑(f i)).sum = a
-- List.keys_nil
@[simp]
theorem keys_nil : @keys α β [] = [] 
Arguments: {α : Type u} {β : α → Type v}
Goal: [].keys = []
-- List.keys_cons
@[simp]
theorem keys_cons {s} {l : List (Sigma β)} : (s :: l).keys = s.1 :: l.keys 
Arguments: {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)}
Goal: (s :: l).keys = s.fst :: l.keys
-- List.mem_keys_of_mem
theorem mem_keys_of_mem {s : Sigma β} {l : List (Sigma β)} : s ∈ l → s.1 ∈ l.keys 
Arguments: {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)}
Goal: s ∈ l → s.fst ∈ l.keys
-- List.exists_of_mem_keys
theorem exists_of_mem_keys {a} {l : List (Sigma β)} (h : a ∈ l.keys) :
    ∃ b : β a, Sigma.mk a b ∈ l 
Arguments: {α : Type u} {β : α → Type v} {a : α} {l : List (Sigma β)} (h : a ∈ l.keys)
Goal: ∃ b, ⟨a, b⟩ ∈ l
-- List.mem_keys
theorem mem_keys {a} {l : List (Sigma β)} : a ∈ l.keys ↔ ∃ b : β a, Sigma.mk a b ∈ l 
Arguments: {α : Type u} {β : α → Type v} {a : α} {l : List (Sigma β)}
Goal: a ∈ l.keys ↔ ∃ b, ⟨a, b⟩ ∈ l
-- List.not_mem_keys
theorem not_mem_keys {a} {l : List (Sigma β)} : a ∉ l.keys ↔ ∀ b : β a, Sigma.mk a b ∉ l 
Arguments: {α : Type u} {β : α → Type v} {a : α} {l : List (Sigma β)}
Goal: a ∉ l.keys ↔ ∀ (b : β a), ⟨a, b⟩ ∉ l
-- List.not_eq_key
theorem not_eq_key {a} {l : List (Sigma β)} : a ∉ l.keys ↔ ∀ s : Sigma β, s ∈ l → a ≠ s.1 
Arguments: {α : Type u} {β : α → Type v} {a : α} {l : List (Sigma β)}
Goal: a ∉ l.keys ↔ ∀ s ∈ l, a ≠ s.fst
-- List.nodupKeys_iff_pairwise
theorem nodupKeys_iff_pairwise {l} : NodupKeys l ↔ Pairwise (fun s s' : Sigma β => s.1 ≠ s'.1) l 
Arguments: {α : Type u} {β : α → Type v} {l : List (Sigma β)}
Goal: l.NodupKeys ↔ List.Pairwise (fun s s' => s.fst ≠ s'.fst) l
-- List.NodupKeys.pairwise_ne
theorem NodupKeys.pairwise_ne {l} (h : NodupKeys l) :
    Pairwise (fun s s' : Sigma β => s.1 ≠ s'.1) l 
Arguments: {α : Type u} {β : α → Type v} {l : List (Sigma β)} (h : l.NodupKeys)
Goal: List.Pairwise (fun s s' => s.fst ≠ s'.fst) l
-- List.nodupKeys_nil
@[simp]
theorem nodupKeys_nil : @NodupKeys α β [] 
Arguments: {α : Type u} {β : α → Type v}
Goal: [].NodupKeys
-- List.nodupKeys_cons
@[simp]
theorem nodupKeys_cons {s : Sigma β} {l : List (Sigma β)} :
    NodupKeys (s :: l) ↔ s.1 ∉ l.keys ∧ NodupKeys l 
Arguments: {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)}
Goal: (s :: l).NodupKeys ↔ s.fst ∉ l.keys ∧ l.NodupKeys
-- List.not_mem_keys_of_nodupKeys_cons
theorem not_mem_keys_of_nodupKeys_cons {s : Sigma β} {l : List (Sigma β)} (h : NodupKeys (s :: l)) :
    s.1 ∉ l.keys 
Arguments: {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)} (h : (s :: l).NodupKeys)
Goal: s.fst ∉ l.keys
-- List.nodupKeys_of_nodupKeys_cons
theorem nodupKeys_of_nodupKeys_cons {s : Sigma β} {l : List (Sigma β)} (h : NodupKeys (s :: l)) :
    NodupKeys l 
Arguments: {α : Type u} {β : α → Type v} {s : Sigma β} {l : List (Sigma β)} (h : (s :: l).NodupKeys)
Goal: l.NodupKeys
-- List.NodupKeys.eq_of_fst_eq
theorem NodupKeys.eq_of_fst_eq {l : List (Sigma β)} (nd : NodupKeys l) {s s' : Sigma β} (h : s ∈ l)
    (h' : s' ∈ l) : s.1 = s'.1 → s = s' 
Arguments: {α : Type u} {β : α → Type v} {l : List (Sigma β)} (nd : l.NodupKeys) {s s' : Sigma β} (h : s ∈ l) (h' : s' ∈ l)
Goal: s.fst = s'.fst → s = s'
-- List.NodupKeys.eq_of_mk_mem
theorem NodupKeys.eq_of_mk_mem {a : α} {b b' : β a} {l : List (Sigma β)} (nd : NodupKeys l)
    (h : Sigma.mk a b ∈ l) (h' : Sigma.mk a b' ∈ l) : b = b' 
Arguments: {α : Type u} {β : α → Type v} {a : α} {b b' : β a} {l : List (Sigma β)} (nd : l.NodupKeys) (h : ⟨a, b⟩ ∈ l) (h' : ⟨a, b'⟩ ∈ l)
Goal: b = b'
-- List.nodupKeys_singleton
theorem nodupKeys_singleton (s : Sigma β) : NodupKeys [s] 
Arguments: {α : Type u} {β : α → Type v} (s : Sigma β)
Goal: [s].NodupKeys
-- List.NodupKeys.sublist
theorem NodupKeys.sublist {l₁ l₂ : List (Sigma β)} (h : l₁ <+ l₂) : NodupKeys l₂ → NodupKeys l₁ 
Arguments: {α : Type u} {β : α → Type v} {l₁ l₂ : List (Sigma β)} (h : l₁.Sublist l₂)
Goal: l₂.NodupKeys → l₁.NodupKeys
-- List.NodupKeys.nodup
protected theorem NodupKeys.nodup {l : List (Sigma β)} : NodupKeys l → Nodup l 
Arguments: {α : Type u} {β : α → Type v} {l : List (Sigma β)}
Goal: l.NodupKeys → l.Nodup
-- List.perm_nodupKeys
theorem perm_nodupKeys {l₁ l₂ : List (Sigma β)} (h : l₁ ~ l₂) : NodupKeys l₁ ↔ NodupKeys l₂ 
Arguments: {α : Type u} {β : α → Type v} {l₁ l₂ : List (Sigma β)} (h : l₁.Perm l₂)
Goal: l₁.NodupKeys ↔ l₂.NodupKeys