Theorem: MvQPF.wEquiv_map
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

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

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

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
state_before: case ind
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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 (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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 (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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✝)

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]
state_before: case abs
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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 (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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✝)

tactic: case trans x y z _ _ ih₁ ih₂ => apply MvQPF.WEquiv.trans; apply ih₁; apply ih₂
state_before: case trans
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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✝)

tactic: rw [q.P.w_map_wMk, q.P.w_map_wMk]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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₁)

tactic: apply WEquiv.ind
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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)

tactic: exact ih
state_before: case a
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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)

tactic: rw [q.P.w_map_wMk, q.P.w_map_wMk]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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₁)

tactic: apply WEquiv.abs
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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 (MvPFunctor.wMk (P F) a₀ (g ⊚ f'₀) fun i => g <$$> f₀ i)
    (MvPFunctor.wMk (P F) a₁ (g ⊚ f'₁) fun i => g <$$> f₁ i)

tactic: 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))
state_before: case a
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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₁ }
⊢ abs { fst := a₀, snd := MvPFunctor.appendContents (P F) (g ⊚ f'₀) fun i => g <$$> f₀ i } =
    abs { fst := a₁, snd := MvPFunctor.appendContents (P F) (g ⊚ f'₁) fun i => g <$$> f₁ i }

tactic: rw [← q.P.map_objAppend1, ← q.P.map_objAppend1, abs_map, abs_map, h]
state_before: case a
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec 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₁ }
⊢ abs (MvPFunctor.objAppend1 (P F) a₀ (g ⊚ f'₀) fun x => MvPFunctor.wMap (P F) g (f₀ x)) =
    abs (MvPFunctor.objAppend1 (P F) a₁ (g ⊚ f'₁) fun x => MvPFunctor.wMap (P F) g (f₁ x))

tactic: apply MvQPF.WEquiv.trans
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec n
g : α ⟹ β
x✝ y✝ x y z : MvPFunctor.W (P F) α
a✝¹ : WEquiv x y
a✝ : WEquiv y z
ih₁ : WEquiv (g <$$> x) (g <$$> y)
ih₂ : WEquiv (g <$$> y) (g <$$> z)
⊢ WEquiv (g <$$> x) (g <$$> z)

tactic: apply ih₁
state_before: case a
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec n
g : α ⟹ β
x✝ y✝ x y z : MvPFunctor.W (P F) α
a✝¹ : WEquiv x y
a✝ : WEquiv y z
ih₁ : WEquiv (g <$$> x) (g <$$> y)
ih₂ : WEquiv (g <$$> y) (g <$$> z)
⊢ WEquiv (g <$$> x) ?v

case a
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec n
g : α ⟹ β
x✝ y✝ x y z : MvPFunctor.W (P F) α
a✝¹ : WEquiv x y
a✝ : WEquiv y z
ih₁ : WEquiv (g <$$> x) (g <$$> y)
ih₂ : WEquiv (g <$$> y) (g <$$> z)
⊢ WEquiv ?v (g <$$> z)

case v
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec n
g : α ⟹ β
x✝ y✝ x y z : MvPFunctor.W (P F) α
a✝¹ : WEquiv x y
a✝ : WEquiv y z
ih₁ : WEquiv (g <$$> x) (g <$$> y)
ih₂ : WEquiv (g <$$> y) (g <$$> z)
⊢ MvPFunctor.W (P F) β

tactic: apply ih₂
state_before: case a
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α β : TypeVec n
g : α ⟹ β
x✝ y✝ x y z : MvPFunctor.W (P F) α
a✝¹ : WEquiv x y
a✝ : WEquiv y z
ih₁ : WEquiv (g <$$> x) (g <$$> y)
ih₂ : WEquiv (g <$$> y) (g <$$> z)
⊢ WEquiv (g <$$> y) (g <$$> z)