-- Mathlib/Data/PFunctor/Multivariate/W.lean
theorem w_map_wMk {α β : TypeVec n} (g : α ⟹ β) (a : P.A) (f' : P.drop.B a ⟹ α)
    (f : P.last.B a → P.W α) : g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') fun i => g <$$> f i

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this✝ : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
this : f = fun i => ⟨(f i).fst, (f i).snd⟩
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩

Tactic:
rw [this]

Result:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this✝ : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
this : f = fun i => ⟨(f i).fst, (f i).snd⟩
⊢ (g <$$> P.wMk a f' fun i => ⟨(f i).fst, (f i).snd⟩) =
    P.wMk a (g ⊚ f') fun i => ⟨((fun i => ⟨(f i).fst, (f i).snd⟩) i).fst, g ⊚ ((fun i => ⟨(f i).fst, (f i).snd⟩) i).snd⟩

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this✝ : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
this : f = fun i => ⟨(f i).fst, (f i).snd⟩
⊢ (g <$$> P.wMk a f' fun i => ⟨(f i).fst, (f i).snd⟩) = P.wMk a (g ⊚ f') fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩

Tactic:
rw [wMk_eq, wMk_eq]

Result:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this✝ : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
this : f = fun i => ⟨(f i).fst, (f i).snd⟩
⊢ g <$$> ⟨WType.mk a fun i => (f i).fst, P.wPathCasesOn f' fun i => (f i).snd⟩ =
    ⟨WType.mk a fun i => (f i).fst, P.wPathCasesOn (g ⊚ f') fun i => g ⊚ (f i).snd⟩

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
⊢ MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩

Tactic:
ext i : 1

Result:
case h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
i : P.last.B a
⊢ (MvFunctor.map g ∘ f) i = ⟨(f i).fst, g ⊚ (f i).snd⟩

Proof state:
case h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
i : P.last.B a
⊢ g <$$> f i = ⟨(f i).fst, g ⊚ (f i).snd⟩

Tactic:
cases f i

Result:
case h.mk
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
i : P.last.B a
fst✝ : P.wp.A
snd✝ : P.wp.B fst✝ ⟹ α
⊢ g <$$> ⟨fst✝, snd✝⟩ = ⟨⟨fst✝, snd✝⟩.fst, g ⊚ ⟨fst✝, snd✝⟩.snd⟩

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this✝ : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
this : f = fun i => ⟨(f i).fst, (f i).snd⟩
h : ∀ (a : P.wp.A) (f : P.wp.B a ⟹ α), g <$$> ⟨a, f⟩ = ⟨a, g ⊚ f⟩
⊢ g <$$> ⟨WType.mk a fun i => (f i).fst, P.wPathCasesOn f' fun i => (f i).snd⟩ =
    ⟨WType.mk a fun i => (f i).fst, P.wPathCasesOn (g ⊚ f') fun i => g ⊚ (f i).snd⟩

Tactic:
rw [h, comp_wPathCasesOn]

Result:
no goals

Proof state:
case h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
x : P.last.B a
⊢ f x = ⟨(f x).fst, (f x).snd⟩

Tactic:
cases f x

Result:
case h.mk
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
x : P.last.B a
fst✝ : P.wp.A
snd✝ : P.wp.B fst✝ ⟹ α
⊢ ⟨fst✝, snd✝⟩ = ⟨⟨fst✝, snd✝⟩.fst, ⟨fst✝, snd✝⟩.snd⟩

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') (MvFunctor.map g ∘ f)

Tactic:
have : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩ := by
  ext i : 1
  dsimp [Function.comp_def]
  cases f i
  rfl

Result:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') (MvFunctor.map g ∘ f)

Proof state:
case h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
i : P.last.B a
⊢ (MvFunctor.map g ∘ f) i = ⟨(f i).fst, g ⊚ (f i).snd⟩

Tactic:
dsimp [Function.comp_def]

Result:
case h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
i : P.last.B a
⊢ g <$$> f i = ⟨(f i).fst, g ⊚ (f i).snd⟩

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
⊢ f = fun i => ⟨(f i).fst, (f i).snd⟩

Tactic:
ext1 x

Result:
case h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
x : P.last.B a
⊢ f x = ⟨(f x).fst, (f x).snd⟩

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩

Tactic:
have : f = fun i => ⟨(f i).fst, (f i).snd⟩ := by
  ext1 x
  cases f x
  rfl

Result:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this✝ : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
this : f = fun i => ⟨(f i).fst, (f i).snd⟩
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩

Proof state:
case h.mk
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
x : P.last.B a
fst✝ : P.wp.A
snd✝ : P.wp.B fst✝ ⟹ α
⊢ ⟨fst✝, snd✝⟩ = ⟨⟨fst✝, snd✝⟩.fst, ⟨fst✝, snd✝⟩.snd⟩

Tactic:
rfl

Result:
no goals

Proof state:
case h.mk
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
i : P.last.B a
fst✝ : P.wp.A
snd✝ : P.wp.B fst✝ ⟹ α
⊢ g <$$> ⟨fst✝, snd✝⟩ = ⟨⟨fst✝, snd✝⟩.fst, g ⊚ ⟨fst✝, snd✝⟩.snd⟩

Tactic:
rfl

Result:
no goals

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') (MvFunctor.map g ∘ f)

Tactic:
rw [this]

Result:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
this : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩

Proof state:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') fun i => g <$$> f i

Tactic:
show _ = P.wMk a (g ⊚ f') (MvFunctor.map g ∘ f)

Result:
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ⟹ β
a : P.A
f' : P.drop.B a ⟹ α
f : P.last.B a → P.W α
⊢ g <$$> P.wMk a f' f = P.wMk a (g ⊚ f') (MvFunctor.map g ∘ f)