l3lab/ntp-mathlib huggingface dataset:
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
h : WEquiv x y
⊢ WEquiv y x

Next tactic:
induction h
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  

Proof state:
case ind
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
a✝¹ : (P F).A
f'✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a✝¹ ⟹ α
f₀✝ f₁✝ : PFunctor.B (MvPFunctor.last (P F)) a✝¹ → MvPFunctor.W (P F) α
a✝ : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a✝¹), WEquiv (f₀✝ x) (f₁✝ x)
a_ih✝ : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a✝¹), WEquiv (f₁✝ x) (f₀✝ x)
⊢ WEquiv (MvPFunctor.wMk (P F) a✝¹ f'✝ f₁✝) (MvPFunctor.wMk (P F) a✝¹ f'✝ f₀✝)
case abs
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
a₀✝ : (P F).A
f'₀✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀✝ ⟹ α
f₀✝ : PFunctor.B (MvPFunctor.last (P F)) a₀✝ → MvPFunctor.W (P F) α
a₁✝ : (P F).A
f'₁✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁✝ ⟹ α
f₁✝ : PFunctor.B (MvPFunctor.last (P F)) a₁✝ → MvPFunctor.W (P F) α
a✝ :
  abs { fst := a₀✝, snd := MvPFunctor.appendContents (P F) f'₀✝ f₀✝ } =
    abs { fst := a₁✝, snd := MvPFunctor.appendContents (P F) f'₁✝ f₁✝ }
⊢ WEquiv (MvPFunctor.wMk (P F) a₁✝ f'₁✝ f₁✝) (MvPFunctor.wMk (P F) a₀✝ f'₀✝ f₀✝)
case trans
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y u✝ v✝ w✝ : MvPFunctor.W (P F) α
a✝¹ : WEquiv u✝ v✝
a✝ : WEquiv v✝ w✝
a_ih✝¹ : WEquiv v✝ u✝
a_ih✝ : WEquiv w✝ v✝
⊢ WEquiv w✝ u✝

Next tactic:
case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f₀ f₁ : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
_h : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₀ x) (f₁ x)
ih : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₁ x) (f₀ x)
⊢ WEquiv (MvPFunctor.wMk (P F) a f' f₁) (MvPFunctor.wMk (P F) a f' f₀)

Next tactic:
case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  case ind a f' f₀ f₁ _h ih => 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f₀ f₁ : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
_h : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₀ x) (f₁ x)
ih : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₁ x) (f₀ x)
⊢ WEquiv (MvPFunctor.wMk (P F) a f' f₁) (MvPFunctor.wMk (P F) a f' f₀)

Next tactic:
exact WEquiv.ind _ _ _ _ ih
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
  

Proof state:
case abs
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
a₀✝ : (P F).A
f'₀✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀✝ ⟹ α
f₀✝ : PFunctor.B (MvPFunctor.last (P F)) a₀✝ → MvPFunctor.W (P F) α
a₁✝ : (P F).A
f'₁✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁✝ ⟹ α
f₁✝ : PFunctor.B (MvPFunctor.last (P F)) a₁✝ → MvPFunctor.W (P F) α
a✝ :
  abs { fst := a₀✝, snd := MvPFunctor.appendContents (P F) f'₀✝ f₀✝ } =
    abs { fst := a₁✝, snd := MvPFunctor.appendContents (P F) f'₁✝ f₁✝ }
⊢ WEquiv (MvPFunctor.wMk (P F) a₁✝ f'₁✝ f₁✝) (MvPFunctor.wMk (P F) a₀✝ f'₀✝ f₀✝)
case trans
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y u✝ v✝ w✝ : MvPFunctor.W (P F) α
a✝¹ : WEquiv u✝ v✝
a✝ : WEquiv v✝ w✝
a_ih✝¹ : WEquiv v✝ u✝
a_ih✝ : WEquiv w✝ v✝
⊢ WEquiv w✝ u✝

Next tactic:
case abs a₀ f'₀ f₀ a₁ f'₁ f₁ h => exact WEquiv.abs _ _ _ _ _ _ h.symm
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
a₀ : (P F).A
f'₀ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀ ⟹ α
f₀ : PFunctor.B (MvPFunctor.last (P F)) a₀ → MvPFunctor.W (P F) α
a₁ : (P F).A
f'₁ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁ ⟹ α
f₁ : PFunctor.B (MvPFunctor.last (P F)) a₁ → MvPFunctor.W (P F) α
h :
  abs { fst := a₀, snd := MvPFunctor.appendContents (P F) f'₀ f₀ } =
    abs { fst := a₁, snd := MvPFunctor.appendContents (P F) f'₁ f₁ }
⊢ WEquiv (MvPFunctor.wMk (P F) a₁ f'₁ f₁) (MvPFunctor.wMk (P F) a₀ f'₀ f₀)

Next tactic:
case abs a₀ f'₀ f₀ a₁ f'₁ f₁ h => exact WEquiv.abs _ _ _ _ _ _ h.symm
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
  case abs a₀ f'₀ f₀ a₁ f'₁ f₁ h => 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y : MvPFunctor.W (P F) α
a₀ : (P F).A
f'₀ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀ ⟹ α
f₀ : PFunctor.B (MvPFunctor.last (P F)) a₀ → MvPFunctor.W (P F) α
a₁ : (P F).A
f'₁ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁ ⟹ α
f₁ : PFunctor.B (MvPFunctor.last (P F)) a₁ → MvPFunctor.W (P F) α
h :
  abs { fst := a₀, snd := MvPFunctor.appendContents (P F) f'₀ f₀ } =
    abs { fst := a₁, snd := MvPFunctor.appendContents (P F) f'₁ f₁ }
⊢ WEquiv (MvPFunctor.wMk (P F) a₁ f'₁ f₁) (MvPFunctor.wMk (P F) a₀ f'₀ f₀)

Next tactic:
exact WEquiv.abs _ _ _ _ _ _ h.symm
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
  case abs a₀ f'₀ f₀ a₁ f'₁ f₁ h => exact WEquiv.abs _ _ _ _ _ _ h.symm
  

Proof state:
case trans
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x y u✝ v✝ w✝ : MvPFunctor.W (P F) α
a✝¹ : WEquiv u✝ v✝
a✝ : WEquiv v✝ w✝
a_ih✝¹ : WEquiv v✝ u✝
a_ih✝ : WEquiv w✝ v✝
⊢ WEquiv w✝ u✝

Next tactic:
case trans x y z _e₁ _e₂ ih₁ ih₂ => exact MvQPF.WEquiv.trans _ _ _ ih₂ ih₁
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
  case abs a₀ f'₀ f₀ a₁ f'₁ f₁ h => exact WEquiv.abs _ _ _ _ _ _ h.symm
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x✝ y✝ x y z : MvPFunctor.W (P F) α
_e₁ : WEquiv x y
_e₂ : WEquiv y z
ih₁ : WEquiv y x
ih₂ : WEquiv z y
⊢ WEquiv z x

Next tactic:
case trans x y z _e₁ _e₂ ih₁ ih₂ => exact MvQPF.WEquiv.trans _ _ _ ih₂ ih₁
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x := by
  intro h; induction h
  case ind a f' f₀ f₁ _h ih => exact WEquiv.ind _ _ _ _ ih
  case abs a₀ f'₀ f₀ a₁ f'₁ f₁ h => exact WEquiv.abs _ _ _ _ _ _ h.symm
  case trans x y z _e₁ _e₂ ih₁ ih₂ => 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x✝ y✝ x y z : MvPFunctor.W (P F) α
_e₁ : WEquiv x y
_e₂ : WEquiv y z
ih₁ : WEquiv y x
ih₂ : WEquiv z y
⊢ WEquiv z x

Next tactic:
exact MvQPF.WEquiv.trans _ _ _ ih₂ ih₁
theorem wrepr_wMk {α : TypeVec n} (a : q.P.A) (f' : q.P.drop.B a ⟹ α)
    (f : q.P.last.B a → q.P.W α) :
    wrepr (q.P.wMk a f' f) =
      q.P.wMk' (repr (abs (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))) :=
  by 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
⊢ wrepr (MvPFunctor.wMk (P F) a f' f) =
    MvPFunctor.wMk' (P F)
      (repr (abs ((TypeVec.id ::: wrepr) <$$> { fst := a, snd := MvPFunctor.appendContents (P F) f' f })))

Next tactic:
rw [wrepr, recF_eq', q.P.wDest'_wMk]
theorem wrepr_wMk {α : TypeVec n} (a : q.P.A) (f' : q.P.drop.B a ⟹ α)
    (f : q.P.last.B a → q.P.W α) :
    wrepr (q.P.wMk a f' f) =
      q.P.wMk' (repr (abs (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))) :=
  by rw [wrepr, recF_eq', q.P.wDest'_wMk]; 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
⊢ (MvPFunctor.wMk' (P F) ∘ repr)
      (abs ((TypeVec.id ::: recF (MvPFunctor.wMk' (P F) ∘ repr)) <$$> { fst := a, snd := splitFun f' f })) =
    MvPFunctor.wMk' (P F)
      (repr
        (abs
          ((TypeVec.id ::: recF (MvPFunctor.wMk' (P F) ∘ repr)) <$$>
            { fst := a, snd := MvPFunctor.appendContents (P F) f' f })))

Next tactic:
rfl
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
⊢ WEquiv (wrepr x) x

Next tactic:
apply q.P.w_ind _ x
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  apply q.P.w_ind _ x; 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
⊢ ∀ (a : (P F).A) (f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α)
    (f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α),
    (∀ (i : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (wrepr (f i)) (f i)) →
      WEquiv (wrepr (MvPFunctor.wMk (P F) a f' f)) (MvPFunctor.wMk (P F) a f' f)

Next tactic:
intro a f' f ih
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  apply q.P.w_ind _ x; intro a f' f ih
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
ih : ∀ (i : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (wrepr (f i)) (f i)
⊢ WEquiv (wrepr (MvPFunctor.wMk (P F) a f' f)) (MvPFunctor.wMk (P F) a f' f)

Next tactic:
apply WEquiv.trans _ (q.P.wMk' (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  apply q.P.w_ind _ x; intro a f' f ih
  apply WEquiv.trans _ (q.P.wMk' (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))
  · 

Proof state:
case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
ih : ∀ (i : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (wrepr (f i)) (f i)
⊢ WEquiv (wrepr (MvPFunctor.wMk (P F) a f' f))
    (MvPFunctor.wMk' (P F) ((TypeVec.id ::: wrepr) <$$> { fst := a, snd := MvPFunctor.appendContents (P F) f' f }))

Next tactic:
apply wEquiv.abs'
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  apply q.P.w_ind _ x; intro a f' f ih
  apply WEquiv.trans _ (q.P.wMk' (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))
  · apply wEquiv.abs'
    

Proof state:
case a.h
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
ih : ∀ (i : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (wrepr (f i)) (f i)
⊢ abs (MvPFunctor.wDest' (P F) (wrepr (MvPFunctor.wMk (P F) a f' f))) =
    abs
      (MvPFunctor.wDest' (P F)
        (MvPFunctor.wMk' (P F) ((TypeVec.id ::: wrepr) <$$> { fst := a, snd := MvPFunctor.appendContents (P F) f' f })))

Next tactic:
rw [wrepr_wMk, q.P.wDest'_wMk', q.P.wDest'_wMk', abs_repr]
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  apply q.P.w_ind _ x; intro a f' f ih
  apply WEquiv.trans _ (q.P.wMk' (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))
  · apply wEquiv.abs'
    rw [wrepr_wMk, q.P.wDest'_wMk', q.P.wDest'_wMk', abs_repr]
  

Proof state:
case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
ih : ∀ (i : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (wrepr (f i)) (f i)
⊢ WEquiv (MvPFunctor.wMk' (P F) ((TypeVec.id ::: wrepr) <$$> { fst := a, snd := MvPFunctor.appendContents (P F) f' f }))
    (MvPFunctor.wMk (P F) a f' f)

Next tactic:
rw [q.P.map_eq, MvPFunctor.wMk', appendFun_comp_splitFun, id_comp]
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  apply q.P.w_ind _ x; intro a f' f ih
  apply WEquiv.trans _ (q.P.wMk' (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))
  · apply wEquiv.abs'
    rw [wrepr_wMk, q.P.wDest'_wMk', q.P.wDest'_wMk', abs_repr]
  rw [q.P.map_eq, MvPFunctor.wMk', appendFun_comp_splitFun, id_comp]
  

Proof state:
case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
ih : ∀ (i : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (wrepr (f i)) (f i)
⊢ WEquiv
    (match { fst := a, snd := splitFun f' (wrepr ∘ f) } with
    | { fst := a, snd := f } => MvPFunctor.wMk (P F) a (dropFun f) (lastFun f))
    (MvPFunctor.wMk (P F) a f' f)

Next tactic:
apply WEquiv.ind
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x := by
  apply q.P.w_ind _ x; intro a f' f ih
  apply WEquiv.trans _ (q.P.wMk' (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))
  · apply wEquiv.abs'
    rw [wrepr_wMk, q.P.wDest'_wMk', q.P.wDest'_wMk', abs_repr]
  rw [q.P.map_eq, MvPFunctor.wMk', appendFun_comp_splitFun, id_comp]
  apply WEquiv.ind; 

Proof state:
case a.a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec.{u} n
x : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
ih : ∀ (i : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (wrepr (f i)) (f i)
⊢ ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (lastFun (splitFun f' (wrepr ∘ f)) x) (f x)

Next tactic:
exact ih
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
⊢ WEquiv x y → WEquiv (g <$$> x) (g <$$> y)

Next tactic:
intro h
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
h : WEquiv x y
⊢ WEquiv (g <$$> x) (g <$$> y)

Next tactic:
induction h
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  

Proof state:
case ind
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a✝¹ : (P F).A
f'✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a✝¹ ⟹ α
f₀✝ f₁✝ : PFunctor.B (MvPFunctor.last (P F)) a✝¹ → MvPFunctor.W (P F) α
a✝ : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a✝¹), WEquiv (f₀✝ x) (f₁✝ x)
a_ih✝ : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a✝¹), WEquiv (g <$$> f₀✝ x) (g <$$> f₁✝ x)
⊢ WEquiv (g <$$> MvPFunctor.wMk (P F) a✝¹ f'✝ f₀✝) (g <$$> MvPFunctor.wMk (P F) a✝¹ f'✝ f₁✝)
case abs
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a₀✝ : (P F).A
f'₀✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀✝ ⟹ α
f₀✝ : PFunctor.B (MvPFunctor.last (P F)) a₀✝ → MvPFunctor.W (P F) α
a₁✝ : (P F).A
f'₁✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁✝ ⟹ α
f₁✝ : PFunctor.B (MvPFunctor.last (P F)) a₁✝ → MvPFunctor.W (P F) α
a✝ :
  abs { fst := a₀✝, snd := MvPFunctor.appendContents (P F) f'₀✝ f₀✝ } =
    abs { fst := a₁✝, snd := MvPFunctor.appendContents (P F) f'₁✝ f₁✝ }
⊢ WEquiv (g <$$> MvPFunctor.wMk (P F) a₀✝ f'₀✝ f₀✝) (g <$$> MvPFunctor.wMk (P F) a₁✝ f'₁✝ f₁✝)
case trans
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y u✝ v✝ w✝ : MvPFunctor.W (P F) α
a✝¹ : WEquiv u✝ v✝
a✝ : WEquiv v✝ w✝
a_ih✝¹ : WEquiv (g <$$> u✝) (g <$$> v✝)
a_ih✝ : WEquiv (g <$$> v✝) (g <$$> w✝)
⊢ WEquiv (g <$$> u✝) (g <$$> w✝)

Next tactic:
case ind a f' f₀ f₁ h ih => rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.ind; exact ih
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f₀ f₁ : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
h : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₀ x) (f₁ x)
ih : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (g <$$> f₀ x) (g <$$> f₁ x)
⊢ WEquiv (g <$$> MvPFunctor.wMk (P F) a f' f₀) (g <$$> MvPFunctor.wMk (P F) a f' f₁)

Next tactic:
case ind a f' f₀ f₁ h ih => rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.ind; exact ih
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  case ind a f' f₀ f₁ h ih => 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f₀ f₁ : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
h : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₀ x) (f₁ x)
ih : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (g <$$> f₀ x) (g <$$> f₁ x)
⊢ WEquiv (g <$$> MvPFunctor.wMk (P F) a f' f₀) (g <$$> MvPFunctor.wMk (P F) a f' f₁)

Next tactic:
rw [q.P.w_map_wMk, q.P.w_map_wMk]
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  case ind a f' f₀ f₁ h ih => rw [q.P.w_map_wMk, q.P.w_map_wMk]; 

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f₀ f₁ : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
h : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₀ x) (f₁ x)
ih : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (g <$$> f₀ x) (g <$$> f₁ x)
⊢ WEquiv (MvPFunctor.wMk (P F) a (g ⊚ f') fun i => g <$$> f₀ i) (MvPFunctor.wMk (P F) a (g ⊚ f') fun i => g <$$> f₁ i)

Next tactic:
apply WEquiv.ind
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  case ind a f' f₀ f₁ h ih => rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.ind; 

Proof state:
case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a : (P F).A
f' : MvPFunctor.B (MvPFunctor.drop (P F)) a ⟹ α
f₀ f₁ : PFunctor.B (MvPFunctor.last (P F)) a → MvPFunctor.W (P F) α
h : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (f₀ x) (f₁ x)
ih : ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (g <$$> f₀ x) (g <$$> f₁ x)
⊢ ∀ (x : PFunctor.B (MvPFunctor.last (P F)) a), WEquiv (g <$$> f₀ x) (g <$$> f₁ x)

Next tactic:
exact ih
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  case ind a f' f₀ f₁ h ih => rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.ind; exact ih
  

Proof state:
case abs
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a₀✝ : (P F).A
f'₀✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀✝ ⟹ α
f₀✝ : PFunctor.B (MvPFunctor.last (P F)) a₀✝ → MvPFunctor.W (P F) α
a₁✝ : (P F).A
f'₁✝ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁✝ ⟹ α
f₁✝ : PFunctor.B (MvPFunctor.last (P F)) a₁✝ → MvPFunctor.W (P F) α
a✝ :
  abs { fst := a₀✝, snd := MvPFunctor.appendContents (P F) f'₀✝ f₀✝ } =
    abs { fst := a₁✝, snd := MvPFunctor.appendContents (P F) f'₁✝ f₁✝ }
⊢ WEquiv (g <$$> MvPFunctor.wMk (P F) a₀✝ f'₀✝ f₀✝) (g <$$> MvPFunctor.wMk (P F) a₁✝ f'₁✝ f₁✝)
case trans
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y u✝ v✝ w✝ : MvPFunctor.W (P F) α
a✝¹ : WEquiv u✝ v✝
a✝ : WEquiv v✝ w✝
a_ih✝¹ : WEquiv (g <$$> u✝) (g <$$> v✝)
a_ih✝ : WEquiv (g <$$> v✝) (g <$$> w✝)
⊢ WEquiv (g <$$> u✝) (g <$$> w✝)

Next tactic:
case
    abs a₀ f'₀ f₀ a₁ f'₁ f₁ h =>
    rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.abs
    show
      abs (q.P.objAppend1 a₀ (g ⊚ f'₀) fun x => q.P.wMap g (f₀ x)) =
        abs (q.P.objAppend1 a₁ (g ⊚ f'₁) fun x => q.P.wMap g (f₁ x))
    rw [← q.P.map_objAppend1, ← q.P.map_objAppend1, abs_map, abs_map, h]
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  case ind a f' f₀ f₁ h ih => rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.ind; exact ih
  

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a₀ : (P F).A
f'₀ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀ ⟹ α
f₀ : PFunctor.B (MvPFunctor.last (P F)) a₀ → MvPFunctor.W (P F) α
a₁ : (P F).A
f'₁ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁ ⟹ α
f₁ : PFunctor.B (MvPFunctor.last (P F)) a₁ → MvPFunctor.W (P F) α
h :
  abs { fst := a₀, snd := MvPFunctor.appendContents (P F) f'₀ f₀ } =
    abs { fst := a₁, snd := MvPFunctor.appendContents (P F) f'₁ f₁ }
⊢ WEquiv (g <$$> MvPFunctor.wMk (P F) a₀ f'₀ f₀) (g <$$> MvPFunctor.wMk (P F) a₁ f'₁ f₁)

Next tactic:
case
    abs a₀ f'₀ f₀ a₁ f'₁ f₁ h =>
    rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.abs
    show
      abs (q.P.objAppend1 a₀ (g ⊚ f'₀) fun x => q.P.wMap g (f₀ x)) =
        abs (q.P.objAppend1 a₁ (g ⊚ f'₁) fun x => q.P.wMap g (f₁ x))
    rw [← q.P.map_objAppend1, ← q.P.map_objAppend1, abs_map, abs_map, h]
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) := by
  intro h; induction h
  case ind a f' f₀ f₁ h ih => rw [q.P.w_map_wMk, q.P.w_map_wMk]; apply WEquiv.ind; exact ih
  case
    abs a₀ f'₀ f₀ a₁ f'₁ f₁ h =>
    

Proof state:
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec.{u} n
g : α ⟹ β
x y : MvPFunctor.W (P F) α
a₀ : (P F).A
f'₀ : MvPFunctor.B (MvPFunctor.drop (P F)) a₀ ⟹ α
f₀ : PFunctor.B (MvPFunctor.last (P F)) a₀ → MvPFunctor.W (P F) α
a₁ : (P F).A
f'₁ : MvPFunctor.B (MvPFunctor.drop (P F)) a₁ ⟹ α
f₁ : PFunctor.B (MvPFunctor.last (P F)) a₁ → MvPFunctor.W (P F) α
h :
  abs { fst := a₀, snd := MvPFunctor.appendContents (P F) f'₀ f₀ } =
    abs { fst := a₁, snd := MvPFunctor.appendContents (P F) f'₁ f₁ }
⊢ WEquiv (g <$$> MvPFunctor.wMk (P F) a₀ f'₀ f₀) (g <$$> MvPFunctor.wMk (P F) a₁ f'₁ f₁)

Next tactic:
rw [q.P.w_map_wMk, q.P.w_map_wMk]