ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Orientation.oangle_sign_sub_right_eq_neg
theorem oangle_sign_sub_right_eq_neg (x y : V) :
    (o.oangle x (x - y)).sign = -(o.oangle x y).sign 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V)
Goal: (o.oangle x (x - y)).sign = -(o.oangle x y).sign
-- Orientation.oangle_sign_sub_left_eq_neg
theorem oangle_sign_sub_left_eq_neg (x y : V) :
    (o.oangle (y - x) y).sign = -(o.oangle x y).sign 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V)
Goal: (o.oangle (y - x) y).sign = -(o.oangle x y).sign
-- Orientation.oangle_sign_sub_right_swap
@[simp]
theorem oangle_sign_sub_right_swap (x y : V) : (o.oangle y (y - x)).sign = (o.oangle x y).sign 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V)
Goal: (o.oangle y (y - x)).sign = (o.oangle x y).sign
-- Orientation.oangle_sign_sub_left_swap
@[simp]
theorem oangle_sign_sub_left_swap (x y : V) : (o.oangle (x - y) x).sign = (o.oangle x y).sign 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V)
Goal: (o.oangle (x - y) x).sign = (o.oangle x y).sign
-- Orientation.oangle_sign_smul_add_smul_right
-- @[simp] -- Porting note (#10618): simp can prove this
theorem oangle_sign_smul_add_smul_right (x y : V) (r₁ r₂ : ℝ) :
    (o.oangle x (r₁ • x + r₂ • y)).sign = SignType.sign r₂ * (o.oangle x y).sign 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V) (r₁ r₂ : ℝ)
Goal: (o.oangle x (r₁ • x + r₂ • y)).sign = SignType.sign r₂ * (o.oangle x y).sign
-- Orientation.oangle_sign_smul_add_smul_left
-- @[simp] -- Porting note (#10618): simp can prove this
theorem oangle_sign_smul_add_smul_left (x y : V) (r₁ r₂ : ℝ) :
    (o.oangle (r₁ • x + r₂ • y) y).sign = SignType.sign r₁ * (o.oangle x y).sign 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V) (r₁ r₂ : ℝ)
Goal: (o.oangle (r₁ • x + r₂ • y) y).sign = SignType.sign r₁ * (o.oangle x y).sign
-- Orientation.oangle_sign_smul_add_smul_smul_add_smul
theorem oangle_sign_smul_add_smul_smul_add_smul (x y : V) (r₁ r₂ r₃ r₄ : ℝ) :
    (o.oangle (r₁ • x + r₂ • y) (r₃ • x + r₄ • y)).sign =
      SignType.sign (r₁ * r₄ - r₂ * r₃) * (o.oangle x y).sign 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) (x y : V) (r₁ r₂ r₃ r₄ : ℝ)
Goal: (o.oangle (r₁ • x + r₂ • y) (r₃ • x + r₄ • y)).sign = SignType.sign (r₁ * r₄ - r₂ * r₃) * (o.oangle x y).sign
-- Orientation.abs_oangle_sub_left_toReal_lt_pi_div_two
theorem abs_oangle_sub_left_toReal_lt_pi_div_two {x y : V} (h : ‖x‖ = ‖y‖) :
    |(o.oangle (y - x) y).toReal| < π / 2 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V} (h : ‖x‖ = ‖y‖)
Goal: |(o.oangle (y - x) y).toReal| < π / 2
-- Orientation.abs_oangle_sub_right_toReal_lt_pi_div_two
theorem abs_oangle_sub_right_toReal_lt_pi_div_two {x y : V} (h : ‖x‖ = ‖y‖) :
    |(o.oangle x (x - y)).toReal| < π / 2 
Arguments: {V : Type u_1} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [Fact (FiniteDimensional.finrank ℝ V = 2)] (o : Orientation ℝ V (Fin 2)) {x y : V} (h : ‖x‖ = ‖y‖)
Goal: |(o.oangle x (x - y)).toReal| < π / 2
-- Unique.uniq
@[ext]
structure Unique (α : Sort u) extends Inhabited α where
    uniq : ∀ a : α, a = default
Arguments: {α : Sort u} (self : Unique α) (a : α)
Goal: a = default
-- unique_iff_exists_unique
theorem unique_iff_exists_unique (α : Sort u) : Nonempty (Unique α) ↔ ∃! _ : α, True 
Arguments: (α : Sort u)
Goal: Nonempty (Unique α) ↔ ∃! x, True
-- unique_subtype_iff_exists_unique
theorem unique_subtype_iff_exists_unique {α} (p : α → Prop) :
    Nonempty (Unique (Subtype p)) ↔ ∃! a, p a 
Arguments: {α : Sort u_1} (p : α → Prop)
Goal: Nonempty (Unique (Subtype p)) ↔ ∃! a, p a
-- PUnit.default_eq_unit
@[simp, nolint simpNF]
theorem PUnit.default_eq_unit : (default : PUnit) = PUnit.unit 
Goal: default = PUnit.unit
-- Unique.eq_default
theorem eq_default (a : α) : a = default 
Arguments: {α : Sort u_1} [Unique α] (a : α)
Goal: a = default
-- Unique.default_eq
theorem default_eq (a : α) : default = a 
Arguments: {α : Sort u_1} [Unique α] (a : α)
Goal: default = a
-- Unique.forall_iff
theorem forall_iff {p : α → Prop} : (∀ a, p a) ↔ p default 
Arguments: {α : Sort u_1} [Unique α] {p : α → Prop}
Goal: (∀ (a : α), p a) ↔ p default
-- Unique.exists_iff
theorem exists_iff {p : α → Prop} : Exists p ↔ p default 
Arguments: {α : Sort u_1} [Unique α] {p : α → Prop}
Goal: Exists p ↔ p default
-- Unique.subsingleton_unique'
@[ext]
protected theorem subsingleton_unique' : ∀ h₁ h₂ : Unique α, h₁ = h₂
  
Arguments: {α : Sort u_1} (h₁ h₂ : Unique α)
Goal: h₁ = h₂
-- unique_iff_subsingleton_and_nonempty
theorem unique_iff_subsingleton_and_nonempty (α : Sort u) :
    Nonempty (Unique α) ↔ Subsingleton α ∧ Nonempty α 
Arguments: (α : Sort u)
Goal: Nonempty (Unique α) ↔ Subsingleton α ∧ Nonempty α
-- Pi.default_def
@[simp]
theorem Pi.default_def {β : α → Sort v} [∀ a, Inhabited (β a)] :
    @default (∀ a, β a) _ = fun a : α ↦ @default (β a) _ 
Arguments: {α : Sort u_1} {β : α → Sort v} [(a : α) → Inhabited (β a)]
Goal: default = fun a => default
-- Pi.default_apply
theorem Pi.default_apply {β : α → Sort v} [∀ a, Inhabited (β a)] (a : α) :
    @default (∀ a, β a) _ a = default 
Arguments: {α : Sort u_1} {β : α → Sort v} [(a : α) → Inhabited (β a)] (a : α)
Goal: default a = default
-- eq_const_of_subsingleton
theorem eq_const_of_subsingleton {β : Sort*} [Subsingleton α] (f : α → β) (a : α) :
    f = Function.const α (f a) 
Arguments: {α : Sort u_1} {β : Sort u_2} [Subsingleton α] (f : α → β) (a : α)
Goal: f = Function.const α (f a)
-- eq_const_of_unique
theorem eq_const_of_unique {β : Sort*} [Unique α] (f : α → β) : f = Function.const α (f default) 
Arguments: {α : Sort u_1} {β : Sort u_2} [Unique α] (f : α → β)
Goal: f = Function.const α (f default)
-- heq_const_of_unique
theorem heq_const_of_unique [Unique α] {β : α → Sort v} (f : ∀ a, β a) :
    HEq f (Function.const α (f default)) 
Arguments: {α : Sort u_1} [Unique α] {β : α → Sort v} (f : (a : α) → β a)
Goal: HEq f (Function.const α (f default))
-- Function.Injective.subsingleton
protected theorem Injective.subsingleton (hf : Injective f) [Subsingleton β] : Subsingleton α 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} (hf : Function.Injective f) [Subsingleton β]
Goal: Subsingleton α
-- Function.Surjective.subsingleton
protected theorem Surjective.subsingleton [Subsingleton α] (hf : Surjective f) : Subsingleton β 
Arguments: {α : Sort u_1} {β : Sort u_2} {f : α → β} [Subsingleton α] (hf : Function.Surjective f)
Goal: Subsingleton β
-- uniqueElim_default
@[simp]
theorem uniqueElim_default {_ : Unique ι} (x : α (default : ι)) : uniqueElim x (default : ι) = x 
Arguments: {ι : Sort u_2} {α : ι → Sort u_3}
Goal: ∀ {x : Unique ι} (x_1 : α default), uniqueElim x_1 default = x_1
-- uniqueElim_const
@[simp]
theorem uniqueElim_const {β : Sort*} {_ : Unique ι} (x : β) (i : ι) :
    uniqueElim (α := fun _ ↦ β) x i = x 
Arguments: {ι : Sort u_2} {β : Sort u_4}
Goal: ∀ {x : Unique ι} (x_1 : β) (i : ι), uniqueElim x_1 i = x_1
-- Unique.bijective
theorem Unique.bijective {A B} [Unique A] [Unique B] {f : A → B} : Function.Bijective f 
Arguments: {A : Sort u_2} {B : Sort u_3} [Unique A] [Unique B] {f : A → B}
Goal: Function.Bijective f
-- Option.subsingleton_iff_isEmpty
theorem subsingleton_iff_isEmpty {α : Type u} : Subsingleton (Option α) ↔ IsEmpty α 
Arguments: {α : Type u}
Goal: Subsingleton (Option α) ↔ IsEmpty α
-- Equiv.pprodEquivProd_symm_apply
@[simps apply symm_apply]
def pprodEquivProd : PProd α β ≃ α × β 
Arguments: {α : Type u_1} {β : Type u_2} (x : α × β)
Goal: Equiv.pprodEquivProd.symm x = ⟨x.1, x.2⟩
-- Equiv.pprodEquivProd_apply
@[simps apply symm_apply]
def pprodEquivProd : PProd α β ≃ α × β 
Arguments: {α : Type u_1} {β : Type u_2} (x : PProd α β)
Goal: Equiv.pprodEquivProd x = (x.fst, x.snd)
-- Equiv.pprodCongr_apply
-- Porting note: in Lean 3 this had `@[congr]`
@[simps apply]
def pprodCongr (e₁ : α ≃ β) (e₂ : γ ≃ δ) : PProd α γ ≃ PProd β δ 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} (e₁ : α ≃ β) (e₂ : γ ≃ δ) (x : PProd α γ)
Goal: (e₁.pprodCongr e₂) x = ⟨e₁ x.fst, e₂ x.snd⟩
-- Equiv.pprodProd_apply
@[simps! apply symm_apply]
def pprodProd (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) :
    PProd α₁ β₁ ≃ α₂ × β₂ 
Arguments: {α₁ : Sort u_1} {α₂ : Type u_2} {β₁ : Sort u_3} {β₂ : Type u_4} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
Goal: ∀ (a : PProd α₁ β₁), (ea.pprodProd eb) a = (ea a.fst, eb a.snd)
-- Equiv.pprodProd_symm_apply
@[simps! apply symm_apply]
def pprodProd (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) :
    PProd α₁ β₁ ≃ α₂ × β₂ 
Arguments: {α₁ : Sort u_1} {α₂ : Type u_2} {β₁ : Sort u_3} {β₂ : Type u_4} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
Goal: ∀ (a : α₂ × β₂), (ea.pprodProd eb).symm a = (ea.pprodCongr eb).symm ⟨a.1, a.2⟩
-- Equiv.prodPProd_symm_apply
@[simps! apply symm_apply]
def prodPProd (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) :
    α₁ × β₁ ≃ PProd α₂ β₂ 
Arguments: {α₁ : Type u_1} {α₂ : Sort u_2} {β₁ : Type u_3} {β₂ : Sort u_4} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
Goal: ∀ (a : PProd α₂ β₂), (ea.prodPProd eb).symm a = (ea.symm a.fst, eb.symm a.snd)
-- Equiv.prodPProd_apply
@[simps! apply symm_apply]
def prodPProd (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) :
    α₁ × β₁ ≃ PProd α₂ β₂ 
Arguments: {α₁ : Type u_1} {α₂ : Sort u_2} {β₁ : Type u_3} {β₂ : Sort u_4} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
Goal: ∀ (a : α₁ × β₁), (ea.prodPProd eb) a = (ea.symm.pprodCongr eb.symm).symm ⟨a.1, a.2⟩
-- Equiv.pprodEquivProdPLift_symm_apply
@[simps! apply symm_apply]
def pprodEquivProdPLift : PProd α β ≃ PLift α × PLift β 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: ∀ (a : PLift α × PLift β),
  Equiv.pprodEquivProdPLift.symm a = (Equiv.plift.symm.pprodCongr Equiv.plift.symm).symm ⟨a.1, a.2⟩
-- Equiv.pprodEquivProdPLift_apply
@[simps! apply symm_apply]
def pprodEquivProdPLift : PProd α β ≃ PLift α × PLift β 
Arguments: {α : Sort u_1} {β : Sort u_2}
Goal: ∀ (a : PProd α β), Equiv.pprodEquivProdPLift a = (Equiv.plift.symm a.fst, Equiv.plift.symm a.snd)
-- Equiv.prodCongr_apply
-- Porting note: in Lean 3 there was also a @[congr] tag
@[simps (config := .asFn) apply]
def prodCongr (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) : α₁ × β₁ ≃ α₂ × β₂ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂)
Goal: ⇑(e₁.prodCongr e₂) = Prod.map ⇑e₁ ⇑e₂
-- Equiv.prodCongr_symm
@[simp]
theorem prodCongr_symm (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
    (prodCongr e₁ e₂).symm = prodCongr e₁.symm e₂.symm 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂)
Goal: (e₁.prodCongr e₂).symm = e₁.symm.prodCongr e₂.symm
-- Equiv.coe_prodComm
@[simp]
theorem coe_prodComm (α β) : (⇑(prodComm α β) : α × β → β × α) = Prod.swap 
Arguments: (α : Type u_1) (β : Type u_2)
Goal: ⇑(Equiv.prodComm α β) = Prod.swap
-- Equiv.prodComm_apply
@[simp]
theorem prodComm_apply (x : α × β) : prodComm α β x = x.swap 
Arguments: {α : Type u_1} {β : Type u_2} (x : α × β)
Goal: (Equiv.prodComm α β) x = x.swap
-- Equiv.prodComm_symm
@[simp]
theorem prodComm_symm (α β) : (prodComm α β).symm = prodComm β α 
Arguments: (α : Type u_1) (β : Type u_2)
Goal: (Equiv.prodComm α β).symm = Equiv.prodComm β α
-- Equiv.prodAssoc_apply
@[simps]
def prodAssoc (α β γ) : (α × β) × γ ≃ α × β × γ 
Arguments: (α : Type u_1) (β : Type u_2) (γ : Type u_3) (p : (α × β) × γ)
Goal: (Equiv.prodAssoc α β γ) p = (p.1.1, p.1.2, p.2)
-- Equiv.prodAssoc_symm_apply
@[simps]
def prodAssoc (α β γ) : (α × β) × γ ≃ α × β × γ 
Arguments: (α : Type u_1) (β : Type u_2) (γ : Type u_3) (p : α × β × γ)
Goal: (Equiv.prodAssoc α β γ).symm p = ((p.1, p.2.1), p.2.2)
-- Equiv.prodProdProdComm_apply
@[simps apply]
def prodProdProdComm (α β γ δ : Type*) : (α × β) × γ × δ ≃ (α × γ) × β × δ 
Arguments: (α : Type u_1) (β : Type u_2) (γ : Type u_3) (δ : Type u_4) (abcd : (α × β) × γ × δ)
Goal: (Equiv.prodProdProdComm α β γ δ) abcd = ((abcd.1.1, abcd.2.1), abcd.1.2, abcd.2.2)
-- Equiv.prodProdProdComm_symm
@[simp]
theorem prodProdProdComm_symm (α β γ δ : Type*) :
    (prodProdProdComm α β γ δ).symm = prodProdProdComm α γ β δ 
Arguments: (α : Type u_1) (β : Type u_2) (γ : Type u_3) (δ : Type u_4)
Goal: (Equiv.prodProdProdComm α β γ δ).symm = Equiv.prodProdProdComm α γ β δ
-- Equiv.curry_symm_apply
@[simps (config := .asFn)]
def curry (α β γ) : (α × β → γ) ≃ (α → β → γ) 
Arguments: (α : Type u_1) (β : Type u_2) (γ : Type u_3)
Goal: ⇑(Equiv.curry α β γ).symm = Function.uncurry
-- Equiv.curry_apply
@[simps (config := .asFn)]
def curry (α β γ) : (α × β → γ) ≃ (α → β → γ) 
Arguments: (α : Type u_1) (β : Type u_2) (γ : Type u_3)
Goal: ⇑(Equiv.curry α β γ) = Function.curry
-- Equiv.prodPUnit_symm_apply
@[simps]
def prodPUnit (α) : α × PUnit ≃ α 
Arguments: (α : Type u_1) (a : α)
Goal: (Equiv.prodPUnit α).symm a = (a, PUnit.unit)
-- Equiv.prodPUnit_apply
@[simps]
def prodPUnit (α) : α × PUnit ≃ α 
Arguments: (α : Type u_1) (p : α × PUnit.{u_2 + 1})
Goal: (Equiv.prodPUnit α) p = p.1
-- Equiv.punitProd_symm_apply
@[simps!]
def punitProd (α) : PUnit × α ≃ α 
Arguments: (α : Type u_1)
Goal: ∀ (a : α), (Equiv.punitProd α).symm a = (PUnit.unit, a)
-- Equiv.punitProd_apply
@[simps!]
def punitProd (α) : PUnit × α ≃ α 
Arguments: (α : Type u_1)
Goal: ∀ (a : PUnit.{u_2 + 1} × α), (Equiv.punitProd α) a = a.2
-- Equiv.sigmaPUnit_apply
@[simps]
def sigmaPUnit (α) : (_ : α) × PUnit ≃ α 
Arguments: (α : Type u_1) (p : (_ : α) × PUnit.{u_2 + 1})
Goal: (Equiv.sigmaPUnit α) p = p.fst
-- Equiv.sigmaPUnit_symm_apply_fst
@[simps]
def sigmaPUnit (α) : (_ : α) × PUnit ≃ α 
Arguments: (α : Type u_1) (a : α)
Goal: ((Equiv.sigmaPUnit α).symm a).fst = a
-- Equiv.sigmaPUnit_symm_apply_snd
@[simps]
def sigmaPUnit (α) : (_ : α) × PUnit ≃ α 
Arguments: (α : Type u_1) (a : α)
Goal: ((Equiv.sigmaPUnit α).symm a).snd = PUnit.unit
-- Equiv.coe_prodUnique
@[simp]
theorem coe_prodUnique [Unique β] : (⇑(prodUnique α β) : α × β → α) = Prod.fst 
Arguments: {β : Type u_1} {α : Type u_2} [Unique β]
Goal: ⇑(Equiv.prodUnique α β) = Prod.fst
-- Equiv.prodUnique_apply
theorem prodUnique_apply [Unique β] (x : α × β) : prodUnique α β x = x.1 
Arguments: {β : Type u_1} {α : Type u_2} [Unique β] (x : α × β)
Goal: (Equiv.prodUnique α β) x = x.1
-- Equiv.prodUnique_symm_apply
@[simp]
theorem prodUnique_symm_apply [Unique β] (x : α) :
    (prodUnique α β).symm x = (x, default) 
Arguments: {β : Type u_1} {α : Type u_2} [Unique β] (x : α)
Goal: (Equiv.prodUnique α β).symm x = (x, default)
-- Equiv.coe_uniqueProd
@[simp]
theorem coe_uniqueProd [Unique β] : (⇑(uniqueProd α β) : β × α → α) = Prod.snd 
Arguments: {β : Type u_1} {α : Type u_2} [Unique β]
Goal: ⇑(Equiv.uniqueProd α β) = Prod.snd
-- Equiv.uniqueProd_apply
theorem uniqueProd_apply [Unique β] (x : β × α) : uniqueProd α β x = x.2 
Arguments: {β : Type u_1} {α : Type u_2} [Unique β] (x : β × α)
Goal: (Equiv.uniqueProd α β) x = x.2
-- Equiv.uniqueProd_symm_apply
@[simp]
theorem uniqueProd_symm_apply [Unique β] (x : α) :
    (uniqueProd α β).symm x = (default, x) 
Arguments: {β : Type u_1} {α : Type u_2} [Unique β] (x : α)
Goal: (Equiv.uniqueProd α β).symm x = (default, x)
-- Equiv.coe_sigmaUnique
@[simp]
theorem coe_sigmaUnique {β : α → Type*} [∀ a, Unique (β a)] :
    (⇑(sigmaUnique α β) : (a : α) × (β a) → α) = Sigma.fst 
Arguments: {α : Type u_2} {β : α → Type u_1} [(a : α) → Unique (β a)]
Goal: ⇑(Equiv.sigmaUnique α β) = Sigma.fst
-- Equiv.sigmaUnique_apply
theorem sigmaUnique_apply {β : α → Type*} [∀ a, Unique (β a)] (x : (a : α) × β a) :
    sigmaUnique α β x = x.1 
Arguments: {α : Type u_2} {β : α → Type u_1} [(a : α) → Unique (β a)] (x : (a : α) × β a)
Goal: (Equiv.sigmaUnique α β) x = x.fst
-- Equiv.sigmaUnique_symm_apply
@[simp]
theorem sigmaUnique_symm_apply {β : α → Type*} [∀ a, Unique (β a)] (x : α) :
    (sigmaUnique α β).symm x = ⟨x, default⟩ 
Arguments: {α : Type u_2} {β : α → Type u_1} [(a : α) → Unique (β a)] (x : α)
Goal: (Equiv.sigmaUnique α β).symm x = ⟨x, default⟩
-- Equiv.sumCongr_apply
@[simps apply]
def sumCongr (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) : α₁ ⊕ β₁ ≃ α₂ ⊕ β₂ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂)
Goal: ∀ (a : α₁ ⊕ β₁), (ea.sumCongr eb) a = Sum.map (⇑ea) (⇑eb) a
-- Equiv.sumCongr_trans
@[simp]
theorem sumCongr_trans (e : α₁ ≃ β₁) (f : α₂ ≃ β₂) (g : β₁ ≃ γ₁) (h : β₂ ≃ γ₂) :
    (Equiv.sumCongr e f).trans (Equiv.sumCongr g h) = Equiv.sumCongr (e.trans g) (f.trans h) 
Arguments: {α₁ : Type u_1} {β₁ : Type u_2} {α₂ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} (e : α₁ ≃ β₁) (f : α₂ ≃ β₂) (g : β₁ ≃ γ₁) (h : β₂ ≃ γ₂)
Goal: (e.sumCongr f).trans (g.sumCongr h) = (e.trans g).sumCongr (f.trans h)
-- Equiv.sumCongr_symm
@[simp]
theorem sumCongr_symm (e : α ≃ β) (f : γ ≃ δ) :
    (Equiv.sumCongr e f).symm = Equiv.sumCongr e.symm f.symm 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e : α ≃ β) (f : γ ≃ δ)
Goal: (e.sumCongr f).symm = e.symm.sumCongr f.symm
-- Equiv.sumCongr_refl
@[simp]
theorem sumCongr_refl : Equiv.sumCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α ⊕ β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: (Equiv.refl α).sumCongr (Equiv.refl β) = Equiv.refl (α ⊕ β)
-- Equiv.Perm.sumCongr_apply
@[simp]
theorem sumCongr_apply (ea : Equiv.Perm α) (eb : Equiv.Perm β) (x : α ⊕ β) :
    sumCongr ea eb x = Sum.map (⇑ea) (⇑eb) x 
Arguments: {α : Type u_1} {β : Type u_2} (ea : Equiv.Perm α) (eb : Equiv.Perm β) (x : α ⊕ β)
Goal: (ea.sumCongr eb) x = Sum.map (⇑ea) (⇑eb) x
-- Equiv.Perm.sumCongr_trans
theorem sumCongr_trans (e : Equiv.Perm α) (f : Equiv.Perm β) (g : Equiv.Perm α)
    (h : Equiv.Perm β) : (sumCongr e f).trans (sumCongr g h) = sumCongr (e.trans g) (f.trans h) 
Arguments: {α : Type u_1} {β : Type u_2} (e : Equiv.Perm α) (f : Equiv.Perm β) (g : Equiv.Perm α) (h : Equiv.Perm β)
Goal: Equiv.trans (e.sumCongr f) (g.sumCongr h) = Equiv.Perm.sumCongr (Equiv.trans e g) (Equiv.trans f h)
-- Equiv.Perm.sumCongr_symm
theorem sumCongr_symm (e : Equiv.Perm α) (f : Equiv.Perm β) :
    (sumCongr e f).symm = sumCongr e.symm f.symm 
Arguments: {α : Type u_1} {β : Type u_2} (e : Equiv.Perm α) (f : Equiv.Perm β)
Goal: Equiv.symm (e.sumCongr f) = Equiv.Perm.sumCongr (Equiv.symm e) (Equiv.symm f)
-- Equiv.Perm.sumCongr_refl
theorem sumCongr_refl : sumCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α ⊕ β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Equiv.Perm.sumCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α ⊕ β)
-- Equiv.sumComm_apply
@[simps (config := .asFn) apply]
def sumComm (α β) : α ⊕ β ≃ β ⊕ α 
Arguments: (α : Type u_1) (β : Type u_2)
Goal: ⇑(Equiv.sumComm α β) = Sum.swap
-- Equiv.sumComm_symm
@[simp]
theorem sumComm_symm (α β) : (sumComm α β).symm = sumComm β α 
Arguments: (α : Type u_1) (β : Type u_2)
Goal: (Equiv.sumComm α β).symm = Equiv.sumComm β α
-- Equiv.sumAssoc_apply_inl_inl
@[simp]
theorem sumAssoc_apply_inl_inl (a) : sumAssoc α β γ (inl (inl a)) = inl a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a : α)
Goal: (Equiv.sumAssoc α β γ) (Sum.inl (Sum.inl a)) = Sum.inl a
-- Equiv.sumAssoc_apply_inl_inr
@[simp]
theorem sumAssoc_apply_inl_inr (b) : sumAssoc α β γ (inl (inr b)) = inr (inl b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (b : β)
Goal: (Equiv.sumAssoc α β γ) (Sum.inl (Sum.inr b)) = Sum.inr (Sum.inl b)
-- Equiv.sumAssoc_apply_inr
@[simp]
theorem sumAssoc_apply_inr (c) : sumAssoc α β γ (inr c) = inr (inr c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (c : γ)
Goal: (Equiv.sumAssoc α β γ) (Sum.inr c) = Sum.inr (Sum.inr c)
-- Equiv.sumAssoc_symm_apply_inl
@[simp]
theorem sumAssoc_symm_apply_inl {α β γ} (a) : (sumAssoc α β γ).symm (inl a) = inl (inl a) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (a : α)
Goal: (Equiv.sumAssoc α β γ).symm (Sum.inl a) = Sum.inl (Sum.inl a)
-- Equiv.sumAssoc_symm_apply_inr_inl
@[simp]
theorem sumAssoc_symm_apply_inr_inl {α β γ} (b) :
    (sumAssoc α β γ).symm (inr (inl b)) = inl (inr b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (b : β)
Goal: (Equiv.sumAssoc α β γ).symm (Sum.inr (Sum.inl b)) = Sum.inl (Sum.inr b)
-- Equiv.sumAssoc_symm_apply_inr_inr
@[simp]
theorem sumAssoc_symm_apply_inr_inr {α β γ} (c) : (sumAssoc α β γ).symm (inr (inr c)) = inr c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (c : γ)
Goal: (Equiv.sumAssoc α β γ).symm (Sum.inr (Sum.inr c)) = Sum.inr c
-- Equiv.sumEmpty_symm_apply
@[simps symm_apply]
def sumEmpty (α β) [IsEmpty β] : α ⊕ β ≃ α 
Arguments: (α : Type u_1) (β : Type u_2) [IsEmpty β] (val : α)
Goal: (Equiv.sumEmpty α β).symm val = Sum.inl val
-- Equiv.sumEmpty_apply_inl
@[simp]
theorem sumEmpty_apply_inl [IsEmpty β] (a : α) : sumEmpty α β (Sum.inl a) = a 
Arguments: {β : Type u_1} {α : Type u_2} [IsEmpty β] (a : α)
Goal: (Equiv.sumEmpty α β) (Sum.inl a) = a
-- Equiv.emptySum_symm_apply
@[simps! symm_apply]
def emptySum (α β) [IsEmpty α] : α ⊕ β ≃ β 
Arguments: (α : Type u_1) (β : Type u_2) [IsEmpty α]
Goal: ∀ (a : β), (Equiv.emptySum α β).symm a = Sum.inr a
-- Equiv.emptySum_apply_inr
@[simp]
theorem emptySum_apply_inr [IsEmpty α] (b : β) : emptySum α β (Sum.inr b) = b 
Arguments: {α : Type u_1} {β : Type u_2} [IsEmpty α] (b : β)
Goal: (Equiv.emptySum α β) (Sum.inr b) = b
-- Equiv.optionEquivSumPUnit_none
@[simp]
theorem optionEquivSumPUnit_none : optionEquivSumPUnit α none = Sum.inr PUnit.unit 
Arguments: {α : Type u_1}
Goal: (Equiv.optionEquivSumPUnit α) none = Sum.inr PUnit.unit
-- Equiv.optionEquivSumPUnit_some
@[simp]
theorem optionEquivSumPUnit_some (a) : optionEquivSumPUnit α (some a) = Sum.inl a 
Arguments: {α : Type u_1} (a : α)
Goal: (Equiv.optionEquivSumPUnit α) (some a) = Sum.inl a
-- Equiv.optionEquivSumPUnit_coe
@[simp]
theorem optionEquivSumPUnit_coe (a : α) : optionEquivSumPUnit α a = Sum.inl a 
Arguments: {α : Type u_1} (a : α)
Goal: (Equiv.optionEquivSumPUnit α) (some a) = Sum.inl a
-- Equiv.optionEquivSumPUnit_symm_inl
@[simp]
theorem optionEquivSumPUnit_symm_inl (a) : (optionEquivSumPUnit α).symm (Sum.inl a) = a 
Arguments: {α : Type u_1} (a : α)
Goal: (Equiv.optionEquivSumPUnit α).symm (Sum.inl a) = some a
-- Equiv.optionEquivSumPUnit_symm_inr
@[simp]
theorem optionEquivSumPUnit_symm_inr (a) : (optionEquivSumPUnit α).symm (Sum.inr a) = none 
Arguments: {α : Type u_1} (a : PUnit.{u_2 + 1})
Goal: (Equiv.optionEquivSumPUnit α).symm (Sum.inr a) = none
-- Equiv.optionIsSomeEquiv_apply
@[simps]
def optionIsSomeEquiv (α) : { x : Option α // x.isSome } ≃ α 
Arguments: (α : Type u_1) (o : { x // x.isSome = true })
Goal: (Equiv.optionIsSomeEquiv α) o = (↑o).get ⋯
-- Equiv.optionIsSomeEquiv_symm_apply_coe
@[simps]
def optionIsSomeEquiv (α) : { x : Option α // x.isSome } ≃ α 
Arguments: (α : Type u_1) (x : α)
Goal: ↑((Equiv.optionIsSomeEquiv α).symm x) = some x
-- Equiv.piOptionEquivProd_apply
@[simps]
def piOptionEquivProd {β : Option α → Type*} :
    (∀ a : Option α, β a) ≃ β none × ∀ a : α, β (some a) 
Arguments: {α : Type u_2} {β : Option α → Type u_1} (f : (a : Option α) → β a)
Goal: Equiv.piOptionEquivProd f = (f none, fun a => f (some a))
-- Equiv.piOptionEquivProd_symm_apply
@[simps]
def piOptionEquivProd {β : Option α → Type*} :
    (∀ a : Option α, β a) ≃ β none × ∀ a : α, β (some a) 
Arguments: {α : Type u_2} {β : Option α → Type u_1} (x : β none × ((a : α) → β (some a))) (a : Option α)
Goal: Equiv.piOptionEquivProd.symm x a = Option.casesOn a x.1 x.2
-- Equiv.sigmaFiberEquiv_symm_apply_snd_coe
@[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).snd = x
-- Equiv.sigmaFiberEquiv_apply
@[simps]
def sigmaFiberEquiv {α β : Type*} (f : α → β) : (Σ y : β, { x // f x = y }) ≃ α 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : (y : β) × { x // f x = y })
Goal: (Equiv.sigmaFiberEquiv f) x = ↑x.snd