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

tactic: have : Fix.mk (abs ⟨a, q.P.appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr (q.P.wMk a f' f)⟧ := by
  apply Quot.sound; apply wEquiv.abs'
  rw [MvPFunctor.wDest'_wMk', abs_map, abs_repr, ← abs_map, MvPFunctor.map_eq]
  conv =>
    rhs
    rw [wrepr_wMk, q.P.wDest'_wMk', abs_repr, MvPFunctor.map_eq]
  congr 2; rw [MvPFunctor.appendContents, MvPFunctor.appendContents]
  rw [appendFun, appendFun, ← splitFun_comp, ← splitFun_comp]
  rfl
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦(P F).wMk a f' f⟧
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
this : mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr ((P F).wMk a f' f)⟧
⊢ mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦(P F).wMk a f' f⟧

tactic: rw [this]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
this : mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr ((P F).wMk a f' f)⟧
⊢ mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦(P F).wMk a f' f⟧
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
this : mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr ((P F).wMk a f' f)⟧
⊢ ⟦wrepr ((P F).wMk a f' f)⟧ = ⟦(P F).wMk a f' f⟧

tactic: apply Quot.sound
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
this : mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr ((P F).wMk a f' f)⟧
⊢ ⟦wrepr ((P F).wMk a f' f)⟧ = ⟦(P F).wMk a f' f⟧
state_after: case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
this : mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr ((P F).wMk a f' f)⟧
⊢ Setoid.r (wrepr ((P F).wMk a f' f)) ((P F).wMk a f' f)

tactic: apply wrepr_equiv
state_before: case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
this : mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr ((P F).wMk a f' f)⟧
⊢ Setoid.r (wrepr ((P F).wMk a f' f)) ((P F).wMk a f' f)
state_after: no goals

tactic: apply Quot.sound
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ mk (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦wrepr ((P F).wMk a f' f)⟧
state_after: case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ Setoid.r ((P F).wMk' ((TypeVec.id ::: fixToW) <$$> repr (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩)))
    (wrepr ((P F).wMk a f' f))

tactic: apply wEquiv.abs'
state_before: case a
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ Setoid.r ((P F).wMk' ((TypeVec.id ::: fixToW) <$$> repr (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩)))
    (wrepr ((P F).wMk a f' f))
state_after: case a.h
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ abs
      ((P F).wDest'
        ((P F).wMk' ((TypeVec.id ::: fixToW) <$$> repr (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩)))) =
    abs ((P F).wDest' (wrepr ((P F).wMk a f' f)))

tactic: rw [MvPFunctor.wDest'_wMk', abs_map, abs_repr, ← abs_map, MvPFunctor.map_eq]
state_before: case a.h
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ abs
      ((P F).wDest'
        ((P F).wMk' ((TypeVec.id ::: fixToW) <$$> repr (abs ⟨a, (P F).appendContents f' fun x => ⟦f x⟧⟩)))) =
    abs ((P F).wDest' (wrepr ((P F).wMk a f' f)))
state_after: case a.h
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ abs ⟨a, (TypeVec.id ::: fixToW) ⊚ (P F).appendContents f' fun x => ⟦f x⟧⟩ =
    abs ((P F).wDest' (wrepr ((P F).wMk a f' f)))

tactic: conv =>
  rhs
  rw [wrepr_wMk, q.P.wDest'_wMk', abs_repr, MvPFunctor.map_eq]
state_before: case a.h
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ abs ⟨a, (TypeVec.id ::: fixToW) ⊚ (P F).appendContents f' fun x => ⟦f x⟧⟩ =
    abs ((P F).wDest' (wrepr ((P F).wMk a f' f)))
state_after: case a.h
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ abs ⟨a, (TypeVec.id ::: fixToW) ⊚ (P F).appendContents f' fun x => ⟦f x⟧⟩ =
    abs ⟨a, (TypeVec.id ::: wrepr) ⊚ (P F).appendContents f' f⟩

tactic: congr 2
state_before: case a.h
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ abs ⟨a, (TypeVec.id ::: fixToW) ⊚ (P F).appendContents f' fun x => ⟦f x⟧⟩ =
    abs ⟨a, (TypeVec.id ::: wrepr) ⊚ (P F).appendContents f' f⟩
state_after: case a.h.e_a.e_snd
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ ((TypeVec.id ::: fixToW) ⊚ (P F).appendContents f' fun x => ⟦f x⟧) =
    (TypeVec.id ::: wrepr) ⊚ (P F).appendContents f' f

tactic: rw [MvPFunctor.appendContents, MvPFunctor.appendContents]
state_before: case a.h.e_a.e_snd
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ ((TypeVec.id ::: fixToW) ⊚ (P F).appendContents f' fun x => ⟦f x⟧) =
    (TypeVec.id ::: wrepr) ⊚ (P F).appendContents f' f
state_after: case a.h.e_a.e_snd
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ ((TypeVec.id ::: fixToW) ⊚ splitFun f' fun x => ⟦f x⟧) = (TypeVec.id ::: wrepr) ⊚ splitFun f' f

tactic: rw [appendFun, appendFun, ← splitFun_comp, ← splitFun_comp]
state_before: case a.h.e_a.e_snd
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ ((TypeVec.id ::: fixToW) ⊚ splitFun f' fun x => ⟦f x⟧) = (TypeVec.id ::: wrepr) ⊚ splitFun f' f
state_after: case a.h.e_a.e_snd
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ splitFun (TypeVec.id ⊚ f') (fixToW ∘ fun x => ⟦f x⟧) = splitFun (TypeVec.id ⊚ f') (wrepr ∘ f)

tactic: rfl
state_before: case a.h.e_a.e_snd
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
a : (P F).A
f' : (P F).drop.B a ⟹ α
f : (P F).last.B a → (P F).W α
⊢ splitFun (TypeVec.id ⊚ f') (fixToW ∘ fun x => ⟦f x⟧) = splitFun (TypeVec.id ⊚ f') (wrepr ∘ f)
state_after: no goals