ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.sigmaFiberEquiv_symm_apply_fst
@[simps]
def sigmaFiberEquiv {α β : Type*} (f : α → β) : (Σ y : β, { x // f x = y }) ≃ α 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : α)
Goal: ((Equiv.sigmaFiberEquiv f).symm x).fst = f x
-- Equiv.sumCompl_apply_inl
@[simp]
theorem sumCompl_apply_inl (p : α → Prop) [DecidablePred p] (x : { a // p a }) :
    sumCompl p (Sum.inl x) = x 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (x : { a // p a })
Goal: (Equiv.sumCompl p) (Sum.inl x) = ↑x
-- Equiv.sumCompl_apply_inr
@[simp]
theorem sumCompl_apply_inr (p : α → Prop) [DecidablePred p] (x : { a // ¬p a }) :
    sumCompl p (Sum.inr x) = x 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (x : { a // ¬p a })
Goal: (Equiv.sumCompl p) (Sum.inr x) = ↑x
-- Equiv.sumCompl_apply_symm_of_pos
@[simp]
theorem sumCompl_apply_symm_of_pos (p : α → Prop) [DecidablePred p] (a : α) (h : p a) :
    (sumCompl p).symm a = Sum.inl ⟨a, h⟩ 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (a : α) (h : p a)
Goal: (Equiv.sumCompl p).symm a = Sum.inl ⟨a, h⟩
-- Equiv.sumCompl_apply_symm_of_neg
@[simp]
theorem sumCompl_apply_symm_of_neg (p : α → Prop) [DecidablePred p] (a : α) (h : ¬p a) :
    (sumCompl p).symm a = Sum.inr ⟨a, h⟩ 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (a : α) (h : ¬p a)
Goal: (Equiv.sumCompl p).symm a = Sum.inr ⟨a, h⟩
-- Equiv.Perm.subtypeCongr.apply
theorem Perm.subtypeCongr.apply (a : ε) : ep.subtypeCongr en a =
    if h : p a then (ep ⟨a, h⟩ : ε) else en ⟨a, h⟩ 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a }) (a : ε)
Goal: (ep.subtypeCongr en) a = if h : p a then ↑(ep ⟨a, h⟩) else ↑(en ⟨a, h⟩)
-- Equiv.Perm.subtypeCongr.left_apply
@[simp]
theorem Perm.subtypeCongr.left_apply {a : ε} (h : p a) : ep.subtypeCongr en a = ep ⟨a, h⟩ 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a }) {a : ε} (h : p a)
Goal: (ep.subtypeCongr en) a = ↑(ep ⟨a, h⟩)
-- Equiv.Perm.subtypeCongr.left_apply_subtype
@[simp]
theorem Perm.subtypeCongr.left_apply_subtype (a : { a // p a }) : ep.subtypeCongr en a = ep a 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a }) (a : { a // p a })
Goal: (ep.subtypeCongr en) ↑a = ↑(ep a)
-- Equiv.Perm.subtypeCongr.right_apply
@[simp]
theorem Perm.subtypeCongr.right_apply {a : ε} (h : ¬p a) : ep.subtypeCongr en a = en ⟨a, h⟩ 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a }) {a : ε} (h : ¬p a)
Goal: (ep.subtypeCongr en) a = ↑(en ⟨a, h⟩)
-- Equiv.Perm.subtypeCongr.right_apply_subtype
@[simp]
theorem Perm.subtypeCongr.right_apply_subtype (a : { a // ¬p a }) : ep.subtypeCongr en a = en a 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a }) (a : { a // ¬p a })
Goal: (ep.subtypeCongr en) ↑a = ↑(en a)
-- Equiv.Perm.subtypeCongr.refl
@[simp]
theorem Perm.subtypeCongr.refl :
    Perm.subtypeCongr (Equiv.refl { a // p a }) (Equiv.refl { a // ¬p a }) = Equiv.refl ε 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p]
Goal: Equiv.Perm.subtypeCongr (Equiv.refl { a // p a }) (Equiv.refl { a // ¬p a }) = Equiv.refl ε
-- Equiv.Perm.subtypeCongr.symm
@[simp]
theorem Perm.subtypeCongr.symm : (ep.subtypeCongr en).symm = Perm.subtypeCongr ep.symm en.symm 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a })
Goal: Equiv.symm (ep.subtypeCongr en) = Equiv.Perm.subtypeCongr (Equiv.symm ep) (Equiv.symm en)
-- Equiv.Perm.subtypeCongr.trans
@[simp]
theorem Perm.subtypeCongr.trans :
    (ep.subtypeCongr en).trans (ep'.subtypeCongr en')
    = Perm.subtypeCongr (ep.trans ep') (en.trans en') 
Arguments: {ε : Type u_1} {p : ε → Prop} [DecidablePred p] (ep ep' : Equiv.Perm { a // p a }) (en en' : Equiv.Perm { a // ¬p a })
Goal: Equiv.trans (ep.subtypeCongr en) (ep'.subtypeCongr en') =
  Equiv.Perm.subtypeCongr (Equiv.trans ep ep') (Equiv.trans en en')
-- Equiv.subtypePreimage_apply
@[simps]
def subtypePreimage : { x : α → β // x ∘ Subtype.val = x₀ } ≃ ({ a // ¬p a } → β) 
Arguments: {α : Sort u_1} {β : Sort u_2} (p : α → Prop) [DecidablePred p] (x₀ : { a // p a } → β) (x : { x // x ∘ Subtype.val = x₀ }) (a : { a // ¬p a })
Goal: (Equiv.subtypePreimage p x₀) x a = ↑x ↑a
-- Equiv.subtypePreimage_symm_apply_coe
@[simps]
def subtypePreimage : { x : α → β // x ∘ Subtype.val = x₀ } ≃ ({ a // ¬p a } → β) 
Arguments: {α : Sort u_1} {β : Sort u_2} (p : α → Prop) [DecidablePred p] (x₀ : { a // p a } → β) (x : { a // ¬p a } → β) (a : α)
Goal: ↑((Equiv.subtypePreimage p x₀).symm x) a = if h : p a then x₀ ⟨a, h⟩ else x ⟨a, h⟩
-- Equiv.subtypePreimage_symm_apply_coe_pos
theorem subtypePreimage_symm_apply_coe_pos (x : { a // ¬p a } → β) (a : α) (h : p a) :
    ((subtypePreimage p x₀).symm x : α → β) a = x₀ ⟨a, h⟩ 
Arguments: {α : Sort u_1} {β : Sort u_2} (p : α → Prop) [DecidablePred p] (x₀ : { a // p a } → β) (x : { a // ¬p a } → β) (a : α) (h : p a)
Goal: ↑((Equiv.subtypePreimage p x₀).symm x) a = x₀ ⟨a, h⟩
-- Equiv.subtypePreimage_symm_apply_coe_neg
theorem subtypePreimage_symm_apply_coe_neg (x : { a // ¬p a } → β) (a : α) (h : ¬p a) :
    ((subtypePreimage p x₀).symm x : α → β) a = x ⟨a, h⟩ 
Arguments: {α : Sort u_1} {β : Sort u_2} (p : α → Prop) [DecidablePred p] (x₀ : { a // p a } → β) (x : { a // ¬p a } → β) (a : α) (h : ¬p a)
Goal: ↑((Equiv.subtypePreimage p x₀).symm x) a = x ⟨a, h⟩
-- Equiv.piComm_apply
@[simps apply]
def piComm (φ : α → β → Sort*) : (∀ a b, φ a b) ≃ ∀ b a, φ a b 
Arguments: {α : Sort u_2} {β : Sort u_3} (φ : α → β → Sort u_1) (f : (x : α) → (y : β) → φ x y) (y : β) (x : α)
Goal: (Equiv.piComm φ) f y x = Function.swap f y x
-- Equiv.piComm_symm
@[simp]
theorem piComm_symm {φ : α → β → Sort*} : (piComm φ).symm = (piComm <| swap φ) 
Arguments: {α : Sort u_2} {β : Sort u_3} {φ : α → β → Sort u_1}
Goal: (Equiv.piComm φ).symm = Equiv.piComm (Function.swap φ)
-- Equiv.piCurry_apply
@[simp] theorem piCurry_apply {β : α → Type*} (γ : ∀ a, β a → Type*)
    (f : ∀ x : Σ i, β i, γ x.1 x.2) :
    piCurry γ f = Sigma.curry f 
Arguments: {α : Type u_3} {β : α → Type u_1} (γ : (a : α) → β a → Type u_2) (f : (x : (i : α) × β i) → γ x.fst x.snd)
Goal: (Equiv.piCurry γ) f = Sigma.curry f
-- Equiv.piCurry_symm_apply
@[simp] theorem piCurry_symm_apply {β : α → Type*} (γ : ∀ a, β a → Type*) (f : ∀ a b, γ a b) :
    (piCurry γ).symm f = Sigma.uncurry f 
Arguments: {α : Type u_3} {β : α → Type u_1} (γ : (a : α) → β a → Type u_2) (f : (a : α) → (b : β a) → γ a b)
Goal: (Equiv.piCurry γ).symm f = Sigma.uncurry f
-- Equiv.prodCongrLeft_apply
@[simp]
theorem prodCongrLeft_apply (b : β₁) (a : α₁) : prodCongrLeft e (b, a) = (e a b, a) 
Arguments: {α₁ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_1} (e : α₁ → β₁ ≃ β₂) (b : β₁) (a : α₁)
Goal: (Equiv.prodCongrLeft e) (b, a) = ((e a) b, a)
-- Equiv.prodCongr_refl_right
theorem prodCongr_refl_right (e : β₁ ≃ β₂) :
    prodCongr e (Equiv.refl α₁) = prodCongrLeft fun _ => e 
Arguments: {α₁ : Type u_3} {β₁ : Type u_1} {β₂ : Type u_2} (e : β₁ ≃ β₂)
Goal: e.prodCongr (Equiv.refl α₁) = Equiv.prodCongrLeft fun x => e
-- Equiv.prodCongrRight_apply
@[simp]
theorem prodCongrRight_apply (a : α₁) (b : β₁) : prodCongrRight e (a, b) = (a, e a b) 
Arguments: {α₁ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_1} (e : α₁ → β₁ ≃ β₂) (a : α₁) (b : β₁)
Goal: (Equiv.prodCongrRight e) (a, b) = (a, (e a) b)
-- Equiv.prodCongr_refl_left
theorem prodCongr_refl_left (e : β₁ ≃ β₂) :
    prodCongr (Equiv.refl α₁) e = prodCongrRight fun _ => e 
Arguments: {α₁ : Type u_3} {β₁ : Type u_1} {β₂ : Type u_2} (e : β₁ ≃ β₂)
Goal: (Equiv.refl α₁).prodCongr e = Equiv.prodCongrRight fun x => e
-- Equiv.prodCongrLeft_trans_prodComm
@[simp]
theorem prodCongrLeft_trans_prodComm :
    (prodCongrLeft e).trans (prodComm _ _) = (prodComm _ _).trans (prodCongrRight e) 
Arguments: {α₁ : Type u_3} {β₁ : Type u_2} {β₂ : Type u_1} (e : α₁ → β₁ ≃ β₂)
Goal: (Equiv.prodCongrLeft e).trans (Equiv.prodComm β₂ α₁) = (Equiv.prodComm β₁ α₁).trans (Equiv.prodCongrRight e)
-- Equiv.prodCongrRight_trans_prodComm
@[simp]
theorem prodCongrRight_trans_prodComm :
    (prodCongrRight e).trans (prodComm _ _) = (prodComm _ _).trans (prodCongrLeft e) 
Arguments: {α₁ : Type u_3} {β₁ : Type u_2} {β₂ : Type u_1} (e : α₁ → β₁ ≃ β₂)
Goal: (Equiv.prodCongrRight e).trans (Equiv.prodComm α₁ β₂) = (Equiv.prodComm α₁ β₁).trans (Equiv.prodCongrLeft e)
-- Equiv.sigmaCongrRight_sigmaEquivProd
theorem sigmaCongrRight_sigmaEquivProd :
    (sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂)
    = (sigmaEquivProd α₁ β₁).trans (prodCongrRight e) 
Arguments: {α₁ : Type u_1} {β₁ : Type u_3} {β₂ : Type u_2} (e : α₁ → β₁ ≃ β₂)
Goal: (Equiv.sigmaCongrRight e).trans (Equiv.sigmaEquivProd α₁ β₂) =
  (Equiv.sigmaEquivProd α₁ β₁).trans (Equiv.prodCongrRight e)
-- Equiv.sigmaEquivProd_sigmaCongrRight
theorem sigmaEquivProd_sigmaCongrRight :
    (sigmaEquivProd α₁ β₁).symm.trans (sigmaCongrRight e)
    = (prodCongrRight e).trans (sigmaEquivProd α₁ β₂).symm 
Arguments: {α₁ : Type u_2} {β₁ : Type u_1} {β₂ : Type u_3} (e : α₁ → β₁ ≃ β₂)
Goal: (Equiv.sigmaEquivProd α₁ β₁).symm.trans (Equiv.sigmaCongrRight e) =
  (Equiv.prodCongrRight e).trans (Equiv.sigmaEquivProd α₁ β₂).symm
-- Equiv.ofFiberEquiv_symm_apply
@[simps!]
def ofFiberEquiv {f : α → γ} {g : β → γ} (e : ∀ c, { a // f a = c } ≃ { b // g b = c }) : α ≃ β 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} {f : α → γ} {g : β → γ} (e : (c : γ) → { a // f a = c } ≃ { b // g b = c })
Goal: ∀ (a : β), (Equiv.ofFiberEquiv e).symm a = ↑((Equiv.sigmaCongrRight e).symm ((Equiv.sigmaFiberEquiv g).symm a)).snd
-- Equiv.ofFiberEquiv_apply
@[simps!]
def ofFiberEquiv {f : α → γ} {g : β → γ} (e : ∀ c, { a // f a = c } ≃ { b // g b = c }) : α ≃ β 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} {f : α → γ} {g : β → γ} (e : (c : γ) → { a // f a = c } ≃ { b // g b = c })
Goal: ∀ (a : α), (Equiv.ofFiberEquiv e) a = ↑((e (f a)) ((Equiv.sigmaFiberEquiv f).symm a).snd)
-- Equiv.ofFiberEquiv_map
theorem ofFiberEquiv_map {α β γ} {f : α → γ} {g : β → γ}
    (e : ∀ c, { a // f a = c } ≃ { b // g b = c }) (a : α) : g (ofFiberEquiv e a) = f a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → γ} {g : β → γ} (e : (c : γ) → { a // f a = c } ≃ { b // g b = c }) (a : α)
Goal: g ((Equiv.ofFiberEquiv e) a) = f a
-- Equiv.prodShear_symm_apply
@[simps (config := .asFn)]
def prodShear (e₁ : α₁ ≃ α₂) (e₂ : α₁ → β₁ ≃ β₂) : α₁ × β₁ ≃ α₂ × β₂ 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} {β₂ : Type u_3} {α₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : α₁ → β₁ ≃ β₂)
Goal: ⇑(e₁.prodShear e₂).symm = fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)
-- Equiv.prodShear_apply
@[simps (config := .asFn)]
def prodShear (e₁ : α₁ ≃ α₂) (e₂ : α₁ → β₁ ≃ β₂) : α₁ × β₁ ≃ α₂ × β₂ 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} {β₂ : Type u_3} {α₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : α₁ → β₁ ≃ β₂)
Goal: ⇑(e₁.prodShear e₂) = fun x => (e₁ x.1, (e₂ x.1) x.2)
-- Equiv.Perm.prodExtendRight_apply_eq
@[simp]
theorem prodExtendRight_apply_eq (b : β₁) : prodExtendRight a e (a, b) = (a, e b) 
Arguments: {α₁ : Type u_2} {β₁ : Type u_1} [DecidableEq α₁] (a : α₁) (e : Equiv.Perm β₁) (b : β₁)
Goal: (Equiv.Perm.prodExtendRight a e) (a, b) = (a, e b)
-- Equiv.Perm.prodExtendRight_apply_ne
theorem prodExtendRight_apply_ne {a a' : α₁} (h : a' ≠ a) (b : β₁) :
    prodExtendRight a e (a', b) = (a', b) 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} [DecidableEq α₁] (e : Equiv.Perm β₁) {a a' : α₁} (h : a' ≠ a) (b : β₁)
Goal: (Equiv.Perm.prodExtendRight a e) (a', b) = (a', b)
-- Equiv.Perm.eq_of_prodExtendRight_ne
theorem eq_of_prodExtendRight_ne {e : Perm β₁} {a a' : α₁} {b : β₁}
    (h : prodExtendRight a e (a', b) ≠ (a', b)) : a' = a 
Arguments: {α₁ : Type u_2} {β₁ : Type u_1} [DecidableEq α₁] {e : Equiv.Perm β₁} {a a' : α₁} {b : β₁} (h : (Equiv.Perm.prodExtendRight a e) (a', b) ≠ (a', b))
Goal: a' = a
-- Equiv.Perm.fst_prodExtendRight
@[simp]
theorem fst_prodExtendRight (ab : α₁ × β₁) : (prodExtendRight a e ab).fst = ab.fst 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} [DecidableEq α₁] (a : α₁) (e : Equiv.Perm β₁) (ab : α₁ × β₁)
Goal: ((Equiv.Perm.prodExtendRight a e) ab).1 = ab.1
-- Equiv.sumPiEquivProdPi_symm_apply
@[simps]
def sumPiEquivProdPi (π : ι ⊕ ι' → Type*) : (∀ i, π i) ≃ (∀ i, π (inl i)) × ∀ i', π (inr i') 
Arguments: {ι : Type u_2} {ι' : Type u_3} (π : ι ⊕ ι' → Type u_1) (g : ((i : ι) → π (Sum.inl i)) × ((i' : ι') → π (Sum.inr i'))) (t : ι ⊕ ι')
Goal: (Equiv.sumPiEquivProdPi π).symm g t = Sum.rec g.1 g.2 t
-- Equiv.sumPiEquivProdPi_apply
@[simps]
def sumPiEquivProdPi (π : ι ⊕ ι' → Type*) : (∀ i, π i) ≃ (∀ i, π (inl i)) × ∀ i', π (inr i') 
Arguments: {ι : Type u_2} {ι' : Type u_3} (π : ι ⊕ ι' → Type u_1) (f : (i : ι ⊕ ι') → π i)
Goal: (Equiv.sumPiEquivProdPi π) f = (fun i => f (Sum.inl i), fun i' => f (Sum.inr i'))
-- Equiv.prodPiEquivSumPi_apply
@[simps!]
def prodPiEquivSumPi (π : ι → Type u) (π' : ι' → Type u) :
    ((∀ i, π i) × ∀ i', π' i') ≃ ∀ i, Sum.elim π π' i 
Arguments: {ι : Type u_1} {ι' : Type u_2} (π : ι → Type u) (π' : ι' → Type u)
Goal: ∀ (a : ((i : ι) → Sum.elim π π' (Sum.inl i)) × ((i' : ι') → Sum.elim π π' (Sum.inr i'))) (i : ι ⊕ ι'),
  (Equiv.prodPiEquivSumPi π π') a i = (Equiv.sumPiEquivProdPi (Sum.elim π π')).symm a i
-- Equiv.prodPiEquivSumPi_symm_apply
@[simps!]
def prodPiEquivSumPi (π : ι → Type u) (π' : ι' → Type u) :
    ((∀ i, π i) × ∀ i', π' i') ≃ ∀ i, Sum.elim π π' i 
Arguments: {ι : Type u_1} {ι' : Type u_2} (π : ι → Type u) (π' : ι' → Type u)
Goal: ∀ (a : (i : ι ⊕ ι') → Sum.elim π π' i),
  (Equiv.prodPiEquivSumPi π π').symm a = (Equiv.sumPiEquivProdPi (Sum.elim π π')) a
-- Equiv.sumArrowEquivProdArrow_apply_fst
@[simp]
theorem sumArrowEquivProdArrow_apply_fst (f : α ⊕ β → γ) (a : α) :
    (sumArrowEquivProdArrow α β γ f).1 a = f (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α ⊕ β → γ) (a : α)
Goal: ((Equiv.sumArrowEquivProdArrow α β γ) f).1 a = f (Sum.inl a)
-- Equiv.sumArrowEquivProdArrow_apply_snd
@[simp]
theorem sumArrowEquivProdArrow_apply_snd (f : α ⊕ β → γ) (b : β) :
    (sumArrowEquivProdArrow α β γ f).2 b = f (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α ⊕ β → γ) (b : β)
Goal: ((Equiv.sumArrowEquivProdArrow α β γ) f).2 b = f (Sum.inr b)
-- Equiv.sumArrowEquivProdArrow_symm_apply_inl
@[simp]
theorem sumArrowEquivProdArrow_symm_apply_inl (f : α → γ) (g : β → γ) (a : α) :
    ((sumArrowEquivProdArrow α β γ).symm (f, g)) (inl a) = f a 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} (f : α → γ) (g : β → γ) (a : α)
Goal: (Equiv.sumArrowEquivProdArrow α β γ).symm (f, g) (Sum.inl a) = f a
-- Equiv.sumArrowEquivProdArrow_symm_apply_inr
@[simp]
theorem sumArrowEquivProdArrow_symm_apply_inr (f : α → γ) (g : β → γ) (b : β) :
    ((sumArrowEquivProdArrow α β γ).symm (f, g)) (inr b) = g b 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} (f : α → γ) (g : β → γ) (b : β)
Goal: (Equiv.sumArrowEquivProdArrow α β γ).symm (f, g) (Sum.inr b) = g b
-- Equiv.sumProdDistrib_apply_left
@[simp]
theorem sumProdDistrib_apply_left (a : α) (c : γ) :
    sumProdDistrib α β γ (Sum.inl a, c) = Sum.inl (a, c) 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} (a : α) (c : γ)
Goal: (Equiv.sumProdDistrib α β γ) (Sum.inl a, c) = Sum.inl (a, c)
-- Equiv.sumProdDistrib_apply_right
@[simp]
theorem sumProdDistrib_apply_right (b : β) (c : γ) :
    sumProdDistrib α β γ (Sum.inr b, c) = Sum.inr (b, c) 
Arguments: {β : Type u_1} {γ : Type u_2} {α : Type u_3} (b : β) (c : γ)
Goal: (Equiv.sumProdDistrib α β γ) (Sum.inr b, c) = Sum.inr (b, c)
-- Equiv.sumProdDistrib_symm_apply_left
@[simp]
theorem sumProdDistrib_symm_apply_left (a : α × γ) :
    (sumProdDistrib α β γ).symm (inl a) = (inl a.1, a.2) 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} (a : α × γ)
Goal: (Equiv.sumProdDistrib α β γ).symm (Sum.inl a) = (Sum.inl a.1, a.2)
-- Equiv.sumProdDistrib_symm_apply_right
@[simp]
theorem sumProdDistrib_symm_apply_right (b : β × γ) :
    (sumProdDistrib α β γ).symm (inr b) = (inr b.1, b.2) 
Arguments: {β : Type u_1} {γ : Type u_2} {α : Type u_3} (b : β × γ)
Goal: (Equiv.sumProdDistrib α β γ).symm (Sum.inr b) = (Sum.inr b.1, b.2)
-- Equiv.prodSumDistrib_apply_left
@[simp]
theorem prodSumDistrib_apply_left (a : α) (b : β) :
    prodSumDistrib α β γ (a, Sum.inl b) = Sum.inl (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a : α) (b : β)
Goal: (Equiv.prodSumDistrib α β γ) (a, Sum.inl b) = Sum.inl (a, b)
-- Equiv.prodSumDistrib_apply_right
@[simp]
theorem prodSumDistrib_apply_right (a : α) (c : γ) :
    prodSumDistrib α β γ (a, Sum.inr c) = Sum.inr (a, c) 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} (a : α) (c : γ)
Goal: (Equiv.prodSumDistrib α β γ) (a, Sum.inr c) = Sum.inr (a, c)
-- Equiv.prodSumDistrib_symm_apply_left
@[simp]
theorem prodSumDistrib_symm_apply_left (a : α × β) :
    (prodSumDistrib α β γ).symm (inl a) = (a.1, inl a.2) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a : α × β)
Goal: (Equiv.prodSumDistrib α β γ).symm (Sum.inl a) = (a.1, Sum.inl a.2)
-- Equiv.prodSumDistrib_symm_apply_right
@[simp]
theorem prodSumDistrib_symm_apply_right (a : α × γ) :
    (prodSumDistrib α β γ).symm (inr a) = (a.1, inr a.2) 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} (a : α × γ)
Goal: (Equiv.prodSumDistrib α β γ).symm (Sum.inr a) = (a.1, Sum.inr a.2)
-- Equiv.sigmaSumDistrib_apply
@[simps]
def sigmaSumDistrib (α β : ι → Type*) :
    (Σ i, α i ⊕ β i) ≃ (Σ i, α i) ⊕ (Σ i, β i) 
Arguments: {ι : Type u_3} (α : ι → Type u_1) (β : ι → Type u_2) (p : (i : ι) × (α i ⊕ β i))
Goal: (Equiv.sigmaSumDistrib α β) p = Sum.map (Sigma.mk p.fst) (Sigma.mk p.fst) p.snd
-- Equiv.sigmaSumDistrib_symm_apply
@[simps]
def sigmaSumDistrib (α β : ι → Type*) :
    (Σ i, α i ⊕ β i) ≃ (Σ i, α i) ⊕ (Σ i, β i) 
Arguments: {ι : Type u_3} (α : ι → Type u_1) (β : ι → Type u_2)
Goal: ∀ (a : (i : ι) × α i ⊕ (i : ι) × β i),
  (Equiv.sigmaSumDistrib α β).symm a = Sum.elim (Sigma.map id fun x => Sum.inl) (Sigma.map id fun x => Sum.inr) a
-- Equiv.boolProdEquivSum_symm_apply
@[simps]
def boolProdEquivSum (α) : Bool × α ≃ α ⊕ α 
Arguments: (α : Type u_1)
Goal: ∀ (a : α ⊕ α), (Equiv.boolProdEquivSum α).symm a = Sum.elim (Prod.mk false) (Prod.mk true) a
-- Equiv.boolProdEquivSum_apply
@[simps]
def boolProdEquivSum (α) : Bool × α ≃ α ⊕ α 
Arguments: (α : Type u_1) (p : Bool × α)
Goal: (Equiv.boolProdEquivSum α) p = Bool.casesOn p.1 (Sum.inl p.2) (Sum.inr p.2)
-- Equiv.boolArrowEquivProd_apply
@[simps]
def boolArrowEquivProd (α) : (Bool → α) ≃ α × α 
Arguments: (α : Type u_1) (f : Bool → α)
Goal: (Equiv.boolArrowEquivProd α) f = (f false, f true)
-- Equiv.boolArrowEquivProd_symm_apply
@[simps]
def boolArrowEquivProd (α) : (Bool → α) ≃ α × α 
Arguments: (α : Type u_1) (p : α × α) (b : Bool)
Goal: (Equiv.boolArrowEquivProd α).symm p b = Bool.casesOn b p.1 p.2
-- Equiv.isEmpty_congr
theorem isEmpty_congr (e : α ≃ β) : IsEmpty α ↔ IsEmpty β 
Arguments: {α : Sort u_1} {β : Sort u_2} (e : α ≃ β)
Goal: IsEmpty α ↔ IsEmpty β
-- Equiv.isEmpty
protected theorem isEmpty (e : α ≃ β) [IsEmpty β] : IsEmpty α 
Arguments: {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) [IsEmpty β]
Goal: IsEmpty α
-- Equiv.coe_subtypeEquiv_eq_map
lemma coe_subtypeEquiv_eq_map {X Y : Type*} {p : X → Prop} {q : Y → Prop} (e : X ≃ Y)
    (h : ∀ x, p x ↔ q (e x)) : ⇑(e.subtypeEquiv h) = Subtype.map e (h · |>.mp) 
Arguments: {X : Type u_1} {Y : Type u_2} {p : X → Prop} {q : Y → Prop} (e : X ≃ Y) (h : ∀ (x : X), p x ↔ q (e x))
Goal: ⇑(e.subtypeEquiv h) = Subtype.map ⇑e ⋯
-- Equiv.subtypeEquiv_refl
@[simp]
theorem subtypeEquiv_refl {p : α → Prop} (h : ∀ a, p a ↔ p (Equiv.refl _ a) := fun a => Iff.rfl) :
    (Equiv.refl α).subtypeEquiv h = Equiv.refl { a : α // p a } 
Arguments: {α : Sort u_1} {p : α → Prop} (h : ∀ (a : α), p a ↔ p ((Equiv.refl α) a) := ⋯)
Goal: (Equiv.refl α).subtypeEquiv h = Equiv.refl { a // p a }
-- Equiv.subtypeEquiv_symm
@[simp]
theorem subtypeEquiv_symm {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ a : α, p a ↔ q (e a)) :
    (e.subtypeEquiv h).symm =
      e.symm.subtypeEquiv fun a => by
        convert (h <| e.symm a).symm
        exact (e.apply_symm_apply a).symm 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a))
Goal: (e.subtypeEquiv h).symm = e.symm.subtypeEquiv ⋯
-- Equiv.subtypeEquiv_trans
@[simp]
theorem subtypeEquiv_trans {p : α → Prop} {q : β → Prop} {r : γ → Prop} (e : α ≃ β) (f : β ≃ γ)
    (h : ∀ a : α, p a ↔ q (e a)) (h' : ∀ b : β, q b ↔ r (f b)) :
    (e.subtypeEquiv h).trans (f.subtypeEquiv h')
    = (e.trans f).subtypeEquiv fun a => (h a).trans (h' <| e a) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {p : α → Prop} {q : β → Prop} {r : γ → Prop} (e : α ≃ β) (f : β ≃ γ) (h : ∀ (a : α), p a ↔ q (e a)) (h' : ∀ (b : β), q b ↔ r (f b))
Goal: (e.subtypeEquiv h).trans (f.subtypeEquiv h') = (e.trans f).subtypeEquiv ⋯
-- Equiv.subtypeEquiv_apply
@[simp]
theorem subtypeEquiv_apply {p : α → Prop} {q : β → Prop}
    (e : α ≃ β) (h : ∀ a : α, p a ↔ q (e a)) (x : { x // p x }) :
    e.subtypeEquiv h x = ⟨e x, (h _).1 x.2⟩ 
Arguments: {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a)) (x : { x // p x })
Goal: (e.subtypeEquiv h) x = ⟨e ↑x, ⋯⟩
-- Equiv.subtypeEquivRight_symm_apply_coe
@[simps!]
def subtypeEquivRight {p q : α → Prop} (e : ∀ x, p x ↔ q x) : { x // p x } ≃ { x // q x } 
Arguments: {α : Sort u_1} {p q : α → Prop} (e : ∀ (x : α), p x ↔ q x) (b : { b // q b })
Goal: ↑((Equiv.subtypeEquivRight e).symm b) = ↑b
-- Equiv.subtypeEquivRight_apply_coe
@[simps!]
def subtypeEquivRight {p q : α → Prop} (e : ∀ x, p x ↔ q x) : { x // p x } ≃ { x // q x } 
Arguments: {α : Sort u_1} {p q : α → Prop} (e : ∀ (x : α), p x ↔ q x) (a : { a // p a })
Goal: ↑((Equiv.subtypeEquivRight e) a) = ↑a
-- Equiv.subtypeEquivRight_apply
lemma subtypeEquivRight_apply {p q : α → Prop} (e : ∀ x, p x ↔ q x)
    (z : { x // p x }) : subtypeEquivRight e z = ⟨z, (e z.1).mp z.2⟩ 
Arguments: {α : Sort u_1} {p q : α → Prop} (e : ∀ (x : α), p x ↔ q x) (z : { x // p x })
Goal: (Equiv.subtypeEquivRight e) z = ⟨↑z, ⋯⟩
-- Equiv.subtypeEquivRight_symm_apply
lemma subtypeEquivRight_symm_apply {p q : α → Prop} (e : ∀ x, p x ↔ q x)
    (z : { x // q x }) : (subtypeEquivRight e).symm z = ⟨z, (e z.1).mpr z.2⟩ 
Arguments: {α : Sort u_1} {p q : α → Prop} (e : ∀ (x : α), p x ↔ q x) (z : { x // q x })
Goal: (Equiv.subtypeEquivRight e).symm z = ⟨↑z, ⋯⟩
-- Equiv.subtypeSubtypeEquivSubtypeExists_apply_coe
@[simps]
def subtypeSubtypeEquivSubtypeExists (p : α → Prop) (q : Subtype p → Prop) :
    Subtype q ≃ { a : α // ∃ h : p a, q ⟨a, h⟩ } 
Arguments: {α : Sort u_1} (p : α → Prop) (q : Subtype p → Prop) (a : Subtype q)
Goal: ↑((Equiv.subtypeSubtypeEquivSubtypeExists p q) a) = ↑↑a
-- Equiv.subtypeSubtypeEquivSubtypeExists_symm_apply_coe_coe
@[simps]
def subtypeSubtypeEquivSubtypeExists (p : α → Prop) (q : Subtype p → Prop) :
    Subtype q ≃ { a : α // ∃ h : p a, q ⟨a, h⟩ } 
Arguments: {α : Sort u_1} (p : α → Prop) (q : Subtype p → Prop) (a : { a // ∃ h, q ⟨a, h⟩ })
Goal: ↑↑((Equiv.subtypeSubtypeEquivSubtypeExists p q).symm a) = ↑a
-- Equiv.subtypeSubtypeEquivSubtypeInter_apply_coe
@[simps!]
def subtypeSubtypeEquivSubtypeInter {α : Type u} (p q : α → Prop) :
    { x : Subtype p // q x.1 } ≃ Subtype fun x => p x ∧ q x 
Arguments: {α : Type u} (p q : α → Prop)
Goal: ∀ (a : { x // q ↑x }), ↑((Equiv.subtypeSubtypeEquivSubtypeInter p q) a) = ↑↑a
-- Equiv.subtypeSubtypeEquivSubtypeInter_symm_apply_coe_coe
@[simps!]
def subtypeSubtypeEquivSubtypeInter {α : Type u} (p q : α → Prop) :
    { x : Subtype p // q x.1 } ≃ Subtype fun x => p x ∧ q x 
Arguments: {α : Type u} (p q : α → Prop)
Goal: ∀ (a : { x // p x ∧ q x }), ↑↑((Equiv.subtypeSubtypeEquivSubtypeInter p q).symm a) = ↑a
-- Equiv.subtypeSubtypeEquivSubtype_symm_apply_coe_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 : Subtype q), ↑↑((Equiv.subtypeSubtypeEquivSubtype h).symm a) = ↑a