ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.subtypeSubtypeEquivSubtype_apply_coe
@[simps!]
def subtypeSubtypeEquivSubtype {p q : α → Prop} (h : ∀ {x}, q x → p x) :
    { x : Subtype p // q x.1 } ≃ Subtype q 
Arguments: {α : Type u_1} {p q : α → Prop} (h : ∀ {x : α}, q x → p x)
Goal: ∀ (a : { x // q ↑x }), ↑((Equiv.subtypeSubtypeEquivSubtype h) a) = ↑↑a
-- Equiv.subtypeUnivEquiv_apply
@[simps apply symm_apply]
def subtypeUnivEquiv {p : α → Prop} (h : ∀ x, p x) : Subtype p ≃ α 
Arguments: {α : Type u_1} {p : α → Prop} (h : ∀ (x : α), p x) (x : Subtype p)
Goal: (Equiv.subtypeUnivEquiv h) x = ↑x
-- Equiv.subtypeUnivEquiv_symm_apply
@[simps apply symm_apply]
def subtypeUnivEquiv {p : α → Prop} (h : ∀ x, p x) : Subtype p ≃ α 
Arguments: {α : Type u_1} {p : α → Prop} (h : ∀ (x : α), p x) (x : α)
Goal: (Equiv.subtypeUnivEquiv h).symm x = ⟨x, ⋯⟩
-- Equiv.piEquivPiSubtypeProd_apply
@[simps]
def piEquivPiSubtypeProd {α : Type*} (p : α → Prop) (β : α → Type*) [DecidablePred p] :
    (∀ i : α, β i) ≃ (∀ i : { x // p x }, β i) × ∀ i : { x // ¬p x }, β i 
Arguments: {α : Type u_1} (p : α → Prop) (β : α → Type u_2) [DecidablePred p] (f : (i : α) → β i)
Goal: (Equiv.piEquivPiSubtypeProd p β) f = (fun x => f ↑x, fun x => f ↑x)
-- Equiv.piEquivPiSubtypeProd_symm_apply
@[simps]
def piEquivPiSubtypeProd {α : Type*} (p : α → Prop) (β : α → Type*) [DecidablePred p] :
    (∀ i : α, β i) ≃ (∀ i : { x // p x }, β i) × ∀ i : { x // ¬p x }, β i 
Arguments: {α : Type u_1} (p : α → Prop) (β : α → Type u_2) [DecidablePred p] (f : ((i : { x // p x }) → β ↑i) × ((i : { x // ¬p x }) → β ↑i)) (x : α)
Goal: (Equiv.piEquivPiSubtypeProd p β).symm f x = if h : p x then f.1 ⟨x, h⟩ else f.2 ⟨x, h⟩
-- Equiv.piSplitAt_symm_apply
@[simps]
def piSplitAt {α : Type*} [DecidableEq α] (i : α) (β : α → Type*) :
    (∀ j, β j) ≃ β i × ∀ j : { j // j ≠ i }, β j 
Arguments: {α : Type u_1} [DecidableEq α] (i : α) (β : α → Type u_2) (f : β i × ((j : { j // j ≠ i }) → β ↑j)) (j : α)
Goal: (Equiv.piSplitAt i β).symm f j = if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩
-- Equiv.piSplitAt_apply
@[simps]
def piSplitAt {α : Type*} [DecidableEq α] (i : α) (β : α → Type*) :
    (∀ j, β j) ≃ β i × ∀ j : { j // j ≠ i }, β j 
Arguments: {α : Type u_1} [DecidableEq α] (i : α) (β : α → Type u_2) (f : (j : α) → β j)
Goal: (Equiv.piSplitAt i β) f = (f i, fun j => f ↑j)
-- Equiv.funSplitAt_apply
@[simps!]
def funSplitAt {α : Type*} [DecidableEq α] (i : α) (β : Type*) :
    (α → β) ≃ β × ({ j // j ≠ i } → β) 
Arguments: {α : Type u_1} [DecidableEq α] (i : α) (β : Type u_2) (f : (j : α) → (fun a => β) j)
Goal: (Equiv.funSplitAt i β) f = (f i, fun j => f ↑j)
-- Equiv.funSplitAt_symm_apply
@[simps!]
def funSplitAt {α : Type*} [DecidableEq α] (i : α) (β : Type*) :
    (α → β) ≃ β × ({ j // j ≠ i } → β) 
Arguments: {α : Type u_1} [DecidableEq α] (i : α) (β : Type u_2) (f : (fun a => β) i × ((j : { j // j ≠ i }) → (fun a => β) ↑j)) (j : α)
Goal: (Equiv.funSplitAt i β).symm f j = if h : j = i then f.1 else f.2 ⟨j, ⋯⟩
-- Equiv.coe_subtypeEquivCodomain
@[simp]
theorem coe_subtypeEquivCodomain (f : { x' // x' ≠ x } → Y) :
    (subtypeEquivCodomain f : _ → Y) =
      fun g : { g : X → Y // g ∘ (↑) = f } => (g : X → Y) x 
Arguments: {X : Sort u_2} [DecidableEq X] {x : X} {Y : Sort u_1} (f : { x' // x' ≠ x } → Y)
Goal: ⇑(Equiv.subtypeEquivCodomain f) = fun g => ↑g x
-- Equiv.subtypeEquivCodomain_apply
@[simp]
theorem subtypeEquivCodomain_apply (f : { x' // x' ≠ x } → Y) (g) :
    subtypeEquivCodomain f g = (g : X → Y) x 
Arguments: {X : Sort u_2} [DecidableEq X] {x : X} {Y : Sort u_1} (f : { x' // x' ≠ x } → Y) (g : { g // g ∘ Subtype.val = f })
Goal: (Equiv.subtypeEquivCodomain f) g = ↑g x
-- Equiv.coe_subtypeEquivCodomain_symm
theorem coe_subtypeEquivCodomain_symm (f : { x' // x' ≠ x } → Y) :
    ((subtypeEquivCodomain f).symm : Y → _) = fun y =>
      ⟨fun x' => if h : x' ≠ x then f ⟨x', h⟩ else y, by
        funext x'
        simp only [ne_eq, dite_not, comp_apply, Subtype.coe_eta, dite_eq_ite, ite_eq_right_iff]
        intro w
        exfalso
        exact x'.property w⟩ 
Arguments: {X : Sort u_2} [DecidableEq X] {x : X} {Y : Sort u_1} (f : { x' // x' ≠ x } → Y)
Goal: ⇑(Equiv.subtypeEquivCodomain f).symm = fun y => ⟨fun x' => if h : x' ≠ x then f ⟨x', h⟩ else y, ⋯⟩
-- Equiv.subtypeEquivCodomain_symm_apply
@[simp]
theorem subtypeEquivCodomain_symm_apply (f : { x' // x' ≠ x } → Y) (y : Y) (x' : X) :
    ((subtypeEquivCodomain f).symm y : X → Y) x' = if h : x' ≠ x then f ⟨x', h⟩ else y 
Arguments: {X : Sort u_2} [DecidableEq X] {x : X} {Y : Sort u_1} (f : { x' // x' ≠ x } → Y) (y : Y) (x' : X)
Goal: ↑((Equiv.subtypeEquivCodomain f).symm y) x' = if h : x' ≠ x then f ⟨x', h⟩ else y
-- Equiv.subtypeEquivCodomain_symm_apply_eq
theorem subtypeEquivCodomain_symm_apply_eq (f : { x' // x' ≠ x } → Y) (y : Y) :
    ((subtypeEquivCodomain f).symm y : X → Y) x = y 
Arguments: {X : Sort u_2} [DecidableEq X] {x : X} {Y : Sort u_1} (f : { x' // x' ≠ x } → Y) (y : Y)
Goal: ↑((Equiv.subtypeEquivCodomain f).symm y) x = y
-- Equiv.subtypeEquivCodomain_symm_apply_ne
theorem subtypeEquivCodomain_symm_apply_ne
    (f : { x' // x' ≠ x } → Y) (y : Y) (x' : X) (h : x' ≠ x) :
    ((subtypeEquivCodomain f).symm y : X → Y) x' = f ⟨x', h⟩ 
Arguments: {X : Sort u_2} [DecidableEq X] {x : X} {Y : Sort u_1} (f : { x' // x' ≠ x } → Y) (y : Y) (x' : X) (h : x' ≠ x)
Goal: ↑((Equiv.subtypeEquivCodomain f).symm y) x' = f ⟨x', h⟩
-- Equiv.Perm.extendDomain_apply_image
@[simp]
theorem Perm.extendDomain_apply_image (a : α') : e.extendDomain f (f a) = f (e a) 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : Equiv.Perm α') {p : β' → Prop} [DecidablePred p] (f : α' ≃ Subtype p) (a : α')
Goal: (e.extendDomain f) ↑(f a) = ↑(f (e a))
-- Equiv.Perm.extendDomain_apply_subtype
theorem Perm.extendDomain_apply_subtype {b : β'} (h : p b) :
    e.extendDomain f b = f (e (f.symm ⟨b, h⟩)) 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : Equiv.Perm α') {p : β' → Prop} [DecidablePred p] (f : α' ≃ Subtype p) {b : β'} (h : p b)
Goal: (e.extendDomain f) b = ↑(f (e (f.symm ⟨b, h⟩)))
-- Equiv.Perm.extendDomain_apply_not_subtype
theorem Perm.extendDomain_apply_not_subtype {b : β'} (h : ¬p b) : e.extendDomain f b = b 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : Equiv.Perm α') {p : β' → Prop} [DecidablePred p] (f : α' ≃ Subtype p) {b : β'} (h : ¬p b)
Goal: (e.extendDomain f) b = b
-- Equiv.Perm.extendDomain_refl
@[simp]
theorem Perm.extendDomain_refl : Perm.extendDomain (Equiv.refl _) f = Equiv.refl _ 
Arguments: {α' : Type u_1} {β' : Type u_2} {p : β' → Prop} [DecidablePred p] (f : α' ≃ Subtype p)
Goal: Equiv.Perm.extendDomain (Equiv.refl α') f = Equiv.refl β'
-- Equiv.Perm.extendDomain_symm
@[simp]
theorem Perm.extendDomain_symm : (e.extendDomain f).symm = Perm.extendDomain e.symm f 
Arguments: {α' : Type u_1} {β' : Type u_2} (e : Equiv.Perm α') {p : β' → Prop} [DecidablePred p] (f : α' ≃ Subtype p)
Goal: Equiv.symm (e.extendDomain f) = Equiv.Perm.extendDomain (Equiv.symm e) f
-- Equiv.Perm.extendDomain_trans
theorem Perm.extendDomain_trans (e e' : Perm α') :
    (e.extendDomain f).trans (e'.extendDomain f) = Perm.extendDomain (e.trans e') f 
Arguments: {α' : Type u_1} {β' : Type u_2} {p : β' → Prop} [DecidablePred p] (f : α' ≃ Subtype p) (e e' : Equiv.Perm α')
Goal: Equiv.trans (e.extendDomain f) (e'.extendDomain f) = Equiv.Perm.extendDomain (Equiv.trans e e') f
-- Equiv.subtypeQuotientEquivQuotientSubtype_mk
@[simp]
theorem subtypeQuotientEquivQuotientSubtype_mk (p₁ : α → Prop)
    [s₁ : Setoid α] [s₂ : Setoid (Subtype p₁)] (p₂ : Quotient s₁ → Prop) (hp₂ : ∀ a, p₁ a ↔ p₂ ⟦a⟧)
    (h : ∀ x y : Subtype p₁, @Setoid.r _ s₂ x y ↔ (x : α) ≈ y)
    (x hx) : subtypeQuotientEquivQuotientSubtype p₁ p₂ hp₂ h ⟨⟦x⟧, hx⟩ = ⟦⟨x, (hp₂ _).2 hx⟩⟧ 
Arguments: {α : Sort u_1} (p₁ : α → Prop) [s₁ : Setoid α] [s₂ : Setoid (Subtype p₁)] (p₂ : Quotient s₁ → Prop) (hp₂ : ∀ (a : α), p₁ a ↔ p₂ ⟦a⟧) (h : ∀ (x y : Subtype p₁), Setoid.r x y ↔ ↑x ≈ ↑y) (x : α) (hx : p₂ ⟦x⟧)
Goal: (Equiv.subtypeQuotientEquivQuotientSubtype p₁ p₂ hp₂ h) ⟨⟦x⟧, hx⟩ = ⟦⟨x, ⋯⟩⟧
-- Equiv.subtypeQuotientEquivQuotientSubtype_symm_mk
@[simp]
theorem subtypeQuotientEquivQuotientSubtype_symm_mk (p₁ : α → Prop)
    [s₁ : Setoid α] [s₂ : Setoid (Subtype p₁)] (p₂ : Quotient s₁ → Prop) (hp₂ : ∀ a, p₁ a ↔ p₂ ⟦a⟧)
    (h : ∀ x y : Subtype p₁, @Setoid.r _ s₂ x y ↔ (x : α) ≈ y) (x) :
    (subtypeQuotientEquivQuotientSubtype p₁ p₂ hp₂ h).symm ⟦x⟧ = ⟨⟦x⟧, (hp₂ _).1 x.property⟩ 
Arguments: {α : Sort u_1} (p₁ : α → Prop) [s₁ : Setoid α] [s₂ : Setoid (Subtype p₁)] (p₂ : Quotient s₁ → Prop) (hp₂ : ∀ (a : α), p₁ a ↔ p₂ ⟦a⟧) (h : ∀ (x y : Subtype p₁), Setoid.r x y ↔ ↑x ≈ ↑y) (x : Subtype p₁)
Goal: (Equiv.subtypeQuotientEquivQuotientSubtype p₁ p₂ hp₂ h).symm ⟦x⟧ = ⟨⟦↑x⟧, ⋯⟩
-- Equiv.swapCore_self
theorem swapCore_self (r a : α) : swapCore a a r = r 
Arguments: {α : Sort u_1} [DecidableEq α] (r a : α)
Goal: Equiv.swapCore a a r = r
-- Equiv.swapCore_swapCore
theorem swapCore_swapCore (r a b : α) : swapCore a b (swapCore a b r) = r 
Arguments: {α : Sort u_1} [DecidableEq α] (r a b : α)
Goal: Equiv.swapCore a b (Equiv.swapCore a b r) = r
-- Equiv.swapCore_comm
theorem swapCore_comm (r a b : α) : swapCore a b r = swapCore b a r 
Arguments: {α : Sort u_1} [DecidableEq α] (r a b : α)
Goal: Equiv.swapCore a b r = Equiv.swapCore b a r
-- Equiv.swap_self
@[simp]
theorem swap_self (a : α) : swap a a = Equiv.refl _ 
Arguments: {α : Sort u_1} [DecidableEq α] (a : α)
Goal: Equiv.swap a a = Equiv.refl α
-- Equiv.swap_comm
theorem swap_comm (a b : α) : swap a b = swap b a 
Arguments: {α : Sort u_1} [DecidableEq α] (a b : α)
Goal: Equiv.swap a b = Equiv.swap b a
-- Equiv.swap_apply_def
theorem swap_apply_def (a b x : α) : swap a b x = if x = a then b else if x = b then a else x 
Arguments: {α : Sort u_1} [DecidableEq α] (a b x : α)
Goal: (Equiv.swap a b) x = if x = a then b else if x = b then a else x
-- Equiv.swap_apply_left
@[simp]
theorem swap_apply_left (a b : α) : swap a b a = b 
Arguments: {α : Sort u_1} [DecidableEq α] (a b : α)
Goal: (Equiv.swap a b) a = b
-- Equiv.swap_apply_right
@[simp]
theorem swap_apply_right (a b : α) : swap a b b = a 
Arguments: {α : Sort u_1} [DecidableEq α] (a b : α)
Goal: (Equiv.swap a b) b = a
-- Equiv.swap_apply_of_ne_of_ne
theorem swap_apply_of_ne_of_ne {a b x : α} : x ≠ a → x ≠ b → swap a b x = x 
Arguments: {α : Sort u_1} [DecidableEq α] {a b x : α}
Goal: x ≠ a → x ≠ b → (Equiv.swap a b) x = x
-- Equiv.eq_or_eq_of_swap_apply_ne_self
theorem eq_or_eq_of_swap_apply_ne_self {a b x : α} (h : swap a b x ≠ x) : x = a ∨ x = b 
Arguments: {α : Sort u_1} [DecidableEq α] {a b x : α} (h : (Equiv.swap a b) x ≠ x)
Goal: x = a ∨ x = b
-- Equiv.swap_swap
@[simp]
theorem swap_swap (a b : α) : (swap a b).trans (swap a b) = Equiv.refl _ 
Arguments: {α : Sort u_1} [DecidableEq α] (a b : α)
Goal: Equiv.trans (Equiv.swap a b) (Equiv.swap a b) = Equiv.refl α
-- Equiv.symm_swap
@[simp]
theorem symm_swap (a b : α) : (swap a b).symm = swap a b 
Arguments: {α : Sort u_1} [DecidableEq α] (a b : α)
Goal: Equiv.symm (Equiv.swap a b) = Equiv.swap a b
-- Equiv.swap_eq_refl_iff
@[simp]
theorem swap_eq_refl_iff {x y : α} : swap x y = Equiv.refl _ ↔ x = y 
Arguments: {α : Sort u_1} [DecidableEq α] {x y : α}
Goal: Equiv.swap x y = Equiv.refl α ↔ x = y
-- Equiv.swap_comp_apply
theorem swap_comp_apply {a b x : α} (π : Perm α) :
    π.trans (swap a b) x = if π x = a then b else if π x = b then a else π x 
Arguments: {α : Sort u_1} [DecidableEq α] {a b x : α} (π : Equiv.Perm α)
Goal: (Equiv.trans π (Equiv.swap a b)) x = if π x = a then b else if π x = b then a else π x
-- Equiv.swap_eq_update
theorem swap_eq_update (i j : α) : (Equiv.swap i j : α → α) = update (update id j i) i j 
Arguments: {α : Sort u_1} [DecidableEq α] (i j : α)
Goal: ⇑(Equiv.swap i j) = Function.update (Function.update id j i) i j
-- Equiv.comp_swap_eq_update
theorem comp_swap_eq_update (i j : α) (f : α → β) :
    f ∘ Equiv.swap i j = update (update f j (f i)) i (f j) 
Arguments: {α : Sort u_2} [DecidableEq α] {β : Sort u_1} (i j : α) (f : α → β)
Goal: f ∘ ⇑(Equiv.swap i j) = Function.update (Function.update f j (f i)) i (f j)
-- Equiv.symm_trans_swap_trans
@[simp]
theorem symm_trans_swap_trans [DecidableEq β] (a b : α) (e : α ≃ β) :
    (e.symm.trans (swap a b)).trans e = swap (e a) (e b) 
Arguments: {α : Sort u_2} [DecidableEq α] {β : Sort u_1} [DecidableEq β] (a b : α) (e : α ≃ β)
Goal: (e.symm.trans (Equiv.swap a b)).trans e = Equiv.swap (e a) (e b)
-- Equiv.trans_swap_trans_symm
@[simp]
theorem trans_swap_trans_symm [DecidableEq β] (a b : β) (e : α ≃ β) :
    (e.trans (swap a b)).trans e.symm = swap (e.symm a) (e.symm b) 
Arguments: {α : Sort u_2} [DecidableEq α] {β : Sort u_1} [DecidableEq β] (a b : β) (e : α ≃ β)
Goal: (e.trans (Equiv.swap a b)).trans e.symm = Equiv.swap (e.symm a) (e.symm b)
-- Equiv.swap_apply_self
@[simp]
theorem swap_apply_self (i j a : α) : swap i j (swap i j a) = a 
Arguments: {α : Sort u_1} [DecidableEq α] (i j a : α)
Goal: (Equiv.swap i j) ((Equiv.swap i j) a) = a
-- Equiv.apply_swap_eq_self
theorem apply_swap_eq_self {v : α → β} {i j : α} (hv : v i = v j) (k : α) :
    v (swap i j k) = v k 
Arguments: {α : Sort u_2} [DecidableEq α] {β : Sort u_1} {v : α → β} {i j : α} (hv : v i = v j) (k : α)
Goal: v ((Equiv.swap i j) k) = v k
-- Equiv.swap_apply_eq_iff
theorem swap_apply_eq_iff {x y z w : α} : swap x y z = w ↔ z = swap x y w 
Arguments: {α : Sort u_1} [DecidableEq α] {x y z w : α}
Goal: (Equiv.swap x y) z = w ↔ z = (Equiv.swap x y) w
-- Equiv.swap_apply_ne_self_iff
theorem swap_apply_ne_self_iff {a b x : α} : swap a b x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b) 
Arguments: {α : Sort u_1} [DecidableEq α] {a b x : α}
Goal: (Equiv.swap a b) x ≠ x ↔ a ≠ b ∧ (x = a ∨ x = b)
-- Equiv.Perm.sumCongr_swap_refl
@[simp]
theorem sumCongr_swap_refl {α β : Sort _} [DecidableEq α] [DecidableEq β] (i j : α) :
    Equiv.Perm.sumCongr (Equiv.swap i j) (Equiv.refl β) = Equiv.swap (Sum.inl i) (Sum.inl j) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (i j : α)
Goal: (Equiv.swap i j).sumCongr (Equiv.refl β) = Equiv.swap (Sum.inl i) (Sum.inl j)
-- Equiv.Perm.sumCongr_refl_swap
@[simp]
theorem sumCongr_refl_swap {α β : Sort _} [DecidableEq α] [DecidableEq β] (i j : β) :
    Equiv.Perm.sumCongr (Equiv.refl α) (Equiv.swap i j) = Equiv.swap (Sum.inr i) (Sum.inr j) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] (i j : β)
Goal: Equiv.Perm.sumCongr (Equiv.refl α) (Equiv.swap i j) = Equiv.swap (Sum.inr i) (Sum.inr j)
-- Equiv.setValue_eq
@[simp]
theorem setValue_eq (f : α ≃ β) (a : α) (b : β) : setValue f a b a = b 
Arguments: {α : Sort u_2} [DecidableEq α] {β : Sort u_1} (f : α ≃ β) (a : α) (b : β)
Goal: (f.setValue a b) a = b
-- Function.Involutive.coe_toPerm
@[simp]
theorem coe_toPerm {f : α → α} (h : Involutive f) : (h.toPerm f : α → α) = f 
Arguments: {α : Sort u_1} {f : α → α} (h : Function.Involutive f)
Goal: ⇑(Function.Involutive.toPerm f h) = f
-- Function.Involutive.toPerm_symm
@[simp]
theorem toPerm_symm {f : α → α} (h : Involutive f) : (h.toPerm f).symm = h.toPerm f 
Arguments: {α : Sort u_1} {f : α → α} (h : Function.Involutive f)
Goal: Equiv.symm (Function.Involutive.toPerm f h) = Function.Involutive.toPerm f h
-- Function.Involutive.toPerm_involutive
theorem toPerm_involutive {f : α → α} (h : Involutive f) : Involutive (h.toPerm f) 
Arguments: {α : Sort u_1} {f : α → α} (h : Function.Involutive f)
Goal: Function.Involutive ⇑(Function.Involutive.toPerm f h)
-- PLift.eq_up_iff_down_eq
theorem PLift.eq_up_iff_down_eq {x : PLift α} {y : α} : x = PLift.up y ↔ x.down = y 
Arguments: {α : Sort u_1} {x : PLift α} {y : α}
Goal: x = { down := y } ↔ x.down = y
-- Function.Injective.map_swap
theorem Function.Injective.map_swap [DecidableEq α] [DecidableEq β] {f : α → β}
    (hf : Function.Injective f) (x y z : α) :
    f (Equiv.swap x y z) = Equiv.swap (f x) (f y) (f z) 
Arguments: {α : Sort u_1} {β : Sort u_2} [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (x y z : α)
Goal: f ((Equiv.swap x y) z) = (Equiv.swap (f x) (f y)) (f z)
-- Equiv.piCongrLeft'_symm_apply
@[simps]
def piCongrLeft' (P : α → Sort*) (e : α ≃ β) : (∀ a, P a) ≃ ∀ b, P (e.symm b) 
Arguments: {α : Sort u_2} {β : Sort u_3} (P : α → Sort u_1) (e : α ≃ β) (f : (b : β) → P (e.symm b)) (x : α)
Goal: (Equiv.piCongrLeft' P e).symm f x = ⋯ ▸ f (e x)
-- Equiv.piCongrLeft'_apply
@[simps]
def piCongrLeft' (P : α → Sort*) (e : α ≃ β) : (∀ a, P a) ≃ ∀ b, P (e.symm b) 
Arguments: {α : Sort u_2} {β : Sort u_3} (P : α → Sort u_1) (e : α ≃ β) (f : (a : α) → P a) (x : β)
Goal: (Equiv.piCongrLeft' P e) f x = f (e.symm x)
-- Equiv.piCongrLeft'_symm
@[simp]
theorem piCongrLeft'_symm (P : Sort*) (e : α ≃ β) :
    (piCongrLeft' (fun _ => P) e).symm = piCongrLeft' _ e.symm 
Arguments: {α : Sort u_2} {β : Sort u_3} (P : Sort u_1) (e : α ≃ β)
Goal: (Equiv.piCongrLeft' (fun x => P) e).symm = Equiv.piCongrLeft' (fun a => P) e.symm
-- Equiv.piCongrLeft'_symm_apply_apply
lemma piCongrLeft'_symm_apply_apply (P : α → Sort*) (e : α ≃ β) (g : ∀ b, P (e.symm b)) (b : β) :
    (piCongrLeft' P e).symm g (e.symm b) = g b 
Arguments: {α : Sort u_2} {β : Sort u_3} (P : α → Sort u_1) (e : α ≃ β) (g : (b : β) → P (e.symm b)) (b : β)
Goal: (Equiv.piCongrLeft' P e).symm g (e.symm b) = g b
-- Equiv.piCongrLeft_apply
@[simp]
lemma piCongrLeft_apply (f : ∀ a, P (e a)) (b : β) :
    (piCongrLeft P e) f b = e.apply_symm_apply b ▸ f (e.symm b) 
Arguments: {β : Sort u_1} {α : Sort u_2} (P : β → Sort w) (e : α ≃ β) (f : (a : α) → P (e a)) (b : β)
Goal: (Equiv.piCongrLeft P e) f b = ⋯ ▸ f (e.symm b)
-- Equiv.piCongrLeft_symm_apply
@[simp]
lemma piCongrLeft_symm_apply (g : ∀ b, P b) (a : α) :
    (piCongrLeft P e).symm g a = g (e a) 
Arguments: {β : Sort u_1} {α : Sort u_2} (P : β → Sort w) (e : α ≃ β) (g : (b : β) → P b) (a : α)
Goal: (Equiv.piCongrLeft P e).symm g a = g (e a)
-- Equiv.piCongrLeft_apply_apply
lemma piCongrLeft_apply_apply (f : ∀ a, P (e a)) (a : α) :
    (piCongrLeft P e) f (e a) = f a 
Arguments: {β : Sort u_1} {α : Sort u_2} (P : β → Sort w) (e : α ≃ β) (f : (a : α) → P (e a)) (a : α)
Goal: (Equiv.piCongrLeft P e) f (e a) = f a
-- Equiv.piCongrLeft_apply_eq_cast
lemma piCongrLeft_apply_eq_cast {P : β → Sort v} {e : α ≃ β}
    (f : (a : α) → P (e a)) (b : β) :
    piCongrLeft P e f b = cast (congr_arg P (e.apply_symm_apply b)) (f (e.symm b)) 
Arguments: {β : Sort u_2} {α : Sort u_1} {P : β → Sort v} {e : α ≃ β} (f : (a : α) → P (e a)) (b : β)
Goal: (Equiv.piCongrLeft P e) f b = cast ⋯ (f (e.symm b))
-- Equiv.piCongrLeft_sum_inl
theorem piCongrLeft_sum_inl (π : ι'' → Type*) (e : ι ⊕ ι' ≃ ι'') (f : ∀ i, π (e (inl i)))
    (g : ∀ i, π (e (inr i))) (i : ι) :
    piCongrLeft π e (sumPiEquivProdPi (fun x => π (e x)) |>.symm (f, g)) (e (inl i)) = f i 
Arguments: {ι'' : Sort u_2} {ι : Type u_3} {ι' : Type u_4} (π : ι'' → Type u_1) (e : ι ⊕ ι' ≃ ι'') (f : (i : ι) → π (e (Sum.inl i))) (g : (i : ι') → π (e (Sum.inr i))) (i : ι)
Goal: (Equiv.piCongrLeft π e) ((Equiv.sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (Sum.inl i)) = f i
-- Equiv.piCongrLeft_sum_inr
theorem piCongrLeft_sum_inr (π : ι'' → Type*) (e : ι ⊕ ι' ≃ ι'') (f : ∀ i, π (e (inl i)))
    (g : ∀ i, π (e (inr i))) (j : ι') :
    piCongrLeft π e (sumPiEquivProdPi (fun x => π (e x)) |>.symm (f, g)) (e (inr j)) = g j 
Arguments: {ι'' : Sort u_2} {ι : Type u_3} {ι' : Type u_4} (π : ι'' → Type u_1) (e : ι ⊕ ι' ≃ ι'') (f : (i : ι) → π (e (Sum.inl i))) (g : (i : ι') → π (e (Sum.inr i))) (j : ι')
Goal: (Equiv.piCongrLeft π e) ((Equiv.sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (Sum.inr j)) = g j
-- Equiv.coe_piCongr_symm
@[simp]
theorem coe_piCongr_symm : ((h₁.piCongr h₂).symm :
    (∀ b, Z b) → ∀ a, W a) = fun f a => (h₂ a).symm (f (h₁ a)) 
Arguments: {α : Sort u_2} {β : Sort u_1} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (a : α) → W a ≃ Z (h₁ a))
Goal: ⇑(h₁.piCongr h₂).symm = fun f a => (h₂ a).symm (f (h₁ a))
-- Equiv.piCongr_symm_apply
theorem piCongr_symm_apply (f : ∀ b, Z b) :
    (h₁.piCongr h₂).symm f = fun a => (h₂ a).symm (f (h₁ a)) 
Arguments: {α : Sort u_1} {β : Sort u_2} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (a : α) → W a ≃ Z (h₁ a)) (f : (b : β) → Z b)
Goal: (h₁.piCongr h₂).symm f = fun a => (h₂ a).symm (f (h₁ a))
-- Equiv.piCongr_apply_apply
@[simp]
theorem piCongr_apply_apply (f : ∀ a, W a) (a : α) : h₁.piCongr h₂ f (h₁ a) = h₂ a (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (a : α) → W a ≃ Z (h₁ a)) (f : (a : α) → W a) (a : α)
Goal: (h₁.piCongr h₂) f (h₁ a) = (h₂ a) (f a)
-- Equiv.coe_piCongr'
@[simp]
theorem coe_piCongr' :
    (h₁.piCongr' h₂ : (∀ a, W a) → ∀ b, Z b) = fun f b => h₂ b <| f <| h₁.symm b 
Arguments: {α : Sort u_1} {β : Sort u_2} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (b : β) → W (h₁.symm b) ≃ Z b)
Goal: ⇑(h₁.piCongr' h₂) = fun f b => (h₂ b) (f (h₁.symm b))
-- Equiv.piCongr'_apply
theorem piCongr'_apply (f : ∀ a, W a) : h₁.piCongr' h₂ f = fun b => h₂ b <| f <| h₁.symm b 
Arguments: {α : Sort u_2} {β : Sort u_1} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (b : β) → W (h₁.symm b) ≃ Z b) (f : (a : α) → W a)
Goal: (h₁.piCongr' h₂) f = fun b => (h₂ b) (f (h₁.symm b))
-- Equiv.piCongr'_symm_apply_symm_apply
@[simp]
theorem piCongr'_symm_apply_symm_apply (f : ∀ b, Z b) (b : β) :
    (h₁.piCongr' h₂).symm f (h₁.symm b) = (h₂ b).symm (f b) 
Arguments: {α : Sort u_1} {β : Sort u_2} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (b : β) → W (h₁.symm b) ≃ Z b) (f : (b : β) → Z b) (b : β)
Goal: (h₁.piCongr' h₂).symm f (h₁.symm b) = (h₂ b).symm (f b)
-- Equiv.semiconj_conj
theorem semiconj_conj (f : α₁ → α₁) : Semiconj e f (e.conj f) 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} (e : α₁ ≃ β₁) (f : α₁ → α₁)
Goal: Function.Semiconj (⇑e) f (e.conj f)
-- Equiv.semiconj₂_conj
theorem semiconj₂_conj : Semiconj₂ e f (e.arrowCongr e.conj f) 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} (e : α₁ ≃ β₁) (f : α₁ → α₁ → α₁)
Goal: Function.Semiconj₂ (⇑e) f ((e.arrowCongr e.conj) f)
-- Equiv.ulift_symm_down
@[simp]
theorem ulift_symm_down (x : α) : (Equiv.ulift.{u, v}.symm x).down = x 
Arguments: {α : Type v} (x : α)
Goal: (Equiv.ulift.symm x).down = x
-- Function.Injective.swap_apply
theorem Function.Injective.swap_apply
    [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (x y z : α) :
    Equiv.swap (f x) (f y) (f z) = f (Equiv.swap x y z) 
Arguments: {α : Sort u_1} {β : Sort u_2} [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (x y z : α)
Goal: (Equiv.swap (f x) (f y)) (f z) = f ((Equiv.swap x y) z)
-- Function.Injective.swap_comp
theorem Function.Injective.swap_comp
    [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (x y : α) :
    Equiv.swap (f x) (f y) ∘ f = f ∘ Equiv.swap x y 
Arguments: {α : Sort u_1} {β : Sort u_2} [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (x y : α)
Goal: ⇑(Equiv.swap (f x) (f y)) ∘ f = f ∘ ⇑(Equiv.swap x y)
-- Function.update_comp_equiv
theorem update_comp_equiv [DecidableEq α'] [DecidableEq α] (f : α → β)
    (g : α' ≃ α) (a : α) (v : β) :
    update f a v ∘ g = update (f ∘ g) (g.symm a) v 
Arguments: {α' : Sort u_1} {α : Sort u_2} {β : Sort u_3} [DecidableEq α'] [DecidableEq α] (f : α → β) (g : α' ≃ α) (a : α) (v : β)
Goal: Function.update f a v ∘ ⇑g = Function.update (f ∘ ⇑g) (g.symm a) v
-- Function.update_apply_equiv_apply
theorem update_apply_equiv_apply [DecidableEq α'] [DecidableEq α] (f : α → β)
    (g : α' ≃ α) (a : α) (v : β) (a' : α') : update f a v (g a') = update (f ∘ g) (g.symm a) v a' 
Arguments: {α' : Sort u_1} {α : Sort u_2} {β : Sort u_3} [DecidableEq α'] [DecidableEq α] (f : α → β) (g : α' ≃ α) (a : α) (v : β) (a' : α')
Goal: Function.update f a v (g a') = Function.update (f ∘ ⇑g) (g.symm a) v a'
-- Function.piCongrLeft'_update
theorem piCongrLeft'_update [DecidableEq α] [DecidableEq β] (P : α → Sort*) (e : α ≃ β)
    (f : ∀ a, P a) (b : β) (x : P (e.symm b)) :
    e.piCongrLeft' P (update f (e.symm b) x) = update (e.piCongrLeft' P f) b x 
Arguments: {α : Sort u_2} {β : Sort u_3} [DecidableEq α] [DecidableEq β] (P : α → Sort u_1) (e : α ≃ β) (f : (a : α) → P a) (b : β) (x : P (e.symm b))
Goal: (Equiv.piCongrLeft' P e) (Function.update f (e.symm b) x) = Function.update ((Equiv.piCongrLeft' P e) f) b x