File: Mathlib/Data/Prod/Basic.lean

full_name: Prod.mk.eta
code: @[simp]
theorem mk.eta : ∀ {p : α × β}, (p.1, p.2) = p
  
goal: (p.1, p.2) = p

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

full_name: Prod.exists
code: @[simp]
theorem «exists» {p : α × β → Prop} : (∃ x, p x) ↔ ∃ a b, p (a, b) 
goal: (∃ x, p x) ↔ ∃ a b, p (a, b)

full_name: Prod.forall'
code: theorem forall' {p : α → β → Prop} : (∀ x : α × β, p x.1 x.2) ↔ ∀ a b, p a b 
goal: (∀ (x : α × β), p x.1 x.2) ↔ ∀ (a : α) (b : β), p a b

full_name: Prod.exists'
code: theorem exists' {p : α → β → Prop} : (∃ x : α × β, p x.1 x.2) ↔ ∃ a b, p a b 
goal: (∃ x, p x.1 x.2) ↔ ∃ a b, p a b

full_name: Prod.snd_comp_mk
code: @[simp]
theorem snd_comp_mk (x : α) : Prod.snd ∘ (Prod.mk x : β → α × β) = id 
goal: Prod.snd ∘ Prod.mk x = id

full_name: Prod.fst_comp_mk
code: @[simp]
theorem fst_comp_mk (x : α) : Prod.fst ∘ (Prod.mk x : β → α × β) = Function.const β x 
goal: Prod.fst ∘ Prod.mk x = Function.const β x

full_name: Prod.map_mk
code: @[simp, mfld_simps]
theorem map_mk (f : α → γ) (g : β → δ) (a : α) (b : β) : map f g (a, b) = (f a, g b) 
goal: Prod.map f g (a, b) = (f a, g b)

full_name: Prod.map_apply'
code: theorem map_apply' (f : α → γ) (g : β → δ) (p : α × β) : map f g p = (f p.1, g p.2) 
goal: Prod.map f g p = (f p.1, g p.2)

full_name: Prod.map_fst'
code: theorem map_fst' (f : α → γ) (g : β → δ) : Prod.fst ∘ map f g = f ∘ Prod.fst 
goal: Prod.fst ∘ Prod.map f g = f ∘ Prod.fst

full_name: Prod.map_snd'
code: theorem map_snd' (f : α → γ) (g : β → δ) : Prod.snd ∘ map f g = g ∘ Prod.snd 
goal: Prod.snd ∘ Prod.map f g = g ∘ Prod.snd

full_name: Prod.map_comp_map
code: /-- Composing a `Prod.map` with another `Prod.map` is equal to
a single `Prod.map` of composed functions.
-/
theorem map_comp_map {ε ζ : Type*} (f : α → β) (f' : γ → δ) (g : β → ε) (g' : δ → ζ) :
    Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f') 
goal: Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f')

full_name: Prod.map_map
code: /-- Composing a `Prod.map` with another `Prod.map` is equal to
a single `Prod.map` of composed functions, fully applied.
-/
theorem map_map {ε ζ : Type*} (f : α → β) (f' : γ → δ) (g : β → ε) (g' : δ → ζ) (x : α × γ) :
    Prod.map g g' (Prod.map f f' x) = Prod.map (g ∘ f) (g' ∘ f') x 
goal: Prod.map g g' (Prod.map f f' x) = Prod.map (g ∘ f) (g' ∘ f') x

full_name: Prod.mk.inj_iff
code: theorem mk.inj_iff {a₁ a₂ : α} {b₁ b₂ : β} : (a₁, b₁) = (a₂, b₂) ↔ a₁ = a₂ ∧ b₁ = b₂ 
goal: (a₁, b₁) = (a₂, b₂) ↔ a₁ = a₂ ∧ b₁ = b₂

full_name: Prod.mk.inj_left
code: theorem mk.inj_left {α β : Type*} (a : α) : Function.Injective (Prod.mk a : β → α × β) 
goal: Function.Injective (Prod.mk a)

full_name: Prod.mk.inj_right
code: theorem mk.inj_right {α β : Type*} (b : β) :
    Function.Injective (fun a ↦ Prod.mk a b : α → α × β) 
goal: Function.Injective fun a => (a, b)

full_name: Prod.mk_inj_left
code: lemma mk_inj_left {a : α} {b₁ b₂ : β} : (a, b₁) = (a, b₂) ↔ b₁ = b₂ 
goal: (a, b₁) = (a, b₂) ↔ b₁ = b₂

full_name: Prod.mk_inj_right
code: lemma mk_inj_right {a₁ a₂ : α} {b : β} : (a₁, b) = (a₂, b) ↔ a₁ = a₂ 
goal: (a₁, b) = (a₂, b) ↔ a₁ = a₂

full_name: Prod.ext_iff
code: protected theorem ext_iff {p q : α × β} : p = q ↔ p.1 = q.1 ∧ p.2 = q.2 
goal: p = q ↔ p.1 = q.1 ∧ p.2 = q.2

full_name: Prod.map_def
code: theorem map_def {f : α → γ} {g : β → δ} : Prod.map f g = fun p : α × β ↦ (f p.1, g p.2) 
goal: Prod.map f g = fun p => (f p.1, g p.2)

full_name: Prod.id_prod
code: theorem id_prod : (fun p : α × β ↦ (p.1, p.2)) = id 
goal: (fun p => (p.1, p.2)) = id

full_name: Prod.map_id
code: @[simp] lemma map_id : Prod.map (@id α) (@id β) = id 
goal: Prod.map id id = id

full_name: Prod.map_id'
code: @[simp] lemma map_id' : Prod.map (fun a : α ↦ a) (fun b : β ↦ b) = fun x ↦ x 
goal: (Prod.map (fun a => a) fun b => b) = fun x => x

full_name: Prod.map_iterate
code: @[simp]
theorem map_iterate (f : α → α) (g : β → β) (n : ℕ) :
    (Prod.map f g)^[n] = Prod.map f^[n] g^[n] 
goal: (Prod.map f g)^[n] = Prod.map f^[n] g^[n]

full_name: Prod.fst_surjective
code: theorem fst_surjective [h : Nonempty β] : Function.Surjective (@fst α β) 
goal: Function.Surjective Prod.fst

full_name: Prod.snd_surjective
code: theorem snd_surjective [h : Nonempty α] : Function.Surjective (@snd α β) 
goal: Function.Surjective Prod.snd

full_name: Prod.fst_injective
code: theorem fst_injective [Subsingleton β] : Function.Injective (@fst α β) 
goal: Function.Injective Prod.fst

full_name: Prod.snd_injective
code: theorem snd_injective [Subsingleton α] : Function.Injective (@snd α β) 
goal: Function.Injective Prod.snd

full_name: Prod.swap
code: /-- Swap the factors of a product. `swap (a, b) = (b, a)` -/
def swap : α × β → β × α 
goal: α × β → β × α

full_name: Prod.swap_swap
code: @[simp]
theorem swap_swap : ∀ x : α × β, swap (swap x) = x
  
goal: x.swap.swap = x

full_name: Prod.fst_swap
code: @[simp]
theorem fst_swap {p : α × β} : (swap p).1 = p.2 
goal: p.swap.1 = p.2

full_name: Prod.snd_swap
code: @[simp]
theorem snd_swap {p : α × β} : (swap p).2 = p.1 
goal: p.swap.2 = p.1

full_name: Prod.swap_prod_mk
code: @[simp]
theorem swap_prod_mk {a : α} {b : β} : swap (a, b) = (b, a) 
goal: (a, b).swap = (b, a)

full_name: Prod.swap_swap_eq
code: @[simp]
theorem swap_swap_eq : swap ∘ swap = @id (α × β) 
goal: Prod.swap ∘ Prod.swap = id

full_name: Prod.swap_leftInverse
code: @[simp]
theorem swap_leftInverse : Function.LeftInverse (@swap α β) swap 
goal: Function.LeftInverse Prod.swap Prod.swap

full_name: Prod.swap_rightInverse
code: @[simp]
theorem swap_rightInverse : Function.RightInverse (@swap α β) swap 
goal: Function.RightInverse Prod.swap Prod.swap

full_name: Prod.swap_injective
code: theorem swap_injective : Function.Injective (@swap α β) 
goal: Function.Injective Prod.swap

full_name: Prod.swap_surjective
code: theorem swap_surjective : Function.Surjective (@swap α β) 
goal: Function.Surjective Prod.swap

full_name: Prod.swap_bijective
code: theorem swap_bijective : Function.Bijective (@swap α β) 
goal: Function.Bijective Prod.swap

full_name: Prod.swap_inj
code: @[simp]
theorem swap_inj {p q : α × β} : swap p = swap q ↔ p = q 
goal: p.swap = q.swap ↔ p = q

full_name: Prod.map_comp_swap
code: /--For two functions `f` and `g`, the composition of `Prod.map f g` with `Prod.swap`
is equal to the composition of `Prod.swap` with `Prod.map g f`.-/
theorem map_comp_swap (f : α → β) (g : γ → δ) :
    Prod.map f g ∘ Prod.swap = Prod.swap ∘ Prod.map g f 
goal: Prod.map f g ∘ Prod.swap = Prod.swap ∘ Prod.map g f

full_name: Prod.eq_iff_fst_eq_snd_eq
code: theorem eq_iff_fst_eq_snd_eq : ∀ {p q : α × β}, p = q ↔ p.1 = q.1 ∧ p.2 = q.2
  
goal: p = q ↔ p.1 = q.1 ∧ p.2 = q.2

full_name: Prod.fst_eq_iff
code: theorem fst_eq_iff : ∀ {p : α × β} {x : α}, p.1 = x ↔ p = (x, p.2)
  
goal: p.1 = x ↔ p = (x, p.2)

full_name: Prod.snd_eq_iff
code: theorem snd_eq_iff : ∀ {p : α × β} {x : β}, p.2 = x ↔ p = (p.1, x)
  
goal: p.2 = x ↔ p = (p.1, x)

full_name: Prod.lex_iff
code: lemma lex_iff : Prod.Lex r s x y ↔ r x.1 y.1 ∨ x.1 = y.1 ∧ s x.2 y.2 
goal: Prod.Lex r s x y ↔ r x.1 y.1 ∨ x.1 = y.1 ∧ s x.2 y.2

full_name: Prod.Lex.decidable
code: instance Lex.decidable [DecidableEq α]
    (r : α → α → Prop) (s : β → β → Prop) [DecidableRel r] [DecidableRel s] :
    DecidableRel (Prod.Lex r s) 
goal: DecidableRel (Prod.Lex r s)

full_name: Prod.Lex.refl_left
code: @[refl]
theorem Lex.refl_left (r : α → α → Prop) (s : β → β → Prop) [IsRefl α r] : ∀ x, Prod.Lex r s x x
  
goal: Prod.Lex r s x x

full_name: Prod.instIsReflLex
code: instance {r : α → α → Prop} {s : β → β → Prop} [IsRefl α r] : IsRefl (α × β) (Prod.Lex r s) 
goal: IsRefl (α × β) (Prod.Lex r s)

full_name: Prod.Lex.refl_right
code: @[refl]
theorem Lex.refl_right (r : α → α → Prop) (s : β → β → Prop) [IsRefl β s] : ∀ x, Prod.Lex r s x x
  
goal: Prod.Lex r s x x

full_name: Prod.instIsReflLex_1
code: instance {r : α → α → Prop} {s : β → β → Prop} [IsRefl β s] : IsRefl (α × β) (Prod.Lex r s) 
goal: IsRefl (α × β) (Prod.Lex r s)

full_name: Prod.isIrrefl
code: instance isIrrefl [IsIrrefl α r] [IsIrrefl β s] : IsIrrefl (α × β) (Prod.Lex r s) 
goal: IsIrrefl (α × β) (Prod.Lex r s)

full_name: Prod.Lex.trans
code: @[trans]
theorem Lex.trans {r : α → α → Prop} {s : β → β → Prop} [IsTrans α r] [IsTrans β s] :
    ∀ {x y z : α × β}, Prod.Lex r s x y → Prod.Lex r s y z → Prod.Lex r s x z
  
goal: Prod.Lex r s x y → Prod.Lex r s y z → Prod.Lex r s x z

full_name: Prod.instIsTransLex
code: instance {r : α → α → Prop} {s : β → β → Prop} [IsTrans α r] [IsTrans β s] :
  IsTrans (α × β) (Prod.Lex r s) 
goal: IsTrans (α × β) (Prod.Lex r s)

full_name: Prod.instIsAntisymmLexOfIsStrictOrder
code: instance {r : α → α → Prop} {s : β → β → Prop} [IsStrictOrder α r] [IsAntisymm β s] :
    IsAntisymm (α × β) (Prod.Lex r s) 
goal: IsAntisymm (α × β) (Prod.Lex r s)

full_name: Prod.isTotal_left
code: instance isTotal_left {r : α → α → Prop} {s : β → β → Prop} [IsTotal α r] :
    IsTotal (α × β) (Prod.Lex r s) 
goal: IsTotal (α × β) (Prod.Lex r s)

full_name: Prod.isTotal_right
code: instance isTotal_right {r : α → α → Prop} {s : β → β → Prop} [IsTrichotomous α r] [IsTotal β s] :
    IsTotal (α × β) (Prod.Lex r s) 
goal: IsTotal (α × β) (Prod.Lex r s)

full_name: Prod.IsTrichotomous
code: instance IsTrichotomous [IsTrichotomous α r] [IsTrichotomous β s] :
  IsTrichotomous (α × β) (Prod.Lex r s) 
goal: IsTrichotomous (α × β) (Prod.Lex r s)

full_name: Function.Injective.prodMap
code: theorem Injective.prodMap (hf : Injective f) (hg : Injective g) : Injective (map f g) 
goal: Function.Injective (Prod.map f g)

full_name: Function.Surjective.prodMap
code: theorem Surjective.prodMap (hf : Surjective f) (hg : Surjective g) : Surjective (map f g) 
goal: Function.Surjective (Prod.map f g)

full_name: Function.Bijective.prodMap
code: theorem Bijective.prodMap (hf : Bijective f) (hg : Bijective g) : Bijective (map f g) 
goal: Function.Bijective (Prod.map f g)

full_name: Function.LeftInverse.prodMap
code: theorem LeftInverse.prodMap (hf : LeftInverse f₁ f₂) (hg : LeftInverse g₁ g₂) :
    LeftInverse (map f₁ g₁) (map f₂ g₂) 
goal: Function.LeftInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂)

full_name: Function.RightInverse.prodMap
code: theorem RightInverse.prodMap :
    RightInverse f₁ f₂ → RightInverse g₁ g₂ → RightInverse (map f₁ g₁) (map f₂ g₂) 
goal: Function.RightInverse f₁ f₂ → Function.RightInverse g₁ g₂ → Function.RightInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂)

full_name: Function.Involutive.prodMap
code: theorem Involutive.prodMap {f : α → α} {g : β → β} :
    Involutive f → Involutive g → Involutive (map f g) 
goal: Function.Involutive f → Function.Involutive g → Function.Involutive (Prod.map f g)

full_name: Prod.map_injective
code: @[simp]
theorem map_injective [Nonempty α] [Nonempty β] {f : α → γ} {g : β → δ} :
    Injective (map f g) ↔ Injective f ∧ Injective g 
goal: Function.Injective (Prod.map f g) ↔ Function.Injective f ∧ Function.Injective g

full_name: Prod.map_surjective
code: @[simp]
theorem map_surjective [Nonempty γ] [Nonempty δ] {f : α → γ} {g : β → δ} :
    Surjective (map f g) ↔ Surjective f ∧ Surjective g 
goal: Function.Surjective (Prod.map f g) ↔ Function.Surjective f ∧ Function.Surjective g

full_name: Prod.map_bijective
code: @[simp]
theorem map_bijective [Nonempty α] [Nonempty β] {f : α → γ} {g : β → δ} :
    Bijective (map f g) ↔ Bijective f ∧ Bijective g 
goal: Function.Bijective (Prod.map f g) ↔ Function.Bijective f ∧ Function.Bijective g

full_name: Prod.map_leftInverse
code: @[simp]
theorem map_leftInverse [Nonempty β] [Nonempty δ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α}
    {g₂ : δ → γ} : LeftInverse (map f₁ g₁) (map f₂ g₂) ↔ LeftInverse f₁ f₂ ∧ LeftInverse g₁ g₂ 
goal: Function.LeftInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂) ↔ Function.LeftInverse f₁ f₂ ∧ Function.LeftInverse g₁ g₂

full_name: Prod.map_rightInverse
code: @[simp]
theorem map_rightInverse [Nonempty α] [Nonempty γ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α}
    {g₂ : δ → γ} : RightInverse (map f₁ g₁) (map f₂ g₂) ↔ RightInverse f₁ f₂ ∧ RightInverse g₁ g₂ 
goal: Function.RightInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂) ↔ Function.RightInverse f₁ f₂ ∧ Function.RightInverse g₁ g₂

full_name: Prod.map_involutive
code: @[simp]
theorem map_involutive [Nonempty α] [Nonempty β] {f : α → α} {g : β → β} :
    Involutive (map f g) ↔ Involutive f ∧ Involutive g 
goal: Function.Involutive (Prod.map f g) ↔ Function.Involutive f ∧ Function.Involutive g

full_name: Prod.delabProdFst
code: /-- Delaborator for `Prod.fst x` as `x.1`. -/
@[delab app.Prod.fst]
def delabProdFst : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab

full_name: Prod.delabProdSnd
code: /-- Delaborator for `Prod.snd x` as `x.2`. -/
@[delab app.Prod.snd]
def delabProdSnd : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab