control.monad.cont | 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

d6814c58

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

d6814c58

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -7,8 +7,8 @@ Monad encapsulating continuation passing programming style, similar to
 Haskell's `Cont`, `ContT` and `MonadCont`:
 <http://hackage.haskell.org/package/mtl-2.2.2/docs/Control-Monad-Cont.html>
 -/
-import Mathbin.Control.Monad.Basic
-import Mathbin.Control.Monad.Writer
+import Control.Monad.Basic
+import Control.Monad.Writer
 
 #align_import control.monad.cont from "leanprover-community/mathlib"@"d6814c584384ddf2825ff038e868451a7c956f31"

d6814c58

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -6,15 +6,12 @@ Authors: Simon Hudon
 Monad encapsulating continuation passing programming style, similar to
 Haskell's `Cont`, `ContT` and `MonadCont`:
 <http://hackage.haskell.org/package/mtl-2.2.2/docs/Control-Monad-Cont.html>
-
-! This file was ported from Lean 3 source module control.monad.cont
-! leanprover-community/mathlib commit d6814c584384ddf2825ff038e868451a7c956f31
-! 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.Writer
 
+#align_import control.monad.cont from "leanprover-community/mathlib"@"d6814c584384ddf2825ff038e868451a7c956f31"
+
 universe u v w u₀ u₁ v₀ v₁
 
 #print MonadCont.Label /-

d6814c58

bump to nightly-2023-06-18-23

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

3b5e23dc

Diff

@@ -17,38 +17,50 @@ import Mathbin.Control.Monad.Writer
 
 universe u v w u₀ u₁ v₀ v₁
 
+#print MonadCont.Label /-
 structure MonadCont.Label (α : Type w) (m : Type u → Type v) (β : Type u) where
   apply : α → m β
 #align monad_cont.label MonadCont.Label
+-/
 
+#print MonadCont.goto /-
 def MonadCont.goto {α β} {m : Type u → Type v} (f : MonadCont.Label α m β) (x : α) :=
   f.apply x
 #align monad_cont.goto MonadCont.goto
+-/
 
+#print MonadCont /-
 class MonadCont (m : Type u → Type v) where
   callCc : ∀ {α β}, (MonadCont.Label α m β → m α) → m α
 #align monad_cont MonadCont
+-/
 
 open MonadCont
 
-class IsLawfulMonadCont (m : Type u → Type v) [Monad m] [MonadCont m] extends LawfulMonad m where
+#print LawfulMonadCont /-
+class LawfulMonadCont (m : Type u → Type v) [Monad m] [MonadCont m] extends LawfulMonad m where
   callCc_bind_right {α ω γ} (cmd : m α) (next : Label ω m γ → α → m ω) :
     (callCc fun f => cmd >>= next f) = cmd >>= fun x => callCc fun f => next f x
   callCc_bind_left {α} (β) (x : α) (dead : Label α m β → β → m α) :
     (callCc fun f : Label α m β => goto f x >>= dead f) = pure x
   callCc_dummy {α β} (dummy : m α) : (callCc fun f : Label α m β => dummy) = dummy
-#align is_lawful_monad_cont IsLawfulMonadCont
+#align is_lawful_monad_cont LawfulMonadCont
+-/
 
-export IsLawfulMonadCont ()
+export LawfulMonadCont ()
 
+#print ContT /-
 def ContT (r : Type u) (m : Type u → Type v) (α : Type w) :=
   (α → m r) → m r
 #align cont_t ContT
+-/
 
+#print Cont /-
 @[reducible]
 def Cont (r : Type u) (α : Type w) :=
   ContT r id α
 #align cont Cont
+-/
 
 namespace ContT
 
@@ -56,29 +68,41 @@ export MonadCont (Label goto)
 
 variable {r : Type u} {m : Type u → Type v} {α β γ ω : Type w}
 
+#print ContT.run /-
 def run : ContT r m α → (α → m r) → m r :=
   id
 #align cont_t.run ContT.run
+-/
 
+#print ContT.map /-
 def map (f : m r → m r) (x : ContT r m α) : ContT r m α :=
   f ∘ x
 #align cont_t.map ContT.map
+-/
 
+#print ContT.run_contT_map_contT /-
 theorem run_contT_map_contT (f : m r → m r) (x : ContT r m α) : run (map f x) = f ∘ run x :=
   rfl
 #align cont_t.run_cont_t_map_cont_t ContT.run_contT_map_contT
+-/
 
+#print ContT.withContT /-
 def withContT (f : (β → m r) → α → m r) (x : ContT r m α) : ContT r m β := fun g => x <| f g
 #align cont_t.with_cont_t ContT.withContT
+-/
 
+#print ContT.run_withContT /-
 theorem run_withContT (f : (β → m r) → α → m r) (x : ContT r m α) :
     run (withContT f x) = run x ∘ f :=
   rfl
 #align cont_t.run_with_cont_t ContT.run_withContT
+-/
 
+#print ContT.ext /-
 @[ext]
 protected theorem ext {x y : ContT r m α} (h : ∀ f, x.run f = y.run f) : x = y := by ext <;> apply h
 #align cont_t.ext ContT.ext
+-/
 
 instance : Monad (ContT r m) where
   pure α x f := f x
@@ -90,11 +114,14 @@ instance : LawfulMonad (ContT r m)
   pure_bind := by intros; ext; rfl
   bind_assoc := by intros; ext; rfl
 
+#print ContT.monadLift /-
 def monadLift [Monad m] {α} : m α → ContT r m α := fun x f => x >>= f
 #align cont_t.monad_lift ContT.monadLift
+-/
 
 instance [Monad m] : HasMonadLift m (ContT r m) where monadLift α := ContT.monadLift
 
+#print ContT.monadLift_bind /-
 theorem monadLift_bind [Monad m] [LawfulMonad m] {α β} (x : m α) (f : α → m β) :
     (monadLift (x >>= f) : ContT r m β) = monadLift x >>= monadLift ∘ f :=
   by
@@ -102,10 +129,11 @@ theorem monadLift_bind [Monad m] [LawfulMonad m] {α β} (x : m α) (f : α →
   simp only [monad_lift, HasMonadLift.monadLift, (· ∘ ·), (· >>= ·), bind_assoc, id.def, run,
     ContT.monadLift]
 #align cont_t.monad_lift_bind ContT.monadLift_bind
+-/
 
 instance : MonadCont (ContT r m) where callCc α β f g := f ⟨fun x h => g x⟩ g
 
-instance : IsLawfulMonadCont (ContT r m)
+instance : LawfulMonadCont (ContT r m)
     where
   callCc_bind_right := by intros <;> ext <;> rfl
   callCc_bind_left := by intros <;> ext <;> rfl
@@ -131,24 +159,24 @@ theorem ExceptT.goto_mkLabel {α β ε : Type _} (x : Label (Except.{u, u} ε α
     goto (ExceptT.mkLabel x) i = ⟨Except.ok <$> goto x (Except.ok i)⟩ := by cases x <;> rfl
 #align except_t.goto_mk_label ExceptTₓ.goto_mkLabel
 
-def ExceptT.callCc {ε} [MonadCont m] {α β : Type _} (f : Label α (ExceptT ε m) β → ExceptT ε m α) :
+def ExceptT.callCC {ε} [MonadCont m] {α β : Type _} (f : Label α (ExceptT ε m) β → ExceptT ε m α) :
     ExceptT ε m α :=
   ExceptT.mk (callCc fun x : Label _ m β => ExceptT.run <| f (ExceptT.mkLabel x) : m (Except ε α))
-#align except_t.call_cc ExceptTₓ.callCc
+#align except_t.call_cc ExceptTₓ.callCC
 
-instance {ε} [MonadCont m] : MonadCont (ExceptT ε m) where callCc α β := ExceptT.callCc
+instance {ε} [MonadCont m] : MonadCont (ExceptT ε m) where callCc α β := ExceptT.callCC
 
-instance {ε} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (ExceptT ε m)
+instance {ε} [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (ExceptT ε m)
     where
   callCc_bind_right := by
-    intros; simp [call_cc, ExceptT.callCc, call_cc_bind_right]; ext; dsimp
+    intros; simp [call_cc, ExceptT.callCC, call_cc_bind_right]; ext; dsimp
     congr with ⟨⟩ <;> simp [ExceptT.bindCont, @call_cc_dummy m _]
   callCc_bind_left := by
     intros
-    simp [call_cc, ExceptT.callCc, call_cc_bind_right, ExceptT.goto_mkLabel, map_eq_bind_pure_comp,
+    simp [call_cc, ExceptT.callCC, call_cc_bind_right, ExceptT.goto_mkLabel, map_eq_bind_pure_comp,
       bind_assoc, @call_cc_bind_left m _]
     ext; rfl
-  callCc_dummy := by intros; simp [call_cc, ExceptT.callCc, @call_cc_dummy m _]; ext; rfl
+  callCc_dummy := by intros; simp [call_cc, ExceptT.callCC, @call_cc_dummy m _]; ext; rfl
 
 def OptionT.mkLabel {α β} : Label (Option.{u} α) m β → Label α (OptionT m) β
   | ⟨f⟩ => ⟨fun a => monadLift <| f (some a)⟩
@@ -158,40 +186,40 @@ theorem OptionT.goto_mkLabel {α β : Type _} (x : Label (Option.{u} α) m β) (
     goto (OptionT.mkLabel x) i = ⟨some <$> goto x (some i)⟩ := by cases x <;> rfl
 #align option_t.goto_mk_label OptionTₓ.goto_mkLabel
 
-def OptionT.callCc [MonadCont m] {α β : Type _} (f : Label α (OptionT m) β → OptionT m α) :
+def OptionT.callCC [MonadCont m] {α β : Type _} (f : Label α (OptionT m) β → OptionT m α) :
     OptionT m α :=
   OptionT.mk (callCc fun x : Label _ m β => OptionT.run <| f (OptionT.mkLabel x) : m (Option α))
-#align option_t.call_cc OptionTₓ.callCc
+#align option_t.call_cc OptionTₓ.callCC
 
-instance [MonadCont m] : MonadCont (OptionT m) where callCc α β := OptionT.callCc
+instance [MonadCont m] : MonadCont (OptionT m) where callCc α β := OptionT.callCC
 
-instance [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (OptionT m)
+instance [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (OptionT m)
     where
   callCc_bind_right := by
-    intros; simp [call_cc, OptionT.callCc, call_cc_bind_right]; ext; dsimp
+    intros; simp [call_cc, OptionT.callCC, call_cc_bind_right]; ext; dsimp
     congr with ⟨⟩ <;> simp [OptionT.bindCont, @call_cc_dummy m _]
   callCc_bind_left := by
     intros;
-    simp [call_cc, OptionT.callCc, call_cc_bind_right, OptionT.goto_mkLabel, map_eq_bind_pure_comp,
+    simp [call_cc, OptionT.callCC, call_cc_bind_right, OptionT.goto_mkLabel, map_eq_bind_pure_comp,
       bind_assoc, @call_cc_bind_left m _]
     ext; rfl
-  callCc_dummy := by intros; simp [call_cc, OptionT.callCc, @call_cc_dummy m _]; ext; rfl
+  callCc_dummy := by intros; simp [call_cc, OptionT.callCC, @call_cc_dummy m _]; ext; rfl
 
-def WriterT.mkLabel {α β ω} [One ω] : Label (α × ω) m β → Label α (WriterT ω m) β
+def WriterT.mkLabel' {α β ω} [One ω] : Label (α × ω) m β → Label α (WriterT ω m) β
   | ⟨f⟩ => ⟨fun a => monadLift <| f (a, 1)⟩
-#align writer_t.mk_label WriterTₓ.mkLabel
+#align writer_t.mk_label WriterTₓ.mkLabel'
 
-theorem WriterT.goto_mkLabel {α β ω : Type _} [One ω] (x : Label (α × ω) m β) (i : α) :
-    goto (WriterT.mkLabel x) i = monadLift (goto x (i, 1)) := by cases x <;> rfl
-#align writer_t.goto_mk_label WriterTₓ.goto_mkLabel
+theorem WriterT.goto_mkLabel' {α β ω : Type _} [One ω] (x : Label (α × ω) m β) (i : α) :
+    goto (WriterT.mkLabel' x) i = monadLift (goto x (i, 1)) := by cases x <;> rfl
+#align writer_t.goto_mk_label WriterTₓ.goto_mkLabel'
 
-def WriterT.callCc [MonadCont m] {α β ω : Type _} [One ω]
+def WriterT.callCC' [MonadCont m] {α β ω : Type _} [One ω]
     (f : Label α (WriterT ω m) β → WriterT ω m α) : WriterT ω m α :=
-  ⟨callCc (WriterT.run ∘ f ∘ WriterT.mkLabel : Label (α × ω) m β → m (α × ω))⟩
-#align writer_t.call_cc WriterTₓ.callCc
+  ⟨callCc (WriterT.run ∘ f ∘ WriterT.mkLabel' : Label (α × ω) m β → m (α × ω))⟩
+#align writer_t.call_cc WriterTₓ.callCC'
 
 instance (ω) [Monad m] [One ω] [MonadCont m] : MonadCont (WriterT ω m)
-    where callCc α β := WriterT.callCc
+    where callCc α β := WriterT.callCC'
 
 def StateT.mkLabel {α β σ : Type u} : Label (α × σ) m (β × σ) → Label α (StateT σ m) β
   | ⟨f⟩ => ⟨fun a => ⟨fun s => f (a, s)⟩⟩
@@ -201,26 +229,26 @@ theorem StateT.goto_mkLabel {α β σ : Type u} (x : Label (α × σ) m (β × 
     goto (StateT.mkLabel x) i = ⟨fun s => goto x (i, s)⟩ := by cases x <;> rfl
 #align state_t.goto_mk_label StateTₓ.goto_mkLabel
 
-def StateT.callCc {σ} [MonadCont m] {α β : Type _} (f : Label α (StateT σ m) β → StateT σ m α) :
+def StateT.callCC {σ} [MonadCont m] {α β : Type _} (f : Label α (StateT σ m) β → StateT σ m α) :
     StateT σ m α :=
   ⟨fun r => callCc fun f' => (f <| StateT.mkLabel f').run r⟩
-#align state_t.call_cc StateTₓ.callCc
+#align state_t.call_cc StateTₓ.callCC
 
-instance {σ} [MonadCont m] : MonadCont (StateT σ m) where callCc α β := StateT.callCc
+instance {σ} [MonadCont m] : MonadCont (StateT σ m) where callCc α β := StateT.callCC
 
-instance {σ} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (StateT σ m)
+instance {σ} [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (StateT σ m)
     where
   callCc_bind_right := by
     intros
-    simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind]; ext; dsimp
+    simp [call_cc, StateT.callCC, call_cc_bind_right, (· >>= ·), StateT.bind]; ext; dsimp
     congr with ⟨x₀, x₁⟩; rfl
   callCc_bind_left := by
     intros;
-    simp [call_cc, StateT.callCc, call_cc_bind_left, (· >>= ·), StateT.bind, StateT.goto_mkLabel]
+    simp [call_cc, StateT.callCC, call_cc_bind_left, (· >>= ·), StateT.bind, StateT.goto_mkLabel]
     ext; rfl
   callCc_dummy := by
     intros;
-    simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind, @call_cc_dummy m _]
+    simp [call_cc, StateT.callCC, call_cc_bind_right, (· >>= ·), StateT.bind, @call_cc_dummy m _]
     ext; rfl
 
 def ReaderT.mkLabel {α β} (ρ) : Label α m β → Label α (ReaderT ρ m) β
@@ -231,21 +259,22 @@ theorem ReaderT.goto_mkLabel {α ρ β} (x : Label α m β) (i : α) :
     goto (ReaderT.mkLabel ρ x) i = monadLift (goto x i) := by cases x <;> rfl
 #align reader_t.goto_mk_label ReaderTₓ.goto_mkLabel
 
-def ReaderT.callCc {ε} [MonadCont m] {α β : Type _} (f : Label α (ReaderT ε m) β → ReaderT ε m α) :
+def ReaderT.callCC {ε} [MonadCont m] {α β : Type _} (f : Label α (ReaderT ε m) β → ReaderT ε m α) :
     ReaderT ε m α :=
   ⟨fun r => callCc fun f' => (f <| ReaderT.mkLabel _ f').run r⟩
-#align reader_t.call_cc ReaderTₓ.callCc
+#align reader_t.call_cc ReaderTₓ.callCC
 
-instance {ρ} [MonadCont m] : MonadCont (ReaderT ρ m) where callCc α β := ReaderT.callCc
+instance {ρ} [MonadCont m] : MonadCont (ReaderT ρ m) where callCc α β := ReaderT.callCC
 
-instance {ρ} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (ReaderT ρ m)
+instance {ρ} [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (ReaderT ρ m)
     where
-  callCc_bind_right := by intros; simp [call_cc, ReaderT.callCc, call_cc_bind_right]; ext; rfl
+  callCc_bind_right := by intros; simp [call_cc, ReaderT.callCC, call_cc_bind_right]; ext; rfl
   callCc_bind_left := by
-    intros; simp [call_cc, ReaderT.callCc, call_cc_bind_left, ReaderT.goto_mkLabel]
+    intros; simp [call_cc, ReaderT.callCC, call_cc_bind_left, ReaderT.goto_mkLabel]
     ext; rfl
-  callCc_dummy := by intros; simp [call_cc, ReaderT.callCc, @call_cc_dummy m _]; ext; rfl
+  callCc_dummy := by intros; simp [call_cc, ReaderT.callCC, @call_cc_dummy m _]; ext; rfl
 
+#print ContT.equiv /-
 /-- reduce the equivalence between two continuation passing monads to the equivalence between
 their underlying monad -/
 def ContT.equiv {m₁ : Type u₀ → Type v₀} {m₂ : Type u₁ → Type v₁} {α₁ r₁ : Type u₀}
@@ -256,4 +285,5 @@ def ContT.equiv {m₁ : Type u₀ → Type v₀} {m₂ : Type u₁ → Type v₁
   left_inv f := by funext r <;> simp
   right_inv f := by funext r <;> simp
 #align cont_t.equiv ContT.equiv
+-/

d6814c58

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -86,9 +86,9 @@ instance : Monad (ContT r m) where
 
 instance : LawfulMonad (ContT r m)
     where
-  id_map := by intros ; rfl
-  pure_bind := by intros ; ext; rfl
-  bind_assoc := by intros ; ext; rfl
+  id_map := by intros; rfl
+  pure_bind := by intros; ext; rfl
+  bind_assoc := by intros; ext; rfl
 
 def monadLift [Monad m] {α} : m α → ContT r m α := fun x f => x >>= f
 #align cont_t.monad_lift ContT.monadLift
@@ -141,14 +141,14 @@ instance {ε} [MonadCont m] : MonadCont (ExceptT ε m) where callCc α β := Exc
 instance {ε} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (ExceptT ε m)
     where
   callCc_bind_right := by
-    intros ; simp [call_cc, ExceptT.callCc, call_cc_bind_right]; ext; dsimp
+    intros; simp [call_cc, ExceptT.callCc, call_cc_bind_right]; ext; dsimp
     congr with ⟨⟩ <;> simp [ExceptT.bindCont, @call_cc_dummy m _]
   callCc_bind_left := by
     intros
     simp [call_cc, ExceptT.callCc, call_cc_bind_right, ExceptT.goto_mkLabel, map_eq_bind_pure_comp,
       bind_assoc, @call_cc_bind_left m _]
     ext; rfl
-  callCc_dummy := by intros ; simp [call_cc, ExceptT.callCc, @call_cc_dummy m _]; ext; rfl
+  callCc_dummy := by intros; simp [call_cc, ExceptT.callCc, @call_cc_dummy m _]; ext; rfl
 
 def OptionT.mkLabel {α β} : Label (Option.{u} α) m β → Label α (OptionT m) β
   | ⟨f⟩ => ⟨fun a => monadLift <| f (some a)⟩
@@ -168,14 +168,14 @@ instance [MonadCont m] : MonadCont (OptionT m) where callCc α β := OptionT.cal
 instance [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (OptionT m)
     where
   callCc_bind_right := by
-    intros ; simp [call_cc, OptionT.callCc, call_cc_bind_right]; ext; dsimp
+    intros; simp [call_cc, OptionT.callCc, call_cc_bind_right]; ext; dsimp
     congr with ⟨⟩ <;> simp [OptionT.bindCont, @call_cc_dummy m _]
   callCc_bind_left := by
-    intros ;
+    intros;
     simp [call_cc, OptionT.callCc, call_cc_bind_right, OptionT.goto_mkLabel, map_eq_bind_pure_comp,
       bind_assoc, @call_cc_bind_left m _]
     ext; rfl
-  callCc_dummy := by intros ; simp [call_cc, OptionT.callCc, @call_cc_dummy m _]; ext; rfl
+  callCc_dummy := by intros; simp [call_cc, OptionT.callCc, @call_cc_dummy m _]; ext; rfl
 
 def WriterT.mkLabel {α β ω} [One ω] : Label (α × ω) m β → Label α (WriterT ω m) β
   | ⟨f⟩ => ⟨fun a => monadLift <| f (a, 1)⟩
@@ -215,11 +215,11 @@ instance {σ} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (StateT σ
     simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind]; ext; dsimp
     congr with ⟨x₀, x₁⟩; rfl
   callCc_bind_left := by
-    intros ;
+    intros;
     simp [call_cc, StateT.callCc, call_cc_bind_left, (· >>= ·), StateT.bind, StateT.goto_mkLabel]
     ext; rfl
   callCc_dummy := by
-    intros ;
+    intros;
     simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind, @call_cc_dummy m _]
     ext; rfl
 
@@ -240,11 +240,11 @@ instance {ρ} [MonadCont m] : MonadCont (ReaderT ρ m) where callCc α β := Rea
 
 instance {ρ} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (ReaderT ρ m)
     where
-  callCc_bind_right := by intros ; simp [call_cc, ReaderT.callCc, call_cc_bind_right]; ext; rfl
+  callCc_bind_right := by intros; simp [call_cc, ReaderT.callCc, call_cc_bind_right]; ext; rfl
   callCc_bind_left := by
-    intros ; simp [call_cc, ReaderT.callCc, call_cc_bind_left, ReaderT.goto_mkLabel]
+    intros; simp [call_cc, ReaderT.callCc, call_cc_bind_left, ReaderT.goto_mkLabel]
     ext; rfl
-  callCc_dummy := by intros ; simp [call_cc, ReaderT.callCc, @call_cc_dummy m _]; ext; rfl
+  callCc_dummy := by intros; simp [call_cc, ReaderT.callCc, @call_cc_dummy m _]; ext; rfl
 
 /-- reduce the equivalence between two continuation passing monads to the equivalence between
 their underlying monad -/

d6814c58

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -177,12 +177,6 @@ instance [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (OptionT m)
     ext; rfl
   callCc_dummy := by intros ; simp [call_cc, OptionT.callCc, @call_cc_dummy m _]; ext; rfl
 
-/- warning: writer_t.mk_label -> WriterTₓ.mkLabel is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1} -> Type.{u2}} [_inst_1 : Monad.{u1, u2} m] {α : Type.{u3}} {β : Type.{u1}} {ω : Type.{u1}} [_inst_2 : One.{u1} ω], (MonadCont.Label.{u1, u2, max u3 u1} (Prod.{u3, u1} α ω) m β) -> (MonadCont.Label.{u1, max u1 u2, u3} α (WriterTₓ.{u1, u2} ω m) β)
-but is expected to have type
-  forall {m : Type.{u2} -> Type.{u3}} [_inst_1 : Monad.{u2, u3} m] {α : Type.{u1}} {β : Type.{u2}} {ω : Type.{u2}} [_inst_2 : One.{u2} ω], (MonadCont.Label.{u2, u3, max u1 u2} (Prod.{u1, u2} α ω) m β) -> (MonadCont.Label.{u2, max u2 u3, u1} α (WriterTₓ.{u2, u3} ω m) β)
-Case conversion may be inaccurate. Consider using '#align writer_t.mk_label WriterTₓ.mkLabelₓ'. -/
 def WriterT.mkLabel {α β ω} [One ω] : Label (α × ω) m β → Label α (WriterT ω m) β
   | ⟨f⟩ => ⟨fun a => monadLift <| f (a, 1)⟩
 #align writer_t.mk_label WriterTₓ.mkLabel
@@ -199,12 +193,6 @@ def WriterT.callCc [MonadCont m] {α β ω : Type _} [One ω]
 instance (ω) [Monad m] [One ω] [MonadCont m] : MonadCont (WriterT ω m)
     where callCc α β := WriterT.callCc
 
-/- warning: state_t.mk_label -> StateTₓ.mkLabel is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1} -> Type.{u2}} [_inst_1 : Monad.{u1, u2} m] {α : Type.{u1}} {β : Type.{u1}} {σ : Type.{u1}}, (MonadCont.Label.{u1, u2, u1} (Prod.{u1, u1} α σ) m (Prod.{u1, u1} β σ)) -> (MonadCont.Label.{u1, max u1 u2, u1} α (StateTₓ.{u1, u2} σ m) β)
-but is expected to have type
-  forall {m : Type.{u1} -> Type.{u2}} {_inst_1 : Type.{u1}} {α : Type.{u1}} {β : Type.{u1}}, (MonadCont.Label.{u1, u2, u1} (Prod.{u1, u1} _inst_1 β) m (Prod.{u1, u1} α β)) -> (MonadCont.Label.{u1, max u1 u2, u1} _inst_1 (StateTₓ.{u1, u2} β m) α)
-Case conversion may be inaccurate. Consider using '#align state_t.mk_label StateTₓ.mkLabelₓ'. -/
 def StateT.mkLabel {α β σ : Type u} : Label (α × σ) m (β × σ) → Label α (StateT σ m) β
   | ⟨f⟩ => ⟨fun a => ⟨fun s => f (a, s)⟩⟩
 #align state_t.mk_label StateTₓ.mkLabel
@@ -235,12 +223,6 @@ instance {σ} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (StateT σ
     simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind, @call_cc_dummy m _]
     ext; rfl
 
-/- warning: reader_t.mk_label -> ReaderTₓ.mkLabel is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1} -> Type.{u2}} [_inst_1 : Monad.{u1, u2} m] {α : Type.{u3}} {β : Type.{u1}} (ρ : Type.{u1}), (MonadCont.Label.{u1, u2, u3} α m β) -> (MonadCont.Label.{u1, max u1 u2, u3} α (ReaderTₓ.{u1, u2} ρ m) β)
-but is expected to have type
-  forall {m : Type.{u2} -> Type.{u3}} [_inst_1 : Monad.{u2, u3} m] {α : Type.{u1}} {β : Type.{u2}} (ρ : Type.{u2}), (MonadCont.Label.{u2, u3, u1} α m β) -> (MonadCont.Label.{u2, max u2 u3, u1} α (ReaderTₓ.{u2, u3} ρ m) β)
-Case conversion may be inaccurate. Consider using '#align reader_t.mk_label ReaderTₓ.mkLabelₓ'. -/
 def ReaderT.mkLabel {α β} (ρ) : Label α m β → Label α (ReaderT ρ m) β
   | ⟨f⟩ => ⟨monadLift ∘ f⟩
 #align reader_t.mk_label ReaderTₓ.mkLabel

d6814c58

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -86,17 +86,9 @@ instance : Monad (ContT r m) where
 
 instance : LawfulMonad (ContT r m)
     where
-  id_map := by
-    intros
-    rfl
-  pure_bind := by
-    intros
-    ext
-    rfl
-  bind_assoc := by
-    intros
-    ext
-    rfl
+  id_map := by intros ; rfl
+  pure_bind := by intros ; ext; rfl
+  bind_assoc := by intros ; ext; rfl
 
 def monadLift [Monad m] {α} : m α → ContT r m α := fun x f => x >>= f
 #align cont_t.monad_lift ContT.monadLift
@@ -149,22 +141,14 @@ instance {ε} [MonadCont m] : MonadCont (ExceptT ε m) where callCc α β := Exc
 instance {ε} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (ExceptT ε m)
     where
   callCc_bind_right := by
-    intros
-    simp [call_cc, ExceptT.callCc, call_cc_bind_right]
-    ext
-    dsimp
+    intros ; simp [call_cc, ExceptT.callCc, call_cc_bind_right]; ext; dsimp
     congr with ⟨⟩ <;> simp [ExceptT.bindCont, @call_cc_dummy m _]
   callCc_bind_left := by
     intros
     simp [call_cc, ExceptT.callCc, call_cc_bind_right, ExceptT.goto_mkLabel, map_eq_bind_pure_comp,
       bind_assoc, @call_cc_bind_left m _]
-    ext
-    rfl
-  callCc_dummy := by
-    intros
-    simp [call_cc, ExceptT.callCc, @call_cc_dummy m _]
-    ext
-    rfl
+    ext; rfl
+  callCc_dummy := by intros ; simp [call_cc, ExceptT.callCc, @call_cc_dummy m _]; ext; rfl
 
 def OptionT.mkLabel {α β} : Label (Option.{u} α) m β → Label α (OptionT m) β
   | ⟨f⟩ => ⟨fun a => monadLift <| f (some a)⟩
@@ -184,22 +168,14 @@ instance [MonadCont m] : MonadCont (OptionT m) where callCc α β := OptionT.cal
 instance [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (OptionT m)
     where
   callCc_bind_right := by
-    intros
-    simp [call_cc, OptionT.callCc, call_cc_bind_right]
-    ext
-    dsimp
+    intros ; simp [call_cc, OptionT.callCc, call_cc_bind_right]; ext; dsimp
     congr with ⟨⟩ <;> simp [OptionT.bindCont, @call_cc_dummy m _]
   callCc_bind_left := by
-    intros
+    intros ;
     simp [call_cc, OptionT.callCc, call_cc_bind_right, OptionT.goto_mkLabel, map_eq_bind_pure_comp,
       bind_assoc, @call_cc_bind_left m _]
-    ext
-    rfl
-  callCc_dummy := by
-    intros
-    simp [call_cc, OptionT.callCc, @call_cc_dummy m _]
-    ext
-    rfl
+    ext; rfl
+  callCc_dummy := by intros ; simp [call_cc, OptionT.callCc, @call_cc_dummy m _]; ext; rfl
 
 /- warning: writer_t.mk_label -> WriterTₓ.mkLabel is a dubious translation:
 lean 3 declaration is
@@ -248,21 +224,16 @@ instance {σ} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (StateT σ
     where
   callCc_bind_right := by
     intros
-    simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind]
-    ext
-    dsimp
-    congr with ⟨x₀, x₁⟩
-    rfl
+    simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind]; ext; dsimp
+    congr with ⟨x₀, x₁⟩; rfl
   callCc_bind_left := by
-    intros
+    intros ;
     simp [call_cc, StateT.callCc, call_cc_bind_left, (· >>= ·), StateT.bind, StateT.goto_mkLabel]
-    ext
-    rfl
+    ext; rfl
   callCc_dummy := by
-    intros
+    intros ;
     simp [call_cc, StateT.callCc, call_cc_bind_right, (· >>= ·), StateT.bind, @call_cc_dummy m _]
-    ext
-    rfl
+    ext; rfl
 
 /- warning: reader_t.mk_label -> ReaderTₓ.mkLabel is a dubious translation:
 lean 3 declaration is
@@ -287,21 +258,11 @@ instance {ρ} [MonadCont m] : MonadCont (ReaderT ρ m) where callCc α β := Rea
 
 instance {ρ} [MonadCont m] [IsLawfulMonadCont m] : IsLawfulMonadCont (ReaderT ρ m)
     where
-  callCc_bind_right := by
-    intros
-    simp [call_cc, ReaderT.callCc, call_cc_bind_right]
-    ext
-    rfl
+  callCc_bind_right := by intros ; simp [call_cc, ReaderT.callCc, call_cc_bind_right]; ext; rfl
   callCc_bind_left := by
-    intros
-    simp [call_cc, ReaderT.callCc, call_cc_bind_left, ReaderT.goto_mkLabel]
-    ext
-    rfl
-  callCc_dummy := by
-    intros
-    simp [call_cc, ReaderT.callCc, @call_cc_dummy m _]
-    ext
-    rfl
+    intros ; simp [call_cc, ReaderT.callCc, call_cc_bind_left, ReaderT.goto_mkLabel]
+    ext; rfl
+  callCc_dummy := by intros ; simp [call_cc, ReaderT.callCc, @call_cc_dummy m _]; ext; rfl
 
 /-- reduce the equivalence between two continuation passing monads to the equivalence between
 their underlying monad -/

d6814c58

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

d6814c58

chore: avoid id.def (adaptation for nightly-2024-03-27) (#11829)

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

b8a0f589

Diff

@@ -102,7 +102,7 @@ instance [Monad m] : MonadLift m (ContT r m) where
 theorem monadLift_bind [Monad m] [LawfulMonad m] {α β} (x : m α) (f : α → m β) :
     (monadLift (x >>= f) : ContT r m β) = monadLift x >>= monadLift ∘ f := by
   ext
-  simp only [monadLift, MonadLift.monadLift, (· ∘ ·), (· >>= ·), bind_assoc, id.def, run,
+  simp only [monadLift, MonadLift.monadLift, (· ∘ ·), (· >>= ·), bind_assoc, id, run,
     ContT.monadLift]
 #align cont_t.monad_lift_bind ContT.monadLift_bind

d6814c58

chore: squeeze some non-terminal simps (#11247)

This PR accompanies #11246, squeezing some non-terminal simps highlighted by the linter until I decided to stop!

1ad8c3fe

Diff

@@ -141,15 +141,15 @@ instance {ε} [MonadCont m] : MonadCont (ExceptT ε m) where
 
 instance {ε} [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (ExceptT ε m) where
   callCC_bind_right := by
-    intros; simp [callCC, ExceptT.callCC, callCC_bind_right]; ext
+    intros; simp only [callCC, ExceptT.callCC, ExceptT.run_bind, callCC_bind_right]; ext
     dsimp
     congr with ⟨⟩ <;> simp [ExceptT.bindCont, @callCC_dummy m _]
   callCC_bind_left := by
     intros
-    simp [callCC, ExceptT.callCC, callCC_bind_right, ExceptT.goto_mkLabel, map_eq_bind_pure_comp,
-      bind_assoc, @callCC_bind_left m _, Function.comp]
+    simp only [callCC, ExceptT.callCC, ExceptT.goto_mkLabel, map_eq_bind_pure_comp, Function.comp,
+      ExceptT.run_bind, ExceptT.run_mk, bind_assoc, pure_bind, @callCC_bind_left m _]
     ext; rfl
-  callCC_dummy := by intros; simp [callCC, ExceptT.callCC, @callCC_dummy m _]; ext; rfl
+  callCC_dummy := by intros; simp only [callCC, ExceptT.callCC, @callCC_dummy m _]; ext; rfl
 
 def OptionT.mkLabel {α β} : Label (Option.{u} α) m β → Label α (OptionT m) β
   | ⟨f⟩ => ⟨fun a => monadLift <| f (some a)⟩
@@ -170,15 +170,15 @@ instance [MonadCont m] : MonadCont (OptionT m) where
 
 instance [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (OptionT m) where
   callCC_bind_right := by
-    intros; simp [callCC, OptionT.callCC, callCC_bind_right]; ext
+    intros; simp only [callCC, OptionT.callCC, OptionT.run_bind, callCC_bind_right]; ext
     dsimp
     congr with ⟨⟩ <;> simp [@callCC_dummy m _]
   callCC_bind_left := by
     intros;
-    simp [callCC, OptionT.callCC, callCC_bind_right, OptionT.goto_mkLabel, map_eq_bind_pure_comp,
-      bind_assoc, @callCC_bind_left m _, Function.comp]
+    simp only [callCC, OptionT.callCC, OptionT.goto_mkLabel, OptionT.run_bind, OptionT.run_mk,
+      bind_assoc, pure_bind, @callCC_bind_left m _]
     ext; rfl
-  callCC_dummy := by intros; simp [callCC, OptionT.callCC, @callCC_dummy m _]; ext; rfl
+  callCC_dummy := by intros; simp only [callCC, OptionT.callCC, @callCC_dummy m _]; ext; rfl
 
 /- Porting note: In Lean 3, `One ω` is required for `MonadLift (WriterT ω m)`. In Lean 4,
                  `EmptyCollection ω` or `Monoid ω` is required. So we give definitions for the both
@@ -233,13 +233,14 @@ instance {σ} [MonadCont m] : MonadCont (StateT σ m) where
 instance {σ} [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (StateT σ m) where
   callCC_bind_right := by
     intros
-    simp [callCC, StateT.callCC, callCC_bind_right]; ext; rfl
+    simp only [callCC, StateT.callCC, StateT.run_bind, callCC_bind_right]; ext; rfl
   callCC_bind_left := by
     intros;
-    simp [callCC, StateT.callCC, callCC_bind_left, StateT.goto_mkLabel]; ext; rfl
+    simp only [callCC, StateT.callCC, StateT.goto_mkLabel, StateT.run_bind, StateT.run_mk,
+      callCC_bind_left]; ext; rfl
   callCC_dummy := by
     intros;
-    simp [callCC, StateT.callCC, callCC_bind_right, @callCC_dummy m _]
+    simp only [callCC, StateT.callCC, @callCC_dummy m _]
     ext; rfl
 
 def ReaderT.mkLabel {α β} (ρ) : Label α m β → Label α (ReaderT ρ m) β
@@ -259,11 +260,13 @@ instance {ρ} [MonadCont m] : MonadCont (ReaderT ρ m) where
   callCC := ReaderT.callCC
 
 instance {ρ} [MonadCont m] [LawfulMonadCont m] : LawfulMonadCont (ReaderT ρ m) where
-  callCC_bind_right := by intros; simp [callCC, ReaderT.callCC, callCC_bind_right]; ext; rfl
+  callCC_bind_right := by intros; simp only [callCC, ReaderT.callCC, ReaderT.run_bind,
+                                    callCC_bind_right]; ext; rfl
   callCC_bind_left := by
-    intros; simp [callCC, ReaderT.callCC, callCC_bind_left, ReaderT.goto_mkLabel]
+    intros; simp only [callCC, ReaderT.callCC, ReaderT.goto_mkLabel, ReaderT.run_bind,
+      ReaderT.run_monadLift, monadLift_self, callCC_bind_left]
     ext; rfl
-  callCC_dummy := by intros; simp [callCC, ReaderT.callCC, @callCC_dummy m _]; ext; rfl
+  callCC_dummy := by intros; simp only [callCC, ReaderT.callCC, @callCC_dummy m _]; ext; rfl
 
 /-- reduce the equivalence between two continuation passing monads to the equivalence between
 their underlying monad -/

d6814c58

feat: Linter that checks that Prop classes are Props (#6148)

930dd29d

Diff

@@ -33,7 +33,8 @@ class MonadCont (m : Type u → Type v) where
 
 open MonadCont
 
-class LawfulMonadCont (m : Type u → Type v) [Monad m] [MonadCont m] extends LawfulMonad m where
+class LawfulMonadCont (m : Type u → Type v) [Monad m] [MonadCont m]
+    extends LawfulMonad m : Prop where
   callCC_bind_right {α ω γ} (cmd : m α) (next : Label ω m γ → α → m ω) :
     (callCC fun f => cmd >>= next f) = cmd >>= fun x => callCC fun f => next f x
   callCC_bind_left {α} (β) (x : α) (dead : Label α m β → β → m α) :

d6814c58

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) 2019 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.monad.cont
-! leanprover-community/mathlib commit d6814c584384ddf2825ff038e868451a7c956f31
-! 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.Writer
 import Mathlib.Init.Control.Lawful
 
+#align_import control.monad.cont from "leanprover-community/mathlib"@"d6814c584384ddf2825ff038e868451a7c956f31"
+
 /-!
 # Continuation Monad

d6814c58

feat: port Control.Monad.Cont (#4981)

b1242d93

`control.monad.cont` ⟷ `Mathlib.Control.Monad.Cont`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 13

control.monad.cont ⟷ Mathlib.Control.Monad.Cont

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 13

`control.monad.cont` ⟷ `Mathlib.Control.Monad.Cont`