l3lab/ntp-mathlib huggingface dataset:
/-- cases distinction for an arrow in the category of 0-length type vectors -/
def typevecCasesNil₃ {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort*}
    (f : β Fin2.elim0 Fin2.elim0 nilFun) :
    ∀ v v' fs, β v v' fs := fun v v' fs => by
  refine' cast _ f
  have eq₁ : v = Fin2.elim0 := by funext i; contradiction
  have eq₂ : v' = Fin2.elim0 := by funext i; contradiction
  have eq₃ : fs = nilFun := by funext i; contradiction
  cases eq₁; cases eq₂; 

Proof state:
case refl.refl
n : ℕ
β : (v : TypeVec.{?u.48284} 0) → (v' : TypeVec.{?u.48297} 0) → v ⟹ v' → Sort u_1
f : β Fin2.elim0 Fin2.elim0 nilFun
fs : Fin2.elim0 ⟹ Fin2.elim0
eq₃ : fs = nilFun
⊢ β Fin2.elim0 Fin2.elim0 nilFun = β Fin2.elim0 Fin2.elim0 fs

Next tactic:
cases eq₃
/-- cases distinction for an arrow in the category of 0-length type vectors -/
def typevecCasesNil₃ {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort*}
    (f : β Fin2.elim0 Fin2.elim0 nilFun) :
    ∀ v v' fs, β v v' fs := fun v v' fs => by
  refine' cast _ f
  have eq₁ : v = Fin2.elim0 := by funext i; contradiction
  have eq₂ : v' = Fin2.elim0 := by funext i; contradiction
  have eq₃ : fs = nilFun := by funext i; contradiction
  cases eq₁; cases eq₂; cases eq₃; 

Proof state:
case refl.refl.refl
n : ℕ
β : (v : TypeVec.{?u.48284} 0) → (v' : TypeVec.{?u.48297} 0) → v ⟹ v' → Sort u_1
f : β Fin2.elim0 Fin2.elim0 nilFun
⊢ β Fin2.elim0 Fin2.elim0 nilFun = β Fin2.elim0 Fin2.elim0 nilFun

Next tactic:
rfl
/-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort*}
    (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
    β (v ::: t) (v' ::: t') (fs ::: f)) :
    ∀ v v' fs, β v v' fs := by
  

Proof state:
n✝ n : ℕ
β : (v : TypeVec.{?u.49885} (n + 1)) → (v' : TypeVec.{?u.49888} (n + 1)) → v ⟹ v' → Sort u_1
F :
  (t : Type ?u.49885) →
    (t' : Type ?u.49888) →
      (f : t → t') →
        (v : TypeVec.{?u.49885} n) → (v' : TypeVec.{?u.49888} n) → (fs : v ⟹ v') → β (v ::: t) (v' ::: t') (fs ::: f)
⊢ (v : TypeVec.{?u.49885} (n + 1)) → (v' : TypeVec.{?u.49888} (n + 1)) → (fs : v ⟹ v') → β v v' fs

Next tactic:
intro v v'
/-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort*}
    (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
    β (v ::: t) (v' ::: t') (fs ::: f)) :
    ∀ v v' fs, β v v' fs := by
  intro v v'
  

Proof state:
n✝ n : ℕ
β : (v : TypeVec.{?u.49885} (n + 1)) → (v' : TypeVec.{?u.49888} (n + 1)) → v ⟹ v' → Sort u_1
F :
  (t : Type ?u.49885) →
    (t' : Type ?u.49888) →
      (f : t → t') →
        (v : TypeVec.{?u.49885} n) → (v' : TypeVec.{?u.49888} n) → (fs : v ⟹ v') → β (v ::: t) (v' ::: t') (fs ::: f)
v : TypeVec.{?u.49885} (n + 1)
v' : TypeVec.{?u.49888} (n + 1)
⊢ (fs : v ⟹ v') → β v v' fs

Next tactic:
rw [← append1_drop_last v, ← append1_drop_last v']
/-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort*}
    (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
    β (v ::: t) (v' ::: t') (fs ::: f)) :
    ∀ v v' fs, β v v' fs := by
  intro v v'
  rw [← append1_drop_last v, ← append1_drop_last v']
  

Proof state:
n✝ n : ℕ
β : (v : TypeVec.{?u.49885} (n + 1)) → (v' : TypeVec.{?u.49888} (n + 1)) → v ⟹ v' → Sort u_1
F :
  (t : Type ?u.49885) →
    (t' : Type ?u.49888) →
      (f : t → t') →
        (v : TypeVec.{?u.49885} n) → (v' : TypeVec.{?u.49888} n) → (fs : v ⟹ v') → β (v ::: t) (v' ::: t') (fs ::: f)
v : TypeVec.{?u.49885} (n + 1)
v' : TypeVec.{?u.49888} (n + 1)
⊢ (fs : drop v ::: last v ⟹ drop v' ::: last v') → β (drop v ::: last v) (drop v' ::: last v') fs

Next tactic:
intro fs
/-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort*}
    (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
    β (v ::: t) (v' ::: t') (fs ::: f)) :
    ∀ v v' fs, β v v' fs := by
  intro v v'
  rw [← append1_drop_last v, ← append1_drop_last v']
  intro fs
  

Proof state:
n✝ n : ℕ
β : (v : TypeVec.{?u.49885} (n + 1)) → (v' : TypeVec.{?u.49888} (n + 1)) → v ⟹ v' → Sort u_1
F :
  (t : Type ?u.49885) →
    (t' : Type ?u.49888) →
      (f : t → t') →
        (v : TypeVec.{?u.49885} n) → (v' : TypeVec.{?u.49888} n) → (fs : v ⟹ v') → β (v ::: t) (v' ::: t') (fs ::: f)
v : TypeVec.{?u.49885} (n + 1)
v' : TypeVec.{?u.49888} (n + 1)
fs : drop v ::: last v ⟹ drop v' ::: last v'
⊢ β (drop v ::: last v) (drop v' ::: last v') fs

Next tactic:
rw [← split_dropFun_lastFun fs]
/-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort*}
    (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
    β (v ::: t) (v' ::: t') (fs ::: f)) :
    ∀ v v' fs, β v v' fs := by
  intro v v'
  rw [← append1_drop_last v, ← append1_drop_last v']
  intro fs
  rw [← split_dropFun_lastFun fs]
  

Proof state:
n✝ n : ℕ
β : (v : TypeVec.{?u.49885} (n + 1)) → (v' : TypeVec.{?u.49888} (n + 1)) → v ⟹ v' → Sort u_1
F :
  (t : Type ?u.49885) →
    (t' : Type ?u.49888) →
      (f : t → t') →
        (v : TypeVec.{?u.49885} n) → (v' : TypeVec.{?u.49888} n) → (fs : v ⟹ v') → β (v ::: t) (v' ::: t') (fs ::: f)
v : TypeVec.{?u.49885} (n + 1)
v' : TypeVec.{?u.49888} (n + 1)
fs : drop v ::: last v ⟹ drop v' ::: last v'
⊢ β (drop v ::: last v) (drop v' ::: last v') (splitFun (dropFun fs) (lastFun fs))

Next tactic:
apply F
/-- specialized cases distinction for an arrow in the category of 0-length type vectors -/
def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun) : ∀ f, β f := by
  

Proof state:
n : ℕ
β : Fin2.elim0 ⟹ Fin2.elim0 → Sort u_1
f : β nilFun
⊢ (f : Fin2.elim0 ⟹ Fin2.elim0) → β f

Next tactic:
intro g
/-- specialized cases distinction for an arrow in the category of 0-length type vectors -/
def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun) : ∀ f, β f := by
  intro g
  

Proof state:
n : ℕ
β : Fin2.elim0 ⟹ Fin2.elim0 → Sort u_1
f : β nilFun
g : Fin2.elim0 ⟹ Fin2.elim0
⊢ β g

Next tactic:
suffices g = nilFun by rwa [this]
/-- specialized cases distinction for an arrow in the category of 0-length type vectors -/
def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun) : ∀ f, β f := by
  intro g
  suffices g = nilFun by 

Proof state:
n : ℕ
β : Fin2.elim0 ⟹ Fin2.elim0 → Sort u_1
f : β nilFun
g : Fin2.elim0 ⟹ Fin2.elim0
this : g = nilFun
⊢ β g

Next tactic:
rwa [this]
/-- specialized cases distinction for an arrow in the category of 0-length type vectors -/
def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun) : ∀ f, β f := by
  intro g
  suffices g = nilFun by rwa [this]
  

Proof state:
n : ℕ
β : Fin2.elim0 ⟹ Fin2.elim0 → Sort u_1
f : β nilFun
g : Fin2.elim0 ⟹ Fin2.elim0
⊢ g = nilFun

Next tactic:
ext ⟨⟩
/-- specialized cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₂ (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
    {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
    (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f)) : ∀ fs, β fs := by
  

Proof state:
n✝ n : ℕ
t : Type u_1
t' : Type u_2
v : TypeVec.{u_1} n
v' : TypeVec.{u_2} n
β : v ::: t ⟹ v' ::: t' → Sort u_3
F : (f : t → t') → (fs : v ⟹ v') → β (fs ::: f)
⊢ (fs : v ::: t ⟹ v' ::: t') → β fs

Next tactic:
intro fs
/-- specialized cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₂ (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
    {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
    (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f)) : ∀ fs, β fs := by
  intro fs
  

Proof state:
n✝ n : ℕ
t : Type u_1
t' : Type u_2
v : TypeVec.{u_1} n
v' : TypeVec.{u_2} n
β : v ::: t ⟹ v' ::: t' → Sort u_3
F : (f : t → t') → (fs : v ⟹ v') → β (fs ::: f)
fs : v ::: t ⟹ v' ::: t'
⊢ β fs

Next tactic:
rw [← split_dropFun_lastFun fs]
/-- specialized cases distinction for an arrow in the category of (n+1)-length type vectors -/
def typevecCasesCons₂ (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
    {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
    (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f)) : ∀ fs, β fs := by
  intro fs
  rw [← split_dropFun_lastFun fs]
  

Proof state:
n✝ n : ℕ
t : Type u_1
t' : Type u_2
v : TypeVec.{u_1} n
v' : TypeVec.{u_2} n
β : v ::: t ⟹ v' ::: t' → Sort u_3
F : (f : t → t') → (fs : v ⟹ v') → β (fs ::: f)
fs : v ::: t ⟹ v' ::: t'
⊢ β (splitFun (dropFun fs) (lastFun fs))

Next tactic:
apply F
theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
    TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x :=
  by 

Proof state:
n✝ : ℕ
β : Type u_1
γ : Type u_2
x : γ
n : ℕ
α : TypeVec.{u_1} n
⊢ TypeVec.const x (α ::: β) = (TypeVec.const x α ::: fun x_1 => x)

Next tactic:
ext i : 1
theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
    TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x :=
  by ext i : 1; 

Proof state:
case a
n✝ : ℕ
β : Type u_1
γ : Type u_2
x : γ
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 (n + 1)
⊢ TypeVec.const x (α ::: β) i = (TypeVec.const x α ::: fun x_1 => x) i

Next tactic:
cases i
theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
    TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x :=
  by ext i : 1; cases i <;> 

Proof state:
case a.fz
n✝ : ℕ
β : Type u_1
γ : Type u_2
x : γ
n : ℕ
α : TypeVec.{u_1} n
⊢ TypeVec.const x (α ::: β) Fin2.fz = (TypeVec.const x α ::: fun x_1 => x) Fin2.fz

Next tactic:
rfl
theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
    TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x :=
  by ext i : 1; cases i <;> 

Proof state:
case a.fs
n✝ : ℕ
β : Type u_1
γ : Type u_2
x : γ
n : ℕ
α : TypeVec.{u_1} n
a✝ : Fin2 (Nat.add n 0)
⊢ TypeVec.const x (α ::: β) (Fin2.fs a✝) = (TypeVec.const x α ::: fun x_1 => x) (Fin2.fs a✝)

Next tactic:
rfl
theorem eq_nilFun {α β : TypeVec 0} (f : α ⟹ β) : f = nilFun :=
  by 

Proof state:
n : ℕ
α : TypeVec.{u_1} 0
β : TypeVec.{u_2} 0
f : α ⟹ β
⊢ f = nilFun

Next tactic:
ext x
theorem eq_nilFun {α β : TypeVec 0} (f : α ⟹ β) : f = nilFun :=
  by ext x; 

Proof state:
case a.h
n : ℕ
α : TypeVec.{u_1} 0
β : TypeVec.{u_2} 0
f : α ⟹ β
x : Fin2 0
x✝ : α x
⊢ f x x✝ = nilFun x x✝

Next tactic:
cases x
theorem id_eq_nilFun {α : TypeVec 0} : @id _ α = nilFun :=
  by 

Proof state:
n : ℕ
α : TypeVec.{u_1} 0
⊢ id = nilFun

Next tactic:
ext x
theorem id_eq_nilFun {α : TypeVec 0} : @id _ α = nilFun :=
  by ext x; 

Proof state:
case a.h
n : ℕ
α : TypeVec.{u_1} 0
x : Fin2 0
x✝ : α x
⊢ id x x✝ = nilFun x x✝

Next tactic:
cases x
theorem const_nil {β} (x : β) (α : TypeVec 0) : TypeVec.const x α = nilFun :=
  by 

Proof state:
n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
⊢ TypeVec.const x α = nilFun

Next tactic:
ext i : 1
theorem const_nil {β} (x : β) (α : TypeVec 0) : TypeVec.const x α = nilFun :=
  by ext i : 1; 

Proof state:
case a
n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
i : Fin2 0
⊢ TypeVec.const x α i = nilFun i

Next tactic:
cases i
@[typevec]
theorem repeat_eq_append1 {β} {n} (α : TypeVec n) :
    repeatEq (α ::: β) = splitFun (α := (α ⊗ α) ::: _ )
    (α' := («repeat» n Prop) ::: _) (repeatEq α) (uncurry Eq) := by
  

Proof state:
n✝ : ℕ
β : Type u_1
n : ℕ
α : TypeVec.{u_1} n
⊢ repeatEq (α ::: β) = splitFun (repeatEq α) (uncurry Eq)

Next tactic:
induction n
@[typevec]
theorem repeat_eq_append1 {β} {n} (α : TypeVec n) :
    repeatEq (α ::: β) = splitFun (α := (α ⊗ α) ::: _ )
    (α' := («repeat» n Prop) ::: _) (repeatEq α) (uncurry Eq) := by
  induction n <;> 

Proof state:
case zero
n : ℕ
β : Type u_1
α : TypeVec.{u_1} zero
⊢ repeatEq (α ::: β) = splitFun (repeatEq α) (uncurry Eq)

Next tactic:
rfl
@[typevec]
theorem repeat_eq_append1 {β} {n} (α : TypeVec n) :
    repeatEq (α ::: β) = splitFun (α := (α ⊗ α) ::: _ )
    (α' := («repeat» n Prop) ::: _) (repeatEq α) (uncurry Eq) := by
  induction n <;> 

Proof state:
case succ
n : ℕ
β : Type u_1
n✝ : ℕ
n_ih✝ : ∀ (α : TypeVec.{u_1} n✝), repeatEq (α ::: β) = splitFun (repeatEq α) (uncurry Eq)
α : TypeVec.{u_1} (succ n✝)
⊢ repeatEq (α ::: β) = splitFun (repeatEq α) (uncurry Eq)

Next tactic:
rfl
@[typevec]
theorem repeat_eq_nil (α : TypeVec 0) : repeatEq α = nilFun := by 

Proof state:
n : ℕ
α : TypeVec.{u_1} 0
⊢ repeatEq α = nilFun

Next tactic:
ext i
@[typevec]
theorem repeat_eq_nil (α : TypeVec 0) : repeatEq α = nilFun := by ext i; 

Proof state:
case a.h
n : ℕ
α : TypeVec.{u_1} 0
i : Fin2 0
x✝ : (α ⊗ α) i
⊢ repeatEq α i x✝ = nilFun i x✝

Next tactic:
cases i
theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
  

Proof state:
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x : α i
p : Prop
⊢ ofRepeat (TypeVec.const p α i x) ↔ p

Next tactic:
induction i
theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
  induction i
  

Proof state:
case fz
n : ℕ
p : Prop
n✝ : ℕ
α : TypeVec.{u_1} (succ n✝)
x : α Fin2.fz
⊢ ofRepeat (TypeVec.const p α Fin2.fz x) ↔ p
case fs
n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec.{u_1} n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec.{u_1} (succ n✝)
x : α (Fin2.fs a✝)
⊢ ofRepeat (TypeVec.const p α (Fin2.fs a✝) x) ↔ p

Next tactic:
case fz      => rfl
theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
  induction i
  

Proof state:
n : ℕ
p : Prop
n✝ : ℕ
α : TypeVec.{u_1} (succ n✝)
x : α Fin2.fz
⊢ ofRepeat (TypeVec.const p α Fin2.fz x) ↔ p

Next tactic:
case fz      => rfl
theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
  induction i
  case fz      => 

Proof state:
n : ℕ
p : Prop
n✝ : ℕ
α : TypeVec.{u_1} (succ n✝)
x : α Fin2.fz
⊢ ofRepeat (TypeVec.const p α Fin2.fz x) ↔ p

Next tactic:
rfl
theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
  induction i
  case fz      => rfl
  

Proof state:
case fs
n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec.{u_1} n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec.{u_1} (succ n✝)
x : α (Fin2.fs a✝)
⊢ ofRepeat (TypeVec.const p α (Fin2.fs a✝) x) ↔ p

Next tactic:
case fs _ ih => erw [TypeVec.const, @ih (drop α) x]
theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
  induction i
  case fz      => rfl
  

Proof state:
n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
ih : ∀ {α : TypeVec.{u_1} n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec.{u_1} (succ n✝)
x : α (Fin2.fs a✝)
⊢ ofRepeat (TypeVec.const p α (Fin2.fs a✝) x) ↔ p

Next tactic:
case fs _ ih => erw [TypeVec.const, @ih (drop α) x]
theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
  induction i
  case fz      => rfl
  case fs _ ih => 

Proof state:
n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
ih : ∀ {α : TypeVec.{u_1} n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec.{u_1} (succ n✝)
x : α (Fin2.fs a✝)
⊢ ofRepeat (TypeVec.const p α (Fin2.fs a✝) x) ↔ p

Next tactic:
erw [TypeVec.const, @ih (drop α) x]
@[simp]
theorem prod_fst_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
    TypeVec.prod.fst i (prod.mk i a b) = a := by
  

Proof state:
n : ℕ
α β : TypeVec.{u_1} n
i : Fin2 n
a : α i
b : β i
⊢ prod.fst i (prod.mk i a b) = a

Next tactic:
induction' i with _ _ _ i_ih
@[simp]
theorem prod_fst_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
    TypeVec.prod.fst i (prod.mk i a b) = a := by
  induction' i with _ _ _ i_ih
  

Proof state:
case fz
n n✝ : ℕ
α β : TypeVec.{u_1} (succ n✝)
a : α Fin2.fz
b : β Fin2.fz
⊢ prod.fst Fin2.fz (prod.mk Fin2.fz a b) = a
case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.fst a✝ (prod.mk a✝ a b) = a
α β : TypeVec.{u_1} (succ n✝)
a : α (Fin2.fs a✝)
b : β (Fin2.fs a✝)
⊢ prod.fst (Fin2.fs a✝) (prod.mk (Fin2.fs a✝) a b) = a

Next tactic:
simp_all only [prod.fst, prod.mk]
@[simp]
theorem prod_fst_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
    TypeVec.prod.fst i (prod.mk i a b) = a := by
  induction' i with _ _ _ i_ih
  simp_all only [prod.fst, prod.mk]
  

Proof state:
case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.fst a✝ (prod.mk a✝ a b) = a
α β : TypeVec.{u_1} (succ n✝)
a : α (Fin2.fs a✝)
b : β (Fin2.fs a✝)
⊢ prod.fst (Fin2.fs a✝) (prod.mk (Fin2.fs a✝) a b) = a

Next tactic:
apply i_ih
@[simp]
theorem prod_snd_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
    TypeVec.prod.snd i (prod.mk i a b) = b := by
  

Proof state:
n : ℕ
α β : TypeVec.{u_1} n
i : Fin2 n
a : α i
b : β i
⊢ prod.snd i (prod.mk i a b) = b

Next tactic:
induction' i with _ _ _ i_ih
@[simp]
theorem prod_snd_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
    TypeVec.prod.snd i (prod.mk i a b) = b := by
  induction' i with _ _ _ i_ih
  

Proof state:
case fz
n n✝ : ℕ
α β : TypeVec.{u_1} (succ n✝)
a : α Fin2.fz
b : β Fin2.fz
⊢ prod.snd Fin2.fz (prod.mk Fin2.fz a b) = b
case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.snd a✝ (prod.mk a✝ a b) = b
α β : TypeVec.{u_1} (succ n✝)
a : α (Fin2.fs a✝)
b : β (Fin2.fs a✝)
⊢ prod.snd (Fin2.fs a✝) (prod.mk (Fin2.fs a✝) a b) = b

Next tactic:
simp_all [prod.snd, prod.mk]
@[simp]
theorem prod_snd_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
    TypeVec.prod.snd i (prod.mk i a b) = b := by
  induction' i with _ _ _ i_ih
  simp_all [prod.snd, prod.mk]
  

Proof state:
case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.snd a✝ (prod.mk a✝ a b) = b
α β : TypeVec.{u_1} (succ n✝)
a : α (Fin2.fs a✝)
b : β (Fin2.fs a✝)
⊢ prod.snd (Fin2.fs a✝) (prod.mk (Fin2.fs a✝) a b) = b

Next tactic:
apply i_ih
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  

Proof state:
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
⊢ prod.fst ⊚ (f ⊗' g) = f ⊚ prod.fst

Next tactic:
funext i
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  funext i; 

Proof state:
case h
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
i : Fin2 n
⊢ (prod.fst ⊚ (f ⊗' g)) i = (f ⊚ prod.fst) i

Next tactic:
induction i
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  funext i; induction i
  

Proof state:
case h.fz
n n✝ : ℕ
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) Fin2.fz = (f ⊚ prod.fst) Fin2.fz
case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.fst ⊚ (f ⊗' g)) a✝ = (f ⊚ prod.fst) a✝
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) (Fin2.fs a✝) = (f ⊚ prod.fst) (Fin2.fs a✝)

Next tactic:
case fz => rfl
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  funext i; induction i
  

Proof state:
n n✝ : ℕ
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) Fin2.fz = (f ⊚ prod.fst) Fin2.fz

Next tactic:
case fz => rfl
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  funext i; induction i
  case fz => 

Proof state:
n n✝ : ℕ
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) Fin2.fz = (f ⊚ prod.fst) Fin2.fz

Next tactic:
rfl
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  funext i; induction i
  case fz => rfl
  

Proof state:
case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.fst ⊚ (f ⊗' g)) a✝ = (f ⊚ prod.fst) a✝
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) (Fin2.fs a✝) = (f ⊚ prod.fst) (Fin2.fs a✝)

Next tactic:
case fs _ _ i_ih => apply i_ih
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  funext i; induction i
  case fz => rfl
  

Proof state:
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.fst ⊚ (f ⊗' g)) a✝ = (f ⊚ prod.fst) a✝
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) (Fin2.fs a✝) = (f ⊚ prod.fst) (Fin2.fs a✝)

Next tactic:
case fs _ _ i_ih => apply i_ih
theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
  funext i; induction i
  case fz => rfl
  case fs _ _ i_ih => 

Proof state:
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.fst ⊚ (f ⊗' g)) a✝ = (f ⊚ prod.fst) a✝
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) (Fin2.fs a✝) = (f ⊚ prod.fst) (Fin2.fs a✝)

Next tactic:
apply i_ih
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
  

Proof state:
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
⊢ prod.snd ⊚ (f ⊗' g) = g ⊚ prod.snd

Next tactic:
funext i
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
  funext i; 

Proof state:
case h
n : ℕ
α α' β β' : TypeVec.{u_1} n
f : α ⟹ β
g : α' ⟹ β'
i : Fin2 n
⊢ (prod.snd ⊚ (f ⊗' g)) i = (g ⊚ prod.snd) i

Next tactic:
induction i
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
  funext i; induction i
  

Proof state:
case h.fz
n n✝ : ℕ
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) Fin2.fz = (g ⊚ prod.snd) Fin2.fz
case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.snd ⊚ (f ⊗' g)) a✝ = (g ⊚ prod.snd) a✝
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) (Fin2.fs a✝) = (g ⊚ prod.snd) (Fin2.fs a✝)

Next tactic:
case fz => rfl
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
  funext i; induction i
  

Proof state:
n n✝ : ℕ
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) Fin2.fz = (g ⊚ prod.snd) Fin2.fz

Next tactic:
case fz => rfl
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
  funext i; induction i
  case fz => 

Proof state:
n n✝ : ℕ
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) Fin2.fz = (g ⊚ prod.snd) Fin2.fz

Next tactic:
rfl
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
  funext i; induction i
  case fz => rfl
  

Proof state:
case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.snd ⊚ (f ⊗' g)) a✝ = (g ⊚ prod.snd) a✝
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) (Fin2.fs a✝) = (g ⊚ prod.snd) (Fin2.fs a✝)

Next tactic:
case fs _ _ i_ih => apply i_ih
theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
  funext i; induction i
  case fz => rfl
  

Proof state:
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α α' β β' : TypeVec.{u_1} n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.snd ⊚ (f ⊗' g)) a✝ = (g ⊚ prod.snd) a✝
α α' β β' : TypeVec.{u_1} (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.snd ⊚ (f ⊗' g)) (Fin2.fs a✝) = (g ⊚ prod.snd) (Fin2.fs a✝)

Next tactic:
case fs _ _ i_ih => apply i_ih