ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.Perm.ext_iff
protected theorem Perm.ext_iff {σ τ : Equiv.Perm α} : σ = τ ↔ ∀ x, σ x = τ x 
Arguments: {α : Sort u} {σ τ : Equiv.Perm α}
Goal: σ = τ ↔ ∀ (x : α), σ x = τ x
-- Equiv.left_inv'
theorem left_inv' (e : α ≃ β) : Function.LeftInverse e.symm e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Function.LeftInverse ⇑e.symm ⇑e
-- Equiv.right_inv'
theorem right_inv' (e : α ≃ β) : Function.RightInverse e.symm e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Function.RightInverse ⇑e.symm ⇑e
-- Equiv.instTrans_trans
@[simps]
instance : Trans Equiv Equiv Equiv 
Goal: ∀ {a : Sort u_2} {b : Sort u_1} {c : Sort u_3} (e₁ : a ≃ b) (e₂ : b ≃ c), Trans.trans e₁ e₂ = e₁.trans e₂
-- Equiv.toFun_as_coe
@[simp, mfld_simps] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: e.toFun = ⇑e
-- Equiv.invFun_as_coe
@[simp, mfld_simps] theorem invFun_as_coe (e : α ≃ β) : e.invFun = e.symm 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: e.invFun = ⇑e.symm
-- Equiv.injective
protected theorem injective (e : α ≃ β) : Injective e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Function.Injective ⇑e
-- Equiv.surjective
protected theorem surjective (e : α ≃ β) : Surjective e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Function.Surjective ⇑e
-- Equiv.bijective
protected theorem bijective (e : α ≃ β) : Bijective e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Function.Bijective ⇑e
-- Equiv.subsingleton
protected theorem subsingleton (e : α ≃ β) [Subsingleton β] : Subsingleton α 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β) [Subsingleton β]
Goal: Subsingleton α
-- Equiv.subsingleton.symm
protected theorem subsingleton.symm (e : α ≃ β) [Subsingleton α] : Subsingleton β 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β) [Subsingleton α]
Goal: Subsingleton β
-- Equiv.subsingleton_congr
theorem subsingleton_congr (e : α ≃ β) : Subsingleton α ↔ Subsingleton β 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Subsingleton α ↔ Subsingleton β
-- Equiv.Perm.subsingleton_eq_refl
theorem Perm.subsingleton_eq_refl [Subsingleton α] (e : Perm α) : e = Equiv.refl α 
Arguments: {α : Sort u} [Subsingleton α] (e : Equiv.Perm α)
Goal: e = Equiv.refl α
-- Equiv.nonempty_congr
theorem nonempty_congr (e : α ≃ β) : Nonempty α ↔ Nonempty β 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: Nonempty α ↔ Nonempty β
-- Equiv.nonempty
protected theorem nonempty (e : α ≃ β) [Nonempty β] : Nonempty α 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β) [Nonempty β]
Goal: Nonempty α
-- Equiv.coe_fn_symm_mk
@[simp] theorem coe_fn_symm_mk (f : α → β) (g l r) : ((Equiv.mk f g l r).symm : β → α) = g 
Arguments: {α : Sort u} {β : Sort v} (f : α → β) (g : β → α) (l : Function.LeftInverse g f) (r : Function.RightInverse g f)
Goal: ⇑{ toFun := f, invFun := g, left_inv := l, right_inv := r }.symm = g
-- Equiv.coe_refl
@[simp] theorem coe_refl : (Equiv.refl α : α → α) = id 
Arguments: {α : Sort u}
Goal: ⇑(Equiv.refl α) = id
-- Equiv.Perm.coe_subsingleton
theorem Perm.coe_subsingleton {α : Type*} [Subsingleton α] (e : Perm α) : (e : α → α) = id 
Arguments: {α : Type u_1} [Subsingleton α] (e : Equiv.Perm α)
Goal: ⇑e = id
-- Equiv.refl_apply
@[simp] theorem refl_apply (x : α) : Equiv.refl α x = x 
Arguments: {α : Sort u} (x : α)
Goal: (Equiv.refl α) x = x
-- Equiv.coe_trans
@[simp] theorem coe_trans (f : α ≃ β) (g : β ≃ γ) : (f.trans g : α → γ) = g ∘ f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (f : α ≃ β) (g : β ≃ γ)
Goal: ⇑(f.trans g) = ⇑g ∘ ⇑f
-- Equiv.trans_apply
@[simp] theorem trans_apply (f : α ≃ β) (g : β ≃ γ) (a : α) : (f.trans g) a = g (f a) 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (f : α ≃ β) (g : β ≃ γ) (a : α)
Goal: (f.trans g) a = g (f a)
-- Equiv.apply_symm_apply
@[simp] theorem apply_symm_apply (e : α ≃ β) (x : β) : e (e.symm x) = x 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β) (x : β)
Goal: e (e.symm x) = x
-- Equiv.symm_apply_apply
@[simp] theorem symm_apply_apply (e : α ≃ β) (x : α) : e.symm (e x) = x 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β) (x : α)
Goal: e.symm (e x) = x
-- Equiv.symm_comp_self
@[simp] theorem symm_comp_self (e : α ≃ β) : e.symm ∘ e = id 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: ⇑e.symm ∘ ⇑e = id
-- Equiv.self_comp_symm
@[simp] theorem self_comp_symm (e : α ≃ β) : e ∘ e.symm = id 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: ⇑e ∘ ⇑e.symm = id
-- EquivLike.apply_coe_symm_apply
@[simp] lemma _root_.EquivLike.apply_coe_symm_apply {F} [EquivLike F α β] (e : F) (x : β) :
    e ((e : α ≃ β).symm x) = x 
Arguments: {α : Sort u} {β : Sort v} {F : Sort u_1} [EquivLike F α β] (e : F) (x : β)
Goal: e ((↑e).symm x) = x
-- EquivLike.coe_symm_apply_apply
@[simp] lemma _root_.EquivLike.coe_symm_apply_apply {F} [EquivLike F α β] (e : F) (x : α) :
    (e : α ≃ β).symm (e x) = x 
Arguments: {α : Sort u} {β : Sort v} {F : Sort u_1} [EquivLike F α β] (e : F) (x : α)
Goal: (↑e).symm (e x) = x
-- EquivLike.coe_symm_comp_self
@[simp] lemma _root_.EquivLike.coe_symm_comp_self {F} [EquivLike F α β] (e : F) :
    (e : α ≃ β).symm ∘ e = id 
Arguments: {α : Sort u} {β : Sort v} {F : Sort u_1} [EquivLike F α β] (e : F)
Goal: ⇑(↑e).symm ∘ ⇑e = id
-- EquivLike.self_comp_coe_symm
@[simp] lemma _root_.EquivLike.self_comp_coe_symm {F} [EquivLike F α β] (e : F) :
    e ∘ (e : α ≃ β).symm = id 
Arguments: {α : Sort u} {β : Sort v} {F : Sort u_1} [EquivLike F α β] (e : F)
Goal: ⇑e ∘ ⇑(↑e).symm = id
-- Equiv.symm_trans_apply
@[simp] theorem symm_trans_apply (f : α ≃ β) (g : β ≃ γ) (a : γ) :
    (f.trans g).symm a = f.symm (g.symm a) 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (f : α ≃ β) (g : β ≃ γ) (a : γ)
Goal: (f.trans g).symm a = f.symm (g.symm a)
-- Equiv.symm_symm_apply
@[simp, nolint simpNF] theorem symm_symm_apply (f : α ≃ β) (b : α) : f.symm.symm b = f b 
Arguments: {α : Sort u} {β : Sort v} (f : α ≃ β) (b : α)
Goal: f.symm.symm b = f b
-- Equiv.apply_eq_iff_eq
theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y 
Arguments: {α : Sort u} {β : Sort v} (f : α ≃ β) {x y : α}
Goal: f x = f y ↔ x = y
-- Equiv.apply_eq_iff_eq_symm_apply
theorem apply_eq_iff_eq_symm_apply {x : α} {y : β} (f : α ≃ β) : f x = y ↔ x = f.symm y 
Arguments: {α : Sort u} {β : Sort v} {x : α} {y : β} (f : α ≃ β)
Goal: f x = y ↔ x = f.symm y
-- Equiv.cast_apply
@[simp] theorem cast_apply {α β} (h : α = β) (x : α) : Equiv.cast h x = cast h x 
Arguments: {α β : Sort u_1} (h : α = β) (x : α)
Goal: (Equiv.cast h) x = cast h x
-- Equiv.cast_symm
@[simp] theorem cast_symm {α β} (h : α = β) : (Equiv.cast h).symm = Equiv.cast h.symm 
Arguments: {α β : Sort u_1} (h : α = β)
Goal: (Equiv.cast h).symm = Equiv.cast ⋯
-- Equiv.cast_refl
@[simp] theorem cast_refl {α} (h : α = α := rfl) : Equiv.cast h = Equiv.refl α 
Arguments: {α : Sort u_1} (h : α = α := ⋯)
Goal: Equiv.cast h = Equiv.refl α
-- Equiv.cast_trans
@[simp] theorem cast_trans {α β γ} (h : α = β) (h2 : β = γ) :
    (Equiv.cast h).trans (Equiv.cast h2) = Equiv.cast (h.trans h2) 
Arguments: {α β γ : Sort u_1} (h : α = β) (h2 : β = γ)
Goal: (Equiv.cast h).trans (Equiv.cast h2) = Equiv.cast ⋯
-- Equiv.cast_eq_iff_heq
theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a = b ↔ HEq a b 
Arguments: {α β : Sort u_1} (h : α = β) {a : α} {b : β}
Goal: (Equiv.cast h) a = b ↔ HEq a b
-- Equiv.symm_apply_eq
theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y 
Arguments: {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}
Goal: e.symm x = y ↔ x = e y
-- Equiv.eq_symm_apply
theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x 
Arguments: {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}
Goal: y = e.symm x ↔ e y = x
-- Equiv.symm_symm
@[simp] theorem symm_symm (e : α ≃ β) : e.symm.symm = e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: e.symm.symm = e
-- Equiv.symm_bijective
theorem symm_bijective : Function.Bijective (Equiv.symm : (α ≃ β) → β ≃ α) 
Arguments: {α : Sort u} {β : Sort v}
Goal: Function.Bijective Equiv.symm
-- Equiv.trans_refl
@[simp] theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: e.trans (Equiv.refl β) = e
-- Equiv.refl_symm
@[simp] theorem refl_symm : (Equiv.refl α).symm = Equiv.refl α 
Arguments: {α : Sort u}
Goal: (Equiv.refl α).symm = Equiv.refl α
-- Equiv.refl_trans
@[simp] theorem refl_trans (e : α ≃ β) : (Equiv.refl α).trans e = e 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: (Equiv.refl α).trans e = e
-- Equiv.symm_trans_self
@[simp] theorem symm_trans_self (e : α ≃ β) : e.symm.trans e = Equiv.refl β 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: e.symm.trans e = Equiv.refl β
-- Equiv.self_trans_symm
@[simp] theorem self_trans_symm (e : α ≃ β) : e.trans e.symm = Equiv.refl α 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: e.trans e.symm = Equiv.refl α
-- Equiv.trans_assoc
theorem trans_assoc {δ} (ab : α ≃ β) (bc : β ≃ γ) (cd : γ ≃ δ) :
    (ab.trans bc).trans cd = ab.trans (bc.trans cd) 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort u_1} (ab : α ≃ β) (bc : β ≃ γ) (cd : γ ≃ δ)
Goal: (ab.trans bc).trans cd = ab.trans (bc.trans cd)
-- Equiv.leftInverse_symm
theorem leftInverse_symm (f : Equiv α β) : LeftInverse f.symm f 
Arguments: {α : Sort u} {β : Sort v} (f : α ≃ β)
Goal: Function.LeftInverse ⇑f.symm ⇑f
-- Equiv.rightInverse_symm
theorem rightInverse_symm (f : Equiv α β) : Function.RightInverse f.symm f 
Arguments: {α : Sort u} {β : Sort v} (f : α ≃ β)
Goal: Function.RightInverse ⇑f.symm ⇑f
-- Equiv.injective_comp
theorem injective_comp (e : α ≃ β) (f : β → γ) : Injective (f ∘ e) ↔ Injective f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ≃ β) (f : β → γ)
Goal: Function.Injective (f ∘ ⇑e) ↔ Function.Injective f
-- Equiv.comp_injective
theorem comp_injective (f : α → β) (e : β ≃ γ) : Injective (e ∘ f) ↔ Injective f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (f : α → β) (e : β ≃ γ)
Goal: Function.Injective (⇑e ∘ f) ↔ Function.Injective f
-- Equiv.surjective_comp
theorem surjective_comp (e : α ≃ β) (f : β → γ) : Surjective (f ∘ e) ↔ Surjective f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ≃ β) (f : β → γ)
Goal: Function.Surjective (f ∘ ⇑e) ↔ Function.Surjective f
-- Equiv.comp_surjective
theorem comp_surjective (f : α → β) (e : β ≃ γ) : Surjective (e ∘ f) ↔ Surjective f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (f : α → β) (e : β ≃ γ)
Goal: Function.Surjective (⇑e ∘ f) ↔ Function.Surjective f
-- Equiv.bijective_comp
theorem bijective_comp (e : α ≃ β) (f : β → γ) : Bijective (f ∘ e) ↔ Bijective f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ≃ β) (f : β → γ)
Goal: Function.Bijective (f ∘ ⇑e) ↔ Function.Bijective f
-- Equiv.comp_bijective
theorem comp_bijective (f : α → β) (e : β ≃ γ) : Bijective (e ∘ f) ↔ Bijective f 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (f : α → β) (e : β ≃ γ)
Goal: Function.Bijective (⇑e ∘ f) ↔ Function.Bijective f
-- Equiv.equivCongr_refl
@[simp] theorem equivCongr_refl {α β} :
    (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β) 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β)
-- Equiv.equivCongr_symm
@[simp] theorem equivCongr_symm {δ} (ab : α ≃ β) (cd : γ ≃ δ) :
    (ab.equivCongr cd).symm = ab.symm.equivCongr cd.symm 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort u_1} (ab : α ≃ β) (cd : γ ≃ δ)
Goal: (ab.equivCongr cd).symm = ab.symm.equivCongr cd.symm
-- Equiv.equivCongr_trans
@[simp] theorem equivCongr_trans {δ ε ζ} (ab : α ≃ β) (de : δ ≃ ε) (bc : β ≃ γ) (ef : ε ≃ ζ) :
    (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort u_1} {ε : Sort u_2} {ζ : Sort u_3} (ab : α ≃ β) (de : δ ≃ ε) (bc : β ≃ γ) (ef : ε ≃ ζ)
Goal: (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef)
-- Equiv.equivCongr_refl_left
@[simp] theorem equivCongr_refl_left {α β γ} (bg : β ≃ γ) (e : α ≃ β) :
    (Equiv.refl α).equivCongr bg e = e.trans bg 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (bg : β ≃ γ) (e : α ≃ β)
Goal: ((Equiv.refl α).equivCongr bg) e = e.trans bg
-- Equiv.equivCongr_refl_right
@[simp] theorem equivCongr_refl_right {α β} (ab e : α ≃ β) :
    ab.equivCongr (Equiv.refl β) e = ab.symm.trans e 
Arguments: {α : Sort u_1} {β : Sort u_2} (ab e : α ≃ β)
Goal: (ab.equivCongr (Equiv.refl β)) e = ab.symm.trans e
-- Equiv.equivCongr_apply_apply
@[simp] theorem equivCongr_apply_apply {δ} (ab : α ≃ β) (cd : γ ≃ δ) (e : α ≃ γ) (x) :
    ab.equivCongr cd e x = cd (e (ab.symm x)) 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort u_1} (ab : α ≃ β) (cd : γ ≃ δ) (e : α ≃ γ) (x : β)
Goal: ((ab.equivCongr cd) e) x = cd (e (ab.symm x))
-- Equiv.permCongr_def
theorem permCongr_def (p : Equiv.Perm α') : e.permCongr p = (e.symm.trans p).trans e 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : α' ≃ β') (p : Equiv.Perm α')
Goal: e.permCongr p = (e.symm.trans p).trans e
-- Equiv.permCongr_refl
@[simp] theorem permCongr_refl : e.permCongr (Equiv.refl _) = Equiv.refl _ 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : α' ≃ β')
Goal: e.permCongr (Equiv.refl α') = Equiv.refl β'
-- Equiv.permCongr_symm
@[simp] theorem permCongr_symm : e.permCongr.symm = e.symm.permCongr 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : α' ≃ β')
Goal: e.permCongr.symm = e.symm.permCongr
-- Equiv.permCongr_apply
@[simp] theorem permCongr_apply (p : Equiv.Perm α') (x) : e.permCongr p x = e (p (e.symm x)) 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : α' ≃ β') (p : Equiv.Perm α') (x : β')
Goal: (e.permCongr p) x = e (p (e.symm x))
-- Equiv.permCongr_symm_apply
theorem permCongr_symm_apply (p : Equiv.Perm β') (x) :
    e.permCongr.symm p x = e.symm (p (e x)) 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : α' ≃ β') (p : Equiv.Perm β') (x : α')
Goal: (e.permCongr.symm p) x = e.symm (p (e x))
-- Equiv.permCongr_trans
theorem permCongr_trans (p p' : Equiv.Perm α') :
    (e.permCongr p).trans (e.permCongr p') = e.permCongr (p.trans p') 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : α' ≃ β') (p p' : Equiv.Perm α')
Goal: Equiv.trans (e.permCongr p) (e.permCongr p') = e.permCongr (Equiv.trans p p')
-- Equiv.ulift_apply
@[simps (config := .asFn) apply]
protected def ulift {α : Type v} : ULift.{u} α ≃ α 
Arguments: {α : Type v}
Goal: ⇑Equiv.ulift = ULift.down
-- Equiv.plift_apply
@[simps (config := .asFn) apply]
protected def plift : PLift α ≃ α 
Arguments: {α : Sort u}
Goal: ⇑Equiv.plift = PLift.down
-- Equiv.arrowCongr_apply
-- Porting note: removing `congr` attribute
@[simps apply]
def arrowCongr {α₁ β₁ α₂ β₂ : Sort*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) 
Arguments: {α₁ : Sort u_1} {β₁ : Sort u_2} {α₂ : Sort u_3} {β₂ : Sort u_4} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) (f : α₁ → β₁)
Goal: ∀ (a : α₂), (e₁.arrowCongr e₂) f a = (⇑e₂ ∘ f ∘ ⇑e₁.symm) a
-- Equiv.arrowCongr_comp
theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
    (f : α₁ → β₁) (g : β₁ → γ₁) :
    arrowCongr ea ec (g ∘ f) = arrowCongr eb ec g ∘ arrowCongr ea eb f 
Arguments: {α₁ : Sort u_1} {β₁ : Sort u_2} {γ₁ : Sort u_3} {α₂ : Sort u_4} {β₂ : Sort u_5} {γ₂ : Sort u_6} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂) (f : α₁ → β₁) (g : β₁ → γ₁)
Goal: (ea.arrowCongr ec) (g ∘ f) = (eb.arrowCongr ec) g ∘ (ea.arrowCongr eb) f
-- Equiv.arrowCongr_refl
@[simp] theorem arrowCongr_refl {α β : Sort*} :
    arrowCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: (Equiv.refl α).arrowCongr (Equiv.refl β) = Equiv.refl (α → β)
-- Equiv.arrowCongr_trans
@[simp] theorem arrowCongr_trans {α₁ α₂ α₃ β₁ β₂ β₃ : Sort*}
    (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
    arrowCongr (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr e₁ e₁').trans (arrowCongr e₂ e₂') 
Arguments: {α₁ : Sort u_1} {α₂ : Sort u_2} {α₃ : Sort u_3} {β₁ : Sort u_4} {β₂ : Sort u_5} {β₃ : Sort u_6} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃)
Goal: (e₁.trans e₂).arrowCongr (e₁'.trans e₂') = (e₁.arrowCongr e₁').trans (e₂.arrowCongr e₂')
-- Equiv.arrowCongr_symm
@[simp] theorem arrowCongr_symm {α₁ α₂ β₁ β₂ : Sort*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
    (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm 
Arguments: {α₁ : Sort u_1} {α₂ : Sort u_2} {β₁ : Sort u_3} {β₂ : Sort u_4} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂)
Goal: (e₁.arrowCongr e₂).symm = e₁.symm.arrowCongr e₂.symm
-- Equiv.arrowCongr'_apply
-- Porting note: removing `congr` attribute
@[simps! apply]
def arrowCongr' {α₁ β₁ α₂ β₂ : Type*} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} {α₂ : Type u_3} {β₂ : Type u_4} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) (f : α₁ → β₁)
Goal: ∀ (a : α₂), (hα.arrowCongr' hβ) f a = hβ (f (hα.symm a))
-- Equiv.arrowCongr'_refl
@[simp] theorem arrowCongr'_refl {α β : Type*} :
    arrowCongr' (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: (Equiv.refl α).arrowCongr' (Equiv.refl β) = Equiv.refl (α → β)
-- Equiv.arrowCongr'_trans
@[simp] theorem arrowCongr'_trans {α₁ α₂ β₁ β₂ α₃ β₃ : Type*}
    (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
    arrowCongr' (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr' e₁ e₁').trans (arrowCongr' e₂ e₂') 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {α₃ : Type u_5} {β₃ : Type u_6} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃)
Goal: (e₁.trans e₂).arrowCongr' (e₁'.trans e₂') = (e₁.arrowCongr' e₁').trans (e₂.arrowCongr' e₂')
-- Equiv.arrowCongr'_symm
@[simp] theorem arrowCongr'_symm {α₁ α₂ β₁ β₂ : Type*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
    (arrowCongr' e₁ e₂).symm = arrowCongr' e₁.symm e₂.symm 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂)
Goal: (e₁.arrowCongr' e₂).symm = e₁.symm.arrowCongr' e₂.symm
-- Equiv.conj_apply
@[simps! apply] def conj (e : α ≃ β) : (α → α) ≃ (β → β) 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β) (f : α → α)
Goal: ∀ (a : β), e.conj f a = e (f (e.symm a))
-- Equiv.conj_refl
@[simp] theorem conj_refl : conj (Equiv.refl α) = Equiv.refl (α → α) 
Arguments: {α : Sort u}
Goal: (Equiv.refl α).conj = Equiv.refl (α → α)
-- Equiv.conj_symm
@[simp] theorem conj_symm (e : α ≃ β) : e.conj.symm = e.symm.conj 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β)
Goal: e.conj.symm = e.symm.conj
-- Equiv.conj_trans
@[simp] theorem conj_trans (e₁ : α ≃ β) (e₂ : β ≃ γ) :
    (e₁.trans e₂).conj = e₁.conj.trans e₂.conj 
Arguments: {α : Sort u} {β : Sort v} {γ : Sort w} (e₁ : α ≃ β) (e₂ : β ≃ γ)
Goal: (e₁.trans e₂).conj = e₁.conj.trans e₂.conj
-- Equiv.conj_comp
theorem conj_comp (e : α ≃ β) (f₁ f₂ : α → α) : e.conj (f₁ ∘ f₂) = e.conj f₁ ∘ e.conj f₂ 
Arguments: {α : Sort u} {β : Sort v} (e : α ≃ β) (f₁ f₂ : α → α)
Goal: e.conj (f₁ ∘ f₂) = e.conj f₁ ∘ e.conj f₂
-- Equiv.eq_comp_symm
theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : f = g ∘ e.symm ↔ f ∘ e = g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : β → γ) (g : α → γ)
Goal: f = g ∘ ⇑e.symm ↔ f ∘ ⇑e = g
-- Equiv.comp_symm_eq
theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : g ∘ e.symm = f ↔ g = f ∘ e 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : β → γ) (g : α → γ)
Goal: g ∘ ⇑e.symm = f ↔ g = f ∘ ⇑e
-- Equiv.eq_symm_comp
theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : f = e.symm ∘ g ↔ e ∘ f = g 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : γ → α) (g : γ → β)
Goal: f = ⇑e.symm ∘ g ↔ ⇑e ∘ f = g
-- Equiv.symm_comp_eq
theorem symm_comp_eq {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : e.symm ∘ g = f ↔ g = e ∘ f 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : γ → α) (g : γ → β)
Goal: ⇑e.symm ∘ g = f ↔ g = ⇑e ∘ f
-- Equiv.piUnique_apply
@[simps (config := .asFn)]
def piUnique [Unique α] (β : α → Sort*) : (∀ i, β i) ≃ β default 
Arguments: {α : Sort u} [Unique α] (β : α → Sort u_1)
Goal: ⇑(Equiv.piUnique β) = fun f => f default
-- Equiv.piUnique_symm_apply
@[simps (config := .asFn)]
def piUnique [Unique α] (β : α → Sort*) : (∀ i, β i) ≃ β default 
Arguments: {α : Sort u} [Unique α] (β : α → Sort u_1)
Goal: ⇑(Equiv.piUnique β).symm = uniqueElim
-- Equiv.funUnique_symm_apply
@[simps! (config := .asFn) apply symm_apply]
def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β 
Arguments: (α : Sort u) (β : Sort u_1) [Unique α]
Goal: ⇑(Equiv.funUnique α β).symm = uniqueElim
-- Equiv.funUnique_apply
@[simps! (config := .asFn) apply symm_apply]
def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β 
Arguments: (α : Sort u) (β : Sort u_1) [Unique α]
Goal: ⇑(Equiv.funUnique α β) = fun f => f default
-- Equiv.psigmaEquivSigma_symm_apply
@[simps apply symm_apply]
def psigmaEquivSigma {α} (β : α → Type*) : (Σ' i, β i) ≃ Σ i, β i 
Arguments: {α : Type u_2} (β : α → Type u_1) (a : (i : α) × β i)
Goal: (Equiv.psigmaEquivSigma β).symm a = ⟨a.fst, a.snd⟩
-- Equiv.psigmaEquivSigma_apply
@[simps apply symm_apply]
def psigmaEquivSigma {α} (β : α → Type*) : (Σ' i, β i) ≃ Σ i, β i 
Arguments: {α : Type u_2} (β : α → Type u_1) (a : (i : α) ×' β i)
Goal: (Equiv.psigmaEquivSigma β) a = ⟨a.fst, a.snd⟩
-- Equiv.psigmaEquivSigmaPLift_apply
@[simps apply symm_apply]
def psigmaEquivSigmaPLift {α} (β : α → Sort*) : (Σ' i, β i) ≃ Σ i : PLift α, PLift (β i.down) 
Arguments: {α : Sort u_2} (β : α → Sort u_1) (a : (i : α) ×' β i)
Goal: (Equiv.psigmaEquivSigmaPLift β) a = ⟨{ down := a.fst }, { down := a.snd }⟩
-- Equiv.psigmaEquivSigmaPLift_symm_apply
@[simps apply symm_apply]
def psigmaEquivSigmaPLift {α} (β : α → Sort*) : (Σ' i, β i) ≃ Σ i : PLift α, PLift (β i.down) 
Arguments: {α : Sort u_2} (β : α → Sort u_1) (a : (i : PLift α) × PLift (β i.down))
Goal: (Equiv.psigmaEquivSigmaPLift β).symm a = ⟨a.fst.down, a.snd.down⟩
-- Equiv.psigmaCongrRight_apply
@[simps apply]
def psigmaCongrRight {β₁ β₂ : α → Sort*} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ' a, β₁ a) ≃ Σ' a, β₂ a 
Arguments: {α : Sort u} {β₁ : α → Sort u_1} {β₂ : α → Sort u_2} (F : (a : α) → β₁ a ≃ β₂ a) (a : (a : α) ×' β₁ a)
Goal: (Equiv.psigmaCongrRight F) a = ⟨a.fst, (F a.fst) a.snd⟩
-- Equiv.psigmaCongrRight_trans
theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort*}
    (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
    (psigmaCongrRight F).trans (psigmaCongrRight G) =
      psigmaCongrRight fun a => (F a).trans (G a) 
Arguments: {α : Sort u_4} {β₁ : α → Sort u_1} {β₂ : α → Sort u_2} {β₃ : α → Sort u_3} (F : (a : α) → β₁ a ≃ β₂ a) (G : (a : α) → β₂ a ≃ β₃ a)
Goal: (Equiv.psigmaCongrRight F).trans (Equiv.psigmaCongrRight G) = Equiv.psigmaCongrRight fun a => (F a).trans (G a)
-- Equiv.psigmaCongrRight_symm
theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort*} (F : ∀ a, β₁ a ≃ β₂ a) :
    (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm 
Arguments: {α : Sort u_3} {β₁ : α → Sort u_1} {β₂ : α → Sort u_2} (F : (a : α) → β₁ a ≃ β₂ a)
Goal: (Equiv.psigmaCongrRight F).symm = Equiv.psigmaCongrRight fun a => (F a).symm
-- Equiv.psigmaCongrRight_refl
theorem psigmaCongrRight_refl {α} {β : α → Sort*} :
    (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ' a, β a) 
Arguments: {α : Sort u_2} {β : α → Sort u_1}
Goal: (Equiv.psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl ((a : α) ×' β a)
-- Equiv.sigmaCongrRight_apply
@[simps apply]
def sigmaCongrRight {α} {β₁ β₂ : α → Type*} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ a, β₁ a) ≃ Σ a, β₂ a 
Arguments: {α : Type u_3} {β₁ : α → Type u_1} {β₂ : α → Type u_2} (F : (a : α) → β₁ a ≃ β₂ a) (a : (a : α) × β₁ a)
Goal: (Equiv.sigmaCongrRight F) a = ⟨a.fst, (F a.fst) a.snd⟩
-- Equiv.sigmaCongrRight_trans
theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type*}
    (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
    (sigmaCongrRight F).trans (sigmaCongrRight G) =
      sigmaCongrRight fun a => (F a).trans (G a) 
Arguments: {α : Type u_4} {β₁ : α → Type u_1} {β₂ : α → Type u_2} {β₃ : α → Type u_3} (F : (a : α) → β₁ a ≃ β₂ a) (G : (a : α) → β₂ a ≃ β₃ a)
Goal: (Equiv.sigmaCongrRight F).trans (Equiv.sigmaCongrRight G) = Equiv.sigmaCongrRight fun a => (F a).trans (G a)