ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Function.invFun_surjective
theorem invFun_surjective (hf : Injective f) : Surjective (invFun f) 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f)
Goal: Function.Surjective (Function.invFun f)
-- Function.invFun_comp
theorem invFun_comp (hf : Injective f) : invFun f ∘ f = id 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f)
Goal: Function.invFun f ∘ f = id
-- Function.Injective.hasLeftInverse
theorem Injective.hasLeftInverse (hf : Injective f) : HasLeftInverse f 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β} (hf : Function.Injective f)
Goal: Function.HasLeftInverse f
-- Function.injective_iff_hasLeftInverse
theorem injective_iff_hasLeftInverse : Injective f ↔ HasLeftInverse f 
Arguments: {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β}
Goal: Function.Injective f ↔ Function.HasLeftInverse f
-- Function.surjInv_eq
theorem surjInv_eq (h : Surjective f) (b) : f (surjInv h b) = b 
Arguments: {α : Sort u} {β : Sort v} {f : α → β} (h : Function.Surjective f) (b : β)
Goal: f (Function.surjInv h b) = b
-- Function.rightInverse_surjInv
theorem rightInverse_surjInv (hf : Surjective f) : RightInverse (surjInv hf) f 
Arguments: {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Surjective f)
Goal: Function.RightInverse (Function.surjInv hf) f
-- Function.leftInverse_surjInv
theorem leftInverse_surjInv (hf : Bijective f) : LeftInverse (surjInv hf.2) f 
Arguments: {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Bijective f)
Goal: Function.LeftInverse (Function.surjInv ⋯) f
-- Function.Surjective.hasRightInverse
theorem Surjective.hasRightInverse (hf : Surjective f) : HasRightInverse f 
Arguments: {α : Sort u} {β : Sort v} {f : α → β} (hf : Function.Surjective f)
Goal: Function.HasRightInverse f
-- Function.surjective_iff_hasRightInverse
theorem surjective_iff_hasRightInverse : Surjective f ↔ HasRightInverse f 
Arguments: {α : Sort u} {β : Sort v} {f : α → β}
Goal: Function.Surjective f ↔ Function.HasRightInverse f
-- Function.bijective_iff_has_inverse
theorem bijective_iff_has_inverse : Bijective f ↔ ∃ g, LeftInverse g f ∧ RightInverse g f 
Arguments: {α : Sort u} {β : Sort v} {f : α → β}
Goal: Function.Bijective f ↔ ∃ g, Function.LeftInverse g f ∧ Function.RightInverse g f
-- Function.injective_surjInv
theorem injective_surjInv (h : Surjective f) : Injective (surjInv h) 
Arguments: {α : Sort u} {β : Sort v} {f : α → β} (h : Function.Surjective f)
Goal: Function.Injective (Function.surjInv h)
-- Function.surjective_to_subsingleton
theorem surjective_to_subsingleton [na : Nonempty α] [Subsingleton β] (f : α → β) :
    Surjective f 
Arguments: {α : Sort u} {β : Sort v} [na : Nonempty α] [Subsingleton β] (f : α → β)
Goal: Function.Surjective f
-- Function.Surjective.comp_left
theorem Surjective.comp_left {g : β → γ} (hg : Surjective g) :
    Surjective (g ∘ · : (α → β) → α → γ) 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ} (hg : Function.Surjective g)
Goal: Function.Surjective fun x => g ∘ x
-- Function.Bijective.comp_left
theorem Bijective.comp_left {g : β → γ} (hg : Bijective g) :
    Bijective (g ∘ · : (α → β) → α → γ) 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ} (hg : Function.Bijective g)
Goal: Function.Bijective fun x => g ∘ x
-- Function.update_same
@[simp]
theorem update_same (a : α) (v : β a) (f : ∀ a, β a) : update f a v a = v 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] (a : α) (v : β a) (f : (a : α) → β a)
Goal: Function.update f a v a = v
-- Function.update_noteq
@[simp]
theorem update_noteq {a a' : α} (h : a ≠ a') (v : β a') (f : ∀ a, β a) : update f a' v a = f a 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {a a' : α} (h : a ≠ a') (v : β a') (f : (a : α) → β a)
Goal: Function.update f a' v a = f a
-- Function.update_apply
theorem update_apply {β : Sort*} (f : α → β) (a' : α) (b : β) (a : α) :
    update f a' b a = if a = a' then b else f a 
Arguments: {α : Sort u} [DecidableEq α] {β : Sort u_1} (f : α → β) (a' : α) (b : β) (a : α)
Goal: Function.update f a' b a = if a = a' then b else f a
-- Function.update_eq_const_of_subsingleton
@[nontriviality]
theorem update_eq_const_of_subsingleton [Subsingleton α] (a : α) (v : α') (f : α → α') :
    update f a v = const α v 
Arguments: {α : Sort u} {α' : Sort w} [DecidableEq α] [Subsingleton α] (a : α) (v : α') (f : α → α')
Goal: Function.update f a v = Function.const α v
-- Function.surjective_eval
theorem surjective_eval {α : Sort u} {β : α → Sort v} [h : ∀ a, Nonempty (β a)] (a : α) :
    Surjective (eval a : (∀ a, β a) → β a) 
Arguments: {α : Sort u} {β : α → Sort v} [h : ∀ (a : α), Nonempty (β a)] (a : α)
Goal: Function.Surjective (Function.eval a)
-- Function.update_injective
theorem update_injective (f : ∀ a, β a) (a' : α) : Injective (update f a') 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] (f : (a : α) → β a) (a' : α)
Goal: Function.Injective (Function.update f a')
-- Function.forall_update_iff
lemma forall_update_iff (f : ∀a, β a) {a : α} {b : β a} (p : ∀a, β a → Prop) :
    (∀ x, p x (update f a b x)) ↔ p a b ∧ ∀ x, x ≠ a → p x (f x) 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] (f : (a : α) → β a) {a : α} {b : β a} (p : (a : α) → β a → Prop)
Goal: (∀ (x : α), p x (Function.update f a b x)) ↔ p a b ∧ ∀ (x : α), x ≠ a → p x (f x)
-- Function.exists_update_iff
theorem exists_update_iff (f : ∀ a, β a) {a : α} {b : β a} (p : ∀ a, β a → Prop) :
    (∃ x, p x (update f a b x)) ↔ p a b ∨ ∃ x ≠ a, p x (f x) 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] (f : (a : α) → β a) {a : α} {b : β a} (p : (a : α) → β a → Prop)
Goal: (∃ x, p x (Function.update f a b x)) ↔ p a b ∨ ∃ x, x ≠ a ∧ p x (f x)
-- Function.update_eq_iff
theorem update_eq_iff {a : α} {b : β a} {f g : ∀ a, β a} :
    update f a b = g ↔ b = g a ∧ ∀ x ≠ a, f x = g x 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {a : α} {b : β a} {f g : (a : α) → β a}
Goal: Function.update f a b = g ↔ b = g a ∧ ∀ (x : α), x ≠ a → f x = g x
-- Function.eq_update_iff
theorem eq_update_iff {a : α} {b : β a} {f g : ∀ a, β a} :
    g = update f a b ↔ g a = b ∧ ∀ x ≠ a, g x = f x 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {a : α} {b : β a} {f g : (a : α) → β a}
Goal: g = Function.update f a b ↔ g a = b ∧ ∀ (x : α), x ≠ a → g x = f x
-- Function.update_eq_self_iff
@[simp] lemma update_eq_self_iff : update f a b = f ↔ b = f a 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a}
Goal: Function.update f a b = f ↔ b = f a
-- Function.eq_update_self_iff
@[simp] lemma eq_update_self_iff : f = update f a b ↔ f a = b 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a}
Goal: f = Function.update f a b ↔ f a = b
-- Function.ne_update_self_iff
lemma ne_update_self_iff : f ≠ update f a b ↔ f a ≠ b 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a}
Goal: f ≠ Function.update f a b ↔ f a ≠ b
-- Function.update_ne_self_iff
lemma update_ne_self_iff : update f a b ≠ f ↔ b ≠ f a 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {f : (a : α) → β a} {a : α} {b : β a}
Goal: Function.update f a b ≠ f ↔ b ≠ f a
-- Function.update_eq_self
@[simp]
theorem update_eq_self (a : α) (f : ∀ a, β a) : update f a (f a) = f 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] (a : α) (f : (a : α) → β a)
Goal: Function.update f a (f a) = f
-- Function.update_comp_eq_of_forall_ne'
theorem update_comp_eq_of_forall_ne' {α'} (g : ∀ a, β a) {f : α' → α} {i : α} (a : β i)
    (h : ∀ x, f x ≠ i) : (fun j ↦ (update g i a) (f j)) = fun j ↦ g (f j) 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] {α' : Sort u_1} (g : (a : α) → β a) {f : α' → α} {i : α} (a : β i) (h : ∀ (x : α'), f x ≠ i)
Goal: (fun j => Function.update g i a (f j)) = fun j => g (f j)
-- Function.update_comp_eq_of_forall_ne
theorem update_comp_eq_of_forall_ne {α β : Sort*} (g : α' → β) {f : α → α'} {i : α'} (a : β)
    (h : ∀ x, f x ≠ i) : update g i a ∘ f = g ∘ f 
Arguments: {α' : Sort w} [DecidableEq α'] {α : Sort u_1} {β : Sort u_2} (g : α' → β) {f : α → α'} {i : α'} (a : β) (h : ∀ (x : α), f x ≠ i)
Goal: Function.update g i a ∘ f = g ∘ f
-- Function.update_comp_eq_of_injective'
theorem update_comp_eq_of_injective' (g : ∀ a, β a) {f : α' → α} (hf : Function.Injective f)
    (i : α') (a : β (f i)) : (fun j ↦ update g (f i) a (f j)) = update (fun i ↦ g (f i)) i a 
Arguments: {α : Sort u} {β : α → Sort v} {α' : Sort w} [DecidableEq α] [DecidableEq α'] (g : (a : α) → β a) {f : α' → α} (hf : Function.Injective f) (i : α') (a : β (f i))
Goal: (fun j => Function.update g (f i) a (f j)) = Function.update (fun i => g (f i)) i a
-- Function.update_comp_eq_of_injective
theorem update_comp_eq_of_injective {β : Sort*} (g : α' → β) {f : α → α'}
    (hf : Function.Injective f) (i : α) (a : β) :
    Function.update g (f i) a ∘ f = Function.update (g ∘ f) i a 
Arguments: {α : Sort u} {α' : Sort w} [DecidableEq α] [DecidableEq α'] {β : Sort u_1} (g : α' → β) {f : α → α'} (hf : Function.Injective f) (i : α) (a : β)
Goal: Function.update g (f i) a ∘ f = Function.update (g ∘ f) i a
-- Function.apply_update
theorem apply_update {ι : Sort*} [DecidableEq ι] {α β : ι → Sort*} (f : ∀ i, α i → β i)
    (g : ∀ i, α i) (i : ι) (v : α i) (j : ι) :
    f j (update g i v j) = update (fun k ↦ f k (g k)) i (f i v) j 
Arguments: {ι : Sort u_1} [DecidableEq ι] {α : ι → Sort u_2} {β : ι → Sort u_3} (f : (i : ι) → α i → β i) (g : (i : ι) → α i) (i : ι) (v : α i) (j : ι)
Goal: f j (Function.update g i v j) = Function.update (fun k => f k (g k)) i (f i v) j
-- Function.apply_update₂
theorem apply_update₂ {ι : Sort*} [DecidableEq ι] {α β γ : ι → Sort*} (f : ∀ i, α i → β i → γ i)
    (g : ∀ i, α i) (h : ∀ i, β i) (i : ι) (v : α i) (w : β i) (j : ι) :
    f j (update g i v j) (update h i w j) = update (fun k ↦ f k (g k) (h k)) i (f i v w) j 
Arguments: {ι : Sort u_1} [DecidableEq ι] {α : ι → Sort u_2} {β : ι → Sort u_3} {γ : ι → Sort u_4} (f : (i : ι) → α i → β i → γ i) (g : (i : ι) → α i) (h : (i : ι) → β i) (i : ι) (v : α i) (w : β i) (j : ι)
Goal: f j (Function.update g i v j) (Function.update h i w j) = Function.update (fun k => f k (g k) (h k)) i (f i v w) j
-- Function.pred_update
theorem pred_update (P : ∀ ⦃a⦄, β a → Prop) (f : ∀ a, β a) (a' : α) (v : β a') (a : α) :
    P (update f a' v a) ↔ a = a' ∧ P v ∨ a ≠ a' ∧ P (f a) 
Arguments: {α : Sort u} {β : α → Sort v} [DecidableEq α] (P : ⦃a : α⦄ → β a → Prop) (f : (a : α) → β a) (a' : α) (v : β a') (a : α)
Goal: P (Function.update f a' v a) ↔ a = a' ∧ P v ∨ a ≠ a' ∧ P (f a)
-- Function.comp_update
theorem comp_update {α' : Sort*} {β : Sort*} (f : α' → β) (g : α → α') (i : α) (v : α') :
    f ∘ update g i v = update (f ∘ g) i (f v) 
Arguments: {α : Sort u} [DecidableEq α] {α' : Sort u_1} {β : Sort u_2} (f : α' → β) (g : α → α') (i : α) (v : α')
Goal: f ∘ Function.update g i v = Function.update (f ∘ g) i (f v)
-- Function.update_comm
theorem update_comm {α} [DecidableEq α] {β : α → Sort*} {a b : α} (h : a ≠ b) (v : β a) (w : β b)
    (f : ∀ a, β a) : update (update f a v) b w = update (update f b w) a v 
Arguments: {α : Sort u_2} [DecidableEq α] {β : α → Sort u_1} {a b : α} (h : a ≠ b) (v : β a) (w : β b) (f : (a : α) → β a)
Goal: Function.update (Function.update f a v) b w = Function.update (Function.update f b w) a v
-- Function.update_idem
@[simp]
theorem update_idem {α} [DecidableEq α] {β : α → Sort*} {a : α} (v w : β a) (f : ∀ a, β a) :
    update (update f a v) a w = update f a w 
Arguments: {α : Sort u_2} [DecidableEq α] {β : α → Sort u_1} {a : α} (v w : β a) (f : (a : α) → β a)
Goal: Function.update (Function.update f a v) a w = Function.update f a w
-- Function.extend_def
theorem extend_def (f : α → β) (g : α → γ) (e' : β → γ) (b : β) [Decidable (∃ a, f a = b)] :
    extend f g e' b = if h : ∃ a, f a = b then g (Classical.choose h) else e' b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (f : α → β) (g : α → γ) (e' : β → γ) (b : β) [Decidable (∃ a, f a = b)]
Goal: Function.extend f g e' b = if h : ∃ a, f a = b then g (Classical.choose h) else e' b
-- Function.Injective.factorsThrough
lemma Injective.factorsThrough (hf : Injective f) (g : α → γ) : g.FactorsThrough f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : α → γ)
Goal: Function.FactorsThrough g f
-- Function.FactorsThrough.extend_apply
lemma FactorsThrough.extend_apply {g : α → γ} (hf : g.FactorsThrough f) (e' : β → γ) (a : α) :
    extend f g e' (f a) = g a 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : α → γ} (hf : Function.FactorsThrough g f) (e' : β → γ) (a : α)
Goal: Function.extend f g e' (f a) = g a
-- Function.Injective.extend_apply
@[simp]
theorem Injective.extend_apply (hf : Injective f) (g : α → γ) (e' : β → γ) (a : α) :
    extend f g e' (f a) = g a 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : α → γ) (e' : β → γ) (a : α)
Goal: Function.extend f g e' (f a) = g a
-- Function.extend_apply'
@[simp]
theorem extend_apply' (g : α → γ) (e' : β → γ) (b : β) (hb : ¬∃ a, f a = b) :
    extend f g e' b = e' b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (g : α → γ) (e' : β → γ) (b : β) (hb : ¬∃ a, f a = b)
Goal: Function.extend f g e' b = e' b
-- Function.factorsThrough_iff
lemma factorsThrough_iff (g : α → γ) [Nonempty γ] : g.FactorsThrough f ↔ ∃ (e : β → γ), g = e ∘ f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (g : α → γ) [Nonempty γ]
Goal: Function.FactorsThrough g f ↔ ∃ e, g = e ∘ f
-- Function.apply_extend
lemma apply_extend {δ} {g : α → γ} (F : γ → δ) (f : α → β) (e' : β → γ) (b : β) :
    F (extend f g e' b) = extend f (F ∘ g) (F ∘ e') b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {g : α → γ} (F : γ → δ) (f : α → β) (e' : β → γ) (b : β)
Goal: F (Function.extend f g e' b) = Function.extend f (F ∘ g) (F ∘ e') b
-- Function.extend_injective
theorem extend_injective (hf : Injective f) (e' : β → γ) : Injective fun g ↦ extend f g e' 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (e' : β → γ)
Goal: Function.Injective fun g => Function.extend f g e'
-- Function.FactorsThrough.extend_comp
lemma FactorsThrough.extend_comp {g : α → γ} (e' : β → γ) (hf : FactorsThrough g f) :
    extend f g e' ∘ f = g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : α → γ} (e' : β → γ) (hf : Function.FactorsThrough g f)
Goal: Function.extend f g e' ∘ f = g
-- Function.extend_comp
@[simp]
theorem extend_comp (hf : Injective f) (g : α → γ) (e' : β → γ) : extend f g e' ∘ f = g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g : α → γ) (e' : β → γ)
Goal: Function.extend f g e' ∘ f = g
-- Function.Injective.surjective_comp_right'
theorem Injective.surjective_comp_right' (hf : Injective f) (g₀ : β → γ) :
    Surjective fun g : β → γ ↦ g ∘ f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Injective f) (g₀ : β → γ)
Goal: Function.Surjective fun g => g ∘ f
-- Function.Injective.surjective_comp_right
theorem Injective.surjective_comp_right [Nonempty γ] (hf : Injective f) :
    Surjective fun g : β → γ ↦ g ∘ f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} [Nonempty γ] (hf : Function.Injective f)
Goal: Function.Surjective fun g => g ∘ f
-- Function.Bijective.comp_right
theorem Bijective.comp_right (hf : Bijective f) : Bijective fun g : β → γ ↦ g ∘ f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} (hf : Function.Bijective f)
Goal: Function.Bijective fun g => g ∘ f
-- Function.FactorsThrough.rfl
protected theorem rfl {α β : Sort*} {f : α → β} : FactorsThrough f f 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β}
Goal: Function.FactorsThrough f f
-- Function.FactorsThrough.comp_left
theorem comp_left {α β γ δ : Sort*} {f : α → β} {g : α → γ} (h : FactorsThrough g f) (g' : γ → δ) :
    FactorsThrough (g' ∘ g) f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {f : α → β} {g : α → γ} (h : Function.FactorsThrough g f) (g' : γ → δ)
Goal: Function.FactorsThrough (g' ∘ g) f
-- Function.FactorsThrough.comp_right
theorem comp_right {α β γ δ : Sort*} {f : α → β} {g : α → γ} (h : FactorsThrough g f) (g' : δ → α) :
    FactorsThrough (g ∘ g') (f ∘ g') 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {f : α → β} {g : α → γ} (h : Function.FactorsThrough g f) (g' : δ → α)
Goal: Function.FactorsThrough (g ∘ g') (f ∘ g')
-- Function.uncurry_def
theorem uncurry_def {α β γ} (f : α → β → γ) : uncurry f = fun p ↦ f p.1 p.2 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ)
Goal: Function.uncurry f = fun p => f p.fst p.snd
-- Function.uncurry_apply_pair
@[simp]
theorem uncurry_apply_pair {α β γ} (f : α → β → γ) (x : α) (y : β) : uncurry f (x, y) = f x y 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (x : α) (y : β)
Goal: Function.uncurry f (x, y) = f x y
-- Function.curry_apply
@[simp]
theorem curry_apply {α β γ} (f : α × β → γ) (x : α) (y : β) : curry f x y = f (x, y) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α × β → γ) (x : α) (y : β)
Goal: Function.curry f x y = f (x, y)
-- Function.uncurry_bicompr
theorem uncurry_bicompr (f : α → β → γ) (g : γ → δ) : uncurry (g ∘₂ f) = g ∘ uncurry f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β → γ) (g : γ → δ)
Goal: Function.uncurry (Function.bicompr g f) = g ∘ Function.uncurry f
-- Function.uncurry_bicompl
theorem uncurry_bicompl (f : γ → δ → ε) (g : α → γ) (h : β → δ) :
    uncurry (bicompl f g h) = uncurry f ∘ Prod.map g h 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} (f : γ → δ → ε) (g : α → γ) (h : β → δ)
Goal: Function.uncurry (Function.bicompl f g h) = Function.uncurry f ∘ Prod.map g h
-- Bool.involutive_not
theorem _root_.Bool.involutive_not : Involutive not 
Goal: Function.Involutive not
-- Function.Involutive.comp_self
@[simp]
theorem comp_self : f ∘ f = id 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f)
Goal: f ∘ f = id
-- Function.Involutive.leftInverse
protected theorem leftInverse : LeftInverse f f 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f)
Goal: Function.LeftInverse f f
-- Function.Involutive.rightInverse
protected theorem rightInverse : RightInverse f f 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f)
Goal: Function.RightInverse f f
-- Function.Involutive.injective
protected theorem injective : Injective f 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f)
Goal: Function.Injective f
-- Function.Involutive.surjective
protected theorem surjective : Surjective f 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f)
Goal: Function.Surjective f
-- Function.Involutive.bijective
protected theorem bijective : Bijective f 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f)
Goal: Function.Bijective f
-- Function.Involutive.ite_not
protected theorem ite_not (P : Prop) [Decidable P] (x : α) :
    f (ite P x (f x)) = ite (¬P) x (f x) 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f) (P : Prop) [Decidable P] (x : α)
Goal: f (if P then x else f x) = if ¬P then x else f x
-- Function.Involutive.eq_iff
protected theorem eq_iff {x y : α} : f x = y ↔ x = f y 
Arguments: {α : Sort u} {f : α → α} (h : Function.Involutive f) {x y : α}
Goal: f x = y ↔ x = f y
-- Function.not_involutive
lemma not_involutive : Involutive Not 
Goal: Function.Involutive Not
-- Function.not_injective
lemma not_injective : Injective Not 
Goal: Function.Injective Not
-- Function.not_surjective
lemma not_surjective : Surjective Not 
Goal: Function.Surjective Not
-- Function.not_bijective
lemma not_bijective : Bijective Not 
Goal: Function.Bijective Not
-- Function.symmetric_apply_eq_iff
@[simp]
lemma symmetric_apply_eq_iff {α : Sort*} {f : α → α} : Symmetric (f · = ·) ↔ Involutive f 
Arguments: {α : Sort u_1} {f : α → α}
Goal: (Symmetric fun x x_1 => f x = x_1) ↔ Function.Involutive f
-- Function.Injective2.left
protected theorem left (hf : Injective2 f) (b : β) : Function.Injective fun a ↦ f a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) (b : β)
Goal: Function.Injective fun a => f a b
-- Function.Injective2.right
protected theorem right (hf : Injective2 f) (a : α) : Function.Injective (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) (a : α)
Goal: Function.Injective (f a)
-- Function.Injective2.uncurry
protected theorem uncurry {α β γ : Type*} {f : α → β → γ} (hf : Injective2 f) :
    Function.Injective (uncurry f) 
Arguments: {α : Type u_4} {β : Type u_5} {γ : Type u_6} {f : α → β → γ} (hf : Function.Injective2 f)
Goal: Function.Injective (Function.uncurry f)
-- Function.Injective2.left'
theorem left' (hf : Injective2 f) [Nonempty β] : Function.Injective f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) [Nonempty β]
Goal: Function.Injective f
-- Function.Injective2.right'
theorem right' (hf : Injective2 f) [Nonempty α] : Function.Injective fun b a ↦ f a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) [Nonempty α]
Goal: Function.Injective fun b a => f a b
-- Function.Injective2.eq_iff
theorem eq_iff (hf : Injective2 f) {a₁ a₂ b₁ b₂} : f a₁ b₁ = f a₂ b₂ ↔ a₁ = a₂ ∧ b₁ = b₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β → γ} (hf : Function.Injective2 f) {a₁ a₂ : α} {b₁ b₂ : β}
Goal: f a₁ b₁ = f a₂ b₂ ↔ a₁ = a₂ ∧ b₁ = b₂
-- Function.sometimes_eq
theorem sometimes_eq {p : Prop} {α} [Nonempty α] (f : p → α) (a : p) : sometimes f = f a 
Arguments: {p : Prop} {α : Sort u_1} [Nonempty α] (f : p → α) (a : p)
Goal: Function.sometimes f = f a
-- Function.sometimes_spec
theorem sometimes_spec {p : Prop} {α} [Nonempty α] (P : α → Prop) (f : p → α) (a : p)
    (h : P (f a)) : P (sometimes f) 
Arguments: {p : Prop} {α : Sort u_1} [Nonempty α] (P : α → Prop) (f : p → α) (a : p) (h : P (f a))
Goal: P (Function.sometimes f)
-- forall_existsUnique_iff
lemma forall_existsUnique_iff {r : α → β → Prop} :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → β, ∀ {a b}, r a b ↔ f a = b 
Arguments: {α : Sort u_1} {β : Sort u_2} {r : α → β → Prop}
Goal: (∀ (a : α), ∃! b, r a b) ↔ ∃ f, ∀ {a : α} {b : β}, r a b ↔ f a = b
-- forall_existsUnique_iff'
lemma forall_existsUnique_iff' {r : α → β → Prop} :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → β, r = (f · = ·) 
Arguments: {α : Sort u_1} {β : Sort u_2} {r : α → β → Prop}
Goal: (∀ (a : α), ∃! b, r a b) ↔ ∃ f, r = fun x x_1 => f x = x_1
-- Symmetric.forall_existsUnique_iff'
protected lemma Symmetric.forall_existsUnique_iff' {r : α → α → Prop} (hr : Symmetric r) :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → α, Involutive f ∧ r = (f · = ·) 
Arguments: {α : Sort u_1} {r : α → α → Prop} (hr : Symmetric r)
Goal: (∀ (a : α), ∃! b, r a b) ↔ ∃ f, Function.Involutive f ∧ r = fun x x_1 => f x = x_1
-- Symmetric.forall_existsUnique_iff
protected lemma Symmetric.forall_existsUnique_iff {r : α → α → Prop} (hr : Symmetric r) :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → α, Involutive f ∧ ∀ {a b}, r a b ↔ f a = b 
Arguments: {α : Sort u_1} {r : α → α → Prop} (hr : Symmetric r)
Goal: (∀ (a : α), ∃! b, r a b) ↔ ∃ f, Function.Involutive f ∧ ∀ {a b : α}, r a b ↔ f a = b
-- eq_rec_on_bijective
theorem eq_rec_on_bijective {C : α → Sort*} :
    ∀ {a a' : α} (h : a = a'), Function.Bijective (@Eq.ndrec _ _ C · _ h)
  
Arguments: {α : Sort u_1} {C : α → Sort u_3} {a a' : α} (h : a = a')
Goal: Function.Bijective fun x => h ▸ x
-- eq_mp_bijective
theorem eq_mp_bijective {α β : Sort _} (h : α = β) : Function.Bijective (Eq.mp h) 
Arguments: {α β : Sort u_3} (h : α = β)
Goal: Function.Bijective h.mp
-- eq_mpr_bijective
theorem eq_mpr_bijective {α β : Sort _} (h : α = β) : Function.Bijective (Eq.mpr h) 
Arguments: {α β : Sort u_3} (h : α = β)
Goal: Function.Bijective h.mpr
-- cast_bijective
theorem cast_bijective {α β : Sort _} (h : α = β) : Function.Bijective (cast h) 
Arguments: {α β : Sort u_3} (h : α = β)
Goal: Function.Bijective (cast h)