control.uliftable | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

cc8c90d4

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

1b089e3b

bump to nightly-2024-02-05-08

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

516c6ec2

Diff

@@ -44,7 +44,7 @@ universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
 
 #print ULiftable /-
-/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:400:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
 `M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/

1b089e3b

bump to nightly-2023-12-23-06

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

b8c74971

Diff

@@ -44,7 +44,7 @@ universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
 
 #print ULiftable /-
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
 `M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/

1b089e3b

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,11 +3,11 @@ Copyright (c) 2020 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
 -/
-import Mathbin.Control.Monad.Basic
-import Mathbin.Control.Monad.Cont
-import Mathbin.Control.Monad.Writer
-import Mathbin.Logic.Equiv.Basic
-import Mathbin.Tactic.Interactive
+import Control.Monad.Basic
+import Control.Monad.Cont
+import Control.Monad.Writer
+import Logic.Equiv.Basic
+import Tactic.Interactive
 
 #align_import control.uliftable from "leanprover-community/mathlib"@"1b089e3bdc3ce6b39cd472543474a0a137128c6c"
 
@@ -44,7 +44,7 @@ universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
 
 #print ULiftable /-
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
 `M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/

1b089e3b

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,11 +2,6 @@
 Copyright (c) 2020 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
-
-! This file was ported from Lean 3 source module control.uliftable
-! leanprover-community/mathlib commit 1b089e3bdc3ce6b39cd472543474a0a137128c6c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Control.Monad.Basic
 import Mathbin.Control.Monad.Cont
@@ -14,6 +9,8 @@ import Mathbin.Control.Monad.Writer
 import Mathbin.Logic.Equiv.Basic
 import Mathbin.Tactic.Interactive
 
+#align_import control.uliftable from "leanprover-community/mathlib"@"1b089e3bdc3ce6b39cd472543474a0a137128c6c"
+
 /-!
 # Universe lifting for type families

1b089e3b

bump to nightly-2023-06-23-03

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

2dc54ce1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
 
 ! This file was ported from Lean 3 source module control.uliftable
-! leanprover-community/mathlib commit cc8c90d4ac61725a8f6c92691d8abcd2dec88115
+! leanprover-community/mathlib commit 1b089e3bdc3ce6b39cd472543474a0a137128c6c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -17,6 +17,9 @@ import Mathbin.Tactic.Interactive
 /-!
 # Universe lifting for type families
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Some functors such as `option` and `list` are universe polymorphic. Unlike
 type polymorphism where `option α` is a function application and reasoning and
 generalizations that apply to functions can be used, `option.{u}` and `option.{v}`

cc8c90d4

bump to nightly-2023-06-21-09

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

7d4d846c

Diff

@@ -43,107 +43,127 @@ universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
 
+#print ULiftable /-
 /- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
 `M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/
-class Uliftable (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) where
+class ULiftable (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) where
   congr {α β} : α ≃ β → f α ≃ g β
-#align uliftable Uliftable
+#align uliftable ULiftable
+-/
 
-namespace Uliftable
+namespace ULiftable
 
+#print ULiftable.up /-
 /-- The most common practical use `uliftable` (together with `up`), this function takes
 `x : M.{u} α` and lifts it to M.{max u v} (ulift.{v} α) -/
 @[reducible]
-def up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [Uliftable f g] {α} :
+def up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α} :
     f α → g (ULift α) :=
-  (Uliftable.congr f g Equiv.ulift.symm).toFun
-#align uliftable.up Uliftable.up
+  (ULiftable.congr f g Equiv.ulift.symm).toFun
+#align uliftable.up ULiftable.up
+-/
 
+#print ULiftable.down /-
 /-- The most common practical use of `uliftable` (together with `up`), this function takes
 `x : M.{max u v} (ulift.{v} α)` and lowers it to `M.{u} α` -/
 @[reducible]
-def down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [Uliftable f g] {α} :
+def down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α} :
     g (ULift α) → f α :=
-  (Uliftable.congr f g Equiv.ulift.symm).invFun
-#align uliftable.down Uliftable.down
+  (ULiftable.congr f g Equiv.ulift.symm).invFun
+#align uliftable.down ULiftable.down
+-/
 
+#print ULiftable.adaptUp /-
 /-- convenient shortcut to avoid manipulating `ulift` -/
-def adaptUp (F : Type v₀ → Type v₁) (G : Type max v₀ u₀ → Type u₁) [Uliftable F G] [Monad G] {α β}
+def adaptUp (F : Type v₀ → Type v₁) (G : Type max v₀ u₀ → Type u₁) [ULiftable F G] [Monad G] {α β}
     (x : F α) (f : α → G β) : G β :=
   up x >>= f ∘ ULift.down
-#align uliftable.adapt_up Uliftable.adaptUp
+#align uliftable.adapt_up ULiftable.adaptUp
+-/
 
+#print ULiftable.adaptDown /-
 /-- convenient shortcut to avoid manipulating `ulift` -/
-def adaptDown {F : Type max u₀ v₀ → Type u₁} {G : Type v₀ → Type v₁} [L : Uliftable G F] [Monad F]
+def adaptDown {F : Type max u₀ v₀ → Type u₁} {G : Type v₀ → Type v₁} [L : ULiftable G F] [Monad F]
     {α β} (x : F α) (f : α → G β) : G β :=
   @down.{v₀, v₁, max u₀ v₀} G F L β <| x >>= @up.{v₀, v₁, max u₀ v₀} G F L β ∘ f
-#align uliftable.adapt_down Uliftable.adaptDown
+#align uliftable.adapt_down ULiftable.adaptDown
+-/
 
+#print ULiftable.upMap /-
 /-- map function that moves up universes -/
-def upMap {F : Type u₀ → Type u₁} {G : Type max u₀ v₀ → Type v₁} [inst : Uliftable F G] [Functor G]
+def upMap {F : Type u₀ → Type u₁} {G : Type max u₀ v₀ → Type v₁} [inst : ULiftable F G] [Functor G]
     {α β} (f : α → β) (x : F α) : G β :=
   Functor.map (f ∘ ULift.down) (up x)
-#align uliftable.up_map Uliftable.upMap
+#align uliftable.up_map ULiftable.upMap
+-/
 
+#print ULiftable.downMap /-
 /-- map function that moves down universes -/
-def downMap {F : Type max u₀ v₀ → Type u₁} {G : Type u₀ → Type v₁} [inst : Uliftable G F]
+def downMap {F : Type max u₀ v₀ → Type u₁} {G : Type u₀ → Type v₁} [inst : ULiftable G F]
     [Functor F] {α β} (f : α → β) (x : F α) : G β :=
   down (Functor.map (ULift.up ∘ f) x : F (ULift β))
-#align uliftable.down_map Uliftable.downMap
+#align uliftable.down_map ULiftable.downMap
+-/
 
+#print ULiftable.up_down /-
 @[simp]
-theorem up_down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [Uliftable f g] {α}
+theorem up_down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α}
     (x : g (ULift α)) : up (down x : f α) = x :=
-  (Uliftable.congr f g Equiv.ulift.symm).right_inv _
-#align uliftable.up_down Uliftable.up_down
+  (ULiftable.congr f g Equiv.ulift.symm).right_inv _
+#align uliftable.up_down ULiftable.up_down
+-/
 
+#print ULiftable.down_up /-
 @[simp]
-theorem down_up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [Uliftable f g] {α}
+theorem down_up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α}
     (x : f α) : down (up x : g _) = x :=
-  (Uliftable.congr f g Equiv.ulift.symm).left_inv _
-#align uliftable.down_up Uliftable.down_up
+  (ULiftable.congr f g Equiv.ulift.symm).left_inv _
+#align uliftable.down_up ULiftable.down_up
+-/
 
-end Uliftable
+end ULiftable
 
 open ULift
 
-instance : Uliftable id id where congr α β F := F
+instance : ULiftable id id where congr α β F := F
 
 /-- for specific state types, this function helps to create a uliftable instance -/
-def StateT.uliftable' {m : Type u₀ → Type v₀} {m' : Type u₁ → Type v₁} [Uliftable m m']
-    (F : s ≃ s') : Uliftable (StateT s m) (StateT s' m')
+def StateT.uliftable' {m : Type u₀ → Type v₀} {m' : Type u₁ → Type v₁} [ULiftable m m']
+    (F : s ≃ s') : ULiftable (StateT s m) (StateT s' m')
     where congr α β G :=
-    StateT.equiv <| Equiv.piCongr F fun _ => Uliftable.congr _ _ <| Equiv.prodCongr G F
+    StateT.equiv <| Equiv.piCongr F fun _ => ULiftable.congr _ _ <| Equiv.prodCongr G F
 #align state_t.uliftable' StateTₓ.uliftable'
 
-instance {m m'} [Uliftable m m'] : Uliftable (StateT s m) (StateT (ULift s) m') :=
+instance {m m'} [ULiftable m m'] : ULiftable (StateT s m) (StateT (ULift s) m') :=
   StateT.uliftable' Equiv.ulift.symm
 
 /-- for specific reader monads, this function helps to create a uliftable instance -/
-def ReaderT.uliftable' {m m'} [Uliftable m m'] (F : s ≃ s') :
-    Uliftable (ReaderT s m) (ReaderT s' m')
-    where congr α β G := ReaderT.equiv <| Equiv.piCongr F fun _ => Uliftable.congr _ _ G
+def ReaderT.uliftable' {m m'} [ULiftable m m'] (F : s ≃ s') :
+    ULiftable (ReaderT s m) (ReaderT s' m')
+    where congr α β G := ReaderT.equiv <| Equiv.piCongr F fun _ => ULiftable.congr _ _ G
 #align reader_t.uliftable' ReaderTₓ.uliftable'
 
-instance {m m'} [Uliftable m m'] : Uliftable (ReaderT s m) (ReaderT (ULift s) m') :=
+instance {m m'} [ULiftable m m'] : ULiftable (ReaderT s m) (ReaderT (ULift s) m') :=
   ReaderT.uliftable' Equiv.ulift.symm
 
+#print ContT.uliftable' /-
 /-- for specific continuation passing monads, this function helps to create a uliftable instance -/
-def ContT.uliftable' {m m'} [Uliftable m m'] (F : r ≃ r') : Uliftable (ContT r m) (ContT r' m')
-    where congr α β := ContT.equiv (Uliftable.congr _ _ F)
+def ContT.uliftable' {m m'} [ULiftable m m'] (F : r ≃ r') : ULiftable (ContT r m) (ContT r' m')
+    where congr α β := ContT.equiv (ULiftable.congr _ _ F)
 #align cont_t.uliftable' ContT.uliftable'
+-/
 
-instance {s m m'} [Uliftable m m'] : Uliftable (ContT s m) (ContT (ULift s) m') :=
+instance {s m m'} [ULiftable m m'] : ULiftable (ContT s m) (ContT (ULift s) m') :=
   ContT.uliftable' Equiv.ulift.symm
 
 /-- for specific writer monads, this function helps to create a uliftable instance -/
-def WriterT.uliftable' {m m'} [Uliftable m m'] (F : w ≃ w') :
-    Uliftable (WriterT w m) (WriterT w' m')
-    where congr α β G := WriterT.equiv <| Uliftable.congr _ _ <| Equiv.prodCongr G F
+def WriterT.uliftable' {m m'} [ULiftable m m'] (F : w ≃ w') :
+    ULiftable (WriterT w m) (WriterT w' m')
+    where congr α β G := WriterT.equiv <| ULiftable.congr _ _ <| Equiv.prodCongr G F
 #align writer_t.uliftable' WriterTₓ.uliftable'
 
-instance {m m'} [Uliftable m m'] : Uliftable (WriterT s m) (WriterT (ULift s) m') :=
+instance {m m'} [ULiftable m m'] : ULiftable (WriterT s m) (WriterT (ULift s) m') :=
   WriterT.uliftable' Equiv.ulift.symm

cc8c90d4

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -43,7 +43,7 @@ universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
 
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
 `M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/

cc8c90d4

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -43,7 +43,7 @@ universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
 
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
 `M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/

cc8c90d4

bump to nightly-2023-04-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

ff662d55

Diff

@@ -43,7 +43,7 @@ universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
 
-/- ./././Mathport/Syntax/Translate/Command.lean:388:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`congr] [] -/
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
 `M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/

cc8c90d4

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

cc8c90d4

chore: classify simp can do this porting notes (#10619)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

de765f60

Diff

@@ -104,13 +104,13 @@ def downMap {F : Type max u₀ v₀ → Type u₁} {G : Type u₀ → Type v₁}
   down (Functor.map (ULift.up.{v₀} ∘ f) x : F (ULift β))
 #align uliftable.down_map ULiftable.downMap
 
--- @[simp] -- Porting note: simp can prove this
+-- @[simp] -- Porting note (#10618): simp can prove this
 theorem up_down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α}
     (x : g (ULift.{v₀} α)) : up (down x : f α) = x :=
   (ULiftable.congr Equiv.ulift.symm).right_inv _
 #align uliftable.up_down ULiftable.up_down
 
--- @[simp] -- Porting note: simp can prove this
+-- @[simp] -- Porting note (#10618): simp can prove this
 theorem down_up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α}
     (x : f α) : down (up x : g (ULift.{v₀} α)) = x :=
   (ULiftable.congr Equiv.ulift.symm).left_inv _

cc8c90d4

refactor(Control/ULiftable): use outParam and adjust universe orders (#8849)

The most useful universe argument to up and down (the one in the ULift type) is now first.

Combined with the outParam, this makes using ULiftable.up more ergonomic downstream, removing a handful of type annotations.

8ec98e47

Diff

@@ -37,20 +37,26 @@ universe polymorphism functor
 -/
 
 
-universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
+universe v u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 
 variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type*}
 
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from
-`M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back -/
-class ULiftable (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) where
+`M.{u} : Type u₁ → Type u₂` to `M.{v} : Type v₁ → Type v₂` and back.
+
+`f` is an outParam, because `g` can almost always be inferred from the current monad.
+At any rate, the lift should be unique, as the intent is to only lift the same constants with
+different universe parameters. -/
+class ULiftable (f : outParam (Type u₀ → Type u₁)) (g : Type v₀ → Type v₁) where
   congr {α β} : α ≃ β → f α ≃ g β
 #align uliftable ULiftable
 
 namespace ULiftable
 
-instance symm (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) [ULiftable f g] : ULiftable g f where
+/-- Not an instance as it is incompatible with `outParam`. In practice it seems not to be needed
+anyway. -/
+abbrev symm (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) [ULiftable f g] : ULiftable g f where
   congr e := (ULiftable.congr e.symm).symm
 
 instance refl (f : Type u₀ → Type u₁) [Functor f] [LawfulFunctor f] : ULiftable f f where
@@ -58,19 +64,19 @@ instance refl (f : Type u₀ → Type u₁) [Functor f] [LawfulFunctor f] : ULif
 
 example : ULiftable IO IO := inferInstance
 
-/-- The most common practical use `ULiftable` (together with `down`), this function takes
+/-- The most common practical use `ULiftable` (together with `down`), the function `up.{v}` takes
 `x : M.{u} α` and lifts it to `M.{max u v} (ULift.{v} α)` -/
 @[reducible]
-def up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α} :
-    f α → g (ULift.{v₀} α) :=
+def up {f : Type u₀ → Type u₁} {g : Type max u₀ v → Type v₁} [ULiftable f g] {α} :
+    f α → g (ULift.{v} α) :=
   (ULiftable.congr Equiv.ulift.symm).toFun
 #align uliftable.up ULiftable.up
 
-/-- The most common practical use of `ULiftable` (together with `up`), this function takes
+/-- The most common practical use of `ULiftable` (together with `up`), the function `down.{v}` takes
 `x : M.{max u v} (ULift.{v} α)` and lowers it to `M.{u} α` -/
 @[reducible]
-def down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α} :
-    g (ULift.{v₀} α) → f α :=
+def down {f : Type u₀ → Type u₁} {g : Type max u₀ v → Type v₁} [ULiftable f g] {α} :
+    g (ULift.{v} α) → f α :=
   (ULiftable.congr Equiv.ulift.symm).invFun
 #align uliftable.down ULiftable.down
 
@@ -83,7 +89,7 @@ def adaptUp (F : Type v₀ → Type v₁) (G : Type max v₀ u₀ → Type u₁)
 /-- convenient shortcut to avoid manipulating `ULift` -/
 def adaptDown {F : Type max u₀ v₀ → Type u₁} {G : Type v₀ → Type v₁} [L : ULiftable G F] [Monad F]
     {α β} (x : F α) (f : α → G β) : G β :=
-  @down.{v₀, v₁, max u₀ v₀} G F L β <| x >>= @up.{v₀, v₁, max u₀ v₀} G F L β ∘ f
+  @down.{max u₀ v₀} G F L β <| x >>= @up.{max u₀ v₀} G F L β ∘ f
 #align uliftable.adapt_down ULiftable.adaptDown
 
 /-- map function that moves up universes -/

cc8c90d4

feat(Init/Control/Lawful): The IO monad is lawful (#8772)

The motivation is to provide a no-op ULiftable IO IO instance; otherwise APIs developed in terms of universe polymorphic monads can't be used with IO, even if specialized to a single universe.

d464fed4

Diff

@@ -7,6 +7,8 @@ import Mathlib.Control.Monad.Basic
 import Mathlib.Control.Monad.Cont
 import Mathlib.Control.Monad.Writer
 import Mathlib.Logic.Equiv.Basic
+import Mathlib.Logic.Equiv.Functor
+import Mathlib.Init.Control.Lawful
 
 #align_import control.uliftable from "leanprover-community/mathlib"@"cc8c90d4ac61725a8f6c92691d8abcd2dec88115"
 
@@ -51,6 +53,11 @@ namespace ULiftable
 instance symm (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) [ULiftable f g] : ULiftable g f where
   congr e := (ULiftable.congr e.symm).symm
 
+instance refl (f : Type u₀ → Type u₁) [Functor f] [LawfulFunctor f] : ULiftable f f where
+  congr e := Functor.mapEquiv _ e
+
+example : ULiftable IO IO := inferInstance
+
 /-- The most common practical use `ULiftable` (together with `down`), this function takes
 `x : M.{u} α` and lifts it to `M.{max u v} (ULift.{v} α)` -/
 @[reducible]

cc8c90d4

feat(Control/ULiftable): instances for Except and Option (#6350)

5d8bd221

Diff

@@ -48,6 +48,9 @@ class ULiftable (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) wher
 
 namespace ULiftable
 
+instance symm (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) [ULiftable f g] : ULiftable g f where
+  congr e := (ULiftable.congr e.symm).symm
+
 /-- The most common practical use `ULiftable` (together with `down`), this function takes
 `x : M.{u} α` and lifts it to `M.{max u v} (ULift.{v} α)` -/
 @[reducible]
@@ -160,3 +163,17 @@ instance {m m'} [ULiftable m m'] : ULiftable (WriterT s m) (WriterT (ULift s) m'
 instance WriterT.instULiftableULiftULift {m m'} [ULiftable m m'] :
     ULiftable (WriterT (ULift.{max v₀ u₀} s) m) (WriterT (ULift.{max v₁ u₀} s) m') :=
   WriterT.uliftable' <| Equiv.ulift.trans Equiv.ulift.symm
+
+instance Except.instULiftable {ε : Type u₀} : ULiftable (Except.{u₀,v₁} ε) (Except.{u₀,v₂} ε) where
+  congr e :=
+    { toFun := Except.map e
+      invFun := Except.map e.symm
+      left_inv := fun f => by cases f <;> simp [Except.map]
+      right_inv := fun f => by cases f <;> simp [Except.map] }
+
+instance Option.instULiftable : ULiftable Option.{u₀} Option.{u₁} where
+  congr e :=
+    { toFun := Option.map e
+      invFun := Option.map e.symm
+      left_inv := fun f => by cases f <;> simp
+      right_inv := fun f => by cases f <;> simp }

cc8c90d4

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

@@ -37,7 +37,7 @@ universe polymorphism functor
 
 universe u₀ u₁ v₀ v₁ v₂ w w₀ w₁
 
-variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type _}
+variable {s : Type u₀} {s' : Type u₁} {r r' w w' : Type*}
 
 /-- Given a universe polymorphic type family `M.{u} : Type u₁ → Type
 u₂`, this class convert between instantiations, from

cc8c90d4

fix: Mathlib/Control/ULiftable doc typos (#6349)

small typos in docstrings

74ee5fbe

Diff

@@ -48,7 +48,7 @@ class ULiftable (f : Type u₀ → Type u₁) (g : Type v₀ → Type v₁) wher
 
 namespace ULiftable
 
-/-- The most common practical use `ULiftable` (together with `up`), this function takes
+/-- The most common practical use `ULiftable` (together with `down`), this function takes
 `x : M.{u} α` and lifts it to `M.{max u v} (ULift.{v} α)` -/
 @[reducible]
 def up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α} :
@@ -57,7 +57,7 @@ def up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULi
 #align uliftable.up ULiftable.up
 
 /-- The most common practical use of `ULiftable` (together with `up`), this function takes
-`x : M.{max u v} (ulift.{v} α)` and lowers it to `M.{u} α` -/
+`x : M.{max u v} (ULift.{v} α)` and lowers it to `M.{u} α` -/
 @[reducible]
 def down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α} :
     g (ULift.{v₀} α) → f α :=

cc8c90d4

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,17 +2,14 @@
 Copyright (c) 2020 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon
-
-! This file was ported from Lean 3 source module control.uliftable
-! leanprover-community/mathlib commit cc8c90d4ac61725a8f6c92691d8abcd2dec88115
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Control.Monad.Basic
 import Mathlib.Control.Monad.Cont
 import Mathlib.Control.Monad.Writer
 import Mathlib.Logic.Equiv.Basic
 
+#align_import control.uliftable from "leanprover-community/mathlib"@"cc8c90d4ac61725a8f6c92691d8abcd2dec88115"
+
 /-!
 # Universe lifting for type families

cc8c90d4

fix: correct universe polymorphism in SlimCheck (#5796)

The use of auto-implicits was introducing a universe metavariable where we wanted a free variable.

The new ULiftable instances handle the common case of a universe polymorphic monad with a universe-lifted state from Type.

fe6a0bdc

Diff

@@ -107,8 +107,9 @@ end ULiftable
 
 open ULift
 
-instance : ULiftable id id where
+instance instULiftableId : ULiftable Id Id where
   congr F := F
+#align id.uliftable instULiftableId
 
 /-- for specific state types, this function helps to create a uliftable instance -/
 def StateT.uliftable' {m : Type u₀ → Type v₀} {m' : Type u₁ → Type v₁} [ULiftable m m']
@@ -120,6 +121,10 @@ def StateT.uliftable' {m : Type u₀ → Type v₀} {m' : Type u₁ → Type v
 instance {m m'} [ULiftable m m'] : ULiftable (StateT s m) (StateT (ULift s) m') :=
   StateT.uliftable' Equiv.ulift.symm
 
+instance StateT.instULiftableULiftULift {m m'} [ULiftable m m'] :
+    ULiftable (StateT (ULift.{max v₀ u₀} s) m) (StateT (ULift.{max v₁ u₀} s) m') :=
+  StateT.uliftable' <| Equiv.ulift.trans Equiv.ulift.symm
+
 /-- for specific reader monads, this function helps to create a uliftable instance -/
 def ReaderT.uliftable' {m m'} [ULiftable m m'] (F : s ≃ s') :
     ULiftable (ReaderT s m) (ReaderT s' m') where
@@ -129,6 +134,10 @@ def ReaderT.uliftable' {m m'} [ULiftable m m'] (F : s ≃ s') :
 instance {m m'} [ULiftable m m'] : ULiftable (ReaderT s m) (ReaderT (ULift s) m') :=
   ReaderT.uliftable' Equiv.ulift.symm
 
+instance ReaderT.instULiftableULiftULift {m m'} [ULiftable m m'] :
+    ULiftable (ReaderT (ULift.{max v₀ u₀} s) m) (ReaderT (ULift.{max v₁ u₀} s) m') :=
+  ReaderT.uliftable' <| Equiv.ulift.trans Equiv.ulift.symm
+
 /-- for specific continuation passing monads, this function helps to create a uliftable instance -/
 def ContT.uliftable' {m m'} [ULiftable m m'] (F : r ≃ r') :
     ULiftable (ContT r m) (ContT r' m') where
@@ -138,6 +147,10 @@ def ContT.uliftable' {m m'} [ULiftable m m'] (F : r ≃ r') :
 instance {s m m'} [ULiftable m m'] : ULiftable (ContT s m) (ContT (ULift s) m') :=
   ContT.uliftable' Equiv.ulift.symm
 
+instance ContT.instULiftableULiftULift {m m'} [ULiftable m m'] :
+    ULiftable (ContT (ULift.{max v₀ u₀} s) m) (ContT (ULift.{max v₁ u₀} s) m') :=
+  ContT.uliftable' <| Equiv.ulift.trans Equiv.ulift.symm
+
 /-- for specific writer monads, this function helps to create a uliftable instance -/
 def WriterT.uliftable' {m m'} [ULiftable m m'] (F : w ≃ w') :
     ULiftable (WriterT w m) (WriterT w' m') where
@@ -146,3 +159,7 @@ def WriterT.uliftable' {m m'} [ULiftable m m'] (F : w ≃ w') :
 
 instance {m m'} [ULiftable m m'] : ULiftable (WriterT s m) (WriterT (ULift s) m') :=
   WriterT.uliftable' Equiv.ulift.symm
+
+instance WriterT.instULiftableULiftULift {m m'} [ULiftable m m'] :
+    ULiftable (WriterT (ULift.{max v₀ u₀} s) m) (WriterT (ULift.{max v₁ u₀} s) m') :=
+  WriterT.uliftable' <| Equiv.ulift.trans Equiv.ulift.symm

cc8c90d4

feat: port Control.ULiftable (#5223)

1e2e427c

`control.uliftable` ⟷ `Mathlib.Control.ULiftable`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 21

control.uliftable ⟷ Mathlib.Control.ULiftable

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 21

`control.uliftable` ⟷ `Mathlib.Control.ULiftable`