ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.preimage_piEquivPiSubtypeProd_symm_pi
theorem preimage_piEquivPiSubtypeProd_symm_pi {α : Type*} {β : α → Type*} (p : α → Prop)
    [DecidablePred p] (s : ∀ i, Set (β i)) :
    (piEquivPiSubtypeProd p β).symm ⁻¹' pi univ s =
      (pi univ fun i : { i // p i } => s i) ×ˢ pi univ fun i : { i // ¬p i } => s i 
Arguments: {α : Type u_1} {β : α → Type u_2} (p : α → Prop) [DecidablePred p] (s : (i : α) → Set (β i))
Goal: ⇑(Equiv.piEquivPiSubtypeProd p β).symm ⁻¹' Set.univ.pi s = (Set.univ.pi fun i => s ↑i) ×ˢ Set.univ.pi fun i => s ↑i
-- Equiv.sigmaPreimageEquiv_apply
@[simps!]
def sigmaPreimageEquiv {α β} (f : α → β) : (Σb, f ⁻¹' {b}) ≃ α 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : (y : β) × { x // f x = y })
Goal: (Equiv.sigmaPreimageEquiv f) x = ↑x.snd
-- Equiv.sigmaPreimageEquiv_symm_apply_snd_coe
@[simps!]
def sigmaPreimageEquiv {α β} (f : α → β) : (Σb, f ⁻¹' {b}) ≃ α 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : α)
Goal: ↑((Equiv.sigmaPreimageEquiv f).symm x).snd = x
-- Equiv.sigmaPreimageEquiv_symm_apply_fst
@[simps!]
def sigmaPreimageEquiv {α β} (f : α → β) : (Σb, f ⁻¹' {b}) ≃ α 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : α)
Goal: ((Equiv.sigmaPreimageEquiv f).symm x).fst = f x
-- Equiv.ofPreimageEquiv_symm_apply
@[simps!]
def ofPreimageEquiv {α β γ} {f : α → γ} {g : β → γ} (e : ∀ c, f ⁻¹' {c} ≃ g ⁻¹' {c}) : α ≃ β 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → γ} {g : β → γ} (e : (c : γ) → ↑(f ⁻¹' {c}) ≃ ↑(g ⁻¹' {c}))
Goal: ∀ (a : β), (Equiv.ofPreimageEquiv e).symm a = ↑((Equiv.sigmaCongrRight e).symm ((Equiv.sigmaFiberEquiv g).symm a)).snd
-- Equiv.ofPreimageEquiv_apply
@[simps!]
def ofPreimageEquiv {α β γ} {f : α → γ} {g : β → γ} (e : ∀ c, f ⁻¹' {c} ≃ g ⁻¹' {c}) : α ≃ β 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → γ} {g : β → γ} (e : (c : γ) → ↑(f ⁻¹' {c}) ≃ ↑(g ⁻¹' {c}))
Goal: ∀ (a : α), (Equiv.ofPreimageEquiv e) a = ↑((e (f a)) ((Equiv.sigmaFiberEquiv f).symm a).snd)
-- Equiv.ofPreimageEquiv_map
theorem ofPreimageEquiv_map {α β γ} {f : α → γ} {g : β → γ} (e : ∀ c, f ⁻¹' {c} ≃ g ⁻¹' {c})
    (a : α) : g (ofPreimageEquiv e a) = f a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → γ} {g : β → γ} (e : (c : γ) → ↑(f ⁻¹' {c}) ≃ ↑(g ⁻¹' {c})) (a : α)
Goal: g ((Equiv.ofPreimageEquiv e) a) = f a
-- dite_comp_equiv_update
-- Porting note: replace `s : Set α` and `: s` with `p : α → Prop` and `: Subtype p`, since the
-- former now unfolds syntactically to a less general case of the latter.
theorem dite_comp_equiv_update {α : Type*} {β : Sort*} {γ : Sort*} {p : α → Prop}
    (e : β ≃ Subtype p)
    (v : β → γ) (w : α → γ) (j : β) (x : γ) [DecidableEq β] [DecidableEq α]
    [∀ j, Decidable (p j)] :
    (fun i : α => if h : p i then (Function.update v j x) (e.symm ⟨i, h⟩) else w i) =
      Function.update (fun i : α => if h : p i then v (e.symm ⟨i, h⟩) else w i) (e j) x 
Arguments: {α : Type u_1} {β : Sort u_2} {γ : Sort u_3} {p : α → Prop} (e : β ≃ Subtype p) (v : β → γ) (w : α → γ) (j : β) (x : γ) [DecidableEq β] [DecidableEq α] [(j : α) → Decidable (p j)]
Goal: (fun i => if h : p i then Function.update v j x (e.symm ⟨i, h⟩) else w i) =
  Function.update (fun i => if h : p i then v (e.symm ⟨i, h⟩) else w i) (↑(e j)) x
-- Equiv.swap_bijOn_self
theorem Equiv.swap_bijOn_self (hs : a ∈ s ↔ b ∈ s) : BijOn (Equiv.swap a b) s s 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} {s : Set α} (hs : a ∈ s ↔ b ∈ s)
Goal: Set.BijOn (⇑(Equiv.swap a b)) s s
-- Equiv.swap_bijOn_exchange
theorem Equiv.swap_bijOn_exchange (ha : a ∈ s) (hb : b ∉ s) :
    BijOn (Equiv.swap a b) s (insert b (s \ {a})) 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} {s : Set α} (ha : a ∈ s) (hb : b ∉ s)
Goal: Set.BijOn (⇑(Equiv.swap a b)) s (insert b (s \ {a}))
-- Function.eval_apply
theorem eval_apply {β : α → Sort*} (x : α) (f : ∀ x, β x) : eval x f = f x 
Arguments: {α : Sort u_1} {β : α → Sort u_4} (x : α) (f : (x : α) → β x)
Goal: Function.eval x f = f x
-- Function.const_def
theorem const_def {y : β} : (fun _ : α ↦ y) = const α y 
Arguments: {α : Sort u_1} {β : Sort u_2} {y : β}
Goal: (fun x => y) = Function.const α y
-- Function.const_injective
theorem const_injective [Nonempty α] : Injective (const α : β → α → β) 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α]
Goal: Function.Injective (Function.const α)
-- Function.const_inj
@[simp]
theorem const_inj [Nonempty α] {y₁ y₂ : β} : const α y₁ = const α y₂ ↔ y₁ = y₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {y₁ y₂ : β}
Goal: Function.const α y₁ = Function.const α y₂ ↔ y₁ = y₂
-- Function.onFun_apply
theorem onFun_apply (f : β → β → γ) (g : α → β) (a b : α) : onFun f g a b = f (g a) (g b) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : β → β → γ) (g : α → β) (a b : α)
Goal: (f on g) a b = f (g a) (g b)
-- Function.hfunext
lemma hfunext {α α' : Sort u} {β : α → Sort v} {β' : α' → Sort v} {f : ∀a, β a} {f' : ∀a, β' a}
    (hα : α = α') (h : ∀a a', HEq a a' → HEq (f a) (f' a')) : HEq f f' 
Arguments: {α α' : Sort u} {β : α → Sort v} {β' : α' → Sort v} {f : (a : α) → β a} {f' : (a : α') → β' a} (hα : α = α') (h : ∀ (a : α) (a' : α'), HEq a a' → HEq (f a) (f' a'))
Goal: HEq f f'
-- Function.ne_iff
theorem ne_iff {β : α → Sort*} {f₁ f₂ : ∀ a, β a} : f₁ ≠ f₂ ↔ ∃ a, f₁ a ≠ f₂ a 
Arguments: {α : Sort u_1} {β : α → Sort u_4} {f₁ f₂ : (a : α) → β a}
Goal: f₁ ≠ f₂ ↔ ∃ a, f₁ a ≠ f₂ a
-- Function.funext_iff_of_subsingleton
lemma funext_iff_of_subsingleton [Subsingleton α] {g : α → β} (x y : α) :
    f x = g y ↔ f = g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} [Subsingleton α] {g : α → β} (x y : α)
Goal: f x = g y ↔ f = g
-- Function.Bijective.injective
protected theorem Bijective.injective {f : α → β} (hf : Bijective f) : Injective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f)
Goal: Function.Injective f
-- Function.Bijective.surjective
protected theorem Bijective.surjective {f : α → β} (hf : Bijective f) : Surjective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f)
Goal: Function.Surjective f
-- Function.Injective.eq_iff
theorem Injective.eq_iff (I : Injective f) {a b : α} : f a = f b ↔ a = b 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (I : Function.Injective f) {a b : α}
Goal: f a = f b ↔ a = b
-- Function.Injective.beq_eq
theorem Injective.beq_eq {α β : Type*} [BEq α] [LawfulBEq α] [BEq β] [LawfulBEq β] {f : α → β}
    (I : Injective f) {a b : α} : (f a == f b) = (a == b) 
Arguments: {α : Type u_4} {β : Type u_5} [BEq α] [LawfulBEq α] [BEq β] [LawfulBEq β] {f : α → β} (I : Function.Injective f) {a b : α}
Goal: (f a == f b) = (a == b)
-- Function.Injective.eq_iff'
theorem Injective.eq_iff' (I : Injective f) {a b : α} {c : β} (h : f b = c) : f a = c ↔ a = b 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (I : Function.Injective f) {a b : α} {c : β} (h : f b = c)
Goal: f a = c ↔ a = b
-- Function.Injective.ne
theorem Injective.ne (hf : Injective f) {a₁ a₂ : α} : a₁ ≠ a₂ → f a₁ ≠ f a₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Injective f) {a₁ a₂ : α}
Goal: a₁ ≠ a₂ → f a₁ ≠ f a₂
-- Function.Injective.ne_iff
theorem Injective.ne_iff (hf : Injective f) {x y : α} : f x ≠ f y ↔ x ≠ y 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Injective f) {x y : α}
Goal: f x ≠ f y ↔ x ≠ y
-- Function.Injective.ne_iff'
theorem Injective.ne_iff' (hf : Injective f) {x y : α} {z : β} (h : f y = z) : f x ≠ z ↔ x ≠ y 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Injective f) {x y : α} {z : β} (h : f y = z)
Goal: f x ≠ z ↔ x ≠ y
-- Function.not_injective_iff
theorem not_injective_iff : ¬ Injective f ↔ ∃ a b, f a = f b ∧ a ≠ b 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β}
Goal: ¬Function.Injective f ↔ ∃ a b, f a = f b ∧ a ≠ b
-- Function.Injective.of_comp
theorem Injective.of_comp {g : γ → α} (I : Injective (f ∘ g)) : Injective g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α} (I : Function.Injective (f ∘ g))
Goal: Function.Injective g
-- Function.Injective.of_comp_iff
@[simp]
theorem Injective.of_comp_iff (hf : Injective f) (g : γ → α) :
    Injective (f ∘ g) ↔ Injective g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : γ → α)
Goal: Function.Injective (f ∘ g) ↔ Function.Injective g
-- Function.Injective.of_comp_right
theorem Injective.of_comp_right {g : γ → α} (I : Injective (f ∘ g)) (hg : Surjective g) :
    Injective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α} (I : Function.Injective (f ∘ g)) (hg : Function.Surjective g)
Goal: Function.Injective f
-- Function.Surjective.bijective₂_of_injective
theorem Surjective.bijective₂_of_injective {g : γ → α} (hf : Surjective f) (hg : Surjective g)
    (I : Injective (f ∘ g)) : Bijective f ∧ Bijective g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α} (hf : Function.Surjective f) (hg : Function.Surjective g) (I : Function.Injective (f ∘ g))
Goal: Function.Bijective f ∧ Function.Bijective g
-- Function.Injective.of_comp_iff'
@[simp]
theorem Injective.of_comp_iff' (f : α → β) {g : γ → α} (hg : Bijective g) :
    Injective (f ∘ g) ↔ Injective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) {g : γ → α} (hg : Function.Bijective g)
Goal: Function.Injective (f ∘ g) ↔ Function.Injective f
-- Function.Injective.comp_left
theorem Injective.comp_left {g : β → γ} (hg : Function.Injective g) :
    Function.Injective (g ∘ · : (α → β) → α → γ) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {g : β → γ} (hg : Function.Injective g)
Goal: Function.Injective fun x => g ∘ x
-- Function.injective_of_subsingleton
theorem injective_of_subsingleton [Subsingleton α] (f : α → β) : Injective f 
Arguments: {α : Sort u_1} {β : Sort u_2} [Subsingleton α] (f : α → β)
Goal: Function.Injective f
-- Function.Injective.dite
lemma Injective.dite (p : α → Prop) [DecidablePred p]
    {f : {a : α // p a} → β} {f' : {a : α // ¬ p a} → β}
    (hf : Injective f) (hf' : Injective f')
    (im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬ p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩) :
    Function.Injective (fun x ↦ if h : p x then f ⟨x, h⟩ else f' ⟨x, h⟩) 
Arguments: {α : Sort u_1} {β : Sort u_2} (p : α → Prop) [DecidablePred p] {f : { a // p a } → β} {f' : { a // ¬p a } → β} (hf : Function.Injective f) (hf' : Function.Injective f') (im_disj : ∀ {x x' : α} {hx : p x} {hx' : ¬p x'}, f ⟨x, hx⟩ ≠ f' ⟨x', hx'⟩)
Goal: Function.Injective fun x => if h : p x then f ⟨x, h⟩ else f' ⟨x, h⟩
-- Function.Surjective.of_comp
theorem Surjective.of_comp {g : γ → α} (S : Surjective (f ∘ g)) : Surjective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α} (S : Function.Surjective (f ∘ g))
Goal: Function.Surjective f
-- Function.Surjective.of_comp_iff
@[simp]
theorem Surjective.of_comp_iff (f : α → β) {g : γ → α} (hg : Surjective g) :
    Surjective (f ∘ g) ↔ Surjective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) {g : γ → α} (hg : Function.Surjective g)
Goal: Function.Surjective (f ∘ g) ↔ Function.Surjective f
-- Function.Surjective.of_comp_left
theorem Surjective.of_comp_left {g : γ → α} (S : Surjective (f ∘ g)) (hf : Injective f) :
    Surjective g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α} (S : Function.Surjective (f ∘ g)) (hf : Function.Injective f)
Goal: Function.Surjective g
-- Function.Injective.bijective₂_of_surjective
theorem Injective.bijective₂_of_surjective {g : γ → α} (hf : Injective f) (hg : Injective g)
    (S : Surjective (f ∘ g)) : Bijective f ∧ Bijective g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : γ → α} (hf : Function.Injective f) (hg : Function.Injective g) (S : Function.Surjective (f ∘ g))
Goal: Function.Bijective f ∧ Function.Bijective g
-- Function.Surjective.of_comp_iff'
@[simp]
theorem Surjective.of_comp_iff' (hf : Bijective f) (g : γ → α) :
    Surjective (f ∘ g) ↔ Surjective g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Bijective f) (g : γ → α)
Goal: Function.Surjective (f ∘ g) ↔ Function.Surjective g
-- Function.Surjective.forall
protected theorem Surjective.forall (hf : Surjective f) {p : β → Prop} :
    (∀ y, p y) ↔ ∀ x, p (f x) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → Prop}
Goal: (∀ (y : β), p y) ↔ ∀ (x : α), p (f x)
-- Function.Surjective.forall₂
protected theorem Surjective.forall₂ (hf : Surjective f) {p : β → β → Prop} :
    (∀ y₁ y₂, p y₁ y₂) ↔ ∀ x₁ x₂, p (f x₁) (f x₂) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → Prop}
Goal: (∀ (y₁ y₂ : β), p y₁ y₂) ↔ ∀ (x₁ x₂ : α), p (f x₁) (f x₂)
-- Function.Surjective.forall₃
protected theorem Surjective.forall₃ (hf : Surjective f) {p : β → β → β → Prop} :
    (∀ y₁ y₂ y₃, p y₁ y₂ y₃) ↔ ∀ x₁ x₂ x₃, p (f x₁) (f x₂) (f x₃) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → β → Prop}
Goal: (∀ (y₁ y₂ y₃ : β), p y₁ y₂ y₃) ↔ ∀ (x₁ x₂ x₃ : α), p (f x₁) (f x₂) (f x₃)
-- Function.Surjective.exists
protected theorem Surjective.exists (hf : Surjective f) {p : β → Prop} :
    (∃ y, p y) ↔ ∃ x, p (f x) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → Prop}
Goal: (∃ y, p y) ↔ ∃ x, p (f x)
-- Function.Surjective.exists₂
protected theorem Surjective.exists₂ (hf : Surjective f) {p : β → β → Prop} :
    (∃ y₁ y₂, p y₁ y₂) ↔ ∃ x₁ x₂, p (f x₁) (f x₂) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → Prop}
Goal: (∃ y₁ y₂, p y₁ y₂) ↔ ∃ x₁ x₂, p (f x₁) (f x₂)
-- Function.Surjective.exists₃
protected theorem Surjective.exists₃ (hf : Surjective f) {p : β → β → β → Prop} :
    (∃ y₁ y₂ y₃, p y₁ y₂ y₃) ↔ ∃ x₁ x₂ x₃, p (f x₁) (f x₂) (f x₃) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Surjective f) {p : β → β → β → Prop}
Goal: (∃ y₁ y₂ y₃, p y₁ y₂ y₃) ↔ ∃ x₁ x₂ x₃, p (f x₁) (f x₂) (f x₃)
-- Function.Surjective.injective_comp_right
theorem Surjective.injective_comp_right (hf : Surjective f) : Injective fun g : β → γ ↦ g ∘ f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Surjective f)
Goal: Function.Injective fun g => g ∘ f
-- Function.Surjective.right_cancellable
protected theorem Surjective.right_cancellable (hf : Surjective f) {g₁ g₂ : β → γ} :
    g₁ ∘ f = g₂ ∘ f ↔ g₁ = g₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Surjective f) {g₁ g₂ : β → γ}
Goal: g₁ ∘ f = g₂ ∘ f ↔ g₁ = g₂
-- Function.surjective_of_right_cancellable_Prop
theorem surjective_of_right_cancellable_Prop (h : ∀ g₁ g₂ : β → Prop, g₁ ∘ f = g₂ ∘ f → g₁ = g₂) :
    Surjective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (h : ∀ (g₁ g₂ : β → Prop), g₁ ∘ f = g₂ ∘ f → g₁ = g₂)
Goal: Function.Surjective f
-- Function.bijective_iff_existsUnique
theorem bijective_iff_existsUnique (f : α → β) : Bijective f ↔ ∀ b : β, ∃! a : α, f a = b 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β)
Goal: Function.Bijective f ↔ ∀ (b : β), ∃! a, f a = b
-- Function.Bijective.existsUnique
protected theorem Bijective.existsUnique {f : α → β} (hf : Bijective f) (b : β) :
    ∃! a : α, f a = b 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f) (b : β)
Goal: ∃! a, f a = b
-- Function.Bijective.existsUnique_iff
theorem Bijective.existsUnique_iff {f : α → β} (hf : Bijective f) {p : β → Prop} :
    (∃! y, p y) ↔ ∃! x, p (f x) 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Bijective f) {p : β → Prop}
Goal: (∃! y, p y) ↔ ∃! x, p (f x)
-- Function.Bijective.of_comp_iff
theorem Bijective.of_comp_iff (f : α → β) {g : γ → α} (hg : Bijective g) :
    Bijective (f ∘ g) ↔ Bijective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) {g : γ → α} (hg : Function.Bijective g)
Goal: Function.Bijective (f ∘ g) ↔ Function.Bijective f
-- Function.Bijective.of_comp_iff'
theorem Bijective.of_comp_iff' {f : α → β} (hf : Bijective f) (g : γ → α) :
    Function.Bijective (f ∘ g) ↔ Function.Bijective g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Bijective f) (g : γ → α)
Goal: Function.Bijective (f ∘ g) ↔ Function.Bijective g
-- Function.cantor_surjective
theorem cantor_surjective {α} (f : α → Set α) : ¬Surjective f
  
Arguments: {α : Type u_4} (f : α → Set α)
Goal: ¬Function.Surjective f
-- Function.cantor_injective
theorem cantor_injective {α : Type*} (f : Set α → α) : ¬Injective f
  
Arguments: {α : Type u_4} (f : Set α → α)
Goal: ¬Function.Injective f
-- Function.not_surjective_Type
theorem not_surjective_Type {α : Type u} (f : α → Type max u v) : ¬Surjective f 
Arguments: {α : Type u} (f : α → Type (max u v))
Goal: ¬Function.Surjective f
-- Function.isPartialInv_left
theorem isPartialInv_left {α β} {f : α → β} {g} (H : IsPartialInv f g) (x) : g (f x) = some x 
Arguments: {α : Type u_4} {β : Sort u_5} {f : α → β} {g : β → Option α} (H : Function.IsPartialInv f g) (x : α)
Goal: g (f x) = some x
-- Function.injective_of_isPartialInv
theorem injective_of_isPartialInv {α β} {f : α → β} {g} (H : IsPartialInv f g) :
    Injective f 
Arguments: {α : Type u_4} {β : Sort u_5} {f : α → β} {g : β → Option α} (H : Function.IsPartialInv f g)
Goal: Function.Injective f
-- Function.injective_of_isPartialInv_right
theorem injective_of_isPartialInv_right {α β} {f : α → β} {g} (H : IsPartialInv f g) (x y b)
    (h₁ : b ∈ g x) (h₂ : b ∈ g y) : x = y 
Arguments: {α : Type u_4} {β : Sort u_5} {f : α → β} {g : β → Option α} (H : Function.IsPartialInv f g) (x y : β) (b : α) (h₁ : b ∈ g x) (h₂ : b ∈ g y)
Goal: x = y
-- Function.LeftInverse.comp_eq_id
theorem LeftInverse.comp_eq_id {f : α → β} {g : β → α} (h : LeftInverse f g) : f ∘ g = id 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.LeftInverse f g)
Goal: f ∘ g = id
-- Function.leftInverse_iff_comp
theorem leftInverse_iff_comp {f : α → β} {g : β → α} : LeftInverse f g ↔ f ∘ g = id 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}
Goal: Function.LeftInverse f g ↔ f ∘ g = id
-- Function.RightInverse.comp_eq_id
theorem RightInverse.comp_eq_id {f : α → β} {g : β → α} (h : RightInverse f g) : g ∘ f = id 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.RightInverse f g)
Goal: g ∘ f = id
-- Function.rightInverse_iff_comp
theorem rightInverse_iff_comp {f : α → β} {g : β → α} : RightInverse f g ↔ g ∘ f = id 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}
Goal: Function.RightInverse f g ↔ g ∘ f = id
-- Function.LeftInverse.comp
theorem LeftInverse.comp {f : α → β} {g : β → α} {h : β → γ} {i : γ → β} (hf : LeftInverse f g)
    (hh : LeftInverse h i) : LeftInverse (h ∘ f) (g ∘ i) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : β → α} {h : β → γ} {i : γ → β} (hf : Function.LeftInverse f g) (hh : Function.LeftInverse h i)
Goal: Function.LeftInverse (h ∘ f) (g ∘ i)
-- Function.RightInverse.comp
theorem RightInverse.comp {f : α → β} {g : β → α} {h : β → γ} {i : γ → β} (hf : RightInverse f g)
    (hh : RightInverse h i) : RightInverse (h ∘ f) (g ∘ i) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : β → α} {h : β → γ} {i : γ → β} (hf : Function.RightInverse f g) (hh : Function.RightInverse h i)
Goal: Function.RightInverse (h ∘ f) (g ∘ i)
-- Function.LeftInverse.rightInverse
theorem LeftInverse.rightInverse {f : α → β} {g : β → α} (h : LeftInverse g f) : RightInverse f g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.LeftInverse g f)
Goal: Function.RightInverse f g
-- Function.RightInverse.leftInverse
theorem RightInverse.leftInverse {f : α → β} {g : β → α} (h : RightInverse g f) : LeftInverse f g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.RightInverse g f)
Goal: Function.LeftInverse f g
-- Function.LeftInverse.surjective
theorem LeftInverse.surjective {f : α → β} {g : β → α} (h : LeftInverse f g) : Surjective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.LeftInverse f g)
Goal: Function.Surjective f
-- Function.RightInverse.injective
theorem RightInverse.injective {f : α → β} {g : β → α} (h : RightInverse f g) : Injective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.RightInverse f g)
Goal: Function.Injective f
-- Function.LeftInverse.rightInverse_of_injective
theorem LeftInverse.rightInverse_of_injective {f : α → β} {g : β → α} (h : LeftInverse f g)
    (hf : Injective f) : RightInverse f g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.LeftInverse f g) (hf : Function.Injective f)
Goal: Function.RightInverse f g
-- Function.LeftInverse.rightInverse_of_surjective
theorem LeftInverse.rightInverse_of_surjective {f : α → β} {g : β → α} (h : LeftInverse f g)
    (hg : Surjective g) : RightInverse f g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α} (h : Function.LeftInverse f g) (hg : Function.Surjective g)
Goal: Function.RightInverse f g
-- Function.RightInverse.leftInverse_of_surjective
theorem RightInverse.leftInverse_of_surjective {f : α → β} {g : β → α} :
    RightInverse f g → Surjective f → LeftInverse f g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}
Goal: Function.RightInverse f g → Function.Surjective f → Function.LeftInverse f g
-- Function.RightInverse.leftInverse_of_injective
theorem RightInverse.leftInverse_of_injective {f : α → β} {g : β → α} :
    RightInverse f g → Injective g → LeftInverse f g 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}
Goal: Function.RightInverse f g → Function.Injective g → Function.LeftInverse f g
-- Function.LeftInverse.eq_rightInverse
theorem LeftInverse.eq_rightInverse {f : α → β} {g₁ g₂ : β → α} (h₁ : LeftInverse g₁ f)
    (h₂ : RightInverse g₂ f) : g₁ = g₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} {g₁ g₂ : β → α} (h₁ : Function.LeftInverse g₁ f) (h₂ : Function.RightInverse g₂ f)
Goal: g₁ = g₂
-- Function.partialInv_of_injective
theorem partialInv_of_injective {α β} {f : α → β} (I : Injective f) : IsPartialInv f (partialInv f)
  
Arguments: {α : Type u_4} {β : Sort u_5} {f : α → β} (I : Function.Injective f)
Goal: Function.IsPartialInv f (Function.partialInv f)
-- Function.partialInv_left
theorem partialInv_left {α β} {f : α → β} (I : Injective f) : ∀ x, partialInv f (f x) = some x 
Arguments: {α : Type u_4} {β : Sort u_5} {f : α → β} (I : Function.Injective f) (x : α)
Goal: Function.partialInv f (f x) = some x
-- Function.invFun_eq
theorem invFun_eq (h : ∃ a, f a = b) : f (invFun f b) = b 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} {b : β} (h : ∃ a, f a = b)
Goal: f (Function.invFun f b) = b
-- Function.apply_invFun_apply
theorem apply_invFun_apply {α β : Type*} {f : α → β} {a : α} :
    f (@invFun _ _ ⟨a⟩ f (f a)) = f a 
Arguments: {α : Type u_3} {β : Type u_4} {f : α → β} {a : α}
Goal: f (Function.invFun f (f a)) = f a
-- Function.invFun_neg
theorem invFun_neg (h : ¬∃ a, f a = b) : invFun f b = Classical.choice ‹_› 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} {b : β} (h : ¬∃ a, f a = b)
Goal: Function.invFun f b = Classical.choice inst✝
-- Function.invFun_eq_of_injective_of_rightInverse
theorem invFun_eq_of_injective_of_rightInverse {g : β → α} (hf : Injective f)
    (hg : RightInverse g f) : invFun f = g 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} {g : β → α} (hf : Function.Injective f) (hg : Function.RightInverse g f)
Goal: Function.invFun f = g
-- Function.rightInverse_invFun
theorem rightInverse_invFun (hf : Surjective f) : RightInverse (invFun f) f 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Surjective f)
Goal: Function.RightInverse (Function.invFun f) f
-- Function.leftInverse_invFun
theorem leftInverse_invFun (hf : Injective f) : LeftInverse (invFun f) f 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f)
Goal: Function.LeftInverse (Function.invFun f) f