File: Mathlib/Data/Sigma/Basic.lean

full_name: Sigma.instInhabitedSigma
code: instance instInhabitedSigma [Inhabited α] [Inhabited (β default)] : Inhabited (Sigma β) 
goal: Inhabited (Sigma β)

full_name: Sigma.instDecidableEqSigma
code: instance instDecidableEqSigma [h₁ : DecidableEq α] [h₂ : ∀ a, DecidableEq (β a)] :
    DecidableEq (Sigma β)
  
goal: DecidableEq (Sigma β)

full_name: Sigma.mk.inj_iff
code: @[simp] -- @[nolint simpNF]
theorem mk.inj_iff {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂} :
    Sigma.mk a₁ b₁ = ⟨a₂, b₂⟩ ↔ a₁ = a₂ ∧ HEq b₁ b₂ 
goal: ⟨a₁, b₁⟩ = ⟨a₂, b₂⟩ ↔ a₁ = a₂ ∧ HEq b₁ b₂

full_name: Sigma.eta
code: @[simp]
theorem eta : ∀ x : Σa, β a, Sigma.mk x.1 x.2 = x
  
goal: ⟨x.fst, x.snd⟩ = x

full_name: Sigma.ext_iff
code: protected theorem ext_iff {x₀ x₁ : Sigma β} : x₀ = x₁ ↔ x₀.1 = x₁.1 ∧ HEq x₀.2 x₁.2 
goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd

full_name: Function.eq_of_sigmaMk_comp
code: /-- A version of `Iff.mp Sigma.ext_iff` for functions from a nonempty type to a sigma type. -/
theorem _root_.Function.eq_of_sigmaMk_comp {γ : Type*} [Nonempty γ]
    {a b : α} {f : γ → β a} {g : γ → β b} (h : Sigma.mk a ∘ f = Sigma.mk b ∘ g) :
    a = b ∧ HEq f g 
goal: a = b ∧ HEq f g

full_name: Sigma.subtype_ext
code: /-- A specialized ext lemma for equality of sigma types over an indexed subtype. -/
@[ext]
theorem subtype_ext {β : Type*} {p : α → β → Prop} :
    ∀ {x₀ x₁ : Σa, Subtype (p a)}, x₀.fst = x₁.fst → (x₀.snd : β) = x₁.snd → x₀ = x₁
  
goal: x₀.fst = x₁.fst → x₀.snd.val = x₁.snd.val → x₀ = x₁

full_name: Sigma.subtype_ext_iff
code: theorem subtype_ext_iff {β : Type*} {p : α → β → Prop} {x₀ x₁ : Σa, Subtype (p a)} :
    x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ (x₀.snd : β) = x₁.snd 
goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ x₀.snd.val = x₁.snd.val

full_name: Sigma.forall
code: @[simp]
theorem «forall» {p : (Σa, β a) → Prop} : (∀ x, p x) ↔ ∀ a b, p ⟨a, b⟩ 
goal: (∀ (x : (a : α) × β a), p x) ↔ ∀ (a : α) (b : β a), p ⟨a, b⟩

full_name: Sigma.exists
code: @[simp]
theorem «exists» {p : (Σa, β a) → Prop} : (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩ 
goal: (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩

full_name: Sigma.exists'
code: lemma exists' {p : ∀ a, β a → Prop} : (∃ a b, p a b) ↔ ∃ x : Σ a, β a, p x.1 x.2 
goal: (∃ a b, p a b) ↔ ∃ x, p x.fst x.snd

full_name: Sigma.forall'
code: lemma forall' {p : ∀ a, β a → Prop} : (∀ a b, p a b) ↔ ∀ x : Σ a, β a, p x.1 x.2 
goal: (∀ (a : α) (b : β a), p a b) ↔ ∀ (x : (a : α) × β a), p x.fst x.snd

full_name: sigma_mk_injective
code: theorem _root_.sigma_mk_injective {i : α} : Injective (@Sigma.mk α β i)
  
goal: Function.Injective (Sigma.mk i)

full_name: Sigma.fst_surjective
code: theorem fst_surjective [h : ∀ a, Nonempty (β a)] : Surjective (fst : (Σ a, β a) → α) 
goal: Function.Surjective Sigma.fst

full_name: Sigma.fst_surjective_iff
code: theorem fst_surjective_iff : Surjective (fst : (Σ a, β a) → α) ↔ ∀ a, Nonempty (β a) 
goal: Function.Surjective Sigma.fst ↔ ∀ (a : α), Nonempty (β a)

full_name: Sigma.fst_injective
code: theorem fst_injective [h : ∀ a, Subsingleton (β a)] : Injective (fst : (Σ a, β a) → α) 
goal: Function.Injective Sigma.fst

full_name: Sigma.fst_injective_iff
code: theorem fst_injective_iff : Injective (fst : (Σ a, β a) → α) ↔ ∀ a, Subsingleton (β a) 
goal: Function.Injective Sigma.fst ↔ ∀ (a : α), Subsingleton (β a)

full_name: Sigma.map
code: /-- Map the left and right components of a sigma -/
def map (f₁ : α₁ → α₂) (f₂ : ∀ a, β₁ a → β₂ (f₁ a)) (x : Sigma β₁) : Sigma β₂ 
goal: Sigma β₂

full_name: Sigma.map_mk
code: lemma map_mk (f₁ : α₁ → α₂) (f₂ : ∀ a, β₁ a → β₂ (f₁ a)) (x : α₁) (y : β₁ x) :
    map f₁ f₂ ⟨x, y⟩ = ⟨f₁ x, f₂ x y⟩ 
goal: Sigma.map f₁ f₂ ⟨x, y⟩ = ⟨f₁ x, f₂ x y⟩

full_name: Function.Injective.sigma_map
code: theorem Function.Injective.sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h₁ : Injective f₁) (h₂ : ∀ a, Injective (f₂ a)) : Injective (Sigma.map f₁ f₂)
  
goal: Function.Injective (Sigma.map f₁ f₂)

full_name: Function.Injective.of_sigma_map
code: theorem Function.Injective.of_sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h : Injective (Sigma.map f₁ f₂)) (a : α₁) : Injective (f₂ a) 
goal: Function.Injective (f₂ a)

full_name: Function.Injective.sigma_map_iff
code: theorem Function.Injective.sigma_map_iff {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h₁ : Injective f₁) : Injective (Sigma.map f₁ f₂) ↔ ∀ a, Injective (f₂ a) 
goal: Function.Injective (Sigma.map f₁ f₂) ↔ ∀ (a : α₁), Function.Injective (f₂ a)

full_name: Function.Surjective.sigma_map
code: theorem Function.Surjective.sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h₁ : Surjective f₁) (h₂ : ∀ a, Surjective (f₂ a)) : Surjective (Sigma.map f₁ f₂) 
goal: Function.Surjective (Sigma.map f₁ f₂)

full_name: Sigma.curry
code: /-- Interpret a function on `Σ x : α, β x` as a dependent function with two arguments.

This also exists as an `Equiv` as `Equiv.piCurry γ`. -/
def Sigma.curry {γ : ∀ a, β a → Type*} (f : ∀ x : Sigma β, γ x.1 x.2) (x : α) (y : β x) : γ x y 
goal: γ x y

full_name: Sigma.uncurry
code: /-- Interpret a dependent function with two arguments as a function on `Σ x : α, β x`.

This also exists as an `Equiv` as `(Equiv.piCurry γ).symm`. -/
def Sigma.uncurry {γ : ∀ a, β a → Type*} (f : ∀ (x) (y : β x), γ x y) (x : Sigma β) : γ x.1 x.2 
goal: γ x.fst x.snd

full_name: Sigma.uncurry_curry
code: @[simp]
theorem Sigma.uncurry_curry {γ : ∀ a, β a → Type*} (f : ∀ x : Sigma β, γ x.1 x.2) :
    Sigma.uncurry (Sigma.curry f) = f 
goal: Sigma.uncurry (Sigma.curry f) = f

full_name: Sigma.curry_uncurry
code: @[simp]
theorem Sigma.curry_uncurry {γ : ∀ a, β a → Type*} (f : ∀ (x) (y : β x), γ x y) :
    Sigma.curry (Sigma.uncurry f) = f 
goal: Sigma.curry (Sigma.uncurry f) = f

full_name: Sigma.curry_update
code: theorem Sigma.curry_update {γ : ∀ a, β a → Type*} [DecidableEq α] [∀ a, DecidableEq (β a)]
    (i : Σ a, β a) (f : (i : Σ a, β a) → γ i.1 i.2) (x : γ i.1 i.2) :
    Sigma.curry (Function.update f i x) =
      Function.update (Sigma.curry f) i.1 (Function.update (Sigma.curry f i.1) i.2 x) 
goal: Sigma.curry (Function.update f i x) =
  Function.update (Sigma.curry f) i.fst (Function.update (Sigma.curry f i.fst) i.snd x)

full_name: Prod.toSigma
code: /-- Convert a product type to a Σ-type. -/
def Prod.toSigma {α β} (p : α × β) : Σ_ : α, β 
goal: (_ : α) × β

full_name: Prod.fst_comp_toSigma
code: @[simp]
theorem Prod.fst_comp_toSigma {α β} : Sigma.fst ∘ @Prod.toSigma α β = Prod.fst 
goal: Sigma.fst ∘ Prod.toSigma = Prod.fst

full_name: Prod.fst_toSigma
code: @[simp]
theorem Prod.fst_toSigma {α β} (x : α × β) : (Prod.toSigma x).fst = x.fst 
goal: x.toSigma.fst = x.fst

full_name: Prod.snd_toSigma
code: @[simp]
theorem Prod.snd_toSigma {α β} (x : α × β) : (Prod.toSigma x).snd = x.snd 
goal: x.toSigma.snd = x.snd

full_name: Prod.toSigma_mk
code: @[simp]
theorem Prod.toSigma_mk {α β} (x : α) (y : β) : (x, y).toSigma = ⟨x, y⟩ 
goal: (x, y).toSigma = ⟨x, y⟩

full_name: PSigma.elim
code: /-- Nondependent eliminator for `PSigma`. -/
def elim {γ} (f : ∀ a, β a → γ) (a : PSigma β) : γ 
goal: γ

full_name: PSigma.elim_val
code: @[simp]
theorem elim_val {γ} (f : ∀ a, β a → γ) (a b) : PSigma.elim f ⟨a, b⟩ = f a b 
goal: PSigma.elim f ⟨a, b⟩ = f a b

full_name: PSigma.instInhabitedOfDefault_mathlib
code: instance [Inhabited α] [Inhabited (β default)] : Inhabited (PSigma β) 
goal: Inhabited (PSigma β)

full_name: PSigma.decidableEq
code: instance decidableEq [h₁ : DecidableEq α] [h₂ : ∀ a, DecidableEq (β a)] : DecidableEq (PSigma β)
  
goal: DecidableEq (PSigma β)

full_name: PSigma.mk.inj_iff
code: theorem mk.inj_iff {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂} :
    @PSigma.mk α β a₁ b₁ = @PSigma.mk α β a₂ b₂ ↔ a₁ = a₂ ∧ HEq b₁ b₂ 
goal: ⟨a₁, b₁⟩ = ⟨a₂, b₂⟩ ↔ a₁ = a₂ ∧ HEq b₁ b₂

full_name: PSigma.ext_iff
code: theorem ext_iff {x₀ x₁ : PSigma β} : x₀ = x₁ ↔ x₀.1 = x₁.1 ∧ HEq x₀.2 x₁.2 
goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd

full_name: PSigma.forall
code: @[simp]
theorem «forall» {p : (Σ'a, β a) → Prop} : (∀ x, p x) ↔ ∀ a b, p ⟨a, b⟩ 
goal: (∀ (x : (a : α) ×' β a), p x) ↔ ∀ (a : α) (b : β a), p ⟨a, b⟩

full_name: PSigma.exists
code: @[simp]
theorem «exists» {p : (Σ'a, β a) → Prop} : (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩ 
goal: (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩

full_name: PSigma.subtype_ext
code: /-- A specialized ext lemma for equality of `PSigma` types over an indexed subtype. -/
@[ext]
theorem subtype_ext {β : Sort*} {p : α → β → Prop} :
    ∀ {x₀ x₁ : Σ'a, Subtype (p a)}, x₀.fst = x₁.fst → (x₀.snd : β) = x₁.snd → x₀ = x₁
  
goal: x₀.fst = x₁.fst → x₀.snd.val = x₁.snd.val → x₀ = x₁

full_name: PSigma.subtype_ext_iff
code: theorem subtype_ext_iff {β : Sort*} {p : α → β → Prop} {x₀ x₁ : Σ'a, Subtype (p a)} :
    x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ (x₀.snd : β) = x₁.snd 
goal: x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ x₀.snd.val = x₁.snd.val

full_name: PSigma.map
code: /-- Map the left and right components of a sigma -/
def map (f₁ : α₁ → α₂) (f₂ : ∀ a, β₁ a → β₂ (f₁ a)) : PSigma β₁ → PSigma β₂
  
goal: PSigma β₁ → PSigma β₂