# Documentation

Mathlib.Data.TypeVec

# Tuples of types, and their categorical structure. #

## Features #

• TypeVec n - n-tuples of types
• α ⟹ β - n-tuples of maps
• f ⊚ g - composition

Also, support functions for operating with n-tuples of types, such as:

• append1 α β - append type β to n-tuple α to obtain an (n+1)-tuple
• drop α - drops the last element of an (n+1)-tuple
• last α - returns the last element of an (n+1)-tuple
• appendFun f g - appends a function g to an n-tuple of functions
• dropFun f - drops the last function from an n+1-tuple
• lastFun f - returns the last function of a tuple.

Since e.g. append1 α.drop α.last is propositionally equal to α but not definitionally equal to it, we need support functions and lemmas to mediate between constructions.

def TypeVec (n : ) :
Type (u_1 + 1)

n-tuples of types, as a category

Equations
Instances For
instance instInhabitedTypeVec {n : } :
Equations
def TypeVec.Arrow {n : } (α : ) (β : ) :
Type (max u_1 u_2)

arrow in the category of TypeVec

Equations
• = ((i : Fin2 n) → α iβ i)
Instances For

arrow in the category of TypeVec

Equations
Instances For
theorem TypeVec.Arrow.ext {n : } {α : } {β : } (f : ) (g : ) :
(∀ (i : Fin2 n), f i = g i)f = g

Extensionality for arrows

instance TypeVec.Arrow.inhabited {n : } (α : ) (β : ) [(i : Fin2 n) → Inhabited (β i)] :
Equations
• = { default := fun (x : Fin2 n) (x_1 : α x) => default }
def TypeVec.id {n : } {α : } :

identity of arrow composition

Equations
Instances For
def TypeVec.comp {n : } {α : } {β : } {γ : } (g : ) (f : ) :

arrow composition in the category of TypeVec

Equations
Instances For

arrow composition in the category of TypeVec

Equations
Instances For
@[simp]
theorem TypeVec.id_comp {n : } {α : } {β : } (f : ) :
TypeVec.comp TypeVec.id f = f
@[simp]
theorem TypeVec.comp_id {n : } {α : } {β : } (f : ) :
TypeVec.comp f TypeVec.id = f
theorem TypeVec.comp_assoc {n : } {α : } {β : } {γ : } {δ : } (h : ) (g : ) (f : ) :
def TypeVec.append1 {n : } (α : ) (β : Type u_1) :

Support for extending a TypeVec by one element.

Equations
• (α ::: β) x = match x with | => α i | Fin2.fz => β
Instances For

Support for extending a TypeVec by one element.

Equations
Instances For
def TypeVec.drop {n : } (α : TypeVec.{u} (n + 1)) :

retain only a n-length prefix of the argument

Equations
• = α ()
Instances For
def TypeVec.last {n : } (α : TypeVec.{u} (n + 1)) :

take the last value of a (n+1)-length vector

Equations
• = α Fin2.fz
Instances For
instance TypeVec.last.inhabited {n : } (α : TypeVec.{u_1} (n + 1)) [Inhabited (α Fin2.fz)] :
Equations
• = { default := let_fun this := default; this }
theorem TypeVec.drop_append1 {n : } {α : } {β : Type u_1} {i : Fin2 n} :
TypeVec.drop (α ::: β) i = α i
@[simp]
theorem TypeVec.drop_append1' {n : } {α : } {β : Type u_1} :
TypeVec.drop (α ::: β) = α
theorem TypeVec.last_append1 {n : } {α : } {β : Type u_1} :
TypeVec.last (α ::: β) = β
@[simp]
theorem TypeVec.append1_drop_last {n : } (α : TypeVec.{u_1} (n + 1)) :
= α
def TypeVec.append1Cases {n : } {C : TypeVec.{u_1} (n + 1)Sort u} (H : (α : ) → (β : Type u_1) → C (α ::: β)) (γ : TypeVec.{u_1} (n + 1)) :
C γ

cases on (n+1)-length vectors

Equations
Instances For
@[simp]
theorem TypeVec.append1_cases_append1 {n : } {C : TypeVec.{u_1} (n + 1)Sort u} (H : (α : ) → (β : Type u_1) → C (α ::: β)) (α : ) (β : Type u_1) :
TypeVec.append1Cases H (α ::: β) = H α β
def TypeVec.splitFun {n : } {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} (f : ) (g : ) :

append an arrow and a function for arbitrary source and target type vectors

Equations
• = match (motive := (x : Fin2 (n + 1)) → α xα' x) x with | => f i | Fin2.fz => g
Instances For
def TypeVec.appendFun {n : } {α : } {α' : } {β : Type u_1} {β' : Type u_2} (f : ) (g : ββ') :
TypeVec.Arrow (α ::: β) (α' ::: β')

append an arrow and a function as well as their respective source and target types / typevecs

Equations
Instances For

append an arrow and a function as well as their respective source and target types / typevecs

Equations
Instances For
def TypeVec.dropFun {n : } {α : TypeVec.{u_1} (n + 1)} {β : TypeVec.{u_2} (n + 1)} (f : ) :

split off the prefix of an arrow

Equations
• = f ()
Instances For
def TypeVec.lastFun {n : } {α : TypeVec.{u_1} (n + 1)} {β : TypeVec.{u_2} (n + 1)} (f : ) :

split off the last function of an arrow

Equations
• = f Fin2.fz
Instances For
def TypeVec.nilFun {α : } {β : } :

arrow in the category of 0-length vectors

Equations
Instances For
theorem TypeVec.eq_of_drop_last_eq {n : } {α : TypeVec.{u_1} (n + 1)} {β : TypeVec.{u_2} (n + 1)} {f : } {g : } (h₀ : ) (h₁ : ) :
f = g
@[simp]
theorem TypeVec.dropFun_splitFun {n : } {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} (f : ) (g : ) :
= f
def TypeVec.Arrow.mp {n : } {α : } {β : } (h : α = β) :

turn an equality into an arrow

Equations
• = match (motive := (x : Fin2 n) → α xβ x) x with | x => Eq.mp (_ : α x = β x)
Instances For
def TypeVec.Arrow.mpr {n : } {α : } {β : } (h : α = β) :

turn an equality into an arrow, with reverse direction

Equations
• = match (motive := (x : Fin2 n) → β xα x) x with | x => Eq.mpr (_ : α x = β x)
Instances For
def TypeVec.toAppend1DropLast {n : } {α : TypeVec.{u_1} (n + 1)} :

decompose a vector into its prefix appended with its last element

Equations
Instances For

stitch two bits of a vector back together

Equations
Instances For
@[simp]
theorem TypeVec.lastFun_splitFun {n : } {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} (f : ) (g : ) :
= g
@[simp]
theorem TypeVec.dropFun_appendFun {n : } {α : } {α' : } {β : Type u_1} {β' : Type u_2} (f : ) (g : ββ') :
@[simp]
theorem TypeVec.lastFun_appendFun {n : } {α : } {α' : } {β : Type u_1} {β' : Type u_2} (f : ) (g : ββ') :
theorem TypeVec.split_dropFun_lastFun {n : } {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} (f : ) :
theorem TypeVec.splitFun_inj {n : } {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} {f : } {f' : } {g : } {g' : } (H : = TypeVec.splitFun f' g') :
f = f' g = g'
theorem TypeVec.appendFun_inj {n : } {α : } {α' : } {β : Type u_1} {β' : Type u_2} {f : } {f' : } {g : ββ'} {g' : ββ'} :
(f ::: g) = (f' ::: g')f = f' g = g'
theorem TypeVec.splitFun_comp {n : } {α₀ : TypeVec.{u_1} (n + 1)} {α₁ : TypeVec.{u_2} (n + 1)} {α₂ : TypeVec.{u_3} (n + 1)} (f₀ : TypeVec.Arrow () ()) (f₁ : TypeVec.Arrow () ()) (g₀ : ) (g₁ : ) :
TypeVec.splitFun (TypeVec.comp f₁ f₀) (g₁ g₀) = TypeVec.comp (TypeVec.splitFun f₁ g₁) (TypeVec.splitFun f₀ g₀)
theorem TypeVec.appendFun_comp_splitFun {n : } {α : } {γ : } {β : Type u_1} {δ : Type u_2} {ε : TypeVec.{u_3} (n + 1)} (f₀ : ) (f₁ : ) (g₀ : β) (g₁ : βδ) :
TypeVec.comp (f₁ ::: g₁) (TypeVec.splitFun f₀ g₀) = TypeVec.splitFun (TypeVec.comp f₁ f₀) (g₁ g₀)
theorem TypeVec.appendFun_comp {n : } {α₀ : } {α₁ : } {α₂ : } {β₀ : Type u_1} {β₁ : Type u_2} {β₂ : Type u_3} (f₀ : TypeVec.Arrow α₀ α₁) (f₁ : TypeVec.Arrow α₁ α₂) (g₀ : β₀β₁) (g₁ : β₁β₂) :
(TypeVec.comp f₁ f₀ ::: g₁ g₀) = TypeVec.comp (f₁ ::: g₁) (f₀ ::: g₀)
theorem TypeVec.appendFun_comp' {n : } {α₀ : } {α₁ : } {α₂ : } {β₀ : Type u_1} {β₁ : Type u_2} {β₂ : Type u_3} (f₀ : TypeVec.Arrow α₀ α₁) (f₁ : TypeVec.Arrow α₁ α₂) (g₀ : β₀β₁) (g₁ : β₁β₂) :
TypeVec.comp (f₁ ::: g₁) (f₀ ::: g₀) = (TypeVec.comp f₁ f₀ ::: g₁ g₀)
theorem TypeVec.nilFun_comp {α₀ : } (f₀ : TypeVec.Arrow α₀ Fin2.elim0) :
TypeVec.comp TypeVec.nilFun f₀ = f₀
theorem TypeVec.appendFun_comp_id {n : } {α : } {β₀ : Type u} {β₁ : Type u} {β₂ : Type u} (g₀ : β₀β₁) (g₁ : β₁β₂) :
(TypeVec.id ::: g₁ g₀) = TypeVec.comp (TypeVec.id ::: g₁) (TypeVec.id ::: g₀)
@[simp]
theorem TypeVec.dropFun_comp {n : } {α₀ : TypeVec.{u_1} (n + 1)} {α₁ : TypeVec.{u_2} (n + 1)} {α₂ : TypeVec.{u_3} (n + 1)} (f₀ : TypeVec.Arrow α₀ α₁) (f₁ : TypeVec.Arrow α₁ α₂) :
@[simp]
theorem TypeVec.lastFun_comp {n : } {α₀ : TypeVec.{u_1} (n + 1)} {α₁ : TypeVec.{u_2} (n + 1)} {α₂ : TypeVec.{u_3} (n + 1)} (f₀ : TypeVec.Arrow α₀ α₁) (f₁ : TypeVec.Arrow α₁ α₂) :
theorem TypeVec.appendFun_aux {n : } {α : } {α' : } {β : Type u_1} {β' : Type u_2} (f : TypeVec.Arrow (α ::: β) (α' ::: β')) :
= f
theorem TypeVec.appendFun_id_id {n : } {α : } {β : Type u_1} :
(TypeVec.id ::: id) = TypeVec.id
Equations
def TypeVec.casesNil {β : Sort u_1} (f : β Fin2.elim0) (v : ) :
β v

cases distinction for 0-length type vector

Equations
• = cast (_ : β Fin2.elim0 = β v) f
Instances For
def TypeVec.casesCons (n : ) {β : TypeVec.{u_2} (n + 1)Sort u_1} (f : (t : Type u_2) → (v : ) → β (v ::: t)) (v : TypeVec.{u_2} (n + 1)) :
β v

cases distinction for (n+1)-length type vector

Equations
• = cast (_ : β () = β v) (f () ())
Instances For
theorem TypeVec.casesNil_append1 {β : Sort u_1} (f : β Fin2.elim0) :
TypeVec.casesNil f Fin2.elim0 = f
theorem TypeVec.casesCons_append1 (n : ) {β : TypeVec.{u_2} (n + 1)Sort u_1} (f : (t : Type u_2) → (v : ) → β (v ::: t)) (v : ) (α : Type u_2) :
TypeVec.casesCons n f (v ::: α) = f α v
def TypeVec.typevecCasesNil₃ {β : (v : ) → (v' : ) → Sort u_1} (f : β Fin2.elim0 Fin2.elim0 TypeVec.nilFun) (v : ) (v' : ) (fs : ) :
β v v' fs

cases distinction for an arrow in the category of 0-length type vectors

Equations
Instances For
def TypeVec.typevecCasesCons₃ (n : ) {β : (v : TypeVec.{u_2} (n + 1)) → (v' : TypeVec.{u_3} (n + 1)) → Sort u_1} (F : (t : Type u_2) → (t' : Type u_3) → (f : tt') → (v : ) → (v' : ) → (fs : ) → β (v ::: t) (v' ::: t') (fs ::: f)) (v : TypeVec.{u_2} (n + 1)) (v' : TypeVec.{u_3} (n + 1)) (fs : ) :
β v v' fs

cases distinction for an arrow in the category of (n+1)-length type vectors

Equations
• One or more equations did not get rendered due to their size.
Instances For
def TypeVec.typevecCasesNil₂ {β : TypeVec.Arrow Fin2.elim0 Fin2.elim0Sort u_1} (f : β TypeVec.nilFun) (f : TypeVec.Arrow Fin2.elim0 Fin2.elim0) :
β f

specialized cases distinction for an arrow in the category of 0-length type vectors

Equations
• = let_fun this := (_ : g = TypeVec.nilFun); Eq.mpr (_ : β g = β TypeVec.nilFun) f
Instances For
def TypeVec.typevecCasesCons₂ (n : ) (t : Type u_1) (t' : Type u_2) (v : ) (v' : ) {β : TypeVec.Arrow (v ::: t) (v' ::: t')Sort u_3} (F : (f : tt') → (fs : ) → β (fs ::: f)) (fs : TypeVec.Arrow (v ::: t) (v' ::: t')) :
β fs

specialized cases distinction for an arrow in the category of (n+1)-length type vectors

Equations
Instances For
theorem TypeVec.typevecCasesNil₂_appendFun {β : TypeVec.Arrow Fin2.elim0 Fin2.elim0Sort u_1} (f : β TypeVec.nilFun) :
TypeVec.typevecCasesNil₂ f TypeVec.nilFun = f
theorem TypeVec.typevecCasesCons₂_appendFun (n : ) (t : Type u_1) (t' : Type u_2) (v : ) (v' : ) {β : TypeVec.Arrow (v ::: t) (v' ::: t')Sort u_3} (F : (f : tt') → (fs : ) → β (fs ::: f)) (f : tt') (fs : ) :
TypeVec.typevecCasesCons₂ n t t' v v' F (fs ::: f) = F f fs
def TypeVec.PredLast {n : } (α : ) {β : Type u_1} (p : βProp) ⦃i : Fin2 (n + 1) :
(α ::: β) iProp

PredLast α p x predicates p of the last element of x : α.append1 β.

Equations
Instances For
def TypeVec.RelLast {n : } (α : ) {β : Type u} {γ : Type u} (r : βγProp) ⦃i : Fin2 (n + 1) :
(α ::: β) i(α ::: γ) iProp

RelLast α r x y says that p the last elements of x y : α.append1 β are related by r and all the other elements are equal.

Equations
Instances For
def TypeVec.repeat (n : ) :
Type u_1 →

repeat n t is a n-length type vector that contains n occurrences of t

Equations
Instances For
def TypeVec.prod {n : } :

prod α β is the pointwise product of the components of α and β

Equations
Instances For

prod α β is the pointwise product of the components of α and β

Equations
Instances For
def TypeVec.const {β : Type u_1} (x : β) {n : } (α : ) :

const x α is an arrow that ignores its source and constructs a TypeVec that contains nothing but x

Equations
Instances For
def TypeVec.repeatEq {n : } (α : ) :

vector of equality on a product of vectors

Equations
• = TypeVec.nilFun
Instances For
theorem TypeVec.const_append1 {β : Type u_1} {γ : Type u_2} (x : γ) {n : } (α : ) :
TypeVec.const x (α ::: β) = ( ::: fun (x_1 : β) => x)
theorem TypeVec.eq_nilFun {α : } {β : } (f : ) :
f = TypeVec.nilFun
theorem TypeVec.id_eq_nilFun {α : } :
TypeVec.id = TypeVec.nilFun
theorem TypeVec.const_nil {β : Type u_1} (x : β) (α : ) :
= TypeVec.nilFun
theorem TypeVec.repeat_eq_append1 {β : Type u_1} {n : } (α : ) :
theorem TypeVec.repeat_eq_nil (α : ) :
= TypeVec.nilFun
def TypeVec.PredLast' {n : } (α : ) {β : Type u_1} (p : βProp) :

predicate on a type vector to constrain only the last object

Equations
Instances For
def TypeVec.RelLast' {n : } (α : ) {β : Type u_1} (p : ββProp) :

predicate on the product of two type vectors to constrain only their last object

Equations
Instances For
def TypeVec.Curry {n : } (F : TypeVec.{u} (n + 1)Type u_1) (α : Type u) (β : ) :
Type u_1

given F : TypeVec.{u} (n+1) → Type u, curry F : Type u → TypeVec.{u} → Type u, i.e. its first argument can be fed in separately from the rest of the vector of arguments

Equations
Instances For
instance TypeVec.Curry.inhabited {n : } (F : TypeVec.{u} (n + 1)Type u_1) (α : Type u) (β : ) [I : Inhabited (F (β ::: α))] :
Equations
def TypeVec.dropRepeat (α : Type u_1) {n : } :

arrow to remove one element of a repeat vector

Equations
Instances For
def TypeVec.ofRepeat {α : Type u_1} {n : } {i : Fin2 n} :
α

projection for a repeat vector

Equations
• TypeVec.ofRepeat = fun (a : α) => a
• TypeVec.ofRepeat = TypeVec.ofRepeat
Instances For
theorem TypeVec.const_iff_true {n : } {α : } {i : Fin2 n} {x : α i} {p : Prop} :
def TypeVec.prod.fst {n : } {α : } {β : } :

left projection of a prod vector

Equations
Instances For
def TypeVec.prod.snd {n : } {α : } {β : } :

right projection of a prod vector

Equations
Instances For
def TypeVec.prod.diag {n : } {α : } :

introduce a product where both components are the same

Equations
Instances For
def TypeVec.prod.mk {n : } {α : } {β : } (i : Fin2 n) :
α iβ iTypeVec.prod α β i

constructor for prod

Equations
Instances For
@[simp]
theorem TypeVec.prod_fst_mk {n : } {α : } {β : } (i : Fin2 n) (a : α i) (b : β i) :
@[simp]
theorem TypeVec.prod_snd_mk {n : } {α : } {β : } (i : Fin2 n) (a : α i) (b : β i) :
def TypeVec.prod.map {n : } {α : } {α' : } {β : } {β' : } :
TypeVec.Arrow α' β'TypeVec.Arrow (TypeVec.prod α α') (TypeVec.prod β β')

prod is functorial

Equations
Instances For

prod is functorial

Equations
Instances For
theorem TypeVec.fst_prod_mk {n : } {α : } {α' : } {β : } {β' : } (f : ) (g : TypeVec.Arrow α' β') :
TypeVec.comp TypeVec.prod.fst () = TypeVec.comp f TypeVec.prod.fst
theorem TypeVec.snd_prod_mk {n : } {α : } {α' : } {β : } {β' : } (f : ) (g : TypeVec.Arrow α' β') :
TypeVec.comp TypeVec.prod.snd () = TypeVec.comp g TypeVec.prod.snd
theorem TypeVec.fst_diag {n : } {α : } :
TypeVec.comp TypeVec.prod.fst TypeVec.prod.diag = TypeVec.id
theorem TypeVec.snd_diag {n : } {α : } :
TypeVec.comp TypeVec.prod.snd TypeVec.prod.diag = TypeVec.id
theorem TypeVec.repeatEq_iff_eq {n : } {α : } {i : Fin2 n} {x : α i} {y : α i} :
def TypeVec.Subtype_ {n : } {α : } :

given a predicate vector p over vector α, Subtype_ p is the type of vectors that contain an α that satisfies p

Equations
Instances For
def TypeVec.subtypeVal {n : } {α : } (p : ) :

projection on Subtype_

Equations
Instances For
def TypeVec.toSubtype {n : } {α : } (p : ) :
TypeVec.Arrow (fun (i : Fin2 n) => { x : α i // TypeVec.ofRepeat (p i x) }) ()

arrow that rearranges the type of Subtype_ to turn a subtype of vector into a vector of subtypes

Equations
Instances For
def TypeVec.ofSubtype {n : } {α : } (p : ) :
TypeVec.Arrow () fun (i : Fin2 n) => { x : α i // TypeVec.ofRepeat (p i x) }

arrow that rearranges the type of Subtype_ to turn a vector of subtypes into a subtype of vector

Equations
Instances For
def TypeVec.toSubtype' {n : } {α : } (p : TypeVec.Arrow () ()) :
TypeVec.Arrow (fun (i : Fin2 n) => { x : α i × α i // TypeVec.ofRepeat (p i (TypeVec.prod.mk i x.fst x.snd)) }) ()

similar to toSubtype adapted to relations (i.e. predicate on product)

Equations
Instances For
def TypeVec.ofSubtype' {n : } {α : } (p : TypeVec.Arrow () ()) :
TypeVec.Arrow () fun (i : Fin2 n) => { x : α i × α i // TypeVec.ofRepeat (p i (TypeVec.prod.mk i x.fst x.snd)) }

similar to of_subtype adapted to relations (i.e. predicate on product)

Equations
Instances For
def TypeVec.diagSub {n : } {α : } :

similar to diag but the target vector is a Subtype_ guaranteeing the equality of the components

Equations
Instances For
theorem TypeVec.subtypeVal_nil {α : } (ps : ) :
= TypeVec.nilFun
theorem TypeVec.diag_sub_val {n : } {α : } :
TypeVec.comp TypeVec.diagSub = TypeVec.prod.diag
theorem TypeVec.prod_id {n : } {α : } {β : } :
TypeVec.prod.map TypeVec.id TypeVec.id = TypeVec.id
theorem TypeVec.append_prod_appendFun {n : } {α : } {α' : } {β : } {β' : } {φ : Type u} {φ' : Type u} {ψ : Type u} {ψ' : Type u} {f₀ : } {g₀ : } {f₁ : φφ'} {g₁ : ψψ'} :
(TypeVec.prod.map f₀ g₀ ::: Prod.map f₁ g₁) = TypeVec.prod.map (f₀ ::: f₁) (g₀ ::: g₁)
@[simp]
theorem TypeVec.dropFun_diag {n : } {α : TypeVec.{u_1} (n + 1)} :
TypeVec.dropFun TypeVec.prod.diag = TypeVec.prod.diag
@[simp]
theorem TypeVec.dropFun_subtypeVal {n : } {α : TypeVec.{u_1} (n + 1)} (p : TypeVec.Arrow α (TypeVec.repeat (n + 1) Prop)) :
@[simp]
theorem TypeVec.lastFun_subtypeVal {n : } {α : TypeVec.{u_1} (n + 1)} (p : TypeVec.Arrow α (TypeVec.repeat (n + 1) Prop)) :
= Subtype.val
@[simp]
theorem TypeVec.dropFun_toSubtype {n : } {α : TypeVec.{u_1} (n + 1)} (p : TypeVec.Arrow α (TypeVec.repeat (n + 1) Prop)) :
= TypeVec.toSubtype fun (i : Fin2 n) (x : α ()) => p () x
@[simp]
theorem TypeVec.lastFun_toSubtype {n : } {α : TypeVec.{u_1} (n + 1)} (p : TypeVec.Arrow α (TypeVec.repeat (n + 1) Prop)) :
@[simp]
theorem TypeVec.dropFun_of_subtype {n : } {α : TypeVec.{u_1} (n + 1)} (p : TypeVec.Arrow α (TypeVec.repeat (n + 1) Prop)) :
@[simp]
theorem TypeVec.lastFun_of_subtype {n : } {α : TypeVec.{u_1} (n + 1)} (p : TypeVec.Arrow α (TypeVec.repeat (n + 1) Prop)) :
@[simp]
theorem TypeVec.dropFun_RelLast' {n : } {α : } {β : Type u_1} (R : ββProp) :
@[simp]
theorem TypeVec.dropFun_prod {n : } {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_1} (n + 1)} {β : TypeVec.{u_1} (n + 1)} {β' : TypeVec.{u_1} (n + 1)} (f : ) (f' : TypeVec.Arrow α' β') :
@[simp]
theorem TypeVec.lastFun_prod {n : } {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_1} (n + 1)} {β : TypeVec.{u_1} (n + 1)} {β' : TypeVec.{u_1} (n + 1)} (f : ) (f' : TypeVec.Arrow α' β') :
=
@[simp]
theorem TypeVec.dropFun_from_append1_drop_last {n : } {α : TypeVec.{u_1} (n + 1)} :
TypeVec.dropFun TypeVec.fromAppend1DropLast = TypeVec.id
@[simp]
theorem TypeVec.lastFun_from_append1_drop_last {n : } {α : TypeVec.{u_1} (n + 1)} :
TypeVec.lastFun TypeVec.fromAppend1DropLast = id
@[simp]
theorem TypeVec.dropFun_id {n : } {α : TypeVec.{u_1} (n + 1)} :
TypeVec.dropFun TypeVec.id = TypeVec.id
@[simp]
theorem TypeVec.prod_map_id {n : } {α : } {β : } :
TypeVec.prod.map TypeVec.id TypeVec.id = TypeVec.id
@[simp]
theorem TypeVec.subtypeVal_diagSub {n : } {α : } :
TypeVec.comp TypeVec.diagSub = TypeVec.prod.diag
@[simp]
theorem TypeVec.toSubtype_of_subtype {n : } {α : } (p : ) :
= TypeVec.id
@[simp]
theorem TypeVec.subtypeVal_toSubtype {n : } {α : } (p : ) :
= fun (x : Fin2 n) => Subtype.val
@[simp]
theorem TypeVec.toSubtype_of_subtype_assoc {n : } {α : } {β : } (p : ) (f : ) :
TypeVec.comp (TypeVec.comp (TypeVec.ofSubtype fun (i : Fin2 n) (x : α i) => p i x) f) = f
@[simp]
theorem TypeVec.toSubtype'_of_subtype' {n : } {α : } (r : TypeVec.Arrow () ()) :
= TypeVec.id
theorem TypeVec.subtypeVal_toSubtype' {n : } {α : } (r : TypeVec.Arrow () ()) :
= fun (i : Fin2 n) (x : (fun (i : Fin2 n) => { x : α i × α i // TypeVec.ofRepeat (r i (TypeVec.prod.mk i x.fst x.snd)) }) i) => TypeVec.prod.mk i (x).fst (x).snd