ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PartialEquiv.disjointUnion_eq_piecewise
theorem disjointUnion_eq_piecewise (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source)
    (ht : Disjoint e.target e'.target) [∀ x, Decidable (x ∈ e.source)]
    [∀ y, Decidable (y ∈ e.target)] :
    e.disjointUnion e' hs ht =
      e.piecewise e' e.source e.target e.isImage_source_target
        (e'.isImage_source_target_of_disjoint _ hs.symm ht.symm) 
Arguments: {α : Type u_1} {β : Type u_2} (e e' : PartialEquiv α β) (hs : Disjoint e.source e'.source) (ht : Disjoint e.target e'.target) [(x : α) → Decidable (x ∈ e.source)] [(y : β) → Decidable (y ∈ e.target)]
Goal: e.disjointUnion e' hs ht = e.piecewise e' e.source e.target ⋯ ⋯
-- PartialEquiv.pi_source
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i) 
Arguments: {ι : Type u_5} {αi : ι → Type u_6} {βi : ι → Type u_7} (ei : (i : ι) → PartialEquiv (αi i) (βi i))
Goal: (PartialEquiv.pi ei).source = Set.univ.pi fun i => (ei i).source
-- PartialEquiv.pi_apply
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i) 
Arguments: {ι : Type u_5} {αi : ι → Type u_6} {βi : ι → Type u_7} (ei : (i : ι) → PartialEquiv (αi i) (βi i))
Goal: ↑(PartialEquiv.pi ei) = fun f i => ↑(ei i) (f i)
-- PartialEquiv.pi_target
@[simps (config := mfld_cfg) apply source target]
protected def pi (ei : ∀ i, PartialEquiv (αi i) (βi i)) : PartialEquiv (∀ i, αi i) (∀ i, βi i) 
Arguments: {ι : Type u_5} {αi : ι → Type u_6} {βi : ι → Type u_7} (ei : (i : ι) → PartialEquiv (αi i) (βi i))
Goal: (PartialEquiv.pi ei).target = Set.univ.pi fun i => (ei i).target
-- PartialEquiv.pi_symm
@[simp, mfld_simps]
theorem pi_symm (ei : ∀ i, PartialEquiv (αi i) (βi i)) :
    (PartialEquiv.pi ei).symm = .pi fun i ↦ (ei i).symm 
Arguments: {ι : Type u_5} {αi : ι → Type u_6} {βi : ι → Type u_7} (ei : (i : ι) → PartialEquiv (αi i) (βi i))
Goal: (PartialEquiv.pi ei).symm = PartialEquiv.pi fun i => (ei i).symm
-- PartialEquiv.pi_symm_apply
theorem pi_symm_apply (ei : ∀ i, PartialEquiv (αi i) (βi i)) :
    ⇑(PartialEquiv.pi ei).symm = fun f i ↦ (ei i).symm (f i) 
Arguments: {ι : Type u_5} {αi : ι → Type u_6} {βi : ι → Type u_7} (ei : (i : ι) → PartialEquiv (αi i) (βi i))
Goal: ↑(PartialEquiv.pi ei).symm = fun f i => ↑(ei i).symm (f i)
-- PartialEquiv.pi_refl
@[simp, mfld_simps]
theorem pi_refl : (PartialEquiv.pi fun i ↦ PartialEquiv.refl (αi i)) = .refl (∀ i, αi i) 
Arguments: {ι : Type u_5} {αi : ι → Type u_6}
Goal: (PartialEquiv.pi fun i => PartialEquiv.refl (αi i)) = PartialEquiv.refl ((i : ι) → αi i)
-- PartialEquiv.pi_trans
@[simp, mfld_simps]
theorem pi_trans (ei : ∀ i, PartialEquiv (αi i) (βi i)) (ei' : ∀ i, PartialEquiv (βi i) (γi i)) :
    (PartialEquiv.pi ei).trans (PartialEquiv.pi ei') = .pi fun i ↦ (ei i).trans (ei' i) 
Arguments: {ι : Type u_5} {αi : ι → Type u_6} {βi : ι → Type u_7} {γi : ι → Type u_8} (ei : (i : ι) → PartialEquiv (αi i) (βi i)) (ei' : (i : ι) → PartialEquiv (βi i) (γi i))
Goal: (PartialEquiv.pi ei).trans (PartialEquiv.pi ei') = PartialEquiv.pi fun i => (ei i).trans (ei' i)
-- Set.BijOn.toPartialEquiv_target
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
Arguments: {α : Type u_1} {β : Type u_2} [Nonempty α] (f : α → β) (s : Set α) (t : Set β) (hf : Set.BijOn f s t)
Goal: (Set.BijOn.toPartialEquiv f s t hf).target = t
-- Set.BijOn.toPartialEquiv_symm_apply
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
Arguments: {α : Type u_1} {β : Type u_2} [Nonempty α] (f : α → β) (s : Set α) (t : Set β) (hf : Set.BijOn f s t)
Goal: ↑(Set.BijOn.toPartialEquiv f s t hf).symm = Function.invFunOn f s
-- Set.BijOn.toPartialEquiv_source
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
Arguments: {α : Type u_1} {β : Type u_2} [Nonempty α] (f : α → β) (s : Set α) (t : Set β) (hf : Set.BijOn f s t)
Goal: (Set.BijOn.toPartialEquiv f s t hf).source = s
-- Set.BijOn.toPartialEquiv_apply
@[simps (config := .asFn)]
noncomputable def BijOn.toPartialEquiv [Nonempty α] (f : α → β) (s : Set α) (t : Set β)
    (hf : BijOn f s t) : PartialEquiv α β 
Arguments: {α : Type u_1} {β : Type u_2} [Nonempty α] (f : α → β) (s : Set α) (t : Set β) (hf : Set.BijOn f s t)
Goal: ↑(Set.BijOn.toPartialEquiv f s t hf) = f
-- Equiv.refl_toPartialEquiv
@[simp, mfld_simps]
theorem refl_toPartialEquiv : (Equiv.refl α).toPartialEquiv = PartialEquiv.refl α 
Arguments: {α : Type u_1}
Goal: (Equiv.refl α).toPartialEquiv = PartialEquiv.refl α
-- Equiv.symm_toPartialEquiv
@[simp, mfld_simps]
theorem symm_toPartialEquiv : e.symm.toPartialEquiv = e.toPartialEquiv.symm 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: e.symm.toPartialEquiv = e.toPartialEquiv.symm
-- Equiv.trans_toPartialEquiv
@[simp, mfld_simps]
theorem trans_toPartialEquiv :
    (e.trans e').toPartialEquiv = e.toPartialEquiv.trans e'.toPartialEquiv 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (e' : β ≃ γ)
Goal: (e.trans e').toPartialEquiv = e.toPartialEquiv.trans e'.toPartialEquiv
-- Equiv.transPartialEquiv_symm_apply
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ)
Goal: ∀ (a : γ), ↑(e.transPartialEquiv f').symm a = e.symm (↑f'.symm a)
-- Equiv.transPartialEquiv_source
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ)
Goal: (e.transPartialEquiv f').source = ⇑e ⁻¹' f'.source
-- Equiv.transPartialEquiv_apply
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ)
Goal: ∀ (a : α), ↑(e.transPartialEquiv f') a = ↑f' (e a)
-- Equiv.transPartialEquiv_target
@[simps!]
def transPartialEquiv (e : α ≃ β) (f' : PartialEquiv β γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ)
Goal: (e.transPartialEquiv f').target = f'.target
-- Equiv.transPartialEquiv_eq_trans
theorem transPartialEquiv_eq_trans (e : α ≃ β) (f' : PartialEquiv β γ) :
    e.transPartialEquiv f' = e.toPartialEquiv.trans f' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ)
Goal: e.transPartialEquiv f' = e.toPartialEquiv.trans f'
-- Equiv.transPartialEquiv_trans
@[simp, mfld_simps]
theorem transPartialEquiv_trans (e : α ≃ β) (f' : PartialEquiv β γ) (f'' : PartialEquiv γ δ) :
    (e.transPartialEquiv f').trans f'' = e.transPartialEquiv (f'.trans f'') 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e : α ≃ β) (f' : PartialEquiv β γ) (f'' : PartialEquiv γ δ)
Goal: (e.transPartialEquiv f').trans f'' = e.transPartialEquiv (f'.trans f'')
-- Equiv.trans_transPartialEquiv
@[simp, mfld_simps]
theorem trans_transPartialEquiv (e : α ≃ β) (e' : β ≃ γ) (f'' : PartialEquiv γ δ) :
    (e.trans e').transPartialEquiv f'' = e.transPartialEquiv (e'.transPartialEquiv f'') 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e : α ≃ β) (e' : β ≃ γ) (f'' : PartialEquiv γ δ)
Goal: (e.trans e').transPartialEquiv f'' = e.transPartialEquiv (e'.transPartialEquiv f'')
-- PartialEquiv.transEquiv_symm_apply
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ)
Goal: ∀ (a : γ), ↑(e.transEquiv f').symm a = ↑e.symm (f'.symm a)
-- PartialEquiv.transEquiv_apply
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ)
Goal: ∀ (a : α), ↑(e.transEquiv f') a = f' (↑e a)
-- PartialEquiv.transEquiv_source
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ)
Goal: (e.transEquiv f').source = e.source
-- PartialEquiv.transEquiv_target
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ)
Goal: (e.transEquiv f').target = ⇑f'.symm ⁻¹' e.target
-- PartialEquiv.transEquiv_eq_trans
theorem transEquiv_eq_trans (e : PartialEquiv α β) (e' : β ≃ γ) :
    e.transEquiv e' = e.trans e'.toPartialEquiv 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (e' : β ≃ γ)
Goal: e.transEquiv e' = e.trans e'.toPartialEquiv
-- PartialEquiv.transEquiv_transEquiv
@[simp, mfld_simps]
theorem transEquiv_transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) (f'' : γ ≃ δ) :
    (e.transEquiv f').transEquiv f'' = e.transEquiv (f'.trans f'') 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e : PartialEquiv α β) (f' : β ≃ γ) (f'' : γ ≃ δ)
Goal: (e.transEquiv f').transEquiv f'' = e.transEquiv (f'.trans f'')
-- PartialEquiv.trans_transEquiv
@[simp, mfld_simps]
theorem trans_transEquiv (e : PartialEquiv α β) (e' : PartialEquiv β γ) (f'' : γ ≃ δ) :
    (e.trans e').transEquiv f'' = e.trans (e'.transEquiv f'') 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e : PartialEquiv α β) (e' : PartialEquiv β γ) (f'' : γ ≃ δ)
Goal: (e.trans e').transEquiv f'' = e.trans (e'.transEquiv f'')
-- Function.semiconj_iff_comp_eq
lemma _root_.Function.semiconj_iff_comp_eq : Semiconj f ga gb ↔ f ∘ ga = gb ∘ f 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β}
Goal: Function.Semiconj f ga gb ↔ f ∘ ga = gb ∘ f
-- Function.Semiconj.eq
protected theorem eq (h : Semiconj f ga gb) (x : α) : f (ga x) = gb (f x) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β} (h : Function.Semiconj f ga gb) (x : α)
Goal: f (ga x) = gb (f x)
-- Function.Semiconj.comp_right
theorem comp_right (h : Semiconj f ga gb) (h' : Semiconj f ga' gb') :
    Semiconj f (ga ∘ ga') (gb ∘ gb') 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga ga' : α → α} {gb gb' : β → β} (h : Function.Semiconj f ga gb) (h' : Function.Semiconj f ga' gb')
Goal: Function.Semiconj f (ga ∘ ga') (gb ∘ gb')
-- Function.Semiconj.trans
protected theorem trans (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) :
    Semiconj (fbc ∘ fab) ga gc 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {fab : α → β} {fbc : β → γ} {ga : α → α} {gb : β → β} {gc : γ → γ} (hab : Function.Semiconj fab ga gb) (hbc : Function.Semiconj fbc gb gc)
Goal: Function.Semiconj (fbc ∘ fab) ga gc
-- Function.Semiconj.comp_left
theorem comp_left (hbc : Semiconj fbc gb gc) (hab : Semiconj fab ga gb) :
    Semiconj (fbc ∘ fab) ga gc 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {fab : α → β} {fbc : β → γ} {ga : α → α} {gb : β → β} {gc : γ → γ} (hbc : Function.Semiconj fbc gb gc) (hab : Function.Semiconj fab ga gb)
Goal: Function.Semiconj (fbc ∘ fab) ga gc
-- Function.Semiconj.id_right
theorem id_right : Semiconj f id id 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β}
Goal: Function.Semiconj f id id
-- Function.Semiconj.id_left
theorem id_left : Semiconj id ga ga 
Arguments: {α : Type u_1} {ga : α → α}
Goal: Function.Semiconj id ga ga
-- Function.Semiconj.inverses_right
theorem inverses_right (h : Semiconj f ga gb) (ha : RightInverse ga' ga) (hb : LeftInverse gb' gb) :
    Semiconj f ga' gb' 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga ga' : α → α} {gb gb' : β → β} (h : Function.Semiconj f ga gb) (ha : Function.RightInverse ga' ga) (hb : Function.LeftInverse gb' gb)
Goal: Function.Semiconj f ga' gb'
-- Function.Semiconj.inverse_left
lemma inverse_left {f' : β → α} (h : Semiconj f ga gb)
    (hf₁ : LeftInverse f' f) (hf₂ : RightInverse f' f) : Semiconj f' gb ga 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β} {f' : β → α} (h : Function.Semiconj f ga gb) (hf₁ : Function.LeftInverse f' f) (hf₂ : Function.RightInverse f' f)
Goal: Function.Semiconj f' gb ga
-- Function.Semiconj.option_map
theorem option_map {f : α → β} {ga : α → α} {gb : β → β} (h : Semiconj f ga gb) :
    Semiconj (Option.map f) (Option.map ga) (Option.map gb)
  
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β} (h : Function.Semiconj f ga gb)
Goal: Function.Semiconj (Option.map f) (Option.map ga) (Option.map gb)
-- Function.Semiconj.commute
theorem Semiconj.commute {f g : α → α} (h : Semiconj f g g) : Commute f g 
Arguments: {α : Type u_1} {f g : α → α} (h : Function.Semiconj f g g)
Goal: Function.Commute f g
-- Function.Commute.semiconj
theorem semiconj (h : Commute f g) : Semiconj f g g 
Arguments: {α : Type u_1} {f g : α → α} (h : Function.Commute f g)
Goal: Function.Semiconj f g g
-- Function.Commute.refl
@[refl]
theorem refl (f : α → α) : Commute f f 
Arguments: {α : Type u_1} (f : α → α)
Goal: Function.Commute f f
-- Function.Commute.symm
@[symm]
theorem symm (h : Commute f g) : Commute g f 
Arguments: {α : Type u_1} {f g : α → α} (h : Function.Commute f g)
Goal: Function.Commute g f
-- Function.Commute.comp_right
theorem comp_right (h : Commute f g) (h' : Commute f g') : Commute f (g ∘ g') 
Arguments: {α : Type u_1} {f g g' : α → α} (h : Function.Commute f g) (h' : Function.Commute f g')
Goal: Function.Commute f (g ∘ g')
-- Function.Commute.comp_left
nonrec theorem comp_left (h : Commute f g) (h' : Commute f' g) : Commute (f ∘ f') g 
Arguments: {α : Type u_1} {f f' g : α → α} (h : Function.Commute f g) (h' : Function.Commute f' g)
Goal: Function.Commute (f ∘ f') g
-- Function.Commute.id_right
theorem id_right : Commute f id 
Arguments: {α : Type u_1} {f : α → α}
Goal: Function.Commute f id
-- Function.Commute.id_left
theorem id_left : Commute id f 
Arguments: {α : Type u_1} {f : α → α}
Goal: Function.Commute id f
-- Function.Commute.option_map
nonrec theorem option_map {f g : α → α} (h : Commute f g) : Commute (Option.map f) (Option.map g) 
Arguments: {α : Type u_1} {f g : α → α} (h : Function.Commute f g)
Goal: Function.Commute (Option.map f) (Option.map g)
-- Function.Semiconj₂.eq
protected theorem eq (h : Semiconj₂ f ga gb) (x y : α) : f (ga x y) = gb (f x) (f y) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α → α} {gb : β → β → β} (h : Function.Semiconj₂ f ga gb) (x y : α)
Goal: f (ga x y) = gb (f x) (f y)
-- Function.Semiconj₂.comp_eq
protected theorem comp_eq (h : Semiconj₂ f ga gb) : bicompr f ga = bicompl gb f f 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α → α} {gb : β → β → β} (h : Function.Semiconj₂ f ga gb)
Goal: Function.bicompr f ga = Function.bicompl gb f f
-- Function.Semiconj₂.id_left
theorem id_left (op : α → α → α) : Semiconj₂ id op op 
Arguments: {α : Type u_1} (op : α → α → α)
Goal: Function.Semiconj₂ id op op
-- Function.Semiconj₂.comp
theorem comp {f' : β → γ} {gc : γ → γ → γ} (hf' : Semiconj₂ f' gb gc) (hf : Semiconj₂ f ga gb) :
    Semiconj₂ (f' ∘ f) ga gc 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {ga : α → α → α} {gb : β → β → β} {f' : β → γ} {gc : γ → γ → γ} (hf' : Function.Semiconj₂ f' gb gc) (hf : Function.Semiconj₂ f ga gb)
Goal: Function.Semiconj₂ (f' ∘ f) ga gc
-- Function.Semiconj₂.isAssociative_right
theorem isAssociative_right [Std.Associative ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
    Std.Associative gb 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α → α} {gb : β → β → β} [Std.Associative ga] (h : Function.Semiconj₂ f ga gb) (h_surj : Function.Surjective f)
Goal: Std.Associative gb
-- Function.Semiconj₂.isAssociative_left
theorem isAssociative_left [Std.Associative gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
    Std.Associative ga 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α → α} {gb : β → β → β} [Std.Associative gb] (h : Function.Semiconj₂ f ga gb) (h_inj : Function.Injective f)
Goal: Std.Associative ga
-- Function.Semiconj₂.isIdempotent_right
theorem isIdempotent_right [Std.IdempotentOp ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
    Std.IdempotentOp gb 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α → α} {gb : β → β → β} [Std.IdempotentOp ga] (h : Function.Semiconj₂ f ga gb) (h_surj : Function.Surjective f)
Goal: Std.IdempotentOp gb
-- Function.Semiconj₂.isIdempotent_left
theorem isIdempotent_left [Std.IdempotentOp gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
    Std.IdempotentOp ga 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α → α} {gb : β → β → β} [Std.IdempotentOp gb] (h : Function.Semiconj₂ f ga gb) (h_inj : Function.Injective f)
Goal: Std.IdempotentOp ga
-- small_of_injective
theorem small_of_injective {α : Type v} {β : Type w} [Small.{u} β] {f : α → β}
    (hf : Function.Injective f) : Small.{u} α 
Arguments: {α : Type v} {β : Type w} [Small.{u, w} β] {f : α → β} (hf : Function.Injective f)
Goal: Small.{u, v} α
-- small_of_surjective
theorem small_of_surjective {α : Type v} {β : Type w} [Small.{u} α] {f : α → β}
    (hf : Function.Surjective f) : Small.{u} β 
Arguments: {α : Type v} {β : Type w} [Small.{u, v} α] {f : α → β} (hf : Function.Surjective f)
Goal: Small.{u, w} β
-- small_of_injective_of_exists
theorem small_of_injective_of_exists {α : Type v} {β : Type w} {γ : Type v'} [Small.{u} α]
    (f : α → γ) {g : β → γ} (hg : Function.Injective g) (h : ∀ b : β, ∃ a : α, f a = g b) :
    Small.{u} β 
Arguments: {α : Type v} {β : Type w} {γ : Type v'} [Small.{u, v} α] (f : α → γ) {g : β → γ} (hg : Function.Injective g) (h : ∀ (b : β), ∃ a, f a = g b)
Goal: Small.{u, w} β
-- Function.iterate_zero
@[simp]
theorem iterate_zero : f^[0] = id 
Arguments: {α : Type u} (f : α → α)
Goal: f^[0] = id
-- Function.iterate_zero_apply
theorem iterate_zero_apply (x : α) : f^[0] x = x 
Arguments: {α : Type u} (f : α → α) (x : α)
Goal: f^[0] x = x
-- Function.iterate_succ
@[simp]
theorem iterate_succ (n : ℕ) : f^[n.succ] = f^[n] ∘ f 
Arguments: {α : Type u} (f : α → α) (n : ℕ)
Goal: f^[n.succ] = f^[n] ∘ f
-- Function.iterate_succ_apply
theorem iterate_succ_apply (n : ℕ) (x : α) : f^[n.succ] x = f^[n] (f x) 
Arguments: {α : Type u} (f : α → α) (n : ℕ) (x : α)
Goal: f^[n.succ] x = f^[n] (f x)
-- Function.iterate_id
@[simp]
theorem iterate_id (n : ℕ) : (id : α → α)^[n] = id 
Arguments: {α : Type u} (n : ℕ)
Goal: id^[n] = id
-- Function.iterate_add
theorem iterate_add (m : ℕ) : ∀ n : ℕ, f^[m + n] = f^[m] ∘ f^[n]
  
Arguments: {α : Type u} (f : α → α) (m n : ℕ)
Goal: f^[m + n] = f^[m] ∘ f^[n]
-- Function.iterate_add_apply
theorem iterate_add_apply (m n : ℕ) (x : α) : f^[m + n] x = f^[m] (f^[n] x) 
Arguments: {α : Type u} (f : α → α) (m n : ℕ) (x : α)
Goal: f^[m + n] x = f^[m] (f^[n] x)
-- Function.iterate_one
@[simp high]
theorem iterate_one : f^[1] = f 
Arguments: {α : Type u} (f : α → α)
Goal: f^[1] = f
-- Function.iterate_mul
theorem iterate_mul (m : ℕ) : ∀ n, f^[m * n] = f^[m]^[n]
  
Arguments: {α : Type u} (f : α → α) (m n : ℕ)
Goal: f^[m * n] = f^[m]^[n]
-- Function.iterate_fixed
theorem iterate_fixed {x} (h : f x = x) (n : ℕ) : f^[n] x = x 
Arguments: {α : Type u} {f : α → α} {x : α} (h : f x = x) (n : ℕ)
Goal: f^[n] x = x
-- Function.Injective.iterate
theorem Injective.iterate (Hinj : Injective f) (n : ℕ) : Injective f^[n] 
Arguments: {α : Type u} {f : α → α} (Hinj : Function.Injective f) (n : ℕ)
Goal: Function.Injective f^[n]
-- Function.Surjective.iterate
theorem Surjective.iterate (Hsurj : Surjective f) (n : ℕ) : Surjective f^[n] 
Arguments: {α : Type u} {f : α → α} (Hsurj : Function.Surjective f) (n : ℕ)
Goal: Function.Surjective f^[n]
-- Function.Bijective.iterate
theorem Bijective.iterate (Hbij : Bijective f) (n : ℕ) : Bijective f^[n] 
Arguments: {α : Type u} {f : α → α} (Hbij : Function.Bijective f) (n : ℕ)
Goal: Function.Bijective f^[n]
-- Function.Semiconj.iterate_right
theorem iterate_right {f : α → β} {ga : α → α} {gb : β → β} (h : Semiconj f ga gb) (n : ℕ) :
    Semiconj f ga^[n] gb^[n] 
Arguments: {α : Type u} {β : Type v} {f : α → β} {ga : α → α} {gb : β → β} (h : Function.Semiconj f ga gb) (n : ℕ)
Goal: Function.Semiconj f ga^[n] gb^[n]
-- Function.Semiconj.iterate_left
theorem iterate_left {g : ℕ → α → α} (H : ∀ n, Semiconj f (g n) (g <| n + 1)) (n k : ℕ) :
    Semiconj f^[n] (g k) (g <| n + k) 
Arguments: {α : Type u} {f : α → α} {g : ℕ → α → α} (H : ∀ (n : ℕ), Function.Semiconj f (g n) (g (n + 1))) (n k : ℕ)
Goal: Function.Semiconj f^[n] (g k) (g (n + k))
-- Function.Commute.iterate_right
theorem iterate_right (h : Commute f g) (n : ℕ) : Commute f g^[n] 
Arguments: {α : Type u} {f g : α → α} (h : Function.Commute f g) (n : ℕ)
Goal: Function.Commute f g^[n]
-- Function.Commute.iterate_left
theorem iterate_left (h : Commute f g) (n : ℕ) : Commute f^[n] g 
Arguments: {α : Type u} {f g : α → α} (h : Function.Commute f g) (n : ℕ)
Goal: Function.Commute f^[n] g
-- Function.Commute.iterate_iterate
theorem iterate_iterate (h : Commute f g) (m n : ℕ) : Commute f^[m] g^[n] 
Arguments: {α : Type u} {f g : α → α} (h : Function.Commute f g) (m n : ℕ)
Goal: Function.Commute f^[m] g^[n]
-- Function.Commute.iterate_eq_of_map_eq
theorem iterate_eq_of_map_eq (h : Commute f g) (n : ℕ) {x} (hx : f x = g x) :
    f^[n] x = g^[n] x 
Arguments: {α : Type u} {f g : α → α} (h : Function.Commute f g) (n : ℕ) {x : α} (hx : f x = g x)
Goal: f^[n] x = g^[n] x
-- Function.Commute.comp_iterate
theorem comp_iterate (h : Commute f g) (n : ℕ) : (f ∘ g)^[n] = f^[n] ∘ g^[n] 
Arguments: {α : Type u} {f g : α → α} (h : Function.Commute f g) (n : ℕ)
Goal: (f ∘ g)^[n] = f^[n] ∘ g^[n]
-- Function.Commute.iterate_self
theorem iterate_self (n : ℕ) : Commute f^[n] f 
Arguments: {α : Type u} (f : α → α) (n : ℕ)
Goal: Function.Commute f^[n] f
-- Function.Commute.self_iterate
theorem self_iterate (n : ℕ) : Commute f f^[n] 
Arguments: {α : Type u} (f : α → α) (n : ℕ)
Goal: Function.Commute f f^[n]
-- Function.Commute.iterate_iterate_self
theorem iterate_iterate_self (m n : ℕ) : Commute f^[m] f^[n] 
Arguments: {α : Type u} (f : α → α) (m n : ℕ)
Goal: Function.Commute f^[m] f^[n]
-- Function.Semiconj₂.iterate
theorem Semiconj₂.iterate {f : α → α} {op : α → α → α} (hf : Semiconj₂ f op op) (n : ℕ) :
    Semiconj₂ f^[n] op op 
Arguments: {α : Type u} {f : α → α} {op : α → α → α} (hf : Function.Semiconj₂ f op op) (n : ℕ)
Goal: Function.Semiconj₂ f^[n] op op
-- Function.iterate_succ'
theorem iterate_succ' (n : ℕ) : f^[n.succ] = f ∘ f^[n] 
Arguments: {α : Type u} (f : α → α) (n : ℕ)
Goal: f^[n.succ] = f ∘ f^[n]
-- Function.iterate_succ_apply'
theorem iterate_succ_apply' (n : ℕ) (x : α) : f^[n.succ] x = f (f^[n] x) 
Arguments: {α : Type u} (f : α → α) (n : ℕ) (x : α)
Goal: f^[n.succ] x = f (f^[n] x)
-- Function.iterate_pred_comp_of_pos
theorem iterate_pred_comp_of_pos {n : ℕ} (hn : 0 < n) : f^[n.pred] ∘ f = f^[n] 
Arguments: {α : Type u} (f : α → α) {n : ℕ} (hn : 0 < n)
Goal: f^[n.pred] ∘ f = f^[n]
-- Function.comp_iterate_pred_of_pos
theorem comp_iterate_pred_of_pos {n : ℕ} (hn : 0 < n) : f ∘ f^[n.pred] = f^[n] 
Arguments: {α : Type u} (f : α → α) {n : ℕ} (hn : 0 < n)
Goal: f ∘ f^[n.pred] = f^[n]
-- Function.Iterate.rec_zero
theorem Iterate.rec_zero (p : α → Sort*) {f : α → α} (h : ∀ a, p a → p (f a)) {a : α} (ha : p a) :
    Iterate.rec p h ha 0 = ha 
Arguments: {α : Type u} (p : α → Sort u_1) {f : α → α} (h : (a : α) → p a → p (f a)) {a : α} (ha : p a)
Goal: Function.Iterate.rec p h ha 0 = ha
-- Function.LeftInverse.iterate
theorem LeftInverse.iterate {g : α → α} (hg : LeftInverse g f) (n : ℕ) :
    LeftInverse g^[n] f^[n] 
Arguments: {α : Type u} {f g : α → α} (hg : Function.LeftInverse g f) (n : ℕ)
Goal: Function.LeftInverse g^[n] f^[n]
-- Function.RightInverse.iterate
theorem RightInverse.iterate {g : α → α} (hg : RightInverse g f) (n : ℕ) :
    RightInverse g^[n] f^[n] 
Arguments: {α : Type u} {f g : α → α} (hg : Function.RightInverse g f) (n : ℕ)
Goal: Function.RightInverse g^[n] f^[n]