Theorem: MvPFunctor.w_map_wMk
File: Mathlib/Data/PFunctor/Multivariate/W.lean

tactic: show _ = P.wMk a (g ⊚ f') (MvFunctor.map g ∘ f)
state_before: n : ℕ
P : MvPFunctor (n + 1)
α β : TypeVec n
g : α ⟹ β
a : P.A
f' : B (drop P) a ⟹ α
f : PFunctor.B (last P) a → W P α
⊢ g <$$> wMk P a f' f = wMk P a (g ⊚ f') fun i => g <$$> f i

tactic: have : MvFunctor.map g ∘ f = fun i => ⟨(f i).fst, g ⊚ (f i).snd⟩ := by
  ext i : 1
  dsimp [Function.comp]
  cases f i
  rfl
state_before: n : ℕ
P : MvPFunctor (n + 1)
α β : TypeVec n
g : α ⟹ β
a : P.A
f' : B (drop P) a ⟹ α
f : PFunctor.B (last P) a → W P α
⊢ g <$$> wMk P a f' f = wMk P a (g ⊚ f') (MvFunctor.map g ∘ f)

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

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

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

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

tactic: rw [wMk_eq, wMk_eq]
state_before: n : ℕ
P : MvPFunctor (n + 1)
α β : TypeVec n
g : α ⟹ β
a : P.A
f' : B (drop P) a ⟹ α
f : PFunctor.B (last P) a → W P α
this✝ : MvFunctor.map g ∘ f = fun i => { fst := (f i).fst, snd := g ⊚ (f i).snd }
this : f = fun i => { fst := (f i).fst, snd := (f i).snd }
⊢ (g <$$> wMk P a f' fun i => { fst := (f i).fst, snd := (f i).snd }) =
    wMk P a (g ⊚ f') fun i => { fst := (f i).fst, snd := g ⊚ (f i).snd }

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

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

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

tactic: dsimp [Function.comp]
state_before: case h
n : ℕ
P : MvPFunctor (n + 1)
α β : TypeVec n
g : α ⟹ β
a : P.A
f' : B (drop P) a ⟹ α
f : PFunctor.B (last P) a → W P α
i : PFunctor.B (last P) a
⊢ (MvFunctor.map g ∘ f) i = { fst := (f i).fst, snd := g ⊚ (f i).snd }

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

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

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

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

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