data.qpf.multivariate.basic ⟷ Mathlib.Data.QPF.Multivariate.Basic

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -3,7 +3,7 @@ Copyright (c) 2018 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Simon Hudon
 -/
-import Data.Pfunctor.Multivariate.Basic
+import Data.PFunctor.Multivariate.Basic
 
 #align_import data.qpf.multivariate.basic from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -198,7 +198,7 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
   constructor
   · intro h
     have : liftp (supp x) x := by rw [h]; introv ; exact id
-    rw [liftp_iff] at this ; rcases this with ⟨a, f, xeq, h'⟩
+    rw [liftp_iff] at this; rcases this with ⟨a, f, xeq, h'⟩
     refine' ⟨a, f, xeq.symm, _⟩
     intro a' f' h''
     rintro hu u ⟨j, h₂, hfi⟩
@@ -295,13 +295,13 @@ theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPP
   by
   constructor <;> intro h
   · rintro α p ⟨a, f⟩
-    have h' := h; rw [supp_preservation_iff_uniform] at h' 
-    dsimp only [supp_preservation, supp] at h 
+    have h' := h; rw [supp_preservation_iff_uniform] at h'
+    dsimp only [supp_preservation, supp] at h
     simp only [liftp_iff_of_is_uniform, supp_eq_of_is_uniform, MvPFunctor.liftP_iff', h',
       image_univ, mem_range, exists_imp]
     constructor <;> intros <;> subst_vars <;> solve_by_elim
   · rintro α ⟨a, f⟩
-    simp only [liftp_preservation] at h 
+    simp only [liftp_preservation] at h
     ext; simp [supp, h]
 #align mvqpf.supp_preservation_iff_liftp_preservation MvQPF.suppPreservation_iff_liftpPreservation
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,7 +3,7 @@ Copyright (c) 2018 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Simon Hudon
 -/
-import Mathbin.Data.Pfunctor.Multivariate.Basic
+import Data.Pfunctor.Multivariate.Basic
 
 #align_import data.qpf.multivariate.basic from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,14 +2,11 @@
 Copyright (c) 2018 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Simon Hudon
-
-! This file was ported from Lean 3 source module data.qpf.multivariate.basic
-! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Pfunctor.Multivariate.Basic
 
+#align_import data.qpf.multivariate.basic from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
+
 /-!
 # Multivariate quotients of polynomial functors.
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -102,8 +102,6 @@ namespace MvQPF
 
 variable {n : ℕ} {F : TypeVec.{u} n → Type _} [MvFunctor F] [q : MvQPF F]
 
-include q
-
 open MvFunctor (Liftp Liftr)
 
 /-!
@@ -111,15 +109,19 @@ open MvFunctor (Liftp Liftr)
 -/
 
 
+#print MvQPF.id_map /-
 protected theorem id_map {α : TypeVec n} (x : F α) : TypeVec.id <$$> x = x := by rw [← abs_repr x];
   cases' repr x with a f; rw [← abs_map]; rfl
 #align mvqpf.id_map MvQPF.id_map
+-/
 
+#print MvQPF.comp_map /-
 @[simp]
 theorem comp_map {α β γ : TypeVec n} (f : α ⟹ β) (g : β ⟹ γ) (x : F α) :
     (g ⊚ f) <$$> x = g <$$> f <$$> x := by rw [← abs_repr x]; cases' repr x with a f;
   rw [← abs_map, ← abs_map, ← abs_map]; rfl
 #align mvqpf.comp_map MvQPF.comp_map
+-/
 
 #print MvQPF.lawfulMvFunctor /-
 instance (priority := 100) lawfulMvFunctor : LawfulMvFunctor F
@@ -129,6 +131,7 @@ instance (priority := 100) lawfulMvFunctor : LawfulMvFunctor F
 #align mvqpf.is_lawful_mvfunctor MvQPF.lawfulMvFunctor
 -/
 
+#print MvQPF.liftP_iff /-
 -- Lifting predicates and relations
 theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
     LiftP p x ↔ ∃ a f, x = abs ⟨a, f⟩ ∧ ∀ i j, p (f i j) :=
@@ -142,7 +145,9 @@ theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
   use abs ⟨a, fun i j => ⟨f i j, h₁ i j⟩⟩
   rw [← abs_map, h₀]; rfl
 #align mvqpf.liftp_iff MvQPF.liftP_iff
+-/
 
+#print MvQPF.liftR_iff /-
 theorem liftR_iff {α : TypeVec n} (r : ∀ ⦃i⦄, α i → α i → Prop) (x y : F α) :
     LiftR r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ i j, r (f₀ i j) (f₁ i j) :=
   by
@@ -158,11 +163,13 @@ theorem liftR_iff {α : TypeVec n} (r : ∀ ⦃i⦄, α i → α i → Prop) (x
   · rw [xeq, ← abs_map]; rfl
   rw [yeq, ← abs_map]; rfl
 #align mvqpf.liftr_iff MvQPF.liftR_iff
+-/
 
 open Set
 
 open MvFunctor
 
+#print MvQPF.mem_supp /-
 theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
     u ∈ supp x i ↔ ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ :=
   by
@@ -178,11 +185,15 @@ theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
   rcases h a f xeq.symm with ⟨i, _, hi⟩
   rw [← hi]; apply h'
 #align mvqpf.mem_supp MvQPF.mem_supp
+-/
 
+#print MvQPF.supp_eq /-
 theorem supp_eq {α : TypeVec n} {i} (x : F α) :
     supp x i = {u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ} := by ext <;> apply mem_supp
 #align mvqpf.supp_eq MvQPF.supp_eq
+-/
 
+#print MvQPF.has_good_supp_iff /-
 theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
     (∀ p, LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u) ↔
       ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ i a' f', abs ⟨a', f'⟩ = x → f i '' univ ⊆ f' i '' univ :=
@@ -207,6 +218,7 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
   apply h _ a' f' xeq'
   apply mem_image_of_mem _ (mem_univ _)
 #align mvqpf.has_good_supp_iff MvQPF.has_good_supp_iff
+-/
 
 variable (q)
 
@@ -235,6 +247,7 @@ def SuppPreservation : Prop :=
 
 variable (q)
 
+#print MvQPF.supp_eq_of_isUniform /-
 theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.p.A) (f : q.p.B a ⟹ α) :
     ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ := by
   intro; ext u; rw [mem_supp]; constructor
@@ -242,7 +255,9 @@ theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.p.A) (f :
   intro h' a' f' e
   rw [← h _ _ _ _ e.symm]; apply h'
 #align mvqpf.supp_eq_of_is_uniform MvQPF.supp_eq_of_isUniform
+-/
 
+#print MvQPF.liftP_iff_of_isUniform /-
 theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
     LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u :=
   by
@@ -256,7 +271,9 @@ theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p
   rw [supp_eq_of_is_uniform h]
   exact ⟨i, mem_univ i, rfl⟩
 #align mvqpf.liftp_iff_of_is_uniform MvQPF.liftP_iff_of_isUniform
+-/
 
+#print MvQPF.supp_map /-
 theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α) (i) :
     supp (g <$$> x) i = g i '' supp x i :=
   by
@@ -264,7 +281,9 @@ theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α
   rw [supp_eq_of_is_uniform h, supp_eq_of_is_uniform h, ← image_comp]
   rfl
 #align mvqpf.supp_map MvQPF.supp_map
+-/
 
+#print MvQPF.suppPreservation_iff_isUniform /-
 theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform :=
   by
   constructor
@@ -272,7 +291,9 @@ theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform :=
     rw [← MvPFunctor.supp_eq, ← MvPFunctor.supp_eq, ← h, h', h]
   · rintro h α ⟨a, f⟩; ext; rwa [supp_eq_of_is_uniform, MvPFunctor.supp_eq]
 #align mvqpf.supp_preservation_iff_uniform MvQPF.suppPreservation_iff_isUniform
+-/
 
+#print MvQPF.suppPreservation_iff_liftpPreservation /-
 theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation :=
   by
   constructor <;> intro h
@@ -286,10 +307,13 @@ theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPP
     simp only [liftp_preservation] at h 
     ext; simp [supp, h]
 #align mvqpf.supp_preservation_iff_liftp_preservation MvQPF.suppPreservation_iff_liftpPreservation
+-/
 
+#print MvQPF.liftpPreservation_iff_uniform /-
 theorem liftpPreservation_iff_uniform : q.LiftPPreservation ↔ q.IsUniform := by
   rw [← supp_preservation_iff_liftp_preservation, supp_preservation_iff_uniform]
 #align mvqpf.liftp_preservation_iff_uniform MvQPF.liftpPreservation_iff_uniform
+-/
 
 end MvQPF
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -180,7 +180,7 @@ theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
 #align mvqpf.mem_supp MvQPF.mem_supp
 
 theorem supp_eq {α : TypeVec n} {i} (x : F α) :
-    supp x i = { u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ } := by ext <;> apply mem_supp
+    supp x i = {u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ} := by ext <;> apply mem_supp
 #align mvqpf.supp_eq MvQPF.supp_eq
 
 theorem has_good_supp_iff {α : TypeVec n} (x : F α) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -190,7 +190,7 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
   constructor
   · intro h
     have : liftp (supp x) x := by rw [h]; introv ; exact id
-    rw [liftp_iff] at this; rcases this with ⟨a, f, xeq, h'⟩
+    rw [liftp_iff] at this ; rcases this with ⟨a, f, xeq, h'⟩
     refine' ⟨a, f, xeq.symm, _⟩
     intro a' f' h''
     rintro hu u ⟨j, h₂, hfi⟩
@@ -237,7 +237,7 @@ variable (q)
 
 theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.p.A) (f : q.p.B a ⟹ α) :
     ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ := by
-  intro ; ext u; rw [mem_supp]; constructor
+  intro; ext u; rw [mem_supp]; constructor
   · intro h'; apply h' _ _ rfl
   intro h' a' f' e
   rw [← h _ _ _ _ e.symm]; apply h'
@@ -277,13 +277,13 @@ theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPP
   by
   constructor <;> intro h
   · rintro α p ⟨a, f⟩
-    have h' := h; rw [supp_preservation_iff_uniform] at h'
-    dsimp only [supp_preservation, supp] at h
+    have h' := h; rw [supp_preservation_iff_uniform] at h' 
+    dsimp only [supp_preservation, supp] at h 
     simp only [liftp_iff_of_is_uniform, supp_eq_of_is_uniform, MvPFunctor.liftP_iff', h',
       image_univ, mem_range, exists_imp]
     constructor <;> intros <;> subst_vars <;> solve_by_elim
   · rintro α ⟨a, f⟩
-    simp only [liftp_preservation] at h
+    simp only [liftp_preservation] at h 
     ext; simp [supp, h]
 #align mvqpf.supp_preservation_iff_liftp_preservation MvQPF.suppPreservation_iff_liftpPreservation
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -84,7 +84,7 @@ each proves that some operations on functors preserves the QPF structure
 
 universe u
 
-open MvFunctor
+open scoped MvFunctor
 
 #print MvQPF /-
 /-- Multivariate quotients of polynomial functors.

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -111,22 +111,10 @@ open MvFunctor (Liftp Liftr)
 -/
 
 
-/- warning: mvqpf.id_map -> MvQPF.id_map is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1] {α : TypeVec.{u1} n} (x : F α), Eq.{succ u2} (F α) (MvFunctor.map.{u1, u2} n F _inst_1 α α (TypeVec.id.{u1} n α) x) x
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} (x : F α), Eq.{succ u1} (F α) (MvFunctor.map.{u2, u1} n F _inst_1 α α (TypeVec.id.{u2} n α) x) x
-Case conversion may be inaccurate. Consider using '#align mvqpf.id_map MvQPF.id_mapₓ'. -/
 protected theorem id_map {α : TypeVec n} (x : F α) : TypeVec.id <$$> x = x := by rw [← abs_repr x];
   cases' repr x with a f; rw [← abs_map]; rfl
 #align mvqpf.id_map MvQPF.id_map
 
-/- warning: mvqpf.comp_map -> MvQPF.comp_map is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1] {α : TypeVec.{u1} n} {β : TypeVec.{u1} n} {γ : TypeVec.{u1} n} (f : TypeVec.Arrow.{u1, u1} n α β) (g : TypeVec.Arrow.{u1, u1} n β γ) (x : F α), Eq.{succ u2} (F γ) (MvFunctor.map.{u1, u2} n (fun {α : TypeVec.{u1} n} => F α) _inst_1 α γ (TypeVec.comp.{u1, u1, u1} n α β γ g f) x) (MvFunctor.map.{u1, u2} n F _inst_1 β γ g (MvFunctor.map.{u1, u2} n F _inst_1 α β f x))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} {β : TypeVec.{u2} n} {γ : TypeVec.{u2} n} (f : TypeVec.Arrow.{u2, u2} n α β) (g : TypeVec.Arrow.{u2, u2} n β γ) (x : F α), Eq.{succ u1} (F γ) (MvFunctor.map.{u2, u1} n F _inst_1 α γ (TypeVec.comp.{u2, u2, u2} n α β γ g f) x) (MvFunctor.map.{u2, u1} n F _inst_1 β γ g (MvFunctor.map.{u2, u1} n F _inst_1 α β f x))
-Case conversion may be inaccurate. Consider using '#align mvqpf.comp_map MvQPF.comp_mapₓ'. -/
 @[simp]
 theorem comp_map {α β γ : TypeVec n} (f : α ⟹ β) (g : β ⟹ γ) (x : F α) :
     (g ⊚ f) <$$> x = g <$$> f <$$> x := by rw [← abs_repr x]; cases' repr x with a f;
@@ -141,12 +129,6 @@ instance (priority := 100) lawfulMvFunctor : LawfulMvFunctor F
 #align mvqpf.is_lawful_mvfunctor MvQPF.lawfulMvFunctor
 -/
 
-/- warning: mvqpf.liftp_iff -> MvQPF.liftP_iff is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1] {α : TypeVec.{u1} n} (p : forall {{i : Fin2 n}}, (α i) -> Prop) (x : F α), Iff (MvFunctor.LiftP.{u1, u2} n F _inst_1 (fun (i : Fin2 n) => α i) p x) (Exists.{succ u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => Exists.{succ u1} (TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) (fun (f : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) => And (Eq.{succ u2} (F α) x (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a f))) (forall (i : Fin2 n) (j : MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i), p i (f i j)))))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} (p : forall {{i : Fin2 n}}, (α i) -> Prop) (x : F α), Iff (MvFunctor.LiftP.{u2, u1} n F _inst_1 (fun (i : Fin2 n) => α i) p x) (Exists.{succ u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => Exists.{succ u2} (TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) (fun (f : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) => And (Eq.{succ u1} (F α) x (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a f))) (forall (i : Fin2 n) (j : MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i), p i (f i j)))))
-Case conversion may be inaccurate. Consider using '#align mvqpf.liftp_iff MvQPF.liftP_iffₓ'. -/
 -- Lifting predicates and relations
 theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
     LiftP p x ↔ ∃ a f, x = abs ⟨a, f⟩ ∧ ∀ i j, p (f i j) :=
@@ -161,9 +143,6 @@ theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
   rw [← abs_map, h₀]; rfl
 #align mvqpf.liftp_iff MvQPF.liftP_iff
 
-/- warning: mvqpf.liftr_iff -> MvQPF.liftR_iff is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align mvqpf.liftr_iff MvQPF.liftR_iffₓ'. -/
 theorem liftR_iff {α : TypeVec n} (r : ∀ ⦃i⦄, α i → α i → Prop) (x y : F α) :
     LiftR r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ i j, r (f₀ i j) (f₁ i j) :=
   by
@@ -184,12 +163,6 @@ open Set
 
 open MvFunctor
 
-/- warning: mvqpf.mem_supp -> MvQPF.mem_supp is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1] {α : TypeVec.{u1} n} (x : F α) (i : Fin2 n) (u : α i), Iff (Membership.Mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.hasMem.{u1} (α i)) u (MvFunctor.supp.{u1, u2} n F _inst_1 α x i)) (forall (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (f : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α), (Eq.{succ u2} (F α) (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a f)) x) -> (Membership.Mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.hasMem.{u1} (α i)) u (Set.image.{u1, u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i)))))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} (x : F α) (i : Fin2 n) (u : α i), Iff (Membership.mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.instMembershipSet.{u2} (α i)) u (MvFunctor.supp.{u2, u1} n F _inst_1 α x i)) (forall (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (f : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α), (Eq.{succ u1} (F α) (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a f)) x) -> (Membership.mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.instMembershipSet.{u2} (α i)) u (Set.image.{u2, u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i)))))
-Case conversion may be inaccurate. Consider using '#align mvqpf.mem_supp MvQPF.mem_suppₓ'. -/
 theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
     u ∈ supp x i ↔ ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ :=
   by
@@ -206,19 +179,10 @@ theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
   rw [← hi]; apply h'
 #align mvqpf.mem_supp MvQPF.mem_supp
 
-/- warning: mvqpf.supp_eq -> MvQPF.supp_eq is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1] {α : TypeVec.{u1} n} {i : Fin2 n} (x : F α), Eq.{succ u1} (Set.{u1} (α i)) (MvFunctor.supp.{u1, u2} n F _inst_1 α x i) (setOf.{u1} (α i) (fun (u : α i) => forall (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (f : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α), (Eq.{succ u2} (F α) (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a f)) x) -> (Membership.Mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.hasMem.{u1} (α i)) u (Set.image.{u1, u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i))))))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} {i : Fin2 n} (x : F α), Eq.{succ u2} (Set.{u2} (α i)) (MvFunctor.supp.{u2, u1} n F _inst_1 α x i) (setOf.{u2} (α i) (fun (u : α i) => forall (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (f : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α), (Eq.{succ u1} (F α) (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a f)) x) -> (Membership.mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.instMembershipSet.{u2} (α i)) u (Set.image.{u2, u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i))))))
-Case conversion may be inaccurate. Consider using '#align mvqpf.supp_eq MvQPF.supp_eqₓ'. -/
 theorem supp_eq {α : TypeVec n} {i} (x : F α) :
     supp x i = { u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ } := by ext <;> apply mem_supp
 #align mvqpf.supp_eq MvQPF.supp_eq
 
-/- warning: mvqpf.has_good_supp_iff -> MvQPF.has_good_supp_iff is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align mvqpf.has_good_supp_iff MvQPF.has_good_supp_iffₓ'. -/
 theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
     (∀ p, LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u) ↔
       ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ i a' f', abs ⟨a', f'⟩ = x → f i '' univ ⊆ f' i '' univ :=
@@ -271,12 +235,6 @@ def SuppPreservation : Prop :=
 
 variable (q)
 
-/- warning: mvqpf.supp_eq_of_is_uniform -> MvQPF.supp_eq_of_isUniform is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1], (MvQPF.IsUniform.{u1, u2} n F _inst_1 q) -> (forall {α : TypeVec.{u1} n} (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (f : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) (i : Fin2 n), Eq.{succ u1} (Set.{u1} (α i)) (MvFunctor.supp.{u1, u2} n F _inst_1 α (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a f)) i) (Set.image.{u1, u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i))))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1], (MvQPF.IsUniform.{u2, u1} n F _inst_1 q) -> (forall {α : TypeVec.{u2} n} (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (f : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) (i : Fin2 n), Eq.{succ u2} (Set.{u2} (α i)) (MvFunctor.supp.{u2, u1} n F _inst_1 α (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a f)) i) (Set.image.{u2, u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i))))
-Case conversion may be inaccurate. Consider using '#align mvqpf.supp_eq_of_is_uniform MvQPF.supp_eq_of_isUniformₓ'. -/
 theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.p.A) (f : q.p.B a ⟹ α) :
     ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ := by
   intro ; ext u; rw [mem_supp]; constructor
@@ -285,12 +243,6 @@ theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.p.A) (f :
   rw [← h _ _ _ _ e.symm]; apply h'
 #align mvqpf.supp_eq_of_is_uniform MvQPF.supp_eq_of_isUniform
 
-/- warning: mvqpf.liftp_iff_of_is_uniform -> MvQPF.liftP_iff_of_isUniform is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1], (MvQPF.IsUniform.{u1, u2} n F _inst_1 q) -> (forall {α : TypeVec.{u1} n} (x : F α) (p : forall (i : Fin2 n), (α i) -> Prop), Iff (MvFunctor.LiftP.{u1, u2} n F _inst_1 (fun (i : Fin2 n) => α i) p x) (forall (i : Fin2 n) (u : α i), (Membership.Mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.hasMem.{u1} (α i)) u (MvFunctor.supp.{u1, u2} n F _inst_1 α x i)) -> (p i u)))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1], (MvQPF.IsUniform.{u2, u1} n F _inst_1 q) -> (forall {α : TypeVec.{u2} n} (x : F α) (p : forall (i : Fin2 n), (α i) -> Prop), Iff (MvFunctor.LiftP.{u2, u1} n F _inst_1 (fun (i : Fin2 n) => α i) p x) (forall (i : Fin2 n) (u : α i), (Membership.mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.instMembershipSet.{u2} (α i)) u (MvFunctor.supp.{u2, u1} n F _inst_1 α x i)) -> (p i u)))
-Case conversion may be inaccurate. Consider using '#align mvqpf.liftp_iff_of_is_uniform MvQPF.liftP_iff_of_isUniformₓ'. -/
 theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
     LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u :=
   by
@@ -305,12 +257,6 @@ theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p
   exact ⟨i, mem_univ i, rfl⟩
 #align mvqpf.liftp_iff_of_is_uniform MvQPF.liftP_iff_of_isUniform
 
-/- warning: mvqpf.supp_map -> MvQPF.supp_map is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1], (MvQPF.IsUniform.{u1, u2} n F _inst_1 q) -> (forall {α : TypeVec.{u1} n} {β : TypeVec.{u1} n} (g : TypeVec.Arrow.{u1, u1} n α β) (x : F α) (i : Fin2 n), Eq.{succ u1} (Set.{u1} (β i)) (MvFunctor.supp.{u1, u2} n (fun {α : TypeVec.{u1} n} => F α) _inst_1 β (MvFunctor.map.{u1, u2} n (fun {α : TypeVec.{u1} n} => F α) _inst_1 α β g x) i) (Set.image.{u1, u1} (α i) (β i) (g i) (MvFunctor.supp.{u1, u2} n (fun {α : TypeVec.{u1} n} => F α) _inst_1 α x i)))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1], (MvQPF.IsUniform.{u2, u1} n F _inst_1 q) -> (forall {α : TypeVec.{u2} n} {β : TypeVec.{u2} n} (g : TypeVec.Arrow.{u2, u2} n α β) (x : F α) (i : Fin2 n), Eq.{succ u2} (Set.{u2} (β i)) (MvFunctor.supp.{u2, u1} n F _inst_1 β (MvFunctor.map.{u2, u1} n F _inst_1 α β g x) i) (Set.image.{u2, u2} (α i) (β i) (g i) (MvFunctor.supp.{u2, u1} n F _inst_1 α x i)))
-Case conversion may be inaccurate. Consider using '#align mvqpf.supp_map MvQPF.supp_mapₓ'. -/
 theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α) (i) :
     supp (g <$$> x) i = g i '' supp x i :=
   by
@@ -319,12 +265,6 @@ theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α
   rfl
 #align mvqpf.supp_map MvQPF.supp_map
 
-/- warning: mvqpf.supp_preservation_iff_uniform -> MvQPF.suppPreservation_iff_isUniform is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1], Iff (MvQPF.SuppPreservation.{u1, u2} n F _inst_1 q) (MvQPF.IsUniform.{u1, u2} n F _inst_1 q)
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1], Iff (MvQPF.SuppPreservation.{u2, u1} n F _inst_1 q) (MvQPF.IsUniform.{u2, u1} n F _inst_1 q)
-Case conversion may be inaccurate. Consider using '#align mvqpf.supp_preservation_iff_uniform MvQPF.suppPreservation_iff_isUniformₓ'. -/
 theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform :=
   by
   constructor
@@ -333,12 +273,6 @@ theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform :=
   · rintro h α ⟨a, f⟩; ext; rwa [supp_eq_of_is_uniform, MvPFunctor.supp_eq]
 #align mvqpf.supp_preservation_iff_uniform MvQPF.suppPreservation_iff_isUniform
 
-/- warning: mvqpf.supp_preservation_iff_liftp_preservation -> MvQPF.suppPreservation_iff_liftpPreservation is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1], Iff (MvQPF.SuppPreservation.{u1, u2} n F _inst_1 q) (MvQPF.LiftPPreservation.{u1, u2} n F _inst_1 q)
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1], Iff (MvQPF.SuppPreservation.{u2, u1} n F _inst_1 q) (MvQPF.LiftPPreservation.{u2, u1} n F _inst_1 q)
-Case conversion may be inaccurate. Consider using '#align mvqpf.supp_preservation_iff_liftp_preservation MvQPF.suppPreservation_iff_liftpPreservationₓ'. -/
 theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation :=
   by
   constructor <;> intro h
@@ -353,12 +287,6 @@ theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPP
     ext; simp [supp, h]
 #align mvqpf.supp_preservation_iff_liftp_preservation MvQPF.suppPreservation_iff_liftpPreservation
 
-/- warning: mvqpf.liftp_preservation_iff_uniform -> MvQPF.liftpPreservation_iff_uniform is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1], Iff (MvQPF.LiftPPreservation.{u1, u2} n F _inst_1 q) (MvQPF.IsUniform.{u1, u2} n F _inst_1 q)
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1], Iff (MvQPF.LiftPPreservation.{u2, u1} n F _inst_1 q) (MvQPF.IsUniform.{u2, u1} n F _inst_1 q)
-Case conversion may be inaccurate. Consider using '#align mvqpf.liftp_preservation_iff_uniform MvQPF.liftpPreservation_iff_uniformₓ'. -/
 theorem liftpPreservation_iff_uniform : q.LiftPPreservation ↔ q.IsUniform := by
   rw [← supp_preservation_iff_liftp_preservation, supp_preservation_iff_uniform]
 #align mvqpf.liftp_preservation_iff_uniform MvQPF.liftpPreservation_iff_uniform

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -117,12 +117,8 @@ lean 3 declaration is
 but is expected to have type
   forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} (x : F α), Eq.{succ u1} (F α) (MvFunctor.map.{u2, u1} n F _inst_1 α α (TypeVec.id.{u2} n α) x) x
 Case conversion may be inaccurate. Consider using '#align mvqpf.id_map MvQPF.id_mapₓ'. -/
-protected theorem id_map {α : TypeVec n} (x : F α) : TypeVec.id <$$> x = x :=
-  by
-  rw [← abs_repr x]
-  cases' repr x with a f
-  rw [← abs_map]
-  rfl
+protected theorem id_map {α : TypeVec n} (x : F α) : TypeVec.id <$$> x = x := by rw [← abs_repr x];
+  cases' repr x with a f; rw [← abs_map]; rfl
 #align mvqpf.id_map MvQPF.id_map
 
 /- warning: mvqpf.comp_map -> MvQPF.comp_map is a dubious translation:
@@ -133,11 +129,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align mvqpf.comp_map MvQPF.comp_mapₓ'. -/
 @[simp]
 theorem comp_map {α β γ : TypeVec n} (f : α ⟹ β) (g : β ⟹ γ) (x : F α) :
-    (g ⊚ f) <$$> x = g <$$> f <$$> x := by
-  rw [← abs_repr x]
-  cases' repr x with a f
-  rw [← abs_map, ← abs_map, ← abs_map]
-  rfl
+    (g ⊚ f) <$$> x = g <$$> f <$$> x := by rw [← abs_repr x]; cases' repr x with a f;
+  rw [← abs_map, ← abs_map, ← abs_map]; rfl
 #align mvqpf.comp_map MvQPF.comp_map
 
 #print MvQPF.lawfulMvFunctor /-
@@ -159,14 +152,10 @@ theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
     LiftP p x ↔ ∃ a f, x = abs ⟨a, f⟩ ∧ ∀ i j, p (f i j) :=
   by
   constructor
-  · rintro ⟨y, hy⟩
-    cases' h : repr y with a f
-    use a, fun i j => (f i j).val
-    constructor
-    · rw [← hy, ← abs_repr y, h, ← abs_map]
-      rfl
-    intro i j
-    apply (f i j).property
+  · rintro ⟨y, hy⟩; cases' h : repr y with a f
+    use a, fun i j => (f i j).val; constructor
+    · rw [← hy, ← abs_repr y, h, ← abs_map]; rfl
+    intro i j; apply (f i j).property
   rintro ⟨a, f, h₀, h₁⟩; dsimp at *
   use abs ⟨a, fun i j => ⟨f i j, h₁ i j⟩⟩
   rw [← abs_map, h₀]; rfl
@@ -179,22 +168,15 @@ theorem liftR_iff {α : TypeVec n} (r : ∀ ⦃i⦄, α i → α i → Prop) (x
     LiftR r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ i j, r (f₀ i j) (f₁ i j) :=
   by
   constructor
-  · rintro ⟨u, xeq, yeq⟩
-    cases' h : repr u with a f
+  · rintro ⟨u, xeq, yeq⟩; cases' h : repr u with a f
     use a, fun i j => (f i j).val.fst, fun i j => (f i j).val.snd
-    constructor
-    · rw [← xeq, ← abs_repr u, h, ← abs_map]
-      rfl
-    constructor
-    · rw [← yeq, ← abs_repr u, h, ← abs_map]
-      rfl
-    intro i j
-    exact (f i j).property
+    constructor; · rw [← xeq, ← abs_repr u, h, ← abs_map]; rfl
+    constructor; · rw [← yeq, ← abs_repr u, h, ← abs_map]; rfl
+    intro i j; exact (f i j).property
   rintro ⟨a, f₀, f₁, xeq, yeq, h⟩
   use abs ⟨a, fun i j => ⟨(f₀ i j, f₁ i j), h i j⟩⟩
   dsimp; constructor
-  · rw [xeq, ← abs_map]
-    rfl
+  · rw [xeq, ← abs_map]; rfl
   rw [yeq, ← abs_map]; rfl
 #align mvqpf.liftr_iff MvQPF.liftR_iff
 
@@ -215,10 +197,8 @@ theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
   · intro h a f haf
     have : liftp (fun i u => u ∈ f i '' univ) x :=
       by
-      rw [liftp_iff]
-      refine' ⟨a, f, haf.symm, _⟩
-      intro i u
-      exact mem_image_of_mem _ (mem_univ _)
+      rw [liftp_iff]; refine' ⟨a, f, haf.symm, _⟩
+      intro i u; exact mem_image_of_mem _ (mem_univ _)
     exact h this
   intro h p; rw [liftp_iff]
   rintro ⟨a, f, xeq, h'⟩
@@ -245,12 +225,8 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
   by
   constructor
   · intro h
-    have : liftp (supp x) x := by
-      rw [h]
-      introv
-      exact id
-    rw [liftp_iff] at this
-    rcases this with ⟨a, f, xeq, h'⟩
+    have : liftp (supp x) x := by rw [h]; introv ; exact id
+    rw [liftp_iff] at this; rcases this with ⟨a, f, xeq, h'⟩
     refine' ⟨a, f, xeq.symm, _⟩
     intro a' f' h''
     rintro hu u ⟨j, h₂, hfi⟩
@@ -259,8 +235,7 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
   rintro ⟨a, f, xeq, h⟩ p; rw [liftp_iff]; constructor
   · rintro ⟨a', f', xeq', h'⟩ i u usuppx
     rcases(mem_supp x _ u).mp (@usuppx) a' f' xeq'.symm with ⟨i, _, f'ieq⟩
-    rw [← f'ieq]
-    apply h'
+    rw [← f'ieq]; apply h'
   intro h'
   refine' ⟨a, f, xeq.symm, _⟩; intro j y
   apply h'; rw [mem_supp]
@@ -305,8 +280,7 @@ Case conversion may be inaccurate. Consider using '#align mvqpf.supp_eq_of_is_un
 theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.p.A) (f : q.p.B a ⟹ α) :
     ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ := by
   intro ; ext u; rw [mem_supp]; constructor
-  · intro h'
-    apply h' _ _ rfl
+  · intro h'; apply h' _ _ rfl
   intro h' a' f' e
   rw [← h _ _ _ _ e.symm]; apply h'
 #align mvqpf.supp_eq_of_is_uniform MvQPF.supp_eq_of_isUniform
@@ -324,9 +298,7 @@ theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p
   cases' repr x with a f; constructor
   · rintro ⟨a', f', abseq, hf⟩ u
     rw [supp_eq_of_is_uniform h, h _ _ _ _ abseq]
-    rintro b ⟨i, _, hi⟩
-    rw [← hi]
-    apply hf
+    rintro b ⟨i, _, hi⟩; rw [← hi]; apply hf
   intro h'
   refine' ⟨a, f, rfl, fun _ i => h' _ _ _⟩
   rw [supp_eq_of_is_uniform h]
@@ -358,9 +330,7 @@ theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform :=
   constructor
   · intro h α a a' f f' h' i
     rw [← MvPFunctor.supp_eq, ← MvPFunctor.supp_eq, ← h, h', h]
-  · rintro h α ⟨a, f⟩
-    ext
-    rwa [supp_eq_of_is_uniform, MvPFunctor.supp_eq]
+  · rintro h α ⟨a, f⟩; ext; rwa [supp_eq_of_is_uniform, MvPFunctor.supp_eq]
 #align mvqpf.supp_preservation_iff_uniform MvQPF.suppPreservation_iff_isUniform
 
 /- warning: mvqpf.supp_preservation_iff_liftp_preservation -> MvQPF.suppPreservation_iff_liftpPreservation is a dubious translation:
@@ -373,16 +343,14 @@ theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPP
   by
   constructor <;> intro h
   · rintro α p ⟨a, f⟩
-    have h' := h
-    rw [supp_preservation_iff_uniform] at h'
+    have h' := h; rw [supp_preservation_iff_uniform] at h'
     dsimp only [supp_preservation, supp] at h
     simp only [liftp_iff_of_is_uniform, supp_eq_of_is_uniform, MvPFunctor.liftP_iff', h',
       image_univ, mem_range, exists_imp]
     constructor <;> intros <;> subst_vars <;> solve_by_elim
   · rintro α ⟨a, f⟩
     simp only [liftp_preservation] at h
-    ext
-    simp [supp, h]
+    ext; simp [supp, h]
 #align mvqpf.supp_preservation_iff_liftp_preservation MvQPF.suppPreservation_iff_liftpPreservation
 
 /- warning: mvqpf.liftp_preservation_iff_uniform -> MvQPF.liftpPreservation_iff_uniform is a dubious translation:

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -173,10 +173,7 @@ theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
 #align mvqpf.liftp_iff MvQPF.liftP_iff
 
 /- warning: mvqpf.liftr_iff -> MvQPF.liftR_iff is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1] {α : TypeVec.{u1} n} (r : forall {{i : Fin2 n}}, (α i) -> (α i) -> Prop) (x : F α) (y : F α), Iff (MvFunctor.LiftR.{u1, u2} n F _inst_1 (fun (i : Fin2 n) => α i) r x y) (Exists.{succ u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => Exists.{succ u1} (TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) (fun (f₀ : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) => Exists.{succ u1} (TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) (fun (f₁ : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) => And (Eq.{succ u2} (F α) x (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a f₀))) (And (Eq.{succ u2} (F α) y (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a f₁))) (forall (i : Fin2 n) (j : MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i), r i (f₀ i j) (f₁ i j)))))))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} (r : forall {i : Fin2 n}, (α i) -> (α i) -> Prop) (x : F α) (y : F α), Iff (MvFunctor.LiftR.{u2, u1} n F _inst_1 (fun {i : Fin2 n} => α i) (fun {i._@.Mathlib.Data.QPF.Multivariate.Basic._hyg.634 : Fin2 n} => r i._@.Mathlib.Data.QPF.Multivariate.Basic._hyg.634) x y) (Exists.{succ u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => Exists.{succ u2} (TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) (fun (f₀ : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) => Exists.{succ u2} (TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) (fun (f₁ : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) => And (Eq.{succ u1} (F α) x (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a f₀))) (And (Eq.{succ u1} (F α) y (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a f₁))) (forall (i : Fin2 n) (j : MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i), r i (f₀ i j) (f₁ i j)))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align mvqpf.liftr_iff MvQPF.liftR_iffₓ'. -/
 theorem liftR_iff {α : TypeVec n} (r : ∀ ⦃i⦄, α i → α i → Prop) (x y : F α) :
     LiftR r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ i j, r (f₀ i j) (f₁ i j) :=
@@ -240,10 +237,7 @@ theorem supp_eq {α : TypeVec n} {i} (x : F α) :
 #align mvqpf.supp_eq MvQPF.supp_eq
 
 /- warning: mvqpf.has_good_supp_iff -> MvQPF.has_good_supp_iff is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {F : (TypeVec.{u1} n) -> Type.{u2}} [_inst_1 : MvFunctor.{u1, u2} n F] [q : MvQPF.{u1, u2} n F _inst_1] {α : TypeVec.{u1} n} (x : F α), Iff (forall (p : forall (i : Fin2 n), (α i) -> Prop), Iff (MvFunctor.LiftP.{u1, u2} n F _inst_1 α p x) (forall (i : Fin2 n) (u : α i), (Membership.Mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.hasMem.{u1} (α i)) u (MvFunctor.supp.{u1, u2} n F _inst_1 α x i)) -> (p i u))) (Exists.{succ u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => Exists.{succ u1} (TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) (fun (f : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) => And (Eq.{succ u2} (F α) (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a f)) x) (forall (i : Fin2 n) (a' : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (f' : TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a') α), (Eq.{succ u2} (F α) (MvQPF.abs.{u1, u2} n F _inst_1 q α (Sigma.mk.{u1, u1} (MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q)) => TypeVec.Arrow.{u1, u1} n (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a) α) a' f')) x) -> (HasSubset.Subset.{u1} (Set.{u1} (α i)) (Set.hasSubset.{u1} (α i)) (Set.image.{u1, u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a i))) (Set.image.{u1, u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a' i) (α i) (f' i) (Set.univ.{u1} (MvPFunctor.b.{u1} n (MvQPF.p.{u1, u2} n F _inst_1 q) a' i))))))))
-but is expected to have type
-  forall {n : Nat} {F : (TypeVec.{u2} n) -> Type.{u1}} [_inst_1 : MvFunctor.{u2, u1} n F] [q : MvQPF.{u2, u1} n F _inst_1] {α : TypeVec.{u2} n} (x : F α), Iff (forall (p : forall (i : Fin2 n), (α i) -> Prop), Iff (MvFunctor.LiftP.{u2, u1} n F _inst_1 α p x) (forall (i : Fin2 n) (u : α i), (Membership.mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.instMembershipSet.{u2} (α i)) u (MvFunctor.supp.{u2, u1} n F _inst_1 α x i)) -> (p i u))) (Exists.{succ u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => Exists.{succ u2} (TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) (fun (f : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) => And (Eq.{succ u1} (F α) (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a f)) x) (forall (i : Fin2 n) (a' : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (f' : TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a') α), (Eq.{succ u1} (F α) (MvQPF.abs.{u2, u1} n F _inst_1 q α (Sigma.mk.{u2, u2} (MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) (fun (a : MvPFunctor.A.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q)) => TypeVec.Arrow.{u2, u2} n (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a) α) a' f')) x) -> (HasSubset.Subset.{u2} (Set.{u2} (α i)) (Set.instHasSubsetSet.{u2} (α i)) (Set.image.{u2, u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i) (α i) (f i) (Set.univ.{u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a i))) (Set.image.{u2, u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a' i) (α i) (f' i) (Set.univ.{u2} (MvPFunctor.B.{u2} n (MvQPF.P.{u2, u1} n F _inst_1 q) a' i))))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align mvqpf.has_good_supp_iff MvQPF.has_good_supp_iffₓ'. -/
 theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
     (∀ p, LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u) ↔

mathlib commit https://github.com/leanprover-community/mathlib/commit/3ade05ac9447ae31a22d2ea5423435e054131240

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Simon Hudon
 
 ! This file was ported from Lean 3 source module data.qpf.multivariate.basic
-! leanprover-community/mathlib commit 3c09987c11add055469578d7d49bc0ca0c74b10e
+! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Data.Pfunctor.Multivariate.Basic
 /-!
 # Multivariate quotients of polynomial functors.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Basic definition of multivariate QPF. QPFs form a compositional framework
 for defining inductive and coinductive types, their quotients and nesting.
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -193,7 +193,7 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
     intro a' f' h''
     rintro hu u ⟨j, _h₂, hfi⟩
     have hh : u ∈ supp x a' := by rw [← hfi]; apply h'
-    refine' (mem_supp x _ u).mp hh _ _ hu
+    exact (mem_supp x _ u).mp hh _ _ hu
   rintro ⟨a, f, xeq, h⟩ p; rw [liftP_iff]; constructor
   · rintro ⟨a', f', xeq', h'⟩ i u usuppx
     rcases (mem_supp x _ u).mp (@usuppx) a' f' xeq'.symm with ⟨i, _, f'ieq⟩

Every polynomial functor P is trivially also a quotient of a polynomial functor, namely, it's a quotient of itself through equality. That is, abs and repr are just the identity.

@@ -297,3 +297,11 @@ def ofEquiv {F F' : TypeVec.{u} n → Type*} [MvFunctor F'] [q : MvQPF F'] [MvFu
   abs_map   := by simp [q.abs_map, map_eq]
 
 end MvQPF
+
+/-- Every polynomial functor is a (trivial) QPF -/
+instance MvPFunctor.instMvQPFObj {n} (P : MvPFunctor n) : MvQPF P where
+  P := P
+  abs := id
+  repr := id
+  abs_repr := by intros; rfl
+  abs_map := by intros; rfl

This is code ported from alexkeizer/QpfTypes. It's primary use is to show that existing type functions which are equivalent to polynomial functors but not defined as such (e.g., Sum, Prod, etc.) are QPFs.

@@ -283,4 +283,17 @@ theorem liftpPreservation_iff_uniform : q.LiftPPreservation ↔ q.IsUniform := b
   rw [← suppPreservation_iff_liftpPreservation, suppPreservation_iff_isUniform]
 #align mvqpf.liftp_preservation_iff_uniform MvQPF.liftpPreservation_iff_uniform
 
+/-- Any type function `F` that is (extensionally) equivalent to a QPF, is itself a QPF,
+assuming that the functorial map of `F` behaves similar to `MvFunctor.ofEquiv eqv` -/
+def ofEquiv {F F' : TypeVec.{u} n → Type*} [MvFunctor F'] [q : MvQPF F'] [MvFunctor F]
+    (eqv : ∀ α, F α ≃ F' α)
+    (map_eq : ∀ (α β : TypeVec n) (f : α ⟹ β) (a : F α),
+      f <$$> a = ((eqv _).symm <| f <$$> eqv _ a) := by intros; rfl) :
+    MvQPF F where
+  P         := q.P
+  abs α     := (eqv _).symm <| q.abs α
+  repr α    := q.repr <| eqv _ α
+  abs_repr  := by simp [q.abs_repr]
+  abs_map   := by simp [q.abs_map, map_eq]
+
 end MvQPF

@@ -84,10 +84,10 @@ open MvFunctor
 -/
 class MvQPF {n : ℕ} (F : TypeVec.{u} n → Type*) [MvFunctor F] where
   P : MvPFunctor.{u} n
-  abs : ∀ {α}, P.Obj α → F α
-  repr : ∀ {α}, F α → P.Obj α
+  abs : ∀ {α}, P α → F α
+  repr : ∀ {α}, F α → P α
   abs_repr : ∀ {α} (x : F α), abs (repr x) = x
-  abs_map : ∀ {α β} (f : α ⟹ β) (p : P.Obj α), abs (f <$$> p) = f <$$> abs p
+  abs_map : ∀ {α β} (f : α ⟹ β) (p : P α), abs (f <$$> p) = f <$$> abs p
 #align mvqpf MvQPF
 
 namespace MvQPF
@@ -216,12 +216,12 @@ def IsUniform : Prop :=
 
 /-- does `abs` preserve `liftp`? -/
 def LiftPPreservation : Prop :=
-  ∀ ⦃α : TypeVec n⦄ (p : ∀ ⦃i⦄, α i → Prop) (x : q.P.Obj α), LiftP p (abs x) ↔ LiftP p x
+  ∀ ⦃α : TypeVec n⦄ (p : ∀ ⦃i⦄, α i → Prop) (x : q.P α), LiftP p (abs x) ↔ LiftP p x
 #align mvqpf.liftp_preservation MvQPF.LiftPPreservation
 
 /-- does `abs` preserve `supp`? -/
 def SuppPreservation : Prop :=
-  ∀ ⦃α⦄ (x : q.P.Obj α), supp (abs x) = supp x
+  ∀ ⦃α⦄ (x : q.P α), supp (abs x) = supp x
 #align mvqpf.supp_preservation MvQPF.SuppPreservation
 
 theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.P.A) (f : q.P.B a ⟹ α) :

Replace rcases( with rcases (. Same thing for convert( and congrm(. No other change.

@@ -196,7 +196,7 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
     refine' (mem_supp x _ u).mp hh _ _ hu
   rintro ⟨a, f, xeq, h⟩ p; rw [liftP_iff]; constructor
   · rintro ⟨a', f', xeq', h'⟩ i u usuppx
-    rcases(mem_supp x _ u).mp (@usuppx) a' f' xeq'.symm with ⟨i, _, f'ieq⟩
+    rcases (mem_supp x _ u).mp (@usuppx) a' f' xeq'.symm with ⟨i, _, f'ieq⟩
     rw [← f'ieq]
     apply h'
   intro h'

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -133,7 +133,7 @@ theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
     · rw [← hy, ← abs_repr y, h, ← abs_map]; rfl
     intro i j
     apply (f i j).property
-  rintro ⟨a, f, h₀, h₁⟩; dsimp at *
+  rintro ⟨a, f, h₀, h₁⟩
   use abs ⟨a, fun i j => ⟨f i j, h₁ i j⟩⟩
   rw [← abs_map, h₀]; rfl
 #align mvqpf.liftp_iff MvQPF.liftP_iff

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -82,7 +82,7 @@ open MvFunctor
 
 /-- Multivariate quotients of polynomial functors.
 -/
-class MvQPF {n : ℕ} (F : TypeVec.{u} n → Type _) [MvFunctor F] where
+class MvQPF {n : ℕ} (F : TypeVec.{u} n → Type*) [MvFunctor F] where
   P : MvPFunctor.{u} n
   abs : ∀ {α}, P.Obj α → F α
   repr : ∀ {α}, F α → P.Obj α
@@ -92,7 +92,7 @@ class MvQPF {n : ℕ} (F : TypeVec.{u} n → Type _) [MvFunctor F] where
 
 namespace MvQPF
 
-variable {n : ℕ} {F : TypeVec.{u} n → Type _} [MvFunctor F] [q : MvQPF F]
+variable {n : ℕ} {F : TypeVec.{u} n → Type*} [MvFunctor F] [q : MvQPF F]
 
 open MvFunctor (LiftP LiftR)
 

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,14 +2,11 @@
 Copyright (c) 2018 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Simon Hudon
-
-! This file was ported from Lean 3 source module data.qpf.multivariate.basic
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.PFunctor.Multivariate.Basic
 
+#align_import data.qpf.multivariate.basic from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Multivariate quotients of polynomial functors.
 

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -181,7 +181,7 @@ theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
 #align mvqpf.mem_supp MvQPF.mem_supp
 
 theorem supp_eq {α : TypeVec n} {i} (x : F α) :
-    supp x i = { u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ } := by ext ; apply mem_supp
+    supp x i = { u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ } := by ext; apply mem_supp
 #align mvqpf.supp_eq MvQPF.supp_eq
 
 theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
@@ -195,7 +195,7 @@ theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
     refine' ⟨a, f, xeq.symm, _⟩
     intro a' f' h''
     rintro hu u ⟨j, _h₂, hfi⟩
-    have hh : u ∈ supp x a' := by rw [← hfi] ; apply h'
+    have hh : u ∈ supp x a' := by rw [← hfi]; apply h'
     refine' (mem_supp x _ u).mp hh _ _ hu
   rintro ⟨a, f, xeq, h⟩ p; rw [liftP_iff]; constructor
   · rintro ⟨a', f', xeq', h'⟩ i u usuppx
@@ -229,7 +229,7 @@ def SuppPreservation : Prop :=
 
 theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.P.A) (f : q.P.B a ⟹ α) :
     ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ := by
-  intro ; ext u; rw [mem_supp]; constructor
+  intro; ext u; rw [mem_supp]; constructor
   · intro h'
     apply h' _ _ rfl
   intro h' a' f' e

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -21,8 +21,8 @@ a list using a shape functor:
 
 ```lean
 inductive ListShape (a b : Type)
-| nil : ListShape
-| cons : a -> b -> ListShape
+  | nil : ListShape
+  | cons : a -> b -> ListShape
 ```
 
 This shape can itself be decomposed as a sum of product which are themselves
@@ -44,7 +44,7 @@ And `Multiset` is also a QPF. We can then create a novel data type (for Lean):
 
 ```lean
 inductive Tree (a : Type)
-| node : a -> Multiset Tree -> Tree
+  | node : a -> Multiset Tree -> Tree
 ```
 
 An unordered tree. This is currently not supported by Lean because it nests
@@ -287,4 +287,3 @@ theorem liftpPreservation_iff_uniform : q.LiftPPreservation ↔ q.IsUniform := b
 #align mvqpf.liftp_preservation_iff_uniform MvQPF.liftpPreservation_iff_uniform
 
 end MvQPF
-