File: Mathlib/Data/Prod/TProd.lean

full_name: List.TProd
code: /-- The product of a family of types over a list. -/
abbrev TProd (l : List ι) : Type v 
goal: Type v

full_name: List.TProd.mk
code: /-- Turning a function `f : ∀ i, α i` into an element of the iterated product `TProd α l`. -/
protected def mk : ∀ (l : List ι) (_f : ∀ i, α i), TProd α l
  
goal: List.TProd α l

full_name: List.TProd.instInhabited
code: instance [∀ i, Inhabited (α i)] : Inhabited (TProd α l) 
goal: Inhabited (List.TProd α l)

full_name: List.TProd.fst_mk
code: @[simp]
theorem fst_mk (i : ι) (l : List ι) (f : ∀ i, α i) : (TProd.mk (i :: l) f).1 = f i 
goal: (List.TProd.mk (i :: l) f).1 = f i

full_name: List.TProd.snd_mk
code: @[simp]
theorem snd_mk (i : ι) (l : List ι) (f : ∀ i, α i) :
    (TProd.mk.{u,v} (i :: l) f).2 = TProd.mk.{u,v} l f 
goal: (List.TProd.mk (i :: l) f).2 = List.TProd.mk l f

full_name: List.TProd.elim
code: /-- Given an element of the iterated product `l.Prod α`, take a projection into direction `i`.
  If `i` appears multiple times in `l`, this chooses the first component in direction `i`. -/
protected def elim : ∀ {l : List ι} (_ : TProd α l) {i : ι} (_ : i ∈ l), α i
  
goal: List.TProd α l → {i : ι} → i ∈ l → α i

full_name: List.TProd.elim_self
code: @[simp]
theorem elim_self (v : TProd α (i :: l)) : v.elim (l.mem_cons_self i) = v.1 
goal: v.elim ⋯ = v.1

full_name: List.TProd.elim_of_ne
code: @[simp]
theorem elim_of_ne (hj : j ∈ i :: l) (hji : j ≠ i) (v : TProd α (i :: l)) :
    v.elim hj = TProd.elim v.2 ((List.mem_cons.mp hj).resolve_left hji) 
goal: v.elim hj = List.TProd.elim v.2 ⋯

full_name: List.TProd.elim_of_mem
code: @[simp]
theorem elim_of_mem (hl : (i :: l).Nodup) (hj : j ∈ l) (v : TProd α (i :: l)) :
    v.elim (mem_cons_of_mem _ hj) = TProd.elim v.2 hj 
goal: v.elim ⋯ = List.TProd.elim v.2 hj

full_name: List.TProd.elim_mk
code: theorem elim_mk : ∀ (l : List ι) (f : ∀ i, α i) {i : ι} (hi : i ∈ l), (TProd.mk l f).elim hi = f i
  
goal: (List.TProd.mk l f).elim hi = f i

full_name: List.TProd.ext
code: @[ext]
theorem ext :
    ∀ {l : List ι} (_ : l.Nodup) {v w : TProd α l}
      (_ : ∀ (i) (hi : i ∈ l), v.elim hi = w.elim hi), v = w
  
goal: l.Nodup → ∀ {v w : List.TProd α l}, (∀ (i : ι) (hi : i ∈ l), v.elim hi = w.elim hi) → v = w

full_name: List.TProd.elim'
code: /-- A version of `TProd.elim` when `l` contains all elements. In this case we get a function into
  `Π i, α i`. -/
@[simp]
protected def elim' (h : ∀ i, i ∈ l) (v : TProd α l) (i : ι) : α i 
goal: α i

full_name: List.TProd.mk_elim
code: theorem mk_elim (hnd : l.Nodup) (h : ∀ i, i ∈ l) (v : TProd α l) : TProd.mk l (v.elim' h) = v 
goal: List.TProd.mk l (List.TProd.elim' h v) = v

full_name: List.TProd.piEquivTProd
code: /-- Pi-types are equivalent to iterated products. -/
def piEquivTProd (hnd : l.Nodup) (h : ∀ i, i ∈ l) : (∀ i, α i) ≃ TProd α l 
goal: ((i : ι) → α i) ≃ List.TProd α l

full_name: Set.tprod
code: /-- A product of sets in `TProd α l`. -/
@[simp]
protected def tprod : ∀ (l : List ι) (_t : ∀ i, Set (α i)), Set (TProd α l)
  
goal: Set (List.TProd α l)

full_name: Set.mk_preimage_tprod
code: theorem mk_preimage_tprod :
    ∀ (l : List ι) (t : ∀ i, Set (α i)), TProd.mk l ⁻¹' Set.tprod l t = { i | i ∈ l }.pi t
  
goal: List.TProd.mk l ⁻¹' Set.tprod l t = {i | i ∈ l}.pi t

full_name: Set.elim_preimage_pi
code: theorem elim_preimage_pi [DecidableEq ι] {l : List ι} (hnd : l.Nodup) (h : ∀ i, i ∈ l)
    (t : ∀ i, Set (α i)) : TProd.elim' h ⁻¹' pi univ t = Set.tprod l t 
goal: List.TProd.elim' h ⁻¹' Set.univ.pi t = Set.tprod l t