data.typevec ⟷ <a href="https://leanprover-community.github.io/mathlib4_docs/Mathlib/Data/TypeVec"> Mathlib.Data.TypeVec

(last sync)

refactor(*): move all mk_simp_attribute commands to 1 file (#19223)

Diff

@@ -235,11 +235,6 @@ eq_of_drop_last_eq rfl rfl
 instance subsingleton0 : subsingleton (typevec 0) :=
 ⟨ λ a b, funext $ λ a, fin2.elim0 a  ⟩
 
-run_cmd do
-  mk_simp_attr `typevec,
-  tactic.add_doc_string `simp_attr.typevec
-"simp set for the manipulation of typevec and arrow expressions"
-
 local prefix `♯`:0 := cast (by try { simp }; congr' 1; try { simp })
 
 /-- cases distinction for 0-length type vector -/

chore(data/*): Removing unnecessary simp lemmas (#17062)

This PR adds a script that looks for and removes unnecessary lemmas in simp calls.

depends on: #17078

Diff

@@ -532,7 +532,7 @@ end liftp'
 @[simp]
 lemma drop_fun_diag {α} :
   drop_fun (@prod.diag (n+1) α) = prod.diag :=
-by { ext i : 2, induction i; simp [drop_fun,*]; refl }
+by { ext i : 2, induction i; simp [drop_fun, *]; refl }
 
 @[simp]
 lemma drop_fun_subtype_val {α} (p : α ⟹ repeat (n+1) Prop) :
@@ -545,22 +545,22 @@ lemma last_fun_subtype_val {α} (p : α ⟹ repeat (n+1) Prop) :
 @[simp]
 lemma drop_fun_to_subtype {α} (p : α ⟹ repeat (n+1) Prop) :
   drop_fun (to_subtype p) = to_subtype _ :=
-by { ext i : 2, induction i; simp [drop_fun,*]; refl }
+by { ext i : 2, induction i; simp [drop_fun, *]; refl }
 
 @[simp]
 lemma last_fun_to_subtype {α} (p : α ⟹ repeat (n+1) Prop) :
   last_fun (to_subtype p) = _root_.id :=
-by { ext i : 2, induction i; simp [drop_fun,*]; refl }
+by { ext i : 2, induction i; simp [drop_fun, *]; refl }
 
 @[simp]
 lemma drop_fun_of_subtype {α} (p : α ⟹ repeat (n+1) Prop) :
   drop_fun (of_subtype p) = of_subtype _ :=
-by { ext i : 2, induction i; simp [drop_fun,*]; refl }
+by { ext i : 2, induction i; simp [drop_fun, *]; refl }
 
 @[simp]
 lemma last_fun_of_subtype {α} (p : α ⟹ repeat (n+1) Prop) :
   last_fun (of_subtype p) = _root_.id :=
-by { ext i : 2, induction i; simp [drop_fun,*]; refl }
+by { ext i : 2, induction i; simp [drop_fun, *]; refl }
 
 @[simp]
 lemma drop_fun_rel_last {α : typevec n} {β}
@@ -573,12 +573,12 @@ open_locale mvfunctor
 @[simp]
 lemma drop_fun_prod {α α' β β' : typevec (n+1)} (f : α ⟹ β) (f' : α' ⟹ β') :
   drop_fun (f ⊗' f') = (drop_fun f ⊗' drop_fun f') :=
-by { ext i : 2, induction i; simp [drop_fun,*]; refl }
+by { ext i : 2, induction i; simp [drop_fun, *]; refl }
 
 @[simp]
 lemma last_fun_prod {α α' β β' : typevec (n+1)} (f : α ⟹ β) (f' : α' ⟹ β') :
   last_fun (f ⊗' f') = _root_.prod.map (last_fun f) (last_fun f') :=
-by { ext i : 1, induction i; simp [last_fun,*]; refl }
+by { ext i : 1, induction i; simp [last_fun, *]; refl }
 
 @[simp]
 lemma drop_fun_from_append1_drop_last {α : typevec (n+1)} :
@@ -595,7 +595,7 @@ lemma drop_fun_id {α : typevec (n+1)} :
 @[simp]
 lemma prod_map_id {α β : typevec n} :
   (@typevec.id _ α ⊗' @typevec.id _ β) = id :=
-by { ext i : 2, induction i; simp only [typevec.prod.map,*,drop_fun_id],
+by { ext i : 2, induction i; simp only [typevec.prod.map, *, drop_fun_id],
      cases x, refl, refl }
 
 @[simp]

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2018 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
 -/
-import Mathbin.Data.Fin.Fin2
-import Mathbin.Logic.Function.Basic
-import Mathbin.Tactic.Basic
+import Data.Fin.Fin2
+import Logic.Function.Basic
+import Tactic.Basic
 
 #align_import data.typevec from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2018 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
-
-! This file was ported from Lean 3 source module data.typevec
-! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fin.Fin2
 import Mathbin.Logic.Function.Basic
 import Mathbin.Tactic.Basic
 
+#align_import data.typevec from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
+
 /-!
 
 # Tuples of types, and their categorical structure.

bump to nightly-2023-07-04-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/728ef9dbb281241906f25cbeb30f90d83e0bb451

05318d71

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
 
 ! This file was ported from Lean 3 source module data.typevec
-! leanprover-community/mathlib commit 63f84d91dd847f50bae04a01071f3a5491934e36
+! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -402,12 +402,6 @@ instance subsingleton0 : Subsingleton (TypeVec 0) :=
 #align typevec.subsingleton0 TypeVec.subsingleton0
 -/
 
-run_cmd
-  do
-    mk_simp_attr `typevec
-    tactic.add_doc_string `simp_attr.typevec
-        "simp set for the manipulation of typevec and arrow expressions"
-
 local prefix:0 "♯" => cast (by try simp <;> congr 1 <;> try simp)
 
 #print TypeVec.casesNil /-

bump to nightly-2023-06-20-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

9b351f8c

Diff

@@ -844,7 +844,7 @@ theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ dia
 #print TypeVec.prod_id /-
 theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ β ⟹ _) :=
   by
-  intros; ext (i a); induction i
+  intros; ext i a; induction i
   · cases a; rfl
   · apply i_ih
 #align typevec.prod_id TypeVec.prod_id
@@ -857,7 +857,7 @@ theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ 
 theorem append_prod_appendFun {n} {α α' β β' : TypeVec.{u} n} {φ φ' ψ ψ' : Type u} {f₀ : α ⟹ α'}
     {g₀ : β ⟹ β'} {f₁ : φ → φ'} {g₁ : ψ → ψ'} :
     (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) := by
-  ext (i a) <;> cases i <;> [cases a; skip] <;> rfl
+  ext i a <;> cases i <;> [cases a; skip] <;> rfl
 #align typevec.append_prod_append_fun TypeVec.append_prod_appendFun
 -/
 
@@ -985,7 +985,7 @@ theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagS
 @[simp]
 theorem toSubtype_of_subtype {α : TypeVec n} (p : α ⟹ repeat n Prop) :
     toSubtype p ⊚ ofSubtype p = id := by
-  ext (i x) <;> induction i <;> dsimp only [id, to_subtype, comp, of_subtype] at * <;> simp [*]
+  ext i x <;> induction i <;> dsimp only [id, to_subtype, comp, of_subtype] at * <;> simp [*]
 #align typevec.to_subtype_of_subtype TypeVec.toSubtype_of_subtype
 -/
 
@@ -993,7 +993,7 @@ theorem toSubtype_of_subtype {α : TypeVec n} (p : α ⟹ repeat n Prop) :
 @[simp]
 theorem subtypeVal_toSubtype {α : TypeVec n} (p : α ⟹ repeat n Prop) :
     subtypeVal p ⊚ toSubtype p = fun _ => Subtype.val := by
-  ext (i x) <;> induction i <;> dsimp only [to_subtype, comp, subtype_val] at * <;> simp [*]
+  ext i x <;> induction i <;> dsimp only [to_subtype, comp, subtype_val] at * <;> simp [*]
 #align typevec.subtype_val_to_subtype TypeVec.subtypeVal_toSubtype
 -/
 
@@ -1008,7 +1008,7 @@ theorem toSubtype_of_subtype_assoc {α β : TypeVec n} (p : α ⟹ repeat n Prop
 @[simp]
 theorem toSubtype'_of_subtype' {α : TypeVec n} (r : α ⊗ α ⟹ repeat n Prop) :
     toSubtype' r ⊚ ofSubtype' r = id := by
-  ext (i x) <;> induction i <;> dsimp only [id, to_subtype', comp, of_subtype'] at * <;>
+  ext i x <;> induction i <;> dsimp only [id, to_subtype', comp, of_subtype'] at * <;>
     simp [Subtype.eta, *]
 #align typevec.to_subtype'_of_subtype' TypeVec.toSubtype'_of_subtype'
 -/
@@ -1016,7 +1016,7 @@ theorem toSubtype'_of_subtype' {α : TypeVec n} (r : α ⊗ α ⟹ repeat n Prop
 #print TypeVec.subtypeVal_toSubtype' /-
 theorem subtypeVal_toSubtype' {α : TypeVec n} (r : α ⊗ α ⟹ repeat n Prop) :
     subtypeVal r ⊚ toSubtype' r = fun i x => prod.mk i x.1.fst x.1.snd := by
-  ext (i x) <;> induction i <;> dsimp only [id, to_subtype', comp, subtype_val, Prod.mk] at * <;>
+  ext i x <;> induction i <;> dsimp only [id, to_subtype', comp, subtype_val, Prod.mk] at * <;>
     simp [*]
 #align typevec.subtype_val_to_subtype' TypeVec.subtypeVal_toSubtype'
 -/

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -63,7 +63,6 @@ def Arrow (α β : TypeVec n) :=
 #align typevec.arrow TypeVec.Arrow
 -/
 
--- mathport name: typevec.arrow
 scoped[MvFunctor] infixl:40 " ⟹ " => TypeVec.Arrow
 
 #print TypeVec.Arrow.inhabited /-
@@ -84,24 +83,29 @@ def comp {α β γ : TypeVec n} (g : β ⟹ γ) (f : α ⟹ β) : α ⟹ γ := f
 #align typevec.comp TypeVec.comp
 -/
 
--- mathport name: typevec.comp
 scoped[MvFunctor] infixr:80 " ⊚ " => TypeVec.comp
 
+#print TypeVec.id_comp /-
 -- type as \oo
 @[simp]
 theorem id_comp {α β : TypeVec n} (f : α ⟹ β) : id ⊚ f = f :=
   rfl
 #align typevec.id_comp TypeVec.id_comp
+-/
 
+#print TypeVec.comp_id /-
 @[simp]
 theorem comp_id {α β : TypeVec n} (f : α ⟹ β) : f ⊚ id = f :=
   rfl
 #align typevec.comp_id TypeVec.comp_id
+-/
 
+#print TypeVec.comp_assoc /-
 theorem comp_assoc {α β γ δ : TypeVec n} (h : γ ⟹ δ) (g : β ⟹ γ) (f : α ⟹ β) :
     (h ⊚ g) ⊚ f = h ⊚ g ⊚ f :=
   rfl
 #align typevec.comp_assoc TypeVec.comp_assoc
+-/
 
 #print TypeVec.append1 /-
 /-- Support for extending a typevec by one element.
@@ -112,7 +116,6 @@ def append1 (α : TypeVec n) (β : Type _) : TypeVec (n + 1)
 #align typevec.append1 TypeVec.append1
 -/
 
--- mathport name: typevec.append1
 infixl:67 " ::: " => append1
 
 #print TypeVec.drop /-
@@ -167,11 +170,13 @@ def append1Cases {C : TypeVec (n + 1) → Sort u} (H : ∀ α β, C (append1 α
 #align typevec.append1_cases TypeVec.append1Cases
 -/
 
+#print TypeVec.append1_cases_append1 /-
 @[simp]
 theorem append1_cases_append1 {C : TypeVec (n + 1) → Sort u} (H : ∀ α β, C (append1 α β)) (α β) :
     @append1Cases _ C H (append1 α β) = H α β :=
   rfl
 #align typevec.append1_cases_append1 TypeVec.append1_cases_append1
+-/
 
 #print TypeVec.splitFun /-
 /-- append an arrow and a function for arbitrary source and target
@@ -191,7 +196,6 @@ def appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β 
 #align typevec.append_fun TypeVec.appendFun
 -/
 
--- mathport name: typevec.append_fun
 infixl:0 " ::: " => appendFun
 
 #print TypeVec.dropFun /-
@@ -213,16 +217,20 @@ def nilFun {α : TypeVec 0} {β : TypeVec 0} : α ⟹ β := fun i => Fin2.elim0
 #align typevec.nil_fun TypeVec.nilFun
 -/
 
+#print TypeVec.eq_of_drop_last_eq /-
 theorem eq_of_drop_last_eq {α β : TypeVec (n + 1)} {f g : α ⟹ β} (h₀ : dropFun f = dropFun g)
     (h₁ : lastFun f = lastFun g) : f = g := by
   replace h₀ := congr_fun h₀ <;> ext1 ⟨⟩ <;> apply_assumption
 #align typevec.eq_of_drop_last_eq TypeVec.eq_of_drop_last_eq
+-/
 
+#print TypeVec.dropFun_splitFun /-
 @[simp]
 theorem dropFun_splitFun {α α' : TypeVec (n + 1)} (f : drop α ⟹ drop α') (g : last α → last α') :
     dropFun (splitFun f g) = f :=
   rfl
 #align typevec.drop_fun_split_fun TypeVec.dropFun_splitFun
+-/
 
 #print TypeVec.Arrow.mp /-
 /-- turn an equality into an arrow -/
@@ -254,74 +262,96 @@ def fromAppend1DropLast {α : TypeVec (n + 1)} : (drop α ::: last α) ⟹ α :=
 #align typevec.from_append1_drop_last TypeVec.fromAppend1DropLast
 -/
 
+#print TypeVec.lastFun_splitFun /-
 @[simp]
 theorem lastFun_splitFun {α α' : TypeVec (n + 1)} (f : drop α ⟹ drop α') (g : last α → last α') :
     lastFun (splitFun f g) = g :=
   rfl
 #align typevec.last_fun_split_fun TypeVec.lastFun_splitFun
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.dropFun_appendFun /-
 @[simp]
 theorem dropFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β → β') :
     dropFun (f ::: g) = f :=
   rfl
 #align typevec.drop_fun_append_fun TypeVec.dropFun_appendFun
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.lastFun_appendFun /-
 @[simp]
 theorem lastFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β → β') :
     lastFun (f ::: g) = g :=
   rfl
 #align typevec.last_fun_append_fun TypeVec.lastFun_appendFun
+-/
 
+#print TypeVec.split_dropFun_lastFun /-
 theorem split_dropFun_lastFun {α α' : TypeVec (n + 1)} (f : α ⟹ α') :
     splitFun (dropFun f) (lastFun f) = f :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.split_drop_fun_last_fun TypeVec.split_dropFun_lastFun
+-/
 
+#print TypeVec.splitFun_inj /-
 theorem splitFun_inj {α α' : TypeVec (n + 1)} {f f' : drop α ⟹ drop α'} {g g' : last α → last α'}
     (H : splitFun f g = splitFun f' g') : f = f' ∧ g = g' := by
   rw [← drop_fun_split_fun f g, H, ← last_fun_split_fun f g, H] <;> simp
 #align typevec.split_fun_inj TypeVec.splitFun_inj
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.appendFun_inj /-
 theorem appendFun_inj {α α' : TypeVec n} {β β' : Type _} {f f' : α ⟹ α'} {g g' : β → β'} :
     (f ::: g) = (f' ::: g') → f = f' ∧ g = g' :=
   splitFun_inj
 #align typevec.append_fun_inj TypeVec.appendFun_inj
+-/
 
+#print TypeVec.splitFun_comp /-
 theorem splitFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : drop α₀ ⟹ drop α₁) (f₁ : drop α₁ ⟹ drop α₂)
     (g₀ : last α₀ → last α₁) (g₁ : last α₁ → last α₂) :
     splitFun (f₁ ⊚ f₀) (g₁ ∘ g₀) = splitFun f₁ g₁ ⊚ splitFun f₀ g₀ :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.split_fun_comp TypeVec.splitFun_comp
+-/
 
+#print TypeVec.appendFun_comp_splitFun /-
 theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type _} {ε : TypeVec (n + 1)}
     (f₀ : drop ε ⟹ α) (f₁ : α ⟹ γ) (g₀ : last ε → β) (g₁ : β → δ) :
     appendFun f₁ g₁ ⊚ splitFun f₀ g₀ = splitFun (f₁ ⊚ f₀) (g₁ ∘ g₀) :=
   (splitFun_comp _ _ _ _).symm
 #align typevec.append_fun_comp_split_fun TypeVec.appendFun_comp_splitFun
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.appendFun_comp /-
 theorem appendFun_comp {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Type _} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
     (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) : (f₁ ⊚ f₀ ::: g₁ ∘ g₀) = (f₁ ::: g₁) ⊚ (f₀ ::: g₀) :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp TypeVec.appendFun_comp
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.appendFun_comp' /-
 theorem appendFun_comp' {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Type _} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
     (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) : (f₁ ::: g₁) ⊚ (f₀ ::: g₀) = (f₁ ⊚ f₀ ::: g₁ ∘ g₀) :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp' TypeVec.appendFun_comp'
+-/
 
+#print TypeVec.nilFun_comp /-
 theorem nilFun_comp {α₀ : TypeVec 0} (f₀ : α₀ ⟹ Fin2.elim0) : nilFun ⊚ f₀ = f₀ :=
   funext fun x => Fin2.elim0 x
 #align typevec.nil_fun_comp TypeVec.nilFun_comp
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -333,25 +363,31 @@ theorem appendFun_comp_id {α : TypeVec n} {β₀ β₁ β₂ : Type _} (g₀ :
 #align typevec.append_fun_comp_id TypeVec.appendFun_comp_id
 -/
 
+#print TypeVec.dropFun_comp /-
 @[simp]
 theorem dropFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂) :
     dropFun (f₁ ⊚ f₀) = dropFun f₁ ⊚ dropFun f₀ :=
   rfl
 #align typevec.drop_fun_comp TypeVec.dropFun_comp
+-/
 
+#print TypeVec.lastFun_comp /-
 @[simp]
 theorem lastFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂) :
     lastFun (f₁ ⊚ f₀) = lastFun f₁ ∘ lastFun f₀ :=
   rfl
 #align typevec.last_fun_comp TypeVec.lastFun_comp
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.appendFun_aux /-
 theorem appendFun_aux {α α' : TypeVec n} {β β' : Type _} (f : (α ::: β) ⟹ (α' ::: β')) :
     (dropFun f ::: lastFun f) = f :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_aux TypeVec.appendFun_aux
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print TypeVec.appendFun_id_id /-
@@ -372,7 +408,6 @@ run_cmd
     tactic.add_doc_string `simp_attr.typevec
         "simp set for the manipulation of typevec and arrow expressions"
 
--- mathport name: «expr♯ »
 local prefix:0 "♯" => cast (by try simp <;> congr 1 <;> try simp)
 
 #print TypeVec.casesNil /-
@@ -390,18 +425,22 @@ protected def casesCons (n : ℕ) {β : TypeVec (n + 1) → Sort _}
 #align typevec.cases_cons TypeVec.casesCons
 -/
 
+#print TypeVec.casesNil_append1 /-
 protected theorem casesNil_append1 {β : TypeVec 0 → Sort _} (f : β Fin2.elim0) :
     TypeVec.casesNil f Fin2.elim0 = f :=
   rfl
 #align typevec.cases_nil_append1 TypeVec.casesNil_append1
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.casesCons_append1 /-
 protected theorem casesCons_append1 (n : ℕ) {β : TypeVec (n + 1) → Sort _}
     (f : ∀ (t) (v : TypeVec n), β (v ::: t)) (v : TypeVec n) (α) :
     TypeVec.casesCons n f (v ::: α) = f α v :=
   rfl
 #align typevec.cases_cons_append1 TypeVec.casesCons_append1
+-/
 
 #print TypeVec.typevecCasesNil₃ /-
 /-- cases distinction for an arrow in the category of 0-length type vectors -/
@@ -451,20 +490,24 @@ def typevecCasesCons₂ (n : ℕ) (t t' : Type _) (v v' : TypeVec n)
 #align typevec.typevec_cases_cons₂ TypeVec.typevecCasesCons₂
 -/
 
+#print TypeVec.typevecCasesNil₂_appendFun /-
 theorem typevecCasesNil₂_appendFun {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort _} (f : β nilFun) :
     typevecCasesNil₂ f nilFun = f :=
   rfl
 #align typevec.typevec_cases_nil₂_append_fun TypeVec.typevecCasesNil₂_appendFun
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.typevecCasesCons₂_appendFun /-
 theorem typevecCasesCons₂_appendFun (n : ℕ) (t t' : Type _) (v v' : TypeVec n)
     {β : (v ::: t) ⟹ (v' ::: t') → Sort _} (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f)) (f fs) :
     typevecCasesCons₂ n t t' v v' F (fs ::: f) = F f fs :=
   rfl
 #align typevec.typevec_cases_cons₂_append_fun TypeVec.typevecCasesCons₂_appendFun
+-/
 
 #print TypeVec.PredLast /-
 -- for lifting predicates and relations
@@ -506,7 +549,6 @@ def prod : ∀ {n} (α β : TypeVec.{u} n), TypeVec n
 #align typevec.prod TypeVec.prod
 -/
 
--- mathport name: typevec.prod
 scoped[MvFunctor] infixl:45 " ⊗ " => TypeVec.prod
 
 #print TypeVec.const /-
@@ -530,22 +572,28 @@ def repeatEq : ∀ {n} (α : TypeVec n), α ⊗ α ⟹ repeat _ Prop
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print TypeVec.const_append1 /-
 theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
     TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x := by
   ext i : 1 <;> cases i <;> rfl
 #align typevec.const_append1 TypeVec.const_append1
+-/
 
+#print TypeVec.eq_nilFun /-
 theorem eq_nilFun {α β : TypeVec 0} (f : α ⟹ β) : f = nilFun := by ext x <;> cases x
 #align typevec.eq_nil_fun TypeVec.eq_nilFun
+-/
 
 #print TypeVec.id_eq_nilFun /-
 theorem id_eq_nilFun {α : TypeVec 0} : @id _ α = nilFun := by ext x <;> cases x
 #align typevec.id_eq_nil_fun TypeVec.id_eq_nilFun
 -/
 
+#print TypeVec.const_nil /-
 theorem const_nil {β} (x : β) (α : TypeVec 0) : TypeVec.const x α = nilFun := by
   ext i : 1 <;> cases i <;> rfl
 #align typevec.const_nil TypeVec.const_nil
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print TypeVec.repeat_eq_append1 /-
@@ -678,7 +726,6 @@ protected def prod.map : ∀ {n} {α α' β β' : TypeVec.{u} n}, α ⟹ β →
 #align typevec.prod.map TypeVec.prod.map
 -/
 
--- mathport name: typevec.prod.map
 scoped[MvFunctor] infixl:45 " ⊗' " => TypeVec.prod.map
 
 #print TypeVec.fst_prod_mk /-
@@ -950,10 +997,12 @@ theorem subtypeVal_toSubtype {α : TypeVec n} (p : α ⟹ repeat n Prop) :
 #align typevec.subtype_val_to_subtype TypeVec.subtypeVal_toSubtype
 -/
 
+#print TypeVec.toSubtype_of_subtype_assoc /-
 @[simp]
 theorem toSubtype_of_subtype_assoc {α β : TypeVec n} (p : α ⟹ repeat n Prop) (f : β ⟹ Subtype_ p) :
     @toSubtype n _ p ⊚ ofSubtype _ ⊚ f = f := by rw [← comp_assoc, to_subtype_of_subtype] <;> simp
 #align typevec.to_subtype_of_subtype_assoc TypeVec.toSubtype_of_subtype_assoc
+-/
 
 #print TypeVec.toSubtype'_of_subtype' /-
 @[simp]

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -930,7 +930,7 @@ theorem prod_map_id {α β : TypeVec n} : (@TypeVec.id _ α ⊗' @TypeVec.id _ 
 #print TypeVec.subtypeVal_diagSub /-
 @[simp]
 theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
-  clear * - ; ext i; induction i <;> [rfl; apply i_ih]
+  clear * -; ext i; induction i <;> [rfl; apply i_ih]
 #align typevec.subtype_val_diag_sub TypeVec.subtypeVal_diagSub
 -/

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -614,7 +614,7 @@ def ofRepeat {α : Sort _} : ∀ {n i}, repeat n α i → α
 
 #print TypeVec.const_iff_true /-
 theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
-  induction i <;> [rfl;erw [TypeVec.const, @i_ih (drop α) x]]
+  induction i <;> [rfl; erw [TypeVec.const, @i_ih (drop α) x]]
 #align typevec.const_iff_true TypeVec.const_iff_true
 -/
 
@@ -684,32 +684,32 @@ scoped[MvFunctor] infixl:45 " ⊗' " => TypeVec.prod.map
 #print TypeVec.fst_prod_mk /-
 theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
-  ext i <;> induction i <;> [rfl;apply i_ih]
+  ext i <;> induction i <;> [rfl; apply i_ih]
 #align typevec.fst_prod_mk TypeVec.fst_prod_mk
 -/
 
 #print TypeVec.snd_prod_mk /-
 theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
-  ext i <;> induction i <;> [rfl;apply i_ih]
+  ext i <;> induction i <;> [rfl; apply i_ih]
 #align typevec.snd_prod_mk TypeVec.snd_prod_mk
 -/
 
 #print TypeVec.fst_diag /-
 theorem fst_diag {α : TypeVec n} : TypeVec.prod.fst ⊚ (prod.diag : α ⟹ _) = id := by
-  ext i <;> induction i <;> [rfl;apply i_ih]
+  ext i <;> induction i <;> [rfl; apply i_ih]
 #align typevec.fst_diag TypeVec.fst_diag
 -/
 
 #print TypeVec.snd_diag /-
 theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _) = id := by
-  ext i <;> induction i <;> [rfl;apply i_ih]
+  ext i <;> induction i <;> [rfl; apply i_ih]
 #align typevec.snd_diag TypeVec.snd_diag
 -/
 
 #print TypeVec.repeatEq_iff_eq /-
 theorem repeatEq_iff_eq {α : TypeVec n} {i x y} : ofRepeat (repeatEq α i (prod.mk _ x y)) ↔ x = y :=
-  by induction i <;> [rfl;erw [repeat_eq, @i_ih (drop α) x y]]
+  by induction i <;> [rfl; erw [repeat_eq, @i_ih (drop α) x y]]
 #align typevec.repeat_eq_iff_eq TypeVec.repeatEq_iff_eq
 -/
 
@@ -790,14 +790,14 @@ theorem subtypeVal_nil {α : TypeVec.{u} 0} (ps : α ⟹ repeat 0 Prop) :
 
 #print TypeVec.diag_sub_val /-
 theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
-  ext i <;> induction i <;> [rfl;apply i_ih]
+  ext i <;> induction i <;> [rfl; apply i_ih]
 #align typevec.diag_sub_val TypeVec.diag_sub_val
 -/
 
 #print TypeVec.prod_id /-
 theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ β ⟹ _) :=
   by
-  intros ; ext (i a); induction i
+  intros; ext (i a); induction i
   · cases a; rfl
   · apply i_ih
 #align typevec.prod_id TypeVec.prod_id
@@ -810,7 +810,7 @@ theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ 
 theorem append_prod_appendFun {n} {α α' β β' : TypeVec.{u} n} {φ φ' ψ ψ' : Type u} {f₀ : α ⟹ α'}
     {g₀ : β ⟹ β'} {f₁ : φ → φ'} {g₁ : ψ → ψ'} :
     (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) := by
-  ext (i a) <;> cases i <;> [cases a;skip] <;> rfl
+  ext (i a) <;> cases i <;> [cases a; skip] <;> rfl
 #align typevec.append_prod_append_fun TypeVec.append_prod_appendFun
 -/
 
@@ -930,7 +930,7 @@ theorem prod_map_id {α β : TypeVec n} : (@TypeVec.id _ α ⊗' @TypeVec.id _ 
 #print TypeVec.subtypeVal_diagSub /-
 @[simp]
 theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
-  clear * - ; ext i; induction i <;> [rfl;apply i_ih]
+  clear * - ; ext i; induction i <;> [rfl; apply i_ih]
 #align typevec.subtype_val_diag_sub TypeVec.subtypeVal_diagSub
 -/

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -877,7 +877,7 @@ theorem dropFun_RelLast' {α : TypeVec n} {β} (R : β → β → Prop) :
 
 attribute [simp] drop_append1'
 
-open MvFunctor
+open scoped MvFunctor
 
 #print TypeVec.dropFun_prod /-
 @[simp]

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -87,35 +87,17 @@ def comp {α β γ : TypeVec n} (g : β ⟹ γ) (f : α ⟹ β) : α ⟹ γ := f
 -- mathport name: typevec.comp
 scoped[MvFunctor] infixr:80 " ⊚ " => TypeVec.comp
 
-/- warning: typevec.id_comp -> TypeVec.id_comp is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {β : TypeVec.{u2} n} (f : TypeVec.Arrow.{u1, u2} n α β), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} n α β) (TypeVec.comp.{u1, u2, u2} n α β β (TypeVec.id.{u2} n β) f) f
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} n} {β : TypeVec.{u1} n} (f : TypeVec.Arrow.{u2, u1} n α β), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n α β) (TypeVec.comp.{u2, u1, u1} n α β β (TypeVec.id.{u1} n β) f) f
-Case conversion may be inaccurate. Consider using '#align typevec.id_comp TypeVec.id_compₓ'. -/
 -- type as \oo
 @[simp]
 theorem id_comp {α β : TypeVec n} (f : α ⟹ β) : id ⊚ f = f :=
   rfl
 #align typevec.id_comp TypeVec.id_comp
 
-/- warning: typevec.comp_id -> TypeVec.comp_id is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {β : TypeVec.{u2} n} (f : TypeVec.Arrow.{u1, u2} n α β), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} n α β) (TypeVec.comp.{u1, u1, u2} n α α β f (TypeVec.id.{u1} n α)) f
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} n} {β : TypeVec.{u1} n} (f : TypeVec.Arrow.{u2, u1} n α β), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n α β) (TypeVec.comp.{u2, u2, u1} n α α β f (TypeVec.id.{u2} n α)) f
-Case conversion may be inaccurate. Consider using '#align typevec.comp_id TypeVec.comp_idₓ'. -/
 @[simp]
 theorem comp_id {α β : TypeVec n} (f : α ⟹ β) : f ⊚ id = f :=
   rfl
 #align typevec.comp_id TypeVec.comp_id
 
-/- warning: typevec.comp_assoc -> TypeVec.comp_assoc is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {β : TypeVec.{u2} n} {γ : TypeVec.{u3} n} {δ : TypeVec.{u4} n} (h : TypeVec.Arrow.{u3, u4} n γ δ) (g : TypeVec.Arrow.{u2, u3} n β γ) (f : TypeVec.Arrow.{u1, u2} n α β), Eq.{max 1 (succ u1) (succ u4)} (TypeVec.Arrow.{u1, u4} n α δ) (TypeVec.comp.{u1, u2, u4} n α β δ (TypeVec.comp.{u2, u3, u4} n β γ δ h g) f) (TypeVec.comp.{u1, u3, u4} n α γ δ h (TypeVec.comp.{u1, u2, u3} n α β γ g f))
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u4} n} {β : TypeVec.{u3} n} {γ : TypeVec.{u2} n} {δ : TypeVec.{u1} n} (h : TypeVec.Arrow.{u2, u1} n γ δ) (g : TypeVec.Arrow.{u3, u2} n β γ) (f : TypeVec.Arrow.{u4, u3} n α β), Eq.{max (succ u4) (succ u1)} (TypeVec.Arrow.{u4, u1} n α δ) (TypeVec.comp.{u4, u3, u1} n α β δ (TypeVec.comp.{u3, u2, u1} n β γ δ h g) f) (TypeVec.comp.{u4, u2, u1} n α γ δ h (TypeVec.comp.{u4, u3, u2} n α β γ g f))
-Case conversion may be inaccurate. Consider using '#align typevec.comp_assoc TypeVec.comp_assocₓ'. -/
 theorem comp_assoc {α β γ δ : TypeVec n} (h : γ ⟹ δ) (g : β ⟹ γ) (f : α ⟹ β) :
     (h ⊚ g) ⊚ f = h ⊚ g ⊚ f :=
   rfl
@@ -185,12 +167,6 @@ def append1Cases {C : TypeVec (n + 1) → Sort u} (H : ∀ α β, C (append1 α
 #align typevec.append1_cases TypeVec.append1Cases
 -/
 
-/- warning: typevec.append1_cases_append1 -> TypeVec.append1_cases_append1 is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {C : (TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) -> Sort.{u1}} (H : forall (α : TypeVec.{u2} n) (β : Type.{u2}), C (TypeVec.append1.{u2} n α β)) (α : TypeVec.{u2} n) (β : Type.{u2}), Eq.{u1} (C (TypeVec.append1.{u2} n α β)) (TypeVec.append1Cases.{u1, u2} n C H (TypeVec.append1.{u2} n α β)) (H α β)
-but is expected to have type
-  forall {n : Nat} {C : (TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) -> Sort.{u2}} (H : forall (α : TypeVec.{u1} n) (β : Type.{u1}), C (TypeVec.append1.{u1} n α β)) (α : TypeVec.{u1} n) (β : Type.{u1}), Eq.{u2} (C (TypeVec.append1.{u1} n α β)) (TypeVec.append1Cases.{u2, u1} n C H (TypeVec.append1.{u1} n α β)) (H α β)
-Case conversion may be inaccurate. Consider using '#align typevec.append1_cases_append1 TypeVec.append1_cases_append1ₓ'. -/
 @[simp]
 theorem append1_cases_append1 {C : TypeVec (n + 1) → Sort u} (H : ∀ α β, C (append1 α β)) (α β) :
     @append1Cases _ C H (append1 α β) = H α β :=
@@ -237,23 +213,11 @@ def nilFun {α : TypeVec 0} {β : TypeVec 0} : α ⟹ β := fun i => Fin2.elim0
 #align typevec.nil_fun TypeVec.nilFun
 -/
 
-/- warning: typevec.eq_of_drop_last_eq -> TypeVec.eq_of_drop_last_eq is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {β : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {f : TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α β} {g : TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α β}, (Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α) (TypeVec.drop.{u2} n β)) (TypeVec.dropFun.{u1, u2} n α β f) (TypeVec.dropFun.{u1, u2} n α β g)) -> (Eq.{max (succ u1) (succ u2)} ((TypeVec.last.{u1} n α) -> (TypeVec.last.{u2} n β)) (TypeVec.lastFun.{u1, u2} n α β f) (TypeVec.lastFun.{u1, u2} n α β g)) -> (Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α β) f g)
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {β : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {f : TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α β} {g : TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α β}, (Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α) (TypeVec.drop.{u1} n β)) (TypeVec.dropFun.{u2, u1} n α β f) (TypeVec.dropFun.{u2, u1} n α β g)) -> (Eq.{max (succ u2) (succ u1)} ((TypeVec.last.{u2} n α) -> (TypeVec.last.{u1} n β)) (TypeVec.lastFun.{u2, u1} n α β f) (TypeVec.lastFun.{u2, u1} n α β g)) -> (Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α β) f g)
-Case conversion may be inaccurate. Consider using '#align typevec.eq_of_drop_last_eq TypeVec.eq_of_drop_last_eqₓ'. -/
 theorem eq_of_drop_last_eq {α β : TypeVec (n + 1)} {f g : α ⟹ β} (h₀ : dropFun f = dropFun g)
     (h₁ : lastFun f = lastFun g) : f = g := by
   replace h₀ := congr_fun h₀ <;> ext1 ⟨⟩ <;> apply_assumption
 #align typevec.eq_of_drop_last_eq TypeVec.eq_of_drop_last_eq
 
-/- warning: typevec.drop_fun_split_fun -> TypeVec.dropFun_splitFun is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α' : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} (f : TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α) (TypeVec.drop.{u2} n α')) (g : (TypeVec.last.{u1} n α) -> (TypeVec.last.{u2} n α')), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α) (TypeVec.drop.{u2} n α')) (TypeVec.dropFun.{u1, u2} n α α' (TypeVec.splitFun.{u1, u2} n α α' f g)) f
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α' : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} (f : TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α) (TypeVec.drop.{u1} n α')) (g : (TypeVec.last.{u2} n α) -> (TypeVec.last.{u1} n α')), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α) (TypeVec.drop.{u1} n α')) (TypeVec.dropFun.{u2, u1} n α α' (TypeVec.splitFun.{u2, u1} n α α' f g)) f
-Case conversion may be inaccurate. Consider using '#align typevec.drop_fun_split_fun TypeVec.dropFun_splitFunₓ'. -/
 @[simp]
 theorem dropFun_splitFun {α α' : TypeVec (n + 1)} (f : drop α ⟹ drop α') (g : last α → last α') :
     dropFun (splitFun f g) = f :=
@@ -290,24 +254,12 @@ def fromAppend1DropLast {α : TypeVec (n + 1)} : (drop α ::: last α) ⟹ α :=
 #align typevec.from_append1_drop_last TypeVec.fromAppend1DropLast
 -/
 
-/- warning: typevec.last_fun_split_fun -> TypeVec.lastFun_splitFun is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α' : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} (f : TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α) (TypeVec.drop.{u2} n α')) (g : (TypeVec.last.{u1} n α) -> (TypeVec.last.{u2} n α')), Eq.{max (succ u1) (succ u2)} ((TypeVec.last.{u1} n α) -> (TypeVec.last.{u2} n α')) (TypeVec.lastFun.{u1, u2} n α α' (TypeVec.splitFun.{u1, u2} n α α' f g)) g
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α' : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} (f : TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α) (TypeVec.drop.{u1} n α')) (g : (TypeVec.last.{u2} n α) -> (TypeVec.last.{u1} n α')), Eq.{max (succ u2) (succ u1)} ((TypeVec.last.{u2} n α) -> (TypeVec.last.{u1} n α')) (TypeVec.lastFun.{u2, u1} n α α' (TypeVec.splitFun.{u2, u1} n α α' f g)) g
-Case conversion may be inaccurate. Consider using '#align typevec.last_fun_split_fun TypeVec.lastFun_splitFunₓ'. -/
 @[simp]
 theorem lastFun_splitFun {α α' : TypeVec (n + 1)} (f : drop α ⟹ drop α') (g : last α → last α') :
     lastFun (splitFun f g) = g :=
   rfl
 #align typevec.last_fun_split_fun TypeVec.lastFun_splitFun
 
-/- warning: typevec.drop_fun_append_fun -> TypeVec.dropFun_appendFun is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {α' : TypeVec.{u2} n} {β : Type.{u1}} {β' : Type.{u2}} (f : TypeVec.Arrow.{u1, u2} n α α') (g : β -> β'), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n (TypeVec.append1.{u1} n α β)) (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n α' β'))) (TypeVec.dropFun.{u1, u2} n (TypeVec.append1.{u1} n α β) (TypeVec.append1.{u2} n α' β') (TypeVec.appendFun.{u1, u2} n α α' β β' f g)) f
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} n} {α' : TypeVec.{u1} n} {β : Type.{u2}} {β' : Type.{u1}} (f : TypeVec.Arrow.{u2, u1} n α α') (g : β -> β'), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n α β)) (TypeVec.drop.{u1} n (TypeVec.append1.{u1} n α' β'))) (TypeVec.dropFun.{u2, u1} n (TypeVec.append1.{u2} n α β) (TypeVec.append1.{u1} n α' β') (TypeVec.appendFun.{u2, u1} n α α' β β' f g)) f
-Case conversion may be inaccurate. Consider using '#align typevec.drop_fun_append_fun TypeVec.dropFun_appendFunₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem dropFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β → β') :
@@ -315,12 +267,6 @@ theorem dropFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α'
   rfl
 #align typevec.drop_fun_append_fun TypeVec.dropFun_appendFun
 
-/- warning: typevec.last_fun_append_fun -> TypeVec.lastFun_appendFun is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {α' : TypeVec.{u2} n} {β : Type.{u1}} {β' : Type.{u2}} (f : TypeVec.Arrow.{u1, u2} n α α') (g : β -> β'), Eq.{max (succ u1) (succ u2)} ((TypeVec.last.{u1} n (TypeVec.append1.{u1} n α β)) -> (TypeVec.last.{u2} n (TypeVec.append1.{u2} n α' β'))) (TypeVec.lastFun.{u1, u2} n (TypeVec.append1.{u1} n α β) (TypeVec.append1.{u2} n α' β') (TypeVec.appendFun.{u1, u2} n α α' β β' f g)) g
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} n} {α' : TypeVec.{u1} n} {β : Type.{u2}} {β' : Type.{u1}} (f : TypeVec.Arrow.{u2, u1} n α α') (g : β -> β'), Eq.{max (succ u2) (succ u1)} ((TypeVec.last.{u2} n (TypeVec.append1.{u2} n α β)) -> (TypeVec.last.{u1} n (TypeVec.append1.{u1} n α' β'))) (TypeVec.lastFun.{u2, u1} n (TypeVec.append1.{u2} n α β) (TypeVec.append1.{u1} n α' β') (TypeVec.appendFun.{u2, u1} n α α' β β' f g)) g
-Case conversion may be inaccurate. Consider using '#align typevec.last_fun_append_fun TypeVec.lastFun_appendFunₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem lastFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β → β') :
@@ -328,34 +274,16 @@ theorem lastFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α'
   rfl
 #align typevec.last_fun_append_fun TypeVec.lastFun_appendFun
 
-/- warning: typevec.split_drop_fun_last_fun -> TypeVec.split_dropFun_lastFun is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α' : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} (f : TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α α'), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α α') (TypeVec.splitFun.{u1, u2} n α α' (TypeVec.dropFun.{u1, u2} n α α' f) (TypeVec.lastFun.{u1, u2} n α α' f)) f
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α' : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} (f : TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α α'), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α α') (TypeVec.splitFun.{u2, u1} n α α' (TypeVec.dropFun.{u2, u1} n α α' f) (TypeVec.lastFun.{u2, u1} n α α' f)) f
-Case conversion may be inaccurate. Consider using '#align typevec.split_drop_fun_last_fun TypeVec.split_dropFun_lastFunₓ'. -/
 theorem split_dropFun_lastFun {α α' : TypeVec (n + 1)} (f : α ⟹ α') :
     splitFun (dropFun f) (lastFun f) = f :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.split_drop_fun_last_fun TypeVec.split_dropFun_lastFun
 
-/- warning: typevec.split_fun_inj -> TypeVec.splitFun_inj is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α' : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {f : TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α) (TypeVec.drop.{u2} n α')} {f' : TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α) (TypeVec.drop.{u2} n α')} {g : (TypeVec.last.{u1} n α) -> (TypeVec.last.{u2} n α')} {g' : (TypeVec.last.{u1} n α) -> (TypeVec.last.{u2} n α')}, (Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α α') (TypeVec.splitFun.{u1, u2} n α α' f g) (TypeVec.splitFun.{u1, u2} n α α' f' g')) -> (And (Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α) (TypeVec.drop.{u2} n α')) f f') (Eq.{max (succ u1) (succ u2)} ((TypeVec.last.{u1} n α) -> (TypeVec.last.{u2} n α')) g g'))
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α' : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {f : TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α) (TypeVec.drop.{u1} n α')} {f' : TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α) (TypeVec.drop.{u1} n α')} {g : (TypeVec.last.{u2} n α) -> (TypeVec.last.{u1} n α')} {g' : (TypeVec.last.{u2} n α) -> (TypeVec.last.{u1} n α')}, (Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α α') (TypeVec.splitFun.{u2, u1} n α α' f g) (TypeVec.splitFun.{u2, u1} n α α' f' g')) -> (And (Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α) (TypeVec.drop.{u1} n α')) f f') (Eq.{max (succ u2) (succ u1)} ((TypeVec.last.{u2} n α) -> (TypeVec.last.{u1} n α')) g g'))
-Case conversion may be inaccurate. Consider using '#align typevec.split_fun_inj TypeVec.splitFun_injₓ'. -/
 theorem splitFun_inj {α α' : TypeVec (n + 1)} {f f' : drop α ⟹ drop α'} {g g' : last α → last α'}
     (H : splitFun f g = splitFun f' g') : f = f' ∧ g = g' := by
   rw [← drop_fun_split_fun f g, H, ← last_fun_split_fun f g, H] <;> simp
 #align typevec.split_fun_inj TypeVec.splitFun_inj
 
-/- warning: typevec.append_fun_inj -> TypeVec.appendFun_inj is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {α' : TypeVec.{u2} n} {β : Type.{u1}} {β' : Type.{u2}} {f : TypeVec.Arrow.{u1, u2} n α α'} {f' : TypeVec.Arrow.{u1, u2} n α α'} {g : β -> β'} {g' : β -> β'}, (Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α β) (TypeVec.append1.{u2} n α' β')) (TypeVec.appendFun.{u1, u2} n α α' β β' f g) (TypeVec.appendFun.{u1, u2} n α α' β β' f' g')) -> (And (Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} n α α') f f') (Eq.{max (succ u1) (succ u2)} (β -> β') g g'))
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} n} {α' : TypeVec.{u1} n} {β : Type.{u2}} {β' : Type.{u1}} {f : TypeVec.Arrow.{u2, u1} n α α'} {f' : TypeVec.Arrow.{u2, u1} n α α'} {g : β -> β'} {g' : β -> β'}, (Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u2} n α β) (TypeVec.append1.{u1} n α' β')) (TypeVec.appendFun.{u2, u1} n α α' β β' f g) (TypeVec.appendFun.{u2, u1} n α α' β β' f' g')) -> (And (Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n α α') f f') (Eq.{max (succ u2) (succ u1)} (β -> β') g g'))
-Case conversion may be inaccurate. Consider using '#align typevec.append_fun_inj TypeVec.appendFun_injₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem appendFun_inj {α α' : TypeVec n} {β β' : Type _} {f f' : α ⟹ α'} {g g' : β → β'} :
@@ -363,36 +291,18 @@ theorem appendFun_inj {α α' : TypeVec n} {β β' : Type _} {f f' : α ⟹ α'}
   splitFun_inj
 #align typevec.append_fun_inj TypeVec.appendFun_inj
 
-/- warning: typevec.split_fun_comp -> TypeVec.splitFun_comp is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α₀ : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α₁ : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α₂ : TypeVec.{u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} (f₀ : TypeVec.Arrow.{u1, u2} n (TypeVec.drop.{u1} n α₀) (TypeVec.drop.{u2} n α₁)) (f₁ : TypeVec.Arrow.{u2, u3} n (TypeVec.drop.{u2} n α₁) (TypeVec.drop.{u3} n α₂)) (g₀ : (TypeVec.last.{u1} n α₀) -> (TypeVec.last.{u2} n α₁)) (g₁ : (TypeVec.last.{u2} n α₁) -> (TypeVec.last.{u3} n α₂)), Eq.{max 1 (succ u1) (succ u3)} (TypeVec.Arrow.{u1, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₀ α₂) (TypeVec.splitFun.{u1, u3} n α₀ α₂ (TypeVec.comp.{u1, u2, u3} n (TypeVec.drop.{u1} n α₀) (TypeVec.drop.{u2} n α₁) (TypeVec.drop.{u3} n α₂) f₁ f₀) (Function.comp.{succ u1, succ u2, succ u3} (TypeVec.last.{u1} n α₀) (TypeVec.last.{u2} n α₁) (TypeVec.last.{u3} n α₂) g₁ g₀)) (TypeVec.comp.{u1, u2, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₀ α₁ α₂ (TypeVec.splitFun.{u2, u3} n α₁ α₂ f₁ g₁) (TypeVec.splitFun.{u1, u2} n α₀ α₁ f₀ g₀))
-but is expected to have type
-  forall {n : Nat} {α₀ : TypeVec.{u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α₁ : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α₂ : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} (f₀ : TypeVec.Arrow.{u3, u2} n (TypeVec.drop.{u3} n α₀) (TypeVec.drop.{u2} n α₁)) (f₁ : TypeVec.Arrow.{u2, u1} n (TypeVec.drop.{u2} n α₁) (TypeVec.drop.{u1} n α₂)) (g₀ : (TypeVec.last.{u3} n α₀) -> (TypeVec.last.{u2} n α₁)) (g₁ : (TypeVec.last.{u2} n α₁) -> (TypeVec.last.{u1} n α₂)), Eq.{max (succ u3) (succ u1)} (TypeVec.Arrow.{u3, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₀ α₂) (TypeVec.splitFun.{u3, u1} n α₀ α₂ (TypeVec.comp.{u3, u2, u1} n (TypeVec.drop.{u3} n α₀) (TypeVec.drop.{u2} n α₁) (TypeVec.drop.{u1} n α₂) f₁ f₀) (Function.comp.{succ u3, succ u2, succ u1} (TypeVec.last.{u3} n α₀) (TypeVec.last.{u2} n α₁) (TypeVec.last.{u1} n α₂) g₁ g₀)) (TypeVec.comp.{u3, u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₀ α₁ α₂ (TypeVec.splitFun.{u2, u1} n α₁ α₂ f₁ g₁) (TypeVec.splitFun.{u3, u2} n α₀ α₁ f₀ g₀))
-Case conversion may be inaccurate. Consider using '#align typevec.split_fun_comp TypeVec.splitFun_compₓ'. -/
 theorem splitFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : drop α₀ ⟹ drop α₁) (f₁ : drop α₁ ⟹ drop α₂)
     (g₀ : last α₀ → last α₁) (g₁ : last α₁ → last α₂) :
     splitFun (f₁ ⊚ f₀) (g₁ ∘ g₀) = splitFun f₁ g₁ ⊚ splitFun f₀ g₀ :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.split_fun_comp TypeVec.splitFun_comp
 
-/- warning: typevec.append_fun_comp_split_fun -> TypeVec.appendFun_comp_splitFun is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {γ : TypeVec.{u2} n} {β : Type.{u1}} {δ : Type.{u2}} {ε : TypeVec.{u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} (f₀ : TypeVec.Arrow.{u3, u1} n (TypeVec.drop.{u3} n ε) α) (f₁ : TypeVec.Arrow.{u1, u2} n α γ) (g₀ : (TypeVec.last.{u3} n ε) -> β) (g₁ : β -> δ), Eq.{max 1 (succ u3) (succ u2)} (TypeVec.Arrow.{u3, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) ε (TypeVec.append1.{u2} n γ δ)) (TypeVec.comp.{u3, u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) ε (TypeVec.append1.{u1} n α β) (TypeVec.append1.{u2} n γ δ) (TypeVec.appendFun.{u1, u2} n α γ β δ f₁ g₁) (TypeVec.splitFun.{u3, u1} n ε (TypeVec.append1.{u1} n α β) f₀ g₀)) (TypeVec.splitFun.{u3, u2} n ε (TypeVec.append1.{u2} n γ δ) (TypeVec.comp.{u3, u1, u2} n (TypeVec.drop.{u3} n ε) α (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n γ δ)) f₁ f₀) (Function.comp.{succ u3, succ u1, succ u2} (TypeVec.last.{u3} n ε) β (TypeVec.last.{u2} n (TypeVec.append1.{u2} n γ δ)) g₁ g₀))
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u3} n} {γ : TypeVec.{u2} n} {β : Type.{u3}} {δ : Type.{u2}} {ε : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} (f₀ : TypeVec.Arrow.{u1, u3} n (TypeVec.drop.{u1} n ε) α) (f₁ : TypeVec.Arrow.{u3, u2} n α γ) (g₀ : (TypeVec.last.{u1} n ε) -> β) (g₁ : β -> δ), Eq.{max (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) ε (TypeVec.append1.{u2} n γ δ)) (TypeVec.comp.{u1, u3, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) ε (TypeVec.append1.{u3} n α β) (TypeVec.append1.{u2} n γ δ) (TypeVec.appendFun.{u3, u2} n α γ β δ f₁ g₁) (TypeVec.splitFun.{u1, u3} n ε (TypeVec.append1.{u3} n α β) f₀ g₀)) (TypeVec.splitFun.{u1, u2} n ε (TypeVec.append1.{u2} n γ δ) (TypeVec.comp.{u1, u3, u2} n (TypeVec.drop.{u1} n ε) α (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n γ δ)) f₁ f₀) (Function.comp.{succ u1, succ u3, succ u2} (TypeVec.last.{u1} n ε) β (TypeVec.last.{u2} n (TypeVec.append1.{u2} n γ δ)) g₁ g₀))
-Case conversion may be inaccurate. Consider using '#align typevec.append_fun_comp_split_fun TypeVec.appendFun_comp_splitFunₓ'. -/
 theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type _} {ε : TypeVec (n + 1)}
     (f₀ : drop ε ⟹ α) (f₁ : α ⟹ γ) (g₀ : last ε → β) (g₁ : β → δ) :
     appendFun f₁ g₁ ⊚ splitFun f₀ g₀ = splitFun (f₁ ⊚ f₀) (g₁ ∘ g₀) :=
   (splitFun_comp _ _ _ _).symm
 #align typevec.append_fun_comp_split_fun TypeVec.appendFun_comp_splitFun
 
-/- warning: typevec.append_fun_comp -> TypeVec.appendFun_comp is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α₀ : TypeVec.{u1} n} {α₁ : TypeVec.{u2} n} {α₂ : TypeVec.{u3} n} {β₀ : Type.{u1}} {β₁ : Type.{u2}} {β₂ : Type.{u3}} (f₀ : TypeVec.Arrow.{u1, u2} n α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u3} n α₁ α₂) (g₀ : β₀ -> β₁) (g₁ : β₁ -> β₂), Eq.{max 1 (succ u1) (succ u3)} (TypeVec.Arrow.{u1, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α₀ β₀) (TypeVec.append1.{u3} n α₂ β₂)) (TypeVec.appendFun.{u1, u3} n α₀ α₂ β₀ β₂ (TypeVec.comp.{u1, u2, u3} n α₀ α₁ α₂ f₁ f₀) (Function.comp.{succ u1, succ u2, succ u3} β₀ β₁ β₂ g₁ g₀)) (TypeVec.comp.{u1, u2, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α₀ β₀) (TypeVec.append1.{u2} n α₁ β₁) (TypeVec.append1.{u3} n α₂ β₂) (TypeVec.appendFun.{u2, u3} n α₁ α₂ β₁ β₂ f₁ g₁) (TypeVec.appendFun.{u1, u2} n α₀ α₁ β₀ β₁ f₀ g₀))
-but is expected to have type
-  forall {n : Nat} {α₀ : TypeVec.{u3} n} {α₁ : TypeVec.{u2} n} {α₂ : TypeVec.{u1} n} {β₀ : Type.{u3}} {β₁ : Type.{u2}} {β₂ : Type.{u1}} (f₀ : TypeVec.Arrow.{u3, u2} n α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u1} n α₁ α₂) (g₀ : β₀ -> β₁) (g₁ : β₁ -> β₂), Eq.{max (succ u3) (succ u1)} (TypeVec.Arrow.{u3, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u3} n α₀ β₀) (TypeVec.append1.{u1} n α₂ β₂)) (TypeVec.appendFun.{u3, u1} n α₀ α₂ β₀ β₂ (TypeVec.comp.{u3, u2, u1} n α₀ α₁ α₂ f₁ f₀) (Function.comp.{succ u3, succ u2, succ u1} β₀ β₁ β₂ g₁ g₀)) (TypeVec.comp.{u3, u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u3} n α₀ β₀) (TypeVec.append1.{u2} n α₁ β₁) (TypeVec.append1.{u1} n α₂ β₂) (TypeVec.appendFun.{u2, u1} n α₁ α₂ β₁ β₂ f₁ g₁) (TypeVec.appendFun.{u3, u2} n α₀ α₁ β₀ β₁ f₀ g₀))
-Case conversion may be inaccurate. Consider using '#align typevec.append_fun_comp TypeVec.appendFun_compₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -401,12 +311,6 @@ theorem appendFun_comp {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Type
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp TypeVec.appendFun_comp
 
-/- warning: typevec.append_fun_comp' -> TypeVec.appendFun_comp' is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α₀ : TypeVec.{u1} n} {α₁ : TypeVec.{u2} n} {α₂ : TypeVec.{u3} n} {β₀ : Type.{u1}} {β₁ : Type.{u2}} {β₂ : Type.{u3}} (f₀ : TypeVec.Arrow.{u1, u2} n α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u3} n α₁ α₂) (g₀ : β₀ -> β₁) (g₁ : β₁ -> β₂), Eq.{max 1 (succ u1) (succ u3)} (TypeVec.Arrow.{u1, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α₀ β₀) (TypeVec.append1.{u3} n α₂ β₂)) (TypeVec.comp.{u1, u2, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α₀ β₀) (TypeVec.append1.{u2} n α₁ β₁) (TypeVec.append1.{u3} n α₂ β₂) (TypeVec.appendFun.{u2, u3} n α₁ α₂ β₁ β₂ f₁ g₁) (TypeVec.appendFun.{u1, u2} n α₀ α₁ β₀ β₁ f₀ g₀)) (TypeVec.appendFun.{u1, u3} n α₀ α₂ β₀ β₂ (TypeVec.comp.{u1, u2, u3} n α₀ α₁ α₂ f₁ f₀) (Function.comp.{succ u1, succ u2, succ u3} β₀ β₁ β₂ g₁ g₀))
-but is expected to have type
-  forall {n : Nat} {α₀ : TypeVec.{u3} n} {α₁ : TypeVec.{u2} n} {α₂ : TypeVec.{u1} n} {β₀ : Type.{u3}} {β₁ : Type.{u2}} {β₂ : Type.{u1}} (f₀ : TypeVec.Arrow.{u3, u2} n α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u1} n α₁ α₂) (g₀ : β₀ -> β₁) (g₁ : β₁ -> β₂), Eq.{max (succ u3) (succ u1)} (TypeVec.Arrow.{u3, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u3} n α₀ β₀) (TypeVec.append1.{u1} n α₂ β₂)) (TypeVec.comp.{u3, u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u3} n α₀ β₀) (TypeVec.append1.{u2} n α₁ β₁) (TypeVec.append1.{u1} n α₂ β₂) (TypeVec.appendFun.{u2, u1} n α₁ α₂ β₁ β₂ f₁ g₁) (TypeVec.appendFun.{u3, u2} n α₀ α₁ β₀ β₁ f₀ g₀)) (TypeVec.appendFun.{u3, u1} n α₀ α₂ β₀ β₂ (TypeVec.comp.{u3, u2, u1} n α₀ α₁ α₂ f₁ f₀) (Function.comp.{succ u3, succ u2, succ u1} β₀ β₁ β₂ g₁ g₀))
-Case conversion may be inaccurate. Consider using '#align typevec.append_fun_comp' TypeVec.appendFun_comp'ₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -415,12 +319,6 @@ theorem appendFun_comp' {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Typ
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp' TypeVec.appendFun_comp'
 
-/- warning: typevec.nil_fun_comp -> TypeVec.nilFun_comp is a dubious translation:
-lean 3 declaration is
-  forall {α₀ : TypeVec.{u1} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))} (f₀ : TypeVec.Arrow.{u1, u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) α₀ (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2}))), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) α₀ (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2}))) (TypeVec.comp.{u1, u2, u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) α₀ (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2})) (TypeVec.nilFun.{u2, u2} (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2}))) f₀) f₀
-but is expected to have type
-  forall {α₀ : TypeVec.{u2} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))} (f₀ : TypeVec.Arrow.{u2, u1} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) α₀ (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u1}))), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) α₀ (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u1}))) (TypeVec.comp.{u2, u1, u1} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) α₀ (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u1})) (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u1})) (TypeVec.nilFun.{u1, u1} (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u1})) (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u1}))) f₀) f₀
-Case conversion may be inaccurate. Consider using '#align typevec.nil_fun_comp TypeVec.nilFun_compₓ'. -/
 theorem nilFun_comp {α₀ : TypeVec 0} (f₀ : α₀ ⟹ Fin2.elim0) : nilFun ⊚ f₀ = f₀ :=
   funext fun x => Fin2.elim0 x
 #align typevec.nil_fun_comp TypeVec.nilFun_comp
@@ -435,36 +333,18 @@ theorem appendFun_comp_id {α : TypeVec n} {β₀ β₁ β₂ : Type _} (g₀ :
 #align typevec.append_fun_comp_id TypeVec.appendFun_comp_id
 -/
 
-/- warning: typevec.drop_fun_comp -> TypeVec.dropFun_comp is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α₀ : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α₁ : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α₂ : TypeVec.{u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} (f₀ : TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₁ α₂), Eq.{max 1 (succ u1) (succ u3)} (TypeVec.Arrow.{u1, u3} n (TypeVec.drop.{u1} n α₀) (TypeVec.drop.{u3} n α₂)) (TypeVec.dropFun.{u1, u3} n α₀ α₂ (TypeVec.comp.{u1, u2, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₀ α₁ α₂ f₁ f₀)) (TypeVec.comp.{u1, u2, u3} n (TypeVec.drop.{u1} n α₀) (TypeVec.drop.{u2} n α₁) (TypeVec.drop.{u3} n α₂) (TypeVec.dropFun.{u2, u3} n α₁ α₂ f₁) (TypeVec.dropFun.{u1, u2} n α₀ α₁ f₀))
-but is expected to have type
-  forall {n : Nat} {α₀ : TypeVec.{u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α₁ : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α₂ : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} (f₀ : TypeVec.Arrow.{u3, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₁ α₂), Eq.{max (succ u3) (succ u1)} (TypeVec.Arrow.{u3, u1} n (TypeVec.drop.{u3} n α₀) (TypeVec.drop.{u1} n α₂)) (TypeVec.dropFun.{u3, u1} n α₀ α₂ (TypeVec.comp.{u3, u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₀ α₁ α₂ f₁ f₀)) (TypeVec.comp.{u3, u2, u1} n (TypeVec.drop.{u3} n α₀) (TypeVec.drop.{u2} n α₁) (TypeVec.drop.{u1} n α₂) (TypeVec.dropFun.{u2, u1} n α₁ α₂ f₁) (TypeVec.dropFun.{u3, u2} n α₀ α₁ f₀))
-Case conversion may be inaccurate. Consider using '#align typevec.drop_fun_comp TypeVec.dropFun_compₓ'. -/
 @[simp]
 theorem dropFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂) :
     dropFun (f₁ ⊚ f₀) = dropFun f₁ ⊚ dropFun f₀ :=
   rfl
 #align typevec.drop_fun_comp TypeVec.dropFun_comp
 
-/- warning: typevec.last_fun_comp -> TypeVec.lastFun_comp is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α₀ : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α₁ : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} {α₂ : TypeVec.{u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))} (f₀ : TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₁ α₂), Eq.{max (succ u1) (succ u3)} ((TypeVec.last.{u1} n α₀) -> (TypeVec.last.{u3} n α₂)) (TypeVec.lastFun.{u1, u3} n α₀ α₂ (TypeVec.comp.{u1, u2, u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) α₀ α₁ α₂ f₁ f₀)) (Function.comp.{succ u1, succ u2, succ u3} (TypeVec.last.{u1} n α₀) (TypeVec.last.{u2} n α₁) (TypeVec.last.{u3} n α₂) (TypeVec.lastFun.{u2, u3} n α₁ α₂ f₁) (TypeVec.lastFun.{u1, u2} n α₀ α₁ f₀))
-but is expected to have type
-  forall {n : Nat} {α₀ : TypeVec.{u3} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α₁ : TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} {α₂ : TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))} (f₀ : TypeVec.Arrow.{u3, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₀ α₁) (f₁ : TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₁ α₂), Eq.{max (succ u3) (succ u1)} ((TypeVec.last.{u3} n α₀) -> (TypeVec.last.{u1} n α₂)) (TypeVec.lastFun.{u3, u1} n α₀ α₂ (TypeVec.comp.{u3, u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) α₀ α₁ α₂ f₁ f₀)) (Function.comp.{succ u3, succ u2, succ u1} (TypeVec.last.{u3} n α₀) (TypeVec.last.{u2} n α₁) (TypeVec.last.{u1} n α₂) (TypeVec.lastFun.{u2, u1} n α₁ α₂ f₁) (TypeVec.lastFun.{u3, u2} n α₀ α₁ f₀))
-Case conversion may be inaccurate. Consider using '#align typevec.last_fun_comp TypeVec.lastFun_compₓ'. -/
 @[simp]
 theorem lastFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂) :
     lastFun (f₁ ⊚ f₀) = lastFun f₁ ∘ lastFun f₀ :=
   rfl
 #align typevec.last_fun_comp TypeVec.lastFun_comp
 
-/- warning: typevec.append_fun_aux -> TypeVec.appendFun_aux is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {α' : TypeVec.{u2} n} {β : Type.{u1}} {β' : Type.{u2}} (f : TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α β) (TypeVec.append1.{u2} n α' β')), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n (TypeVec.drop.{u1} n (TypeVec.append1.{u1} n α β)) (TypeVec.last.{u1} n (TypeVec.append1.{u1} n α β))) (TypeVec.append1.{u2} n (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n α' β')) (TypeVec.last.{u2} n (TypeVec.append1.{u2} n α' β')))) (TypeVec.appendFun.{u1, u2} n (TypeVec.drop.{u1} n (TypeVec.append1.{u1} n α β)) (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n α' β')) (TypeVec.last.{u1} n (TypeVec.append1.{u1} n α β)) (TypeVec.last.{u2} n (TypeVec.append1.{u2} n α' β')) (TypeVec.dropFun.{u1, u2} n (TypeVec.append1.{u1} n α β) (TypeVec.append1.{u2} n α' β') f) (TypeVec.lastFun.{u1, u2} n (TypeVec.append1.{u1} n α β) (TypeVec.append1.{u2} n α' β') f)) f
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} n} {α' : TypeVec.{u1} n} {β : Type.{u2}} {β' : Type.{u1}} (f : TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u2} n α β) (TypeVec.append1.{u1} n α' β')), Eq.{max (succ u1) (succ u2)} (TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u2} n (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n α β)) (TypeVec.last.{u2} n (TypeVec.append1.{u2} n α β))) (TypeVec.append1.{u1} n (TypeVec.drop.{u1} n (TypeVec.append1.{u1} n α' β')) (TypeVec.last.{u1} n (TypeVec.append1.{u1} n α' β')))) (TypeVec.appendFun.{u2, u1} n (TypeVec.drop.{u2} n (TypeVec.append1.{u2} n α β)) (TypeVec.drop.{u1} n (TypeVec.append1.{u1} n α' β')) (TypeVec.last.{u2} n (TypeVec.append1.{u2} n α β)) (TypeVec.last.{u1} n (TypeVec.append1.{u1} n α' β')) (TypeVec.dropFun.{u2, u1} n (TypeVec.append1.{u2} n α β) (TypeVec.append1.{u1} n α' β') f) (TypeVec.lastFun.{u2, u1} n (TypeVec.append1.{u2} n α β) (TypeVec.append1.{u1} n α' β') f)) f
-Case conversion may be inaccurate. Consider using '#align typevec.append_fun_aux TypeVec.appendFun_auxₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -510,23 +390,11 @@ protected def casesCons (n : ℕ) {β : TypeVec (n + 1) → Sort _}
 #align typevec.cases_cons TypeVec.casesCons
 -/
 
-/- warning: typevec.cases_nil_append1 -> TypeVec.casesNil_append1 is a dubious translation:
-lean 3 declaration is
-  forall {β : (TypeVec.{u1} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> Sort.{u2}} (f : β (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u1}))), Eq.{u2} (β (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u1}))) (TypeVec.casesNil.{u1, u2} β f (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u1}))) f
-but is expected to have type
-  forall {β : (TypeVec.{u2} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> Sort.{u1}} (f : β (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u2}))), Eq.{u1} (β (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u2}))) (TypeVec.casesNil.{u2, u1} β f (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u2}))) f
-Case conversion may be inaccurate. Consider using '#align typevec.cases_nil_append1 TypeVec.casesNil_append1ₓ'. -/
 protected theorem casesNil_append1 {β : TypeVec 0 → Sort _} (f : β Fin2.elim0) :
     TypeVec.casesNil f Fin2.elim0 = f :=
   rfl
 #align typevec.cases_nil_append1 TypeVec.casesNil_append1
 
-/- warning: typevec.cases_cons_append1 -> TypeVec.casesCons_append1 is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat) {β : (TypeVec.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) -> Sort.{u2}} (f : forall (t : Type.{u1}) (v : TypeVec.{u1} n), β (TypeVec.append1.{u1} n v t)) (v : TypeVec.{u1} n) (α : Type.{u1}), Eq.{u2} (β (TypeVec.append1.{u1} n v α)) (TypeVec.casesCons.{u1, u2} n β f (TypeVec.append1.{u1} n v α)) (f α v)
-but is expected to have type
-  forall (n : Nat) {β : (TypeVec.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) -> Sort.{u1}} (f : forall (t : Type.{u2}) (v : TypeVec.{u2} n), β (TypeVec.append1.{u2} n v t)) (v : TypeVec.{u2} n) (α : Type.{u2}), Eq.{u1} (β (TypeVec.append1.{u2} n v α)) (TypeVec.casesCons.{u2, u1} n β f (TypeVec.append1.{u2} n v α)) (f α v)
-Case conversion may be inaccurate. Consider using '#align typevec.cases_cons_append1 TypeVec.casesCons_append1ₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 protected theorem casesCons_append1 (n : ℕ) {β : TypeVec (n + 1) → Sort _}
@@ -583,23 +451,11 @@ def typevecCasesCons₂ (n : ℕ) (t t' : Type _) (v v' : TypeVec n)
 #align typevec.typevec_cases_cons₂ TypeVec.typevecCasesCons₂
 -/
 
-/- warning: typevec.typevec_cases_nil₂_append_fun -> TypeVec.typevecCasesNil₂_appendFun is a dubious translation:
-lean 3 declaration is
-  forall {β : (TypeVec.Arrow.{u1, u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u1})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2}))) -> Sort.{u3}} (f : β (TypeVec.nilFun.{u1, u2} (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u1})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2})))), Eq.{u3} (β (TypeVec.nilFun.{u1, u2} (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u1})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2})))) (TypeVec.typevecCasesNil₂.{u1, u2, u3} β f (TypeVec.nilFun.{u1, u2} (Fin2.elim0.{succ (succ u1)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u1})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => Type.{u2})))) f
-but is expected to have type
-  forall {β : (TypeVec.Arrow.{u3, u2} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (Fin2.elim0.{succ (succ u3)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u3})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u2}))) -> Sort.{u1}} (f : β (TypeVec.nilFun.{u3, u2} (Fin2.elim0.{succ (succ u3)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u3})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u2})))), Eq.{u1} (β (TypeVec.nilFun.{u3, u2} (Fin2.elim0.{succ (succ u3)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u3})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u2})))) (TypeVec.typevecCasesNil₂.{u3, u2, u1} β f (TypeVec.nilFun.{u3, u2} (Fin2.elim0.{succ (succ u3)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u3})) (Fin2.elim0.{succ (succ u2)} (fun (ᾰ : Fin2 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) => Type.{u2})))) f
-Case conversion may be inaccurate. Consider using '#align typevec.typevec_cases_nil₂_append_fun TypeVec.typevecCasesNil₂_appendFunₓ'. -/
 theorem typevecCasesNil₂_appendFun {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort _} (f : β nilFun) :
     typevecCasesNil₂ f nilFun = f :=
   rfl
 #align typevec.typevec_cases_nil₂_append_fun TypeVec.typevecCasesNil₂_appendFun
 
-/- warning: typevec.typevec_cases_cons₂_append_fun -> TypeVec.typevecCasesCons₂_appendFun is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat) (t : Type.{u1}) (t' : Type.{u2}) (v : TypeVec.{u1} n) (v' : TypeVec.{u2} n) {β : (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n v t) (TypeVec.append1.{u2} n v' t')) -> Sort.{u3}} (F : forall (f : t -> t') (fs : TypeVec.Arrow.{u1, u2} n v v'), β (TypeVec.appendFun.{u1, u2} n v v' t t' fs f)) (f : t -> t') (fs : TypeVec.Arrow.{u1, u2} n v v'), Eq.{u3} (β (TypeVec.appendFun.{u1, u2} n v v' t t' fs f)) (TypeVec.typevecCasesCons₂.{u1, u2, u3} n t t' v v' β F (TypeVec.appendFun.{u1, u2} n v v' t t' fs f)) (F f fs)
-but is expected to have type
-  forall (n : Nat) (t : Type.{u3}) (t' : Type.{u2}) (v : TypeVec.{u3} n) (v' : TypeVec.{u2} n) {β : (TypeVec.Arrow.{u3, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u3} n v t) (TypeVec.append1.{u2} n v' t')) -> Sort.{u1}} (F : forall (f : t -> t') (fs : TypeVec.Arrow.{u3, u2} n v v'), β (TypeVec.appendFun.{u3, u2} n v v' t t' fs f)) (f : t -> t') (fs : TypeVec.Arrow.{u3, u2} n v v'), Eq.{u1} (β (TypeVec.appendFun.{u3, u2} n v v' t t' fs f)) (TypeVec.typevecCasesCons₂.{u3, u2, u1} n t t' v v' β F (TypeVec.appendFun.{u3, u2} n v v' t t' fs f)) (F f fs)
-Case conversion may be inaccurate. Consider using '#align typevec.typevec_cases_cons₂_append_fun TypeVec.typevecCasesCons₂_appendFunₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -673,24 +529,12 @@ def repeatEq : ∀ {n} (α : TypeVec n), α ⊗ α ⟹ repeat _ Prop
 #align typevec.repeat_eq TypeVec.repeatEq
 -/
 
-/- warning: typevec.const_append1 -> TypeVec.const_append1 is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} {γ : Type.{u2}} (x : γ) {n : Nat} (α : TypeVec.{u1} n), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α β) (TypeVec.repeat.{u2} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) γ)) (TypeVec.const.{u2, u1} γ x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (TypeVec.append1.{u1} n α β)) (TypeVec.appendFun.{u1, u2} n α (TypeVec.repeat.{u2} (Nat.add n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) γ) β γ (TypeVec.const.{u2, u1} γ x n α) (fun (_x : β) => x))
-but is expected to have type
-  forall {β : Type.{u2}} {γ : Type.{u1}} (x : γ) {n : Nat} (α : TypeVec.{u2} n), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u2} n α β) (TypeVec.repeat.{u1} (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) γ)) (TypeVec.const.{u1, u2} γ x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (TypeVec.append1.{u2} n α β)) (TypeVec.appendFun.{u2, u1} n α (TypeVec.repeat.{u1} n γ) β γ (TypeVec.const.{u1, u2} γ x n α) (fun (_x : β) => x))
-Case conversion may be inaccurate. Consider using '#align typevec.const_append1 TypeVec.const_append1ₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
     TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x := by
   ext i : 1 <;> cases i <;> rfl
 #align typevec.const_append1 TypeVec.const_append1
 
-/- warning: typevec.eq_nil_fun -> TypeVec.eq_nilFun is a dubious translation:
-lean 3 declaration is
-  forall {α : TypeVec.{u1} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))} {β : TypeVec.{u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))} (f : TypeVec.Arrow.{u1, u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) α β), Eq.{max 1 (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) α β) f (TypeVec.nilFun.{u1, u2} α β)
-but is expected to have type
-  forall {α : TypeVec.{u2} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))} {β : TypeVec.{u1} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))} (f : TypeVec.Arrow.{u2, u1} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) α β), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) α β) f (TypeVec.nilFun.{u2, u1} α β)
-Case conversion may be inaccurate. Consider using '#align typevec.eq_nil_fun TypeVec.eq_nilFunₓ'. -/
 theorem eq_nilFun {α β : TypeVec 0} (f : α ⟹ β) : f = nilFun := by ext x <;> cases x
 #align typevec.eq_nil_fun TypeVec.eq_nilFun
 
@@ -699,12 +543,6 @@ theorem id_eq_nilFun {α : TypeVec 0} : @id _ α = nilFun := by ext x <;> cases
 #align typevec.id_eq_nil_fun TypeVec.id_eq_nilFun
 -/
 
-/- warning: typevec.const_nil -> TypeVec.const_nil is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} (x : β) (α : TypeVec.{u2} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))), Eq.{max 1 (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) α (TypeVec.repeat.{u1} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) β)) (TypeVec.const.{u1, u2} β x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) α) (TypeVec.nilFun.{u2, u1} α (TypeVec.repeat.{u1} (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) β))
-but is expected to have type
-  forall {β : Type.{u2}} (x : β) (α : TypeVec.{u1} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))), Eq.{max (succ u1) (succ u2)} (TypeVec.Arrow.{u1, u2} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) α (TypeVec.repeat.{u2} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) β)) (TypeVec.const.{u2, u1} β x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) α) (TypeVec.nilFun.{u1, u2} α (TypeVec.repeat.{u2} (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) β))
-Case conversion may be inaccurate. Consider using '#align typevec.const_nil TypeVec.const_nilₓ'. -/
 theorem const_nil {β} (x : β) (α : TypeVec 0) : TypeVec.const x α = nilFun := by
   ext i : 1 <;> cases i <;> rfl
 #align typevec.const_nil TypeVec.const_nil
@@ -1112,12 +950,6 @@ theorem subtypeVal_toSubtype {α : TypeVec n} (p : α ⟹ repeat n Prop) :
 #align typevec.subtype_val_to_subtype TypeVec.subtypeVal_toSubtype
 -/
 
-/- warning: typevec.to_subtype_of_subtype_assoc -> TypeVec.toSubtype_of_subtype_assoc is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat} {α : TypeVec.{u1} n} {β : TypeVec.{u2} n} (p : TypeVec.Arrow.{u1, 0} n α (TypeVec.repeat.{0} n Prop)) (f : TypeVec.Arrow.{u2, u1} n β (TypeVec.Subtype_.{u1} n α p)), Eq.{max 1 (succ u2) (succ u1)} (TypeVec.Arrow.{u2, u1} n β (TypeVec.Subtype_.{u1} n α p)) (TypeVec.comp.{u2, u1, u1} n β (fun (i : Fin2 n) => Subtype.{succ u1} (α i) (fun (x : α i) => TypeVec.ofRepeat.{0} Prop n i (p i x))) (TypeVec.Subtype_.{u1} n α p) (TypeVec.toSubtype.{u1} n α p) (TypeVec.comp.{u2, u1, u1} n β (TypeVec.Subtype_.{u1} n (fun (i : Fin2 n) => α i) (fun (i : Fin2 n) (x : α i) => p i x)) (fun (i : Fin2 n) => Subtype.{succ u1} (α i) (fun (x : α i) => TypeVec.ofRepeat.{0} Prop n i (p i x))) (TypeVec.ofSubtype.{u1} n (fun (i : Fin2 n) => α i) (fun (i : Fin2 n) (x : α i) => p i x)) f)) f
-but is expected to have type
-  forall {n : Nat} {α : TypeVec.{u2} n} {β : TypeVec.{u1} n} (p : TypeVec.Arrow.{u2, 0} n α (TypeVec.repeat.{0} n Prop)) (f : TypeVec.Arrow.{u1, u2} n β (TypeVec.Subtype_.{u2} n α p)), Eq.{max (succ u2) (succ u1)} (TypeVec.Arrow.{u1, u2} n β (TypeVec.Subtype_.{u2} n α p)) (TypeVec.comp.{u1, u2, u2} n β (fun (i : Fin2 n) => Subtype.{succ u2} (α i) (fun (x : α i) => TypeVec.ofRepeat.{0} Prop n i (p i x))) (TypeVec.Subtype_.{u2} n α p) (TypeVec.toSubtype.{u2} n α p) (TypeVec.comp.{u1, u2, u2} n β (TypeVec.Subtype_.{u2} n (fun (i : Fin2 n) => α i) (fun (i : Fin2 n) (x : α i) => p i x)) (fun (i : Fin2 n) => Subtype.{succ u2} (α i) (fun (x : α i) => TypeVec.ofRepeat.{0} Prop n i (p i x))) (TypeVec.ofSubtype.{u2} n (fun (i : Fin2 n) => α i) (fun (i : Fin2 n) (x : α i) => p i x)) f)) f
-Case conversion may be inaccurate. Consider using '#align typevec.to_subtype_of_subtype_assoc TypeVec.toSubtype_of_subtype_assocₓ'. -/
 @[simp]
 theorem toSubtype_of_subtype_assoc {α β : TypeVec n} (p : α ⟹ repeat n Prop) (f : β ⟹ Subtype_ p) :
     @toSubtype n _ p ⊚ ofSubtype _ ⊚ f = f := by rw [← comp_assoc, to_subtype_of_subtype] <;> simp

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -960,8 +960,7 @@ theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ dia
 theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ β ⟹ _) :=
   by
   intros ; ext (i a); induction i
-  · cases a
-    rfl
+  · cases a; rfl
   · apply i_ih
 #align typevec.prod_id TypeVec.prod_id
 -/
@@ -981,9 +980,7 @@ end Liftp'
 
 #print TypeVec.dropFun_diag /-
 @[simp]
-theorem dropFun_diag {α} : dropFun (@prod.diag (n + 1) α) = prod.diag :=
-  by
-  ext i : 2
+theorem dropFun_diag {α} : dropFun (@prod.diag (n + 1) α) = prod.diag := by ext i : 2;
   induction i <;> simp [drop_fun, *] <;> rfl
 #align typevec.drop_fun_diag TypeVec.dropFun_diag
 -/
@@ -1007,36 +1004,28 @@ theorem lastFun_subtypeVal {α} (p : α ⟹ repeat (n + 1) Prop) :
 #print TypeVec.dropFun_toSubtype /-
 @[simp]
 theorem dropFun_toSubtype {α} (p : α ⟹ repeat (n + 1) Prop) : dropFun (toSubtype p) = toSubtype _ :=
-  by
-  ext i : 2
-  induction i <;> simp [drop_fun, *] <;> rfl
+  by ext i : 2; induction i <;> simp [drop_fun, *] <;> rfl
 #align typevec.drop_fun_to_subtype TypeVec.dropFun_toSubtype
 -/
 
 #print TypeVec.lastFun_toSubtype /-
 @[simp]
-theorem lastFun_toSubtype {α} (p : α ⟹ repeat (n + 1) Prop) : lastFun (toSubtype p) = id :=
-  by
-  ext i : 2
-  induction i <;> simp [drop_fun, *] <;> rfl
+theorem lastFun_toSubtype {α} (p : α ⟹ repeat (n + 1) Prop) : lastFun (toSubtype p) = id := by
+  ext i : 2; induction i <;> simp [drop_fun, *] <;> rfl
 #align typevec.last_fun_to_subtype TypeVec.lastFun_toSubtype
 -/
 
 #print TypeVec.dropFun_of_subtype /-
 @[simp]
 theorem dropFun_of_subtype {α} (p : α ⟹ repeat (n + 1) Prop) :
-    dropFun (ofSubtype p) = ofSubtype _ := by
-  ext i : 2
-  induction i <;> simp [drop_fun, *] <;> rfl
+    dropFun (ofSubtype p) = ofSubtype _ := by ext i : 2; induction i <;> simp [drop_fun, *] <;> rfl
 #align typevec.drop_fun_of_subtype TypeVec.dropFun_of_subtype
 -/
 
 #print TypeVec.lastFun_of_subtype /-
 @[simp]
-theorem lastFun_of_subtype {α} (p : α ⟹ repeat (n + 1) Prop) : lastFun (ofSubtype p) = id :=
-  by
-  ext i : 2
-  induction i <;> simp [drop_fun, *] <;> rfl
+theorem lastFun_of_subtype {α} (p : α ⟹ repeat (n + 1) Prop) : lastFun (ofSubtype p) = id := by
+  ext i : 2; induction i <;> simp [drop_fun, *] <;> rfl
 #align typevec.last_fun_of_subtype TypeVec.lastFun_of_subtype
 -/
 
@@ -1055,9 +1044,7 @@ open MvFunctor
 #print TypeVec.dropFun_prod /-
 @[simp]
 theorem dropFun_prod {α α' β β' : TypeVec (n + 1)} (f : α ⟹ β) (f' : α' ⟹ β') :
-    dropFun (f ⊗' f') = (dropFun f ⊗' dropFun f') :=
-  by
-  ext i : 2
+    dropFun (f ⊗' f') = (dropFun f ⊗' dropFun f') := by ext i : 2;
   induction i <;> simp [drop_fun, *] <;> rfl
 #align typevec.drop_fun_prod TypeVec.dropFun_prod
 -/
@@ -1065,9 +1052,7 @@ theorem dropFun_prod {α α' β β' : TypeVec (n + 1)} (f : α ⟹ β) (f' : α'
 #print TypeVec.lastFun_prod /-
 @[simp]
 theorem lastFun_prod {α α' β β' : TypeVec (n + 1)} (f : α ⟹ β) (f' : α' ⟹ β') :
-    lastFun (f ⊗' f') = Prod.map (lastFun f) (lastFun f') :=
-  by
-  ext i : 1
+    lastFun (f ⊗' f') = Prod.map (lastFun f) (lastFun f') := by ext i : 1;
   induction i <;> simp [last_fun, *] <;> rfl
 #align typevec.last_fun_prod TypeVec.lastFun_prod
 -/
@@ -1099,21 +1084,15 @@ theorem dropFun_id {α : TypeVec (n + 1)} : dropFun (@TypeVec.id _ α) = id :=
 @[simp]
 theorem prod_map_id {α β : TypeVec n} : (@TypeVec.id _ α ⊗' @TypeVec.id _ β) = id :=
   by
-  ext i : 2
-  induction i <;> simp only [TypeVec.prod.map, *, drop_fun_id]
-  cases x
-  rfl
-  rfl
+  ext i : 2; induction i <;> simp only [TypeVec.prod.map, *, drop_fun_id]
+  cases x; rfl; rfl
 #align typevec.prod_map_id TypeVec.prod_map_id
 -/
 
 #print TypeVec.subtypeVal_diagSub /-
 @[simp]
-theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag :=
-  by
-  clear * -
-  ext i
-  induction i <;> [rfl;apply i_ih]
+theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
+  clear * - ; ext i; induction i <;> [rfl;apply i_ih]
 #align typevec.subtype_val_diag_sub TypeVec.subtypeVal_diagSub
 -/

bump to nightly-2023-05-24-06

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

fbc7b476

Diff

@@ -776,7 +776,7 @@ def ofRepeat {α : Sort _} : ∀ {n i}, repeat n α i → α
 
 #print TypeVec.const_iff_true /-
 theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
-  induction i <;> [rfl, erw [TypeVec.const, @i_ih (drop α) x]]
+  induction i <;> [rfl;erw [TypeVec.const, @i_ih (drop α) x]]
 #align typevec.const_iff_true TypeVec.const_iff_true
 -/
 
@@ -846,32 +846,32 @@ scoped[MvFunctor] infixl:45 " ⊗' " => TypeVec.prod.map
 #print TypeVec.fst_prod_mk /-
 theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
-  ext i <;> induction i <;> [rfl, apply i_ih]
+  ext i <;> induction i <;> [rfl;apply i_ih]
 #align typevec.fst_prod_mk TypeVec.fst_prod_mk
 -/
 
 #print TypeVec.snd_prod_mk /-
 theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
-  ext i <;> induction i <;> [rfl, apply i_ih]
+  ext i <;> induction i <;> [rfl;apply i_ih]
 #align typevec.snd_prod_mk TypeVec.snd_prod_mk
 -/
 
 #print TypeVec.fst_diag /-
 theorem fst_diag {α : TypeVec n} : TypeVec.prod.fst ⊚ (prod.diag : α ⟹ _) = id := by
-  ext i <;> induction i <;> [rfl, apply i_ih]
+  ext i <;> induction i <;> [rfl;apply i_ih]
 #align typevec.fst_diag TypeVec.fst_diag
 -/
 
 #print TypeVec.snd_diag /-
 theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _) = id := by
-  ext i <;> induction i <;> [rfl, apply i_ih]
+  ext i <;> induction i <;> [rfl;apply i_ih]
 #align typevec.snd_diag TypeVec.snd_diag
 -/
 
 #print TypeVec.repeatEq_iff_eq /-
 theorem repeatEq_iff_eq {α : TypeVec n} {i x y} : ofRepeat (repeatEq α i (prod.mk _ x y)) ↔ x = y :=
-  by induction i <;> [rfl, erw [repeat_eq, @i_ih (drop α) x y]]
+  by induction i <;> [rfl;erw [repeat_eq, @i_ih (drop α) x y]]
 #align typevec.repeat_eq_iff_eq TypeVec.repeatEq_iff_eq
 -/
 
@@ -952,7 +952,7 @@ theorem subtypeVal_nil {α : TypeVec.{u} 0} (ps : α ⟹ repeat 0 Prop) :
 
 #print TypeVec.diag_sub_val /-
 theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
-  ext i <;> induction i <;> [rfl, apply i_ih]
+  ext i <;> induction i <;> [rfl;apply i_ih]
 #align typevec.diag_sub_val TypeVec.diag_sub_val
 -/
 
@@ -973,7 +973,7 @@ theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ 
 theorem append_prod_appendFun {n} {α α' β β' : TypeVec.{u} n} {φ φ' ψ ψ' : Type u} {f₀ : α ⟹ α'}
     {g₀ : β ⟹ β'} {f₁ : φ → φ'} {g₁ : ψ → ψ'} :
     (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) := by
-  ext (i a) <;> cases i <;> [cases a, skip] <;> rfl
+  ext (i a) <;> cases i <;> [cases a;skip] <;> rfl
 #align typevec.append_prod_append_fun TypeVec.append_prod_appendFun
 -/
 
@@ -1113,7 +1113,7 @@ theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagS
   by
   clear * -
   ext i
-  induction i <;> [rfl, apply i_ih]
+  induction i <;> [rfl;apply i_ih]
 #align typevec.subtype_val_diag_sub TypeVec.subtypeVal_diagSub
 -/

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -530,7 +530,7 @@ end
 theorem prod_fst_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
     TypeVec.prod.fst i (prod.mk i a b) = a := by
   induction' i with _ _ _ i_ih
-  simp_all only [prod.fst, prod.mk]
+  · simp_all only [prod.fst, prod.mk]
   apply i_ih
 #align typevec.prod_fst_mk TypeVec.prod_fst_mk
 
@@ -538,7 +538,7 @@ theorem prod_fst_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
 theorem prod_snd_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
     TypeVec.prod.snd i (prod.mk i a b) = b := by
   induction' i with _ _ _ i_ih
-  simp_all [prod.snd, prod.mk]
+  · simp_all [prod.snd, prod.mk]
   apply i_ih
 #align typevec.prod_snd_mk TypeVec.prod_snd_mk
 
@@ -582,7 +582,7 @@ theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _)
 theorem repeatEq_iff_eq {α : TypeVec n} {i x y} :
     ofRepeat (repeatEq α i (prod.mk _ x y)) ↔ x = y := by
   induction' i with _ _ _ i_ih
-  rfl
+  · rfl
   erw [repeatEq, i_ih]
 #align typevec.repeat_eq_iff_eq TypeVec.repeatEq_iff_eq
 
@@ -645,7 +645,7 @@ theorem subtypeVal_nil {α : TypeVec.{u} 0} (ps : α ⟹ «repeat» 0 Prop) :
 theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
   ext i x
   induction' i with _ _ _ i_ih
-  simp only [comp, subtypeVal, repeatEq._eq_2, diagSub, prod.diag]
+  · simp only [comp, subtypeVal, repeatEq._eq_2, diagSub, prod.diag]
   apply @i_ih (drop α)
 #align typevec.diag_sub_val TypeVec.diag_sub_val
 
@@ -762,8 +762,8 @@ theorem prod_map_id {α β : TypeVec n} : (@TypeVec.id _ α ⊗' @TypeVec.id _ 
   ext i x : 2
   induction i <;> simp only [TypeVec.prod.map, *, dropFun_id]
   cases x
-  rfl
-  rfl
+  · rfl
+  · rfl
 #align typevec.prod_map_id TypeVec.prod_map_id
 
 @[simp]

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -497,7 +497,6 @@ theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i
 
 section
 variable {α β γ : TypeVec.{u} n}
-
 variable (p : α ⟹ «repeat» n Prop) (r : α ⊗ α ⟹ «repeat» n Prop)
 
 /-- left projection of a `prod` vector -/

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -163,14 +163,14 @@ def lastFun {α β : TypeVec (n + 1)} (f : α ⟹ β) : last α → last β :=
   f Fin2.fz
 #align typevec.last_fun TypeVec.lastFun
 
--- porting note: Lean wasn't able to infer the motive in term mode
+-- Porting note: Lean wasn't able to infer the motive in term mode
 /-- arrow in the category of `0-length` vectors -/
 def nilFun {α : TypeVec 0} {β : TypeVec 0} : α ⟹ β := fun i => by apply Fin2.elim0 i
 #align typevec.nil_fun TypeVec.nilFun
 
 theorem eq_of_drop_last_eq {α β : TypeVec (n + 1)} {f g : α ⟹ β} (h₀ : dropFun f = dropFun g)
     (h₁ : lastFun f = lastFun g) : f = g := by
-  -- porting note: FIXME: congr_fun h₀ <;> ext1 ⟨⟩ <;> apply_assumption
+  -- Porting note: FIXME: congr_fun h₀ <;> ext1 ⟨⟩ <;> apply_assumption
   refine funext (fun x => ?_)
   cases x
   · apply h₁
@@ -264,7 +264,7 @@ theorem appendFun_comp' {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Typ
 #align typevec.append_fun_comp' TypeVec.appendFun_comp'
 
 theorem nilFun_comp {α₀ : TypeVec 0} (f₀ : α₀ ⟹ Fin2.elim0) : nilFun ⊚ f₀ = f₀ :=
-  funext fun x => by apply Fin2.elim0 x -- porting note: `by apply` is necessary?
+  funext fun x => by apply Fin2.elim0 x -- Porting note: `by apply` is necessary?
 #align typevec.nil_fun_comp TypeVec.nilFun_comp
 
 theorem appendFun_comp_id {α : TypeVec n} {β₀ β₁ β₂ : Type u} (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
@@ -295,7 +295,7 @@ theorem appendFun_id_id {α : TypeVec n} {β : Type*} :
 #align typevec.append_fun_id_id TypeVec.appendFun_id_id
 
 instance subsingleton0 : Subsingleton (TypeVec 0) :=
-  ⟨fun a b => funext fun a => by apply Fin2.elim0 a⟩ -- porting note: `by apply` necessary?
+  ⟨fun a b => funext fun a => by apply Fin2.elim0 a⟩ -- Porting note: `by apply` necessary?
 #align typevec.subsingleton0 TypeVec.subsingleton0
 
 -- Porting note: `simp` attribute `TypeVec` moved to file `Tactic/Attr/Register.lean`

chore(*): drop $/<| before fun (#9361)

Subset of #9319

3694e27d

Diff

@@ -116,7 +116,7 @@ theorem drop_append1 {α : TypeVec n} {β : Type*} {i : Fin2 n} : drop (append1
 #align typevec.drop_append1 TypeVec.drop_append1
 
 theorem drop_append1' {α : TypeVec n} {β : Type*} : drop (append1 α β) = α :=
-  funext <| fun _ => drop_append1
+  funext fun _ => drop_append1
 #align typevec.drop_append1' TypeVec.drop_append1'
 
 theorem last_append1 {α : TypeVec n} {β : Type*} : last (append1 α β) = β :=

style: use cases x with | ... instead of cases x; case => ... (#9321)

This converts usages of the pattern

cases h
case inl h' => ...
case inr h' => ...

which derive from mathported code, to the "structured cases" syntax:

cases h with
| inl h' => ...
| inr h' => ...

The case where the subgoals are handled with · instead of case is more contentious (and much more numerous) so I left those alone. This pattern also appears with cases', induction, induction', and rcases. Furthermore, there is a similar transformation for by_cases:

by_cases h : cond
case pos => ...
case neg => ...

is replaced by:

if h : cond then
  ...
else
  ...

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

e04a464d

Diff

@@ -489,9 +489,9 @@ def ofRepeat {α : Sort _} : ∀ {n i}, «repeat» n α i → α
 #align typevec.of_repeat TypeVec.ofRepeat
 
 theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
-  induction i
-  case fz      => rfl
-  case fs _ ih => erw [TypeVec.const, @ih (drop α) x]
+  induction i with
+  | fz      => rfl
+  | fs _ ih => erw [TypeVec.const, @ih (drop α) x]
 #align typevec.const_iff_true TypeVec.const_iff_true
 
 
@@ -556,28 +556,28 @@ protected def prod.map : ∀ {n} {α α' β β' : TypeVec.{u} n}, α ⟹ β →
 
 theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
-  funext i; induction i
-  case fz => rfl
-  case fs _ _ i_ih => apply i_ih
+  funext i; induction i with
+  | fz => rfl
+  | fs _ i_ih => apply i_ih
 #align typevec.fst_prod_mk TypeVec.fst_prod_mk
 
 theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
-  funext i; induction i
-  case fz => rfl
-  case fs _ _ i_ih => apply i_ih
+  funext i; induction i with
+  | fz => rfl
+  | fs _ i_ih => apply i_ih
 #align typevec.snd_prod_mk TypeVec.snd_prod_mk
 
 theorem fst_diag {α : TypeVec n} : TypeVec.prod.fst ⊚ (prod.diag : α ⟹ _) = id := by
-  funext i; induction i
-  case fz => rfl
-  case fs _ _ i_ih => apply i_ih
+  funext i; induction i with
+  | fz => rfl
+  | fs _ i_ih => apply i_ih
 #align typevec.fst_diag TypeVec.fst_diag
 
 theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _) = id := by
-  funext i; induction i
-  case fz => rfl
-  case fs _ _ i_ih => apply i_ih
+  funext i; induction i with
+  | fz => rfl
+  | fs _ i_ih => apply i_ih
 #align typevec.snd_diag TypeVec.snd_diag
 
 theorem repeatEq_iff_eq {α : TypeVec n} {i x y} :

chore: Remove nonterminal simp at (#7795)

Removes nonterminal uses of simp at. Replaces most of these with instances of simp? ... says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

4160b2aa

Diff

@@ -773,7 +773,8 @@ theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagS
   induction' i with _ _ _ i_ih
   · simp [comp, diagSub, subtypeVal, prod.diag]
   · simp [prod.diag]
-    simp [comp, diagSub, subtypeVal, prod.diag] at *
+    simp? [comp, diagSub, subtypeVal, prod.diag] at * says
+      simp only [comp, subtypeVal, diagSub] at *
     apply @i_ih (drop _)
 #align typevec.subtype_val_diag_sub TypeVec.subtypeVal_diagSub

chore: remove nonterminal simp (#7580)

Removes nonterminal simps on lines looking like simp [...]

6fc8e6ec

Diff

@@ -646,7 +646,7 @@ theorem subtypeVal_nil {α : TypeVec.{u} 0} (ps : α ⟹ «repeat» 0 Prop) :
 theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
   ext i x
   induction' i with _ _ _ i_ih
-  simp [prod.diag, diagSub, repeatEq, subtypeVal, comp]
+  simp only [comp, subtypeVal, repeatEq._eq_2, diagSub, prod.diag]
   apply @i_ih (drop α)
 #align typevec.diag_sub_val TypeVec.diag_sub_val

style: pp_with_univ for TypeVec & PFunctor & MvPFunctor (#7742)

68b12e11

Diff

@@ -35,6 +35,7 @@ to it, we need support functions and lemmas to mediate between constructions.
 universe u v w
 
 /-- n-tuples of types, as a category -/
+@[pp_with_univ]
 def TypeVec (n : ℕ) :=
   Fin2 n → Type*
 #align typevec TypeVec

chore: remove many Type _ before the colon (#7718)

We have turned to Type* instead of Type _, but many of them remained in mathlib because the straight replacement did not work. In general, having Type _ before the colon is a code smell, though, as it hides which types should be in the same universe and which shouldn't, and is not very robust.

This PR replaces most of the remaining Type _ before the colon (except those in category theory) by Type* or Type u. This has uncovered a few bugs (where declarations were not as polymorphic as they should be).

I had to increase heartbeats at two places when replacing Type _ by Type*, but I think it's worth it as it's really more robust.

fe9572d2

Diff

@@ -266,7 +266,7 @@ theorem nilFun_comp {α₀ : TypeVec 0} (f₀ : α₀ ⟹ Fin2.elim0) : nilFun 
   funext fun x => by apply Fin2.elim0 x -- porting note: `by apply` is necessary?
 #align typevec.nil_fun_comp TypeVec.nilFun_comp
 
-theorem appendFun_comp_id {α : TypeVec n} {β₀ β₁ β₂ : Type _} (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
+theorem appendFun_comp_id {α : TypeVec n} {β₀ β₁ β₂ : Type u} (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
     (@id _ α ::: g₁ ∘ g₀) = (id ::: g₁) ⊚ (id ::: g₀) :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp_id TypeVec.appendFun_comp_id
@@ -384,7 +384,7 @@ def PredLast (α : TypeVec n) {β : Type*} (p : β → Prop) : ∀ ⦃i⦄, (α.
 
 /-- `RelLast α r x y` says that `p` the last elements of `x y : α.append1 β` are related by `r` and
 all the other elements are equal. -/
-def RelLast (α : TypeVec n) {β γ : Type _} (r : β → γ → Prop) :
+def RelLast (α : TypeVec n) {β γ : Type u} (r : β → γ → Prop) :
     ∀ ⦃i⦄, (α.append1 β) i → (α.append1 γ) i → Prop
   | Fin2.fs _ => Eq
   | Fin2.fz => r
@@ -466,7 +466,7 @@ def RelLast' (α : TypeVec n) {β : Type*} (p : β → β → Prop) :
 
 /-- given `F : TypeVec.{u} (n+1) → Type u`, `curry F : Type u → TypeVec.{u} → Type u`,
 i.e. its first argument can be fed in separately from the rest of the vector of arguments -/
-def Curry (F : TypeVec.{u} (n + 1) → Type _) (α : Type u) (β : TypeVec.{u} n) : Type* :=
+def Curry (F : TypeVec.{u} (n + 1) → Type*) (α : Type u) (β : TypeVec.{u} n) : Type _ :=
   F (β ::: α)
 #align typevec.curry TypeVec.Curry

chore: exactly 4 spaces in theorems (#7328)

Co-authored-by: Moritz Firsching <firsching@google.com>

d3263b23

Diff

@@ -243,26 +243,21 @@ theorem splitFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : drop α₀ 
 #align typevec.split_fun_comp TypeVec.splitFun_comp
 
 theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type*} {ε : TypeVec (n + 1)}
-          (f₀ : drop ε ⟹ α)
-          (f₁ : α ⟹ γ)
-          (g₀ : last ε → β)
-          (g₁ : β → δ) :
-   appendFun f₁ g₁ ⊚ splitFun f₀ g₀
-      = splitFun (α' := γ.append1 δ) (f₁ ⊚ f₀) (g₁ ∘ g₀) :=
+    (f₀ : drop ε ⟹ α) (f₁ : α ⟹ γ) (g₀ : last ε → β) (g₁ : β → δ) :
+    appendFun f₁ g₁ ⊚ splitFun f₀ g₀ = splitFun (α' := γ.append1 δ) (f₁ ⊚ f₀) (g₁ ∘ g₀) :=
   (splitFun_comp _ _ _ _).symm
 #align typevec.append_fun_comp_split_fun TypeVec.appendFun_comp_splitFun
 
 theorem appendFun_comp  {α₀ α₁ α₂ : TypeVec n}
-                        {β₀ β₁ β₂ : Type*}
-                        (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
-                        (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
+    {β₀ β₁ β₂ : Type*}
+    (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
+    (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
     (f₁ ⊚ f₀ ::: g₁ ∘ g₀) = (f₁ ::: g₁) ⊚ (f₀ ::: g₀) :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp TypeVec.appendFun_comp
 
 theorem appendFun_comp' {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Type*}
-                        (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
-                        (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
+    (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂) (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
     (f₁ ::: g₁) ⊚ (f₀ ::: g₀) = (f₁ ⊚ f₀ ::: g₁ ∘ g₀) :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp' TypeVec.appendFun_comp'
@@ -311,7 +306,7 @@ protected def casesNil {β : TypeVec 0 → Sort*} (f : β Fin2.elim0) : ∀ v, 
 
 /-- cases distinction for (n+1)-length type vector -/
 protected def casesCons (n : ℕ) {β : TypeVec (n + 1) → Sort*}
-                        (f : ∀ (t) (v : TypeVec n), β (v ::: t)) :
+    (f : ∀ (t) (v : TypeVec n), β (v ::: t)) :
     ∀ v, β v :=
   fun v : TypeVec (n + 1) => cast (by simp) (f v.last v.drop)
 #align typevec.cases_cons TypeVec.casesCons
@@ -340,8 +335,8 @@ def typevecCasesNil₃ {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort*}
 
 /-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
 def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort*}
-                      (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
-                              β (v ::: t) (v' ::: t') (fs ::: f)) :
+    (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
+    β (v ::: t) (v' ::: t') (fs ::: f)) :
     ∀ v v' fs, β v v' fs := by
   intro v v'
   rw [← append1_drop_last v, ← append1_drop_last v']
@@ -359,7 +354,7 @@ def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun
 
 /-- specialized cases distinction for an arrow in the category of (n+1)-length type vectors -/
 def typevecCasesCons₂ (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
-                      {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
+    {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
     (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f)) : ∀ fs, β fs := by
   intro fs
   rw [← split_dropFun_lastFun fs]
@@ -373,9 +368,9 @@ theorem typevecCasesNil₂_appendFun {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*}
 #align typevec.typevec_cases_nil₂_append_fun TypeVec.typevecCasesNil₂_appendFun
 
 theorem typevecCasesCons₂_appendFun (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
-                                      {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
-                                      (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f))
-                                      (f fs) :
+    {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
+    (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f))
+    (f fs) :
     typevecCasesCons₂ n t t' v v' F (fs ::: f) = F f fs :=
   rfl
 #align typevec.typevec_cases_cons₂_append_fun TypeVec.typevecCasesCons₂_appendFun

chore: exactly 4 spaces in subsequent lines for def (#7321)

Co-authored-by: Moritz Firsching <firsching@google.com>

11dbfb2b

Diff

@@ -390,7 +390,7 @@ def PredLast (α : TypeVec n) {β : Type*} (p : β → Prop) : ∀ ⦃i⦄, (α.
 /-- `RelLast α r x y` says that `p` the last elements of `x y : α.append1 β` are related by `r` and
 all the other elements are equal. -/
 def RelLast (α : TypeVec n) {β γ : Type _} (r : β → γ → Prop) :
-      ∀ ⦃i⦄, (α.append1 β) i → (α.append1 γ) i → Prop
+    ∀ ⦃i⦄, (α.append1 β) i → (α.append1 γ) i → Prop
   | Fin2.fs _ => Eq
   | Fin2.fz => r
 #align typevec.rel_last TypeVec.RelLast
@@ -616,21 +616,21 @@ def toSubtype :
 /-- arrow that rearranges the type of `Subtype_` to turn a vector of subtypes
 into a subtype of vector -/
 def ofSubtype {n} {α : TypeVec.{u} n} (p : α ⟹ «repeat» n Prop) :
-      Subtype_ p ⟹ fun i : Fin2 n => { x // ofRepeat <| p i x }
+    Subtype_ p ⟹ fun i : Fin2 n => { x // ofRepeat <| p i x }
   | Fin2.fs i, x => ofSubtype _ i x
   | Fin2.fz,   x => x
 #align typevec.of_subtype TypeVec.ofSubtype
 
 /-- similar to `toSubtype` adapted to relations (i.e. predicate on product) -/
 def toSubtype' {n} {α : TypeVec.{u} n} (p : α ⊗ α ⟹ «repeat» n Prop) :
-      (fun i : Fin2 n => { x : α i × α i // ofRepeat <| p i (prod.mk _ x.1 x.2) }) ⟹ Subtype_ p
+    (fun i : Fin2 n => { x : α i × α i // ofRepeat <| p i (prod.mk _ x.1 x.2) }) ⟹ Subtype_ p
   | Fin2.fs i, x => toSubtype' (dropFun p) i x
   | Fin2.fz, x => ⟨x.val, cast (by congr) x.property⟩
 #align typevec.to_subtype' TypeVec.toSubtype'
 
 /-- similar to `of_subtype` adapted to relations (i.e. predicate on product) -/
 def ofSubtype' {n} {α : TypeVec.{u} n} (p : α ⊗ α ⟹ «repeat» n Prop) :
-      Subtype_ p ⟹ fun i : Fin2 n => { x : α i × α i // ofRepeat <| p i (prod.mk _ x.1 x.2) }
+    Subtype_ p ⟹ fun i : Fin2 n => { x : α i × α i // ofRepeat <| p i (prod.mk _ x.1 x.2) }
   | Fin2.fs i, x => ofSubtype' _ i x
   | Fin2.fz, x => ⟨x.val, cast (by congr) x.property⟩
 #align typevec.of_subtype' TypeVec.ofSubtype'

style: a linter for colons (#6761)

A linter that throws on seeing a colon at the start of a line, according to the style guideline that says these operators should go before linebreaks.

69a3de31

Diff

@@ -248,8 +248,7 @@ theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type*} {ε : TypeVe
           (g₀ : last ε → β)
           (g₁ : β → δ) :
    appendFun f₁ g₁ ⊚ splitFun f₀ g₀
-      = splitFun (α' := γ.append1 δ) (f₁ ⊚ f₀) (g₁ ∘ g₀)
-  :=
+      = splitFun (α' := γ.append1 δ) (f₁ ⊚ f₀) (g₁ ∘ g₀) :=
   (splitFun_comp _ _ _ _).symm
 #align typevec.append_fun_comp_split_fun TypeVec.appendFun_comp_splitFun
 
@@ -306,8 +305,8 @@ instance subsingleton0 : Subsingleton (TypeVec 0) :=
 -- Porting note: `simp` attribute `TypeVec` moved to file `Tactic/Attr/Register.lean`
 
 /-- cases distinction for 0-length type vector -/
-protected def casesNil {β : TypeVec 0 → Sort*} (f : β Fin2.elim0) : ∀ v, β v
-  := fun v => cast (by congr; funext i; cases i) f
+protected def casesNil {β : TypeVec 0 → Sort*} (f : β Fin2.elim0) : ∀ v, β v :=
+  fun v => cast (by congr; funext i; cases i) f
 #align typevec.cases_nil TypeVec.casesNil
 
 /-- cases distinction for (n+1)-length type vector -/

chore: avoid lean3 style have/suffices (#6964)

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

bdc47f68

Diff

@@ -354,10 +354,8 @@ def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' →
 /-- specialized cases distinction for an arrow in the category of 0-length type vectors -/
 def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun) : ∀ f, β f := by
   intro g
-  have : g = nilFun
+  suffices g = nilFun by rwa [this]
   ext ⟨⟩
-  rw [this]
-  exact f
 #align typevec.typevec_cases_nil₂ TypeVec.typevecCasesNil₂
 
 /-- specialized cases distinction for an arrow in the category of (n+1)-length type vectors -/

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -36,7 +36,7 @@ universe u v w
 
 /-- n-tuples of types, as a category -/
 def TypeVec (n : ℕ) :=
-  Fin2 n → Type _
+  Fin2 n → Type*
 #align typevec TypeVec
 
 instance {n} : Inhabited (TypeVec.{u} n) :=
@@ -90,7 +90,7 @@ theorem comp_assoc {α β γ δ : TypeVec n} (h : γ ⟹ δ) (g : β ⟹ γ) (f
 #align typevec.comp_assoc TypeVec.comp_assoc
 
 /-- Support for extending a `TypeVec` by one element. -/
-def append1 (α : TypeVec n) (β : Type _) : TypeVec (n + 1)
+def append1 (α : TypeVec n) (β : Type*) : TypeVec (n + 1)
   | Fin2.fs i => α i
   | Fin2.fz => β
 #align typevec.append1 TypeVec.append1
@@ -110,15 +110,15 @@ instance last.inhabited (α : TypeVec (n + 1)) [Inhabited (α Fin2.fz)] : Inhabi
   ⟨show α Fin2.fz from default⟩
 #align typevec.last.inhabited TypeVec.last.inhabited
 
-theorem drop_append1 {α : TypeVec n} {β : Type _} {i : Fin2 n} : drop (append1 α β) i = α i :=
+theorem drop_append1 {α : TypeVec n} {β : Type*} {i : Fin2 n} : drop (append1 α β) i = α i :=
   rfl
 #align typevec.drop_append1 TypeVec.drop_append1
 
-theorem drop_append1' {α : TypeVec n} {β : Type _} : drop (append1 α β) = α :=
+theorem drop_append1' {α : TypeVec n} {β : Type*} : drop (append1 α β) = α :=
   funext <| fun _ => drop_append1
 #align typevec.drop_append1' TypeVec.drop_append1'
 
-theorem last_append1 {α : TypeVec n} {β : Type _} : last (append1 α β) = β :=
+theorem last_append1 {α : TypeVec n} {β : Type*} : last (append1 α β) = β :=
   rfl
 #align typevec.last_append1 TypeVec.last_append1
 
@@ -146,7 +146,7 @@ def splitFun {α α' : TypeVec (n + 1)} (f : drop α ⟹ drop α') (g : last α
 #align typevec.split_fun TypeVec.splitFun
 
 /-- append an arrow and a function as well as their respective source and target types / typevecs -/
-def appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β → β') :
+def appendFun {α α' : TypeVec n} {β β' : Type*} (f : α ⟹ α') (g : β → β') :
     append1 α β ⟹ append1 α' β' :=
   splitFun f g
 #align typevec.append_fun TypeVec.appendFun
@@ -209,13 +209,13 @@ theorem lastFun_splitFun {α α' : TypeVec (n + 1)} (f : drop α ⟹ drop α') (
 #align typevec.last_fun_split_fun TypeVec.lastFun_splitFun
 
 @[simp]
-theorem dropFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β → β') :
+theorem dropFun_appendFun {α α' : TypeVec n} {β β' : Type*} (f : α ⟹ α') (g : β → β') :
     dropFun (f ::: g) = f :=
   rfl
 #align typevec.drop_fun_append_fun TypeVec.dropFun_appendFun
 
 @[simp]
-theorem lastFun_appendFun {α α' : TypeVec n} {β β' : Type _} (f : α ⟹ α') (g : β → β') :
+theorem lastFun_appendFun {α α' : TypeVec n} {β β' : Type*} (f : α ⟹ α') (g : β → β') :
     lastFun (f ::: g) = g :=
   rfl
 #align typevec.last_fun_append_fun TypeVec.lastFun_appendFun
@@ -230,7 +230,7 @@ theorem splitFun_inj {α α' : TypeVec (n + 1)} {f f' : drop α ⟹ drop α'} {g
   rw [← dropFun_splitFun f g, H, ← lastFun_splitFun f g, H]; simp
 #align typevec.split_fun_inj TypeVec.splitFun_inj
 
-theorem appendFun_inj {α α' : TypeVec n} {β β' : Type _} {f f' : α ⟹ α'} {g g' : β → β'} :
+theorem appendFun_inj {α α' : TypeVec n} {β β' : Type*} {f f' : α ⟹ α'} {g g' : β → β'} :
     (f ::: g : (α ::: β) ⟹ _) = (f' ::: g' : (α ::: β) ⟹ _)
     → f = f' ∧ g = g' :=
   splitFun_inj
@@ -242,7 +242,7 @@ theorem splitFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : drop α₀ 
   eq_of_drop_last_eq rfl rfl
 #align typevec.split_fun_comp TypeVec.splitFun_comp
 
-theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type _} {ε : TypeVec (n + 1)}
+theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type*} {ε : TypeVec (n + 1)}
           (f₀ : drop ε ⟹ α)
           (f₁ : α ⟹ γ)
           (g₀ : last ε → β)
@@ -254,14 +254,14 @@ theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type _} {ε : TypeV
 #align typevec.append_fun_comp_split_fun TypeVec.appendFun_comp_splitFun
 
 theorem appendFun_comp  {α₀ α₁ α₂ : TypeVec n}
-                        {β₀ β₁ β₂ : Type _}
+                        {β₀ β₁ β₂ : Type*}
                         (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
                         (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
     (f₁ ⊚ f₀ ::: g₁ ∘ g₀) = (f₁ ::: g₁) ⊚ (f₀ ::: g₀) :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_comp TypeVec.appendFun_comp
 
-theorem appendFun_comp' {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Type _}
+theorem appendFun_comp' {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Type*}
                         (f₀ : α₀ ⟹ α₁) (f₁ : α₁ ⟹ α₂)
                         (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
     (f₁ ::: g₁) ⊚ (f₀ ::: g₀) = (f₁ ⊚ f₀ ::: g₁ ∘ g₀) :=
@@ -289,12 +289,12 @@ theorem lastFun_comp {α₀ α₁ α₂ : TypeVec (n + 1)} (f₀ : α₀ ⟹ α
   rfl
 #align typevec.last_fun_comp TypeVec.lastFun_comp
 
-theorem appendFun_aux {α α' : TypeVec n} {β β' : Type _} (f : (α ::: β) ⟹ (α' ::: β')) :
+theorem appendFun_aux {α α' : TypeVec n} {β β' : Type*} (f : (α ::: β) ⟹ (α' ::: β')) :
     (dropFun f ::: lastFun f) = f :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_aux TypeVec.appendFun_aux
 
-theorem appendFun_id_id {α : TypeVec n} {β : Type _} :
+theorem appendFun_id_id {α : TypeVec n} {β : Type*} :
     (@TypeVec.id n α ::: @_root_.id β) = TypeVec.id :=
   eq_of_drop_last_eq rfl rfl
 #align typevec.append_fun_id_id TypeVec.appendFun_id_id
@@ -306,30 +306,30 @@ instance subsingleton0 : Subsingleton (TypeVec 0) :=
 -- Porting note: `simp` attribute `TypeVec` moved to file `Tactic/Attr/Register.lean`
 
 /-- cases distinction for 0-length type vector -/
-protected def casesNil {β : TypeVec 0 → Sort _} (f : β Fin2.elim0) : ∀ v, β v
+protected def casesNil {β : TypeVec 0 → Sort*} (f : β Fin2.elim0) : ∀ v, β v
   := fun v => cast (by congr; funext i; cases i) f
 #align typevec.cases_nil TypeVec.casesNil
 
 /-- cases distinction for (n+1)-length type vector -/
-protected def casesCons (n : ℕ) {β : TypeVec (n + 1) → Sort _}
+protected def casesCons (n : ℕ) {β : TypeVec (n + 1) → Sort*}
                         (f : ∀ (t) (v : TypeVec n), β (v ::: t)) :
     ∀ v, β v :=
   fun v : TypeVec (n + 1) => cast (by simp) (f v.last v.drop)
 #align typevec.cases_cons TypeVec.casesCons
 
-protected theorem casesNil_append1 {β : TypeVec 0 → Sort _} (f : β Fin2.elim0) :
+protected theorem casesNil_append1 {β : TypeVec 0 → Sort*} (f : β Fin2.elim0) :
     TypeVec.casesNil f Fin2.elim0 = f :=
   rfl
 #align typevec.cases_nil_append1 TypeVec.casesNil_append1
 
-protected theorem casesCons_append1 (n : ℕ) {β : TypeVec (n + 1) → Sort _}
+protected theorem casesCons_append1 (n : ℕ) {β : TypeVec (n + 1) → Sort*}
     (f : ∀ (t) (v : TypeVec n), β (v ::: t)) (v : TypeVec n) (α) :
     TypeVec.casesCons n f (v ::: α) = f α v :=
   rfl
 #align typevec.cases_cons_append1 TypeVec.casesCons_append1
 
 /-- cases distinction for an arrow in the category of 0-length type vectors -/
-def typevecCasesNil₃ {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort _}
+def typevecCasesNil₃ {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort*}
     (f : β Fin2.elim0 Fin2.elim0 nilFun) :
     ∀ v v' fs, β v v' fs := fun v v' fs => by
   refine' cast _ f
@@ -340,7 +340,7 @@ def typevecCasesNil₃ {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort _}
 #align typevec.typevec_cases_nil₃ TypeVec.typevecCasesNil₃
 
 /-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
-def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort _}
+def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort*}
                       (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
                               β (v ::: t) (v' ::: t') (fs ::: f)) :
     ∀ v v' fs, β v v' fs := by
@@ -352,7 +352,7 @@ def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' →
 #align typevec.typevec_cases_cons₃ TypeVec.typevecCasesCons₃
 
 /-- specialized cases distinction for an arrow in the category of 0-length type vectors -/
-def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort _} (f : β nilFun) : ∀ f, β f := by
+def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun) : ∀ f, β f := by
   intro g
   have : g = nilFun
   ext ⟨⟩
@@ -361,8 +361,8 @@ def typevecCasesNil₂ {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort _} (f : β nilFu
 #align typevec.typevec_cases_nil₂ TypeVec.typevecCasesNil₂
 
 /-- specialized cases distinction for an arrow in the category of (n+1)-length type vectors -/
-def typevecCasesCons₂ (n : ℕ) (t t' : Type _) (v v' : TypeVec n)
-                      {β : (v ::: t) ⟹ (v' ::: t') → Sort _}
+def typevecCasesCons₂ (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
+                      {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
     (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f)) : ∀ fs, β fs := by
   intro fs
   rw [← split_dropFun_lastFun fs]
@@ -370,13 +370,13 @@ def typevecCasesCons₂ (n : ℕ) (t t' : Type _) (v v' : TypeVec n)
 #align typevec.typevec_cases_cons₂ TypeVec.typevecCasesCons₂
 
 
-theorem typevecCasesNil₂_appendFun {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort _} (f : β nilFun) :
+theorem typevecCasesNil₂_appendFun {β : Fin2.elim0 ⟹ Fin2.elim0 → Sort*} (f : β nilFun) :
     typevecCasesNil₂ f nilFun = f :=
   rfl
 #align typevec.typevec_cases_nil₂_append_fun TypeVec.typevecCasesNil₂_appendFun
 
-theorem typevecCasesCons₂_appendFun (n : ℕ) (t t' : Type _) (v v' : TypeVec n)
-                                      {β : (v ::: t) ⟹ (v' ::: t') → Sort _}
+theorem typevecCasesCons₂_appendFun (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
+                                      {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
                                       (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f))
                                       (f fs) :
     typevecCasesCons₂ n t t' v v' F (fs ::: f) = F f fs :=
@@ -385,7 +385,7 @@ theorem typevecCasesCons₂_appendFun (n : ℕ) (t t' : Type _) (v v' : TypeVec
 
 -- for lifting predicates and relations
 /-- `PredLast α p x` predicates `p` of the last element of `x : α.append1 β`. -/
-def PredLast (α : TypeVec n) {β : Type _} (p : β → Prop) : ∀ ⦃i⦄, (α.append1 β) i → Prop
+def PredLast (α : TypeVec n) {β : Type*} (p : β → Prop) : ∀ ⦃i⦄, (α.append1 β) i → Prop
   | Fin2.fs _ => fun _ => True
   | Fin2.fz => p
 #align typevec.pred_last TypeVec.PredLast
@@ -461,30 +461,30 @@ theorem repeat_eq_nil (α : TypeVec 0) : repeatEq α = nilFun := by ext i; cases
 #align typevec.repeat_eq_nil TypeVec.repeat_eq_nil
 
 /-- predicate on a type vector to constrain only the last object -/
-def PredLast' (α : TypeVec n) {β : Type _} (p : β → Prop) :
+def PredLast' (α : TypeVec n) {β : Type*} (p : β → Prop) :
     (α ::: β) ⟹ «repeat» (n + 1) Prop :=
   splitFun (TypeVec.const True α) p
 #align typevec.pred_last' TypeVec.PredLast'
 
 /-- predicate on the product of two type vectors to constrain only their last object -/
-def RelLast' (α : TypeVec n) {β : Type _} (p : β → β → Prop) :
+def RelLast' (α : TypeVec n) {β : Type*} (p : β → β → Prop) :
     (α ::: β) ⊗ (α ::: β) ⟹ «repeat» (n + 1) Prop :=
   splitFun (repeatEq α) (uncurry p)
 #align typevec.rel_last' TypeVec.RelLast'
 
 /-- given `F : TypeVec.{u} (n+1) → Type u`, `curry F : Type u → TypeVec.{u} → Type u`,
 i.e. its first argument can be fed in separately from the rest of the vector of arguments -/
-def Curry (F : TypeVec.{u} (n + 1) → Type _) (α : Type u) (β : TypeVec.{u} n) : Type _ :=
+def Curry (F : TypeVec.{u} (n + 1) → Type _) (α : Type u) (β : TypeVec.{u} n) : Type* :=
   F (β ::: α)
 #align typevec.curry TypeVec.Curry
 
-instance Curry.inhabited (F : TypeVec.{u} (n + 1) → Type _) (α : Type u) (β : TypeVec.{u} n)
+instance Curry.inhabited (F : TypeVec.{u} (n + 1) → Type*) (α : Type u) (β : TypeVec.{u} n)
     [I : Inhabited (F <| (β ::: α))] : Inhabited (Curry F α β) :=
   I
 #align typevec.curry.inhabited TypeVec.Curry.inhabited
 
 /-- arrow to remove one element of a `repeat` vector -/
-def dropRepeat (α : Type _) : ∀ {n}, drop («repeat» (succ n) α) ⟹ «repeat» n α
+def dropRepeat (α : Type*) : ∀ {n}, drop («repeat» (succ n) α) ⟹ «repeat» n α
   | succ _, Fin2.fs i => dropRepeat α i
   | succ _, Fin2.fz   => fun (a : α) => a
 #align typevec.drop_repeat TypeVec.dropRepeat

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2018 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
-
-! This file was ported from Lean 3 source module data.typevec
-! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fin.Fin2
 import Mathlib.Logic.Function.Basic
 import Mathlib.Tactic.Common
 
+#align_import data.typevec from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
+
 /-!
 
 # Tuples of types, and their categorical structure.

chore: cleanup whitespace (#5988)

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

12343aa5

Diff

@@ -325,15 +325,15 @@ protected theorem casesNil_append1 {β : TypeVec 0 → Sort _} (f : β Fin2.elim
   rfl
 #align typevec.cases_nil_append1 TypeVec.casesNil_append1
 
-protected theorem casesCons_append1  (n : ℕ) {β : TypeVec (n + 1) → Sort _}
-                                      (f : ∀ (t) (v : TypeVec n), β (v ::: t))
-    (v : TypeVec n) (α) : TypeVec.casesCons n f (v ::: α) = f α v :=
+protected theorem casesCons_append1 (n : ℕ) {β : TypeVec (n + 1) → Sort _}
+    (f : ∀ (t) (v : TypeVec n), β (v ::: t)) (v : TypeVec n) (α) :
+    TypeVec.casesCons n f (v ::: α) = f α v :=
   rfl
 #align typevec.cases_cons_append1 TypeVec.casesCons_append1
 
 /-- cases distinction for an arrow in the category of 0-length type vectors -/
-def typevecCasesNil₃  {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort _}
-                      (f : β Fin2.elim0 Fin2.elim0 nilFun) :
+def typevecCasesNil₃ {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort _}
+    (f : β Fin2.elim0 Fin2.elim0 nilFun) :
     ∀ v v' fs, β v v' fs := fun v v' fs => by
   refine' cast _ f
   have eq₁ : v = Fin2.elim0 := by funext i; contradiction
@@ -344,7 +344,7 @@ def typevecCasesNil₃  {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort _}
 
 /-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
 def typevecCasesCons₃ (n : ℕ) {β : ∀ v v' : TypeVec (n + 1), v ⟹ v' → Sort _}
-                      (F : ∀ (t t') (f : t → t')  (v v' : TypeVec n) (fs : v ⟹ v'),
+                      (F : ∀ (t t') (f : t → t') (v v' : TypeVec n) (fs : v ⟹ v'),
                               β (v ::: t) (v' ::: t') (fs ::: f)) :
     ∀ v v' fs, β v v' fs := by
   intro v v'
@@ -423,8 +423,8 @@ def prod : ∀ {n}, TypeVec.{u} n → TypeVec.{u} n → TypeVec n
 /-- `const x α` is an arrow that ignores its source and constructs a `TypeVec` that
 contains nothing but `x` -/
 protected def const {β} (x : β) : ∀ {n} (α : TypeVec n), α ⟹ «repeat» _ β
-  | succ _, α, Fin2.fs _  => TypeVec.const x (drop α) _
-  | succ _, _, Fin2.fz    => fun _ => x
+  | succ _, α, Fin2.fs _ => TypeVec.const x (drop α) _
+  | succ _, _, Fin2.fz   => fun _ => x
 #align typevec.const TypeVec.const
 
 open Function (uncurry)
@@ -500,8 +500,8 @@ def ofRepeat {α : Sort _} : ∀ {n i}, «repeat» n α i → α
 
 theorem const_iff_true {α : TypeVec n} {i x p} : ofRepeat (TypeVec.const p α i x) ↔ p := by
   induction i
-  case fz       => rfl
-  case fs _ ih  => erw [TypeVec.const, @ih (drop α) x]
+  case fz      => rfl
+  case fs _ ih => erw [TypeVec.const, @ih (drop α) x]
 #align typevec.const_iff_true TypeVec.const_iff_true
 
 
@@ -623,8 +623,8 @@ def toSubtype :
 into a subtype of vector -/
 def ofSubtype {n} {α : TypeVec.{u} n} (p : α ⟹ «repeat» n Prop) :
       Subtype_ p ⟹ fun i : Fin2 n => { x // ofRepeat <| p i x }
-  | Fin2.fs i,  x => ofSubtype _ i x
-  | Fin2.fz,    x => x
+  | Fin2.fs i, x => ofSubtype _ i x
+  | Fin2.fz,   x => x
 #align typevec.of_subtype TypeVec.ofSubtype
 
 /-- similar to `toSubtype` adapted to relations (i.e. predicate on product) -/
@@ -804,9 +804,8 @@ theorem subtypeVal_toSubtype {α : TypeVec n} (p : α ⟹ «repeat» n Prop) :
 #align typevec.subtype_val_to_subtype TypeVec.subtypeVal_toSubtype
 
 @[simp]
-theorem toSubtype_of_subtype_assoc  {α β : TypeVec n}
-                                    (p : α ⟹ «repeat» n Prop)
-                                    (f : β ⟹ Subtype_ p) :
+theorem toSubtype_of_subtype_assoc
+    {α β : TypeVec n} (p : α ⟹ «repeat» n Prop) (f : β ⟹ Subtype_ p) :
     @toSubtype n _ p ⊚ ofSubtype _ ⊚ f = f :=
   by rw [← comp_assoc, toSubtype_of_subtype]; simp
 #align typevec.to_subtype_of_subtype_assoc TypeVec.toSubtype_of_subtype_assoc

chore: remove a few superfluous semicolons (#5880)

Alongside any necessary spacing/flow changes to accommodate their removal.

870068af

Diff

@@ -61,7 +61,7 @@ open MvFunctor
 @[ext]
 theorem Arrow.ext {α β : TypeVec n} (f g : α ⟹ β) :
     (∀ i, f i = g i) → f = g := by
-  intro h; funext i; apply h;
+  intro h; funext i; apply h
 
 instance Arrow.inhabited (α β : TypeVec n) [∀ i, Inhabited (β i)] : Inhabited (α ⟹ β) :=
   ⟨fun _ _ => default⟩
@@ -335,12 +335,11 @@ protected theorem casesCons_append1  (n : ℕ) {β : TypeVec (n + 1) → Sort _}
 def typevecCasesNil₃  {β : ∀ v v' : TypeVec 0, v ⟹ v' → Sort _}
                       (f : β Fin2.elim0 Fin2.elim0 nilFun) :
     ∀ v v' fs, β v v' fs := fun v v' fs => by
-  refine' cast _ f;
+  refine' cast _ f
   have eq₁ : v = Fin2.elim0 := by funext i; contradiction
   have eq₂ : v' = Fin2.elim0 := by funext i; contradiction
-  have eq₃ : fs = nilFun := by funext i; contradiction;
-  cases eq₁; cases eq₂; cases eq₃;
-  rfl
+  have eq₃ : fs = nilFun := by funext i; contradiction
+  cases eq₁; cases eq₂; cases eq₃; rfl
 #align typevec.typevec_cases_nil₃ TypeVec.typevecCasesNil₃
 
 /-- cases distinction for an arrow in the category of (n+1)-length type vectors -/
@@ -567,26 +566,26 @@ protected def prod.map : ∀ {n} {α α' β β' : TypeVec.{u} n}, α ⟹ β →
 
 theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
-  funext i; induction i;
+  funext i; induction i
   case fz => rfl
   case fs _ _ i_ih => apply i_ih
 #align typevec.fst_prod_mk TypeVec.fst_prod_mk
 
 theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
     TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
-  funext i; induction i;
+  funext i; induction i
   case fz => rfl
   case fs _ _ i_ih => apply i_ih
 #align typevec.snd_prod_mk TypeVec.snd_prod_mk
 
 theorem fst_diag {α : TypeVec n} : TypeVec.prod.fst ⊚ (prod.diag : α ⟹ _) = id := by
-  funext i; induction i;
+  funext i; induction i
   case fz => rfl
   case fs _ _ i_ih => apply i_ih
 #align typevec.fst_diag TypeVec.fst_diag
 
 theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _) = id := by
-  funext i; induction i;
+  funext i; induction i
   case fz => rfl
   case fs _ _ i_ih => apply i_ih
 #align typevec.snd_diag TypeVec.snd_diag

chore: fix focusing dots (#5708)

This PR is the result of running

find . -type f -name "*.lean" -exec sed -i -E 's/^( +)\. /\1· /' {} \;
find . -type f -name "*.lean" -exec sed -i -E 'N;s/^( +·)\n +(.*)$/\1 \2/;P;D' {} \;

which firstly replaces . focusing dots with · and secondly removes isolated instances of such dots, unifying them with the following line. A new rule is placed in the style linter to verify this.

cb02d09e

Diff

@@ -175,8 +175,8 @@ theorem eq_of_drop_last_eq {α β : TypeVec (n + 1)} {f g : α ⟹ β} (h₀ : d
   -- porting note: FIXME: congr_fun h₀ <;> ext1 ⟨⟩ <;> apply_assumption
   refine funext (fun x => ?_)
   cases x
-  . apply h₁
-  . apply congr_fun h₀
+  · apply h₁
+  · apply congr_fun h₀
 #align typevec.eq_of_drop_last_eq TypeVec.eq_of_drop_last_eq
 
 @[simp]
@@ -675,9 +675,9 @@ theorem append_prod_appendFun {n} {α α' β β' : TypeVec.{u} n} {φ φ' ψ ψ'
     ((f₀ ⊗' g₀) ::: (_root_.Prod.map f₁ g₁)) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) := by
   ext i a
   cases i
-  . cases a
+  · cases a
     rfl
-  . rfl
+  · rfl
 #align typevec.append_prod_append_fun TypeVec.append_prod_appendFun
 
 end Liftp'
@@ -782,8 +782,8 @@ theorem prod_map_id {α β : TypeVec n} : (@TypeVec.id _ α ⊗' @TypeVec.id _ 
 theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
   ext i x
   induction' i with _ _ _ i_ih
-  . simp [comp, diagSub, subtypeVal, prod.diag]
-  . simp [prod.diag]
+  · simp [comp, diagSub, subtypeVal, prod.diag]
+  · simp [prod.diag]
     simp [comp, diagSub, subtypeVal, prod.diag] at *
     apply @i_ih (drop _)
 #align typevec.subtype_val_diag_sub TypeVec.subtypeVal_diagSub

refactor: move all register_simp_attrs to 1 file (#5681)

There are slight differences between mathlib3 and mathlib4 (different set of attributes, different lemmas are in core/std), so I redid the same refactor instead of forward-porting changes.

mathlib3 PR: leanprover-community/mathlib#19223

ceaa4ecb

Diff

@@ -4,12 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
 
 ! This file was ported from Lean 3 source module data.typevec
-! leanprover-community/mathlib commit 4fcbc82dc2257986c03e113f87bc5ce021243a44
+! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fin.Fin2
-import Mathlib.Data.TypeVec.Attr
 import Mathlib.Logic.Function.Basic
 import Mathlib.Tactic.Common
 
@@ -307,8 +306,7 @@ instance subsingleton0 : Subsingleton (TypeVec 0) :=
   ⟨fun a b => funext fun a => by apply Fin2.elim0 a⟩ -- porting note: `by apply` necessary?
 #align typevec.subsingleton0 TypeVec.subsingleton0
 
--- Porting note: `simp` attribute `TypeVec` moved to file `Data/TypeVec/Attr.lean`
-
+-- Porting note: `simp` attribute `TypeVec` moved to file `Tactic/Attr/Register.lean`
 
 /-- cases distinction for 0-length type vector -/
 protected def casesNil {β : TypeVec 0 → Sort _} (f : β Fin2.elim0) : ∀ v, β v

chore: remove superfluous parentheses in calls to ext (#5258)

Co-authored-by: Xavier Roblot <46200072+xroblot@users.noreply.github.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Riccardo Brasca <riccardo.brasca@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Pol'tta / Miyahara Kō <pol_tta@outlook.jp> Co-authored-by: Jason Yuen <jason_yuen2007@hotmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com> Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

3d6731dc

Diff

@@ -665,7 +665,7 @@ theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ dia
 
 theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ β ⟹ _) := by
   intros
-  ext (i a)
+  ext i a
   induction' i with _ _ _ i_ih
   · cases a
     rfl
@@ -675,7 +675,7 @@ theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ 
 theorem append_prod_appendFun {n} {α α' β β' : TypeVec.{u} n} {φ φ' ψ ψ' : Type u}
     {f₀ : α ⟹ α'} {g₀ : β ⟹ β'} {f₁ : φ → φ'} {g₁ : ψ → ψ'} :
     ((f₀ ⊗' g₀) ::: (_root_.Prod.map f₁ g₁)) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) := by
-  ext (i a)
+  ext i a
   cases i
   . cases a
     rfl
@@ -793,7 +793,7 @@ theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagS
 @[simp]
 theorem toSubtype_of_subtype {α : TypeVec n} (p : α ⟹ «repeat» n Prop) :
     toSubtype p ⊚ ofSubtype p = id := by
-  ext (i x)
+  ext i x
   induction i <;> dsimp only [id, toSubtype, comp, ofSubtype] at *
   simp [*]
 #align typevec.to_subtype_of_subtype TypeVec.toSubtype_of_subtype
@@ -801,7 +801,7 @@ theorem toSubtype_of_subtype {α : TypeVec n} (p : α ⟹ «repeat» n Prop) :
 @[simp]
 theorem subtypeVal_toSubtype {α : TypeVec n} (p : α ⟹ «repeat» n Prop) :
     subtypeVal p ⊚ toSubtype p = fun _ => Subtype.val := by
-  ext (i x)
+  ext i x
   induction i <;> dsimp only [toSubtype, comp, subtypeVal] at *
   simp [*]
 #align typevec.subtype_val_to_subtype TypeVec.subtypeVal_toSubtype
@@ -817,7 +817,7 @@ theorem toSubtype_of_subtype_assoc  {α β : TypeVec n}
 @[simp]
 theorem toSubtype'_of_subtype' {α : TypeVec n} (r : α ⊗ α ⟹ «repeat» n Prop) :
     toSubtype' r ⊚ ofSubtype' r = id := by
-  ext (i x)
+  ext i x
   induction i
   <;> dsimp only [id, toSubtype', comp, ofSubtype'] at *
   <;> simp [Subtype.eta, *]
@@ -825,7 +825,9 @@ theorem toSubtype'_of_subtype' {α : TypeVec n} (r : α ⊗ α ⟹ «repeat» n
 
 theorem subtypeVal_toSubtype' {α : TypeVec n} (r : α ⊗ α ⟹ «repeat» n Prop) :
     subtypeVal r ⊚ toSubtype' r = fun i x => prod.mk i x.1.fst x.1.snd := by
-  ext (i x); induction i <;> dsimp only [id, toSubtype', comp, subtypeVal, prod.mk] at *; simp [*]
+  ext i x
+  induction i <;> dsimp only [id, toSubtype', comp, subtypeVal, prod.mk] at *
+  simp [*]
 #align typevec.subtype_val_to_subtype' TypeVec.subtypeVal_toSubtype'
 
 end TypeVec

chore: formatting issues (#4947)

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

5068808d

Diff

@@ -252,7 +252,7 @@ theorem appendFun_comp_splitFun {α γ : TypeVec n} {β δ : Type _} {ε : TypeV
           (g₀ : last ε → β)
           (g₁ : β → δ) :
    appendFun f₁ g₁ ⊚ splitFun f₀ g₀
-      = splitFun (α':=γ.append1 δ) (f₁ ⊚ f₀) (g₁ ∘ g₀)
+      = splitFun (α' := γ.append1 δ) (f₁ ⊚ f₀) (g₁ ∘ g₀)
   :=
   (splitFun_comp _ _ _ _).symm
 #align typevec.append_fun_comp_split_fun TypeVec.appendFun_comp_splitFun

chore: fix typos (#4518)

I ran codespell Mathlib and got tired halfway through the suggestions.

92beef58

Diff

@@ -408,7 +408,7 @@ section Liftp'
 
 open Nat
 
-/-- `repeat n t` is a `n-length` type vector that contains `n` occurences of `t` -/
+/-- `repeat n t` is a `n-length` type vector that contains `n` occurrences of `t` -/
 def «repeat» : ∀ (n : ℕ), Sort _ → TypeVec n
   | 0, _ => Fin2.elim0
   | Nat.succ i, t => append1 («repeat» i t) t

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -307,7 +307,7 @@ instance subsingleton0 : Subsingleton (TypeVec 0) :=
   ⟨fun a b => funext fun a => by apply Fin2.elim0 a⟩ -- porting note: `by apply` necessary?
 #align typevec.subsingleton0 TypeVec.subsingleton0
 
--- Porting note: `simp` attribute `typevec` moved to file `Data/TypeVec/Attr.lean`
+-- Porting note: `simp` attribute `TypeVec` moved to file `Data/TypeVec/Attr.lean`
 
 
 /-- cases distinction for 0-length type vector -/

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

a4eaf1c4

Diff

@@ -11,10 +11,7 @@ Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
 import Mathlib.Data.Fin.Fin2
 import Mathlib.Data.TypeVec.Attr
 import Mathlib.Logic.Function.Basic
-import Mathlib.Tactic.Basic
-import Mathlib.Tactic.ScopedNS
-import Mathlib.Tactic.Replace
-import Mathlib.Tactic.SolveByElim
+import Mathlib.Tactic.Common
 
 /-!

Revert "feat: add Mathlib.Tactic.Common, and import"

This reverts commit 1ce2f69b.

7a81a20c

Diff

@@ -11,7 +11,10 @@ Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
 import Mathlib.Data.Fin.Fin2
 import Mathlib.Data.TypeVec.Attr
 import Mathlib.Logic.Function.Basic
-import Mathlib.Tactic.Common
+import Mathlib.Tactic.Basic
+import Mathlib.Tactic.ScopedNS
+import Mathlib.Tactic.Replace
+import Mathlib.Tactic.SolveByElim
 
 /-!

feat: add Mathlib.Tactic.Common, and import

1ce2f69b

Diff

@@ -11,10 +11,7 @@ Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
 import Mathlib.Data.Fin.Fin2
 import Mathlib.Data.TypeVec.Attr
 import Mathlib.Logic.Function.Basic
-import Mathlib.Tactic.Basic
-import Mathlib.Tactic.ScopedNS
-import Mathlib.Tactic.Replace
-import Mathlib.Tactic.SolveByElim
+import Mathlib.Tactic.Common
 
 /-!

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -64,8 +64,7 @@ open MvFunctor
 /-- Extensionality for arrows -/
 @[ext]
 theorem Arrow.ext {α β : TypeVec n} (f g : α ⟹ β) :
-  (∀ i, f i = g i) → f = g :=
-by
+    (∀ i, f i = g i) → f = g := by
   intro h; funext i; apply h;
 
 instance Arrow.inhabited (α β : TypeVec n) [∀ i, Inhabited (β i)] : Inhabited (α ⟹ β) :=
@@ -461,11 +460,8 @@ theorem const_nil {β} (x : β) (α : TypeVec 0) : TypeVec.const x α = nilFun :
 
 @[typevec]
 theorem repeat_eq_append1 {β} {n} (α : TypeVec n) :
-  repeatEq (α ::: β) = splitFun (α := (α ⊗ α) ::: _ )
-                                (α' := («repeat» n Prop) ::: _)
-                                (repeatEq α)
-                                (uncurry Eq) :=
-by
+    repeatEq (α ::: β) = splitFun (α := (α ⊗ α) ::: _ )
+    (α' := («repeat» n Prop) ::: _) (repeatEq α) (uncurry Eq) := by
   induction n <;> rfl
 #align typevec.repeat_eq_append1 TypeVec.repeat_eq_append1
 
@@ -549,8 +545,7 @@ end
 
 @[simp]
 theorem prod_fst_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
-  TypeVec.prod.fst i (prod.mk i a b) = a :=
-by
+    TypeVec.prod.fst i (prod.mk i a b) = a := by
   induction' i with _ _ _ i_ih
   simp_all only [prod.fst, prod.mk]
   apply i_ih
@@ -558,8 +553,7 @@ by
 
 @[simp]
 theorem prod_snd_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
-  TypeVec.prod.snd i (prod.mk i a b) = b :=
-by
+    TypeVec.prod.snd i (prod.mk i a b) = b := by
   induction' i with _ _ _ i_ih
   simp_all [prod.snd, prod.mk]
   apply i_ih
@@ -577,38 +571,33 @@ protected def prod.map : ∀ {n} {α α' β β' : TypeVec.{u} n}, α ⟹ β →
 @[inherit_doc] scoped[MvFunctor] infixl:45 " ⊗' " => TypeVec.prod.map
 
 theorem fst_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
-    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst :=
-  by
-    funext i; induction i;
-    case fz => rfl
-    case fs _ _ i_ih => apply i_ih
+    TypeVec.prod.fst ⊚ (f ⊗' g) = f ⊚ TypeVec.prod.fst := by
+  funext i; induction i;
+  case fz => rfl
+  case fs _ _ i_ih => apply i_ih
 #align typevec.fst_prod_mk TypeVec.fst_prod_mk
 
 theorem snd_prod_mk {α α' β β' : TypeVec n} (f : α ⟹ β) (g : α' ⟹ β') :
-    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd :=
-  by
-    funext i; induction i;
-    case fz => rfl
-    case fs _ _ i_ih => apply i_ih
+    TypeVec.prod.snd ⊚ (f ⊗' g) = g ⊚ TypeVec.prod.snd := by
+  funext i; induction i;
+  case fz => rfl
+  case fs _ _ i_ih => apply i_ih
 #align typevec.snd_prod_mk TypeVec.snd_prod_mk
 
-theorem fst_diag {α : TypeVec n} : TypeVec.prod.fst ⊚ (prod.diag : α ⟹ _) = id :=
-  by
-    funext i; induction i;
-    case fz => rfl
-    case fs _ _ i_ih => apply i_ih
+theorem fst_diag {α : TypeVec n} : TypeVec.prod.fst ⊚ (prod.diag : α ⟹ _) = id := by
+  funext i; induction i;
+  case fz => rfl
+  case fs _ _ i_ih => apply i_ih
 #align typevec.fst_diag TypeVec.fst_diag
 
-theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _) = id :=
-  by
-    funext i; induction i;
-    case fz => rfl
-    case fs _ _ i_ih => apply i_ih
+theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _) = id := by
+  funext i; induction i;
+  case fz => rfl
+  case fs _ _ i_ih => apply i_ih
 #align typevec.snd_diag TypeVec.snd_diag
 
 theorem repeatEq_iff_eq {α : TypeVec n} {i x y} :
-  ofRepeat (repeatEq α i (prod.mk _ x y)) ↔ x = y :=
-by
+    ofRepeat (repeatEq α i (prod.mk _ x y)) ↔ x = y := by
   induction' i with _ _ _ i_ih
   rfl
   erw [repeatEq, i_ih]
@@ -670,8 +659,7 @@ theorem subtypeVal_nil {α : TypeVec.{u} 0} (ps : α ⟹ «repeat» 0 Prop) :
   funext <| by rintro ⟨⟩
 #align typevec.subtype_val_nil TypeVec.subtypeVal_nil
 
-theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag :=
-by
+theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
   ext i x
   induction' i with _ _ _ i_ih
   simp [prod.diag, diagSub, repeatEq, subtypeVal, comp]
@@ -687,15 +675,9 @@ theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ 
   · apply i_ih
 #align typevec.prod_id TypeVec.prod_id
 
-theorem append_prod_appendFun  {n}
-                                {α α' β β' : TypeVec.{u} n}
-                                {φ φ' ψ ψ' : Type u}
-                                {f₀ : α ⟹ α'}
-                                {g₀ : β ⟹ β'}
-                                {f₁ : φ → φ'}
-                                {g₁ : ψ → ψ'} :
-        ((f₀ ⊗' g₀) ::: (_root_.Prod.map f₁ g₁)) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) :=
-by
+theorem append_prod_appendFun {n} {α α' β β' : TypeVec.{u} n} {φ φ' ψ ψ' : Type u}
+    {f₀ : α ⟹ α'} {g₀ : β ⟹ β'} {f₁ : φ → φ'} {g₁ : ψ → ψ'} :
+    ((f₀ ⊗' g₀) ::: (_root_.Prod.map f₁ g₁)) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) := by
   ext (i a)
   cases i
   . cases a
@@ -725,8 +707,7 @@ theorem lastFun_subtypeVal {α} (p : α ⟹ «repeat» (n + 1) Prop) :
 
 @[simp]
 theorem dropFun_toSubtype {α} (p : α ⟹ «repeat» (n + 1) Prop) :
-  dropFun (toSubtype p) = toSubtype _ :=
-by
+    dropFun (toSubtype p) = toSubtype _ := by
   ext i
   induction i <;> simp [dropFun, *] <;> rfl
 #align typevec.drop_fun_to_subtype TypeVec.dropFun_toSubtype
@@ -838,8 +819,7 @@ theorem toSubtype_of_subtype_assoc  {α β : TypeVec n}
 
 @[simp]
 theorem toSubtype'_of_subtype' {α : TypeVec n} (r : α ⊗ α ⟹ «repeat» n Prop) :
-    toSubtype' r ⊚ ofSubtype' r = id :=
-by
+    toSubtype' r ⊚ ofSubtype' r = id := by
   ext (i x)
   induction i
   <;> dsimp only [id, toSubtype', comp, ofSubtype'] at *

chore: fix #align lines (#3640)

This PR fixes two things:

Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

2b42dc7c

Diff

@@ -685,7 +685,6 @@ theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ 
   · cases a
     rfl
   · apply i_ih
-
 #align typevec.prod_id TypeVec.prod_id
 
 theorem append_prod_appendFun  {n}

chore: bump SHA in Data.TypeVec (#3177)

Only whitespace changes in

data.typevec@39af7d3bf61a98e928812dbc3e16f4ea8b795ca3..4fcbc82dc2257986c03e113f87bc5ce021243a44

so just bumping the SHA.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

915c292b

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Simon Hudon
 
 ! This file was ported from Lean 3 source module data.typevec
-! leanprover-community/mathlib commit 39af7d3bf61a98e928812dbc3e16f4ea8b795ca3
+! leanprover-community/mathlib commit 4fcbc82dc2257986c03e113f87bc5ce021243a44
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

Refactor uses to rename_i that have easy fixes (#2429)

ffbbaaae

Diff

@@ -551,9 +551,8 @@ end
 theorem prod_fst_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
   TypeVec.prod.fst i (prod.mk i a b) = a :=
 by
-  induction i
+  induction' i with _ _ _ i_ih
   simp_all only [prod.fst, prod.mk]
-  rename_i i_ih
   apply i_ih
 #align typevec.prod_fst_mk TypeVec.prod_fst_mk
 
@@ -561,9 +560,8 @@ by
 theorem prod_snd_mk {α β : TypeVec n} (i : Fin2 n) (a : α i) (b : β i) :
   TypeVec.prod.snd i (prod.mk i a b) = b :=
 by
-  induction i
+  induction' i with _ _ _ i_ih
   simp_all [prod.snd, prod.mk]
-  rename_i i_ih
   apply i_ih
 #align typevec.prod_snd_mk TypeVec.prod_snd_mk
 
@@ -611,9 +609,8 @@ theorem snd_diag {α : TypeVec n} : TypeVec.prod.snd ⊚ (prod.diag : α ⟹ _)
 theorem repeatEq_iff_eq {α : TypeVec n} {i x y} :
   ofRepeat (repeatEq α i (prod.mk _ x y)) ↔ x = y :=
 by
-  induction i
+  induction' i with _ _ _ i_ih
   rfl
-  rename_i i i_ih
   erw [repeatEq, i_ih]
 #align typevec.repeat_eq_iff_eq TypeVec.repeatEq_iff_eq
 
@@ -676,20 +673,18 @@ theorem subtypeVal_nil {α : TypeVec.{u} 0} (ps : α ⟹ «repeat» 0 Prop) :
 theorem diag_sub_val {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag :=
 by
   ext i x
-  induction i
+  induction' i with _ _ _ i_ih
   simp [prod.diag, diagSub, repeatEq, subtypeVal, comp]
-  rename_i _ i_ih
   apply @i_ih (drop α)
 #align typevec.diag_sub_val TypeVec.diag_sub_val
 
 theorem prod_id : ∀ {n} {α β : TypeVec.{u} n}, (id ⊗' id) = (id : α ⊗ β ⟹ _) := by
   intros
   ext (i a)
-  induction i
+  induction' i with _ _ _ i_ih
   · cases a
     rfl
-  · rename_i i_ih _ _
-    apply i_ih
+  · apply i_ih
 
 #align typevec.prod_id TypeVec.prod_id
 
@@ -811,10 +806,9 @@ theorem prod_map_id {α β : TypeVec n} : (@TypeVec.id _ α ⊗' @TypeVec.id _ 
 @[simp]
 theorem subtypeVal_diagSub {α : TypeVec n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
   ext i x
-  induction i
+  induction' i with _ _ _ i_ih
   . simp [comp, diagSub, subtypeVal, prod.diag]
-  . rename_i i i_ih
-    simp [prod.diag]
+  . simp [prod.diag]
     simp [comp, diagSub, subtypeVal, prod.diag] at *
     apply @i_ih (drop _)
 #align typevec.subtype_val_diag_sub TypeVec.subtypeVal_diagSub

chore: fix casing errors per naming scheme (#1670)

526ab32a

Diff

@@ -485,7 +485,7 @@ def RelLast' (α : TypeVec n) {β : Type _} (p : β → β → Prop) :
   splitFun (repeatEq α) (uncurry p)
 #align typevec.rel_last' TypeVec.RelLast'
 
-/-- given `F : typevec.{u} (n+1) → Type u`, `curry F : Type u → typevec.{u} → Type u`,
+/-- given `F : TypeVec.{u} (n+1) → Type u`, `curry F : Type u → TypeVec.{u} → Type u`,
 i.e. its first argument can be fed in separately from the rest of the vector of arguments -/
 def Curry (F : TypeVec.{u} (n + 1) → Type _) (α : Type u) (β : TypeVec.{u} n) : Type _ :=
   F (β ::: α)

feat: add uppercase lean 3 linter (#1796)

depends on: #1794

Implements a linter for lean 3 declarations containing capital letters (as suggested on Zulip).

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

702d8f3d

Diff

@@ -278,7 +278,7 @@ theorem appendFun_comp' {α₀ α₁ α₂ : TypeVec n} {β₀ β₁ β₂ : Typ
 
 theorem nilFun_comp {α₀ : TypeVec 0} (f₀ : α₀ ⟹ Fin2.elim0) : nilFun ⊚ f₀ = f₀ :=
   funext fun x => by apply Fin2.elim0 x -- porting note: `by apply` is necessary?
-#align typevec.nilFun_comp TypeVec.nilFun_comp
+#align typevec.nil_fun_comp TypeVec.nilFun_comp
 
 theorem appendFun_comp_id {α : TypeVec n} {β₀ β₁ β₂ : Type _} (g₀ : β₀ → β₁) (g₁ : β₁ → β₂) :
     (@id _ α ::: g₁ ∘ g₀) = (id ::: g₁) ⊚ (id ::: g₀) :=

feat: port Control.Functor.Multivariate (#1638)

Co-authored-by: Reid Barton <rwbarton@gmail.com>

38c9db93

Diff

@@ -394,13 +394,13 @@ theorem typevecCasesCons₂_appendFun (n : ℕ) (t t' : Type _) (v v' : TypeVec
 #align typevec.typevec_cases_cons₂_append_fun TypeVec.typevecCasesCons₂_appendFun
 
 -- for lifting predicates and relations
-/-- `pred_last α p x` predicates `p` of the last element of `x : α.append1 β`. -/
+/-- `PredLast α p x` predicates `p` of the last element of `x : α.append1 β`. -/
 def PredLast (α : TypeVec n) {β : Type _} (p : β → Prop) : ∀ ⦃i⦄, (α.append1 β) i → Prop
   | Fin2.fs _ => fun _ => True
   | Fin2.fz => p
 #align typevec.pred_last TypeVec.PredLast
 
-/-- `rel_last α r x y` says that `p` the last elements of `x y : α.append1 β` are related by `r` and
+/-- `RelLast α r x y` says that `p` the last elements of `x y : α.append1 β` are related by `r` and
 all the other elements are equal. -/
 def RelLast (α : TypeVec n) {β γ : Type _} (r : β → γ → Prop) :
       ∀ ⦃i⦄, (α.append1 β) i → (α.append1 γ) i → Prop
@@ -474,16 +474,16 @@ theorem repeat_eq_nil (α : TypeVec 0) : repeatEq α = nilFun := by ext i; cases
 #align typevec.repeat_eq_nil TypeVec.repeat_eq_nil
 
 /-- predicate on a type vector to constrain only the last object -/
-def predLast' (α : TypeVec n) {β : Type _} (p : β → Prop) :
+def PredLast' (α : TypeVec n) {β : Type _} (p : β → Prop) :
     (α ::: β) ⟹ «repeat» (n + 1) Prop :=
   splitFun (TypeVec.const True α) p
-#align typevec.pred_last' TypeVec.predLast'
+#align typevec.pred_last' TypeVec.PredLast'
 
 /-- predicate on the product of two type vectors to constrain only their last object -/
-def relLast' (α : TypeVec n) {β : Type _} (p : β → β → Prop) :
+def RelLast' (α : TypeVec n) {β : Type _} (p : β → β → Prop) :
     (α ::: β) ⊗ (α ::: β) ⟹ «repeat» (n + 1) Prop :=
   splitFun (repeatEq α) (uncurry p)
-#align typevec.rel_last' TypeVec.relLast'
+#align typevec.rel_last' TypeVec.RelLast'
 
 /-- given `F : typevec.{u} (n+1) → Type u`, `curry F : Type u → typevec.{u} → Type u`,
 i.e. its first argument can be fed in separately from the rest of the vector of arguments -/
@@ -759,10 +759,10 @@ theorem lastFun_of_subtype {α} (p : α ⟹ «repeat» (n + 1) Prop) :
 #align typevec.last_fun_of_subtype TypeVec.lastFun_of_subtype
 
 @[simp]
-theorem dropFun_rel_last {α : TypeVec n} {β} (R : β → β → Prop) :
-    dropFun (relLast' α R) = repeatEq α :=
+theorem dropFun_RelLast' {α : TypeVec n} {β} (R : β → β → Prop) :
+    dropFun (RelLast' α R) = repeatEq α :=
   rfl
-#align typevec.drop_fun_rel_last TypeVec.dropFun_rel_last
+#align typevec.drop_fun_rel_last TypeVec.dropFun_RelLast'
 
 attribute [simp] drop_append1'