data.rbtree.min_max | 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

8f6fd1b6

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

8f6fd1b6

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -65,15 +65,15 @@ theorem Std.RBNode.min_is_minimal {a : α} {t : Std.RBNode α} :
   · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
   all_goals
     cases t_lchild <;> intro lo hi hs hmin b hmem
-    · simp [Std.RBNode.min] at hmin ; subst t_val
-      simp [mem] at hmem ; cases' hmem with heqv hmem
+    · simp [Std.RBNode.min] at hmin; subst t_val
+      simp [mem] at hmem; cases' hmem with heqv hmem
       · left; exact heqv.swap
       · have := lt_of_mem_right hs (by constructor) hmem
         right; assumption
     all_goals
       have hs' := hs
-      cases hs; simp [Std.RBNode.min] at hmin 
-      rw [mem] at hmem ; cases_type* or.1
+      cases hs; simp [Std.RBNode.min] at hmin
+      rw [mem] at hmem; cases_type* or.1
       · exact t_ih_lchild hs_hs₁ hmin hmem
       · have hmm := mem_of_min_eq lt hmin
         have a_lt_val := lt_of_mem_left hs' (by constructor) hmm
@@ -94,15 +94,15 @@ theorem Std.RBNode.max_is_maximal {a : α} {t : Std.RBNode α} :
   · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
   all_goals
     cases t_rchild <;> intro lo hi hs hmax b hmem
-    · simp [Std.RBNode.max] at hmax ; subst t_val
-      simp [mem] at hmem ; cases' hmem with hmem heqv
+    · simp [Std.RBNode.max] at hmax; subst t_val
+      simp [mem] at hmem; cases' hmem with hmem heqv
       · have := lt_of_mem_left hs (by constructor) hmem
         right; assumption
       · left; exact heqv.swap
     all_goals
       have hs' := hs
-      cases hs; simp [Std.RBNode.max] at hmax 
-      rw [mem] at hmem ; cases_type* or.1
+      cases hs; simp [Std.RBNode.max] at hmax
+      rw [mem] at hmem; cases_type* or.1
       · have hmm := mem_of_max_eq lt hmax
         have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
         right; assumption

8f6fd1b6

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -59,14 +59,58 @@ theorem Std.RBNode.min_is_minimal {a : α} {t : Std.RBNode α} :
     ∀ {lo hi},
       Std.RBNode.IsSearchable lt t lo hi →
         t.min = some a → ∀ {b}, Std.RBNode.Mem lt b t → a ≈[lt]b ∨ lt a b :=
-  by classical
+  by
+  classical
+  induction t
+  · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
+  all_goals
+    cases t_lchild <;> intro lo hi hs hmin b hmem
+    · simp [Std.RBNode.min] at hmin ; subst t_val
+      simp [mem] at hmem ; cases' hmem with heqv hmem
+      · left; exact heqv.swap
+      · have := lt_of_mem_right hs (by constructor) hmem
+        right; assumption
+    all_goals
+      have hs' := hs
+      cases hs; simp [Std.RBNode.min] at hmin 
+      rw [mem] at hmem ; cases_type* or.1
+      · exact t_ih_lchild hs_hs₁ hmin hmem
+      · have hmm := mem_of_min_eq lt hmin
+        have a_lt_val := lt_of_mem_left hs' (by constructor) hmm
+        have a_lt_b := lt_of_lt_of_incomp a_lt_val hmem.swap
+        right; assumption
+      · have hmm := mem_of_min_eq lt hmin
+        have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmm hmem
+        right; assumption
 #align rbnode.min_is_minimal Std.RBNode.min_is_minimal
 
 theorem Std.RBNode.max_is_maximal {a : α} {t : Std.RBNode α} :
     ∀ {lo hi},
       Std.RBNode.IsSearchable lt t lo hi →
         t.max = some a → ∀ {b}, Std.RBNode.Mem lt b t → a ≈[lt]b ∨ lt b a :=
-  by classical
+  by
+  classical
+  induction t
+  · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
+  all_goals
+    cases t_rchild <;> intro lo hi hs hmax b hmem
+    · simp [Std.RBNode.max] at hmax ; subst t_val
+      simp [mem] at hmem ; cases' hmem with hmem heqv
+      · have := lt_of_mem_left hs (by constructor) hmem
+        right; assumption
+      · left; exact heqv.swap
+    all_goals
+      have hs' := hs
+      cases hs; simp [Std.RBNode.max] at hmax 
+      rw [mem] at hmem ; cases_type* or.1
+      · have hmm := mem_of_max_eq lt hmax
+        have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
+        right; assumption
+      · have hmm := mem_of_max_eq lt hmax
+        have val_lt_a := lt_of_mem_right hs' (by constructor) hmm
+        have a_lt_b := lt_of_incomp_of_lt hmem val_lt_a
+        right; assumption
+      · exact t_ih_rchild hs_hs₂ hmax hmem
 #align rbnode.max_is_maximal Std.RBNode.max_is_maximal
 
 end Std.RBNode

8f6fd1b6

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -59,58 +59,14 @@ theorem Std.RBNode.min_is_minimal {a : α} {t : Std.RBNode α} :
     ∀ {lo hi},
       Std.RBNode.IsSearchable lt t lo hi →
         t.min = some a → ∀ {b}, Std.RBNode.Mem lt b t → a ≈[lt]b ∨ lt a b :=
-  by
-  classical
-  induction t
-  · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
-  all_goals
-    cases t_lchild <;> intro lo hi hs hmin b hmem
-    · simp [Std.RBNode.min] at hmin ; subst t_val
-      simp [mem] at hmem ; cases' hmem with heqv hmem
-      · left; exact heqv.swap
-      · have := lt_of_mem_right hs (by constructor) hmem
-        right; assumption
-    all_goals
-      have hs' := hs
-      cases hs; simp [Std.RBNode.min] at hmin 
-      rw [mem] at hmem ; cases_type* or.1
-      · exact t_ih_lchild hs_hs₁ hmin hmem
-      · have hmm := mem_of_min_eq lt hmin
-        have a_lt_val := lt_of_mem_left hs' (by constructor) hmm
-        have a_lt_b := lt_of_lt_of_incomp a_lt_val hmem.swap
-        right; assumption
-      · have hmm := mem_of_min_eq lt hmin
-        have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmm hmem
-        right; assumption
+  by classical
 #align rbnode.min_is_minimal Std.RBNode.min_is_minimal
 
 theorem Std.RBNode.max_is_maximal {a : α} {t : Std.RBNode α} :
     ∀ {lo hi},
       Std.RBNode.IsSearchable lt t lo hi →
         t.max = some a → ∀ {b}, Std.RBNode.Mem lt b t → a ≈[lt]b ∨ lt b a :=
-  by
-  classical
-  induction t
-  · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
-  all_goals
-    cases t_rchild <;> intro lo hi hs hmax b hmem
-    · simp [Std.RBNode.max] at hmax ; subst t_val
-      simp [mem] at hmem ; cases' hmem with hmem heqv
-      · have := lt_of_mem_left hs (by constructor) hmem
-        right; assumption
-      · left; exact heqv.swap
-    all_goals
-      have hs' := hs
-      cases hs; simp [Std.RBNode.max] at hmax 
-      rw [mem] at hmem ; cases_type* or.1
-      · have hmm := mem_of_max_eq lt hmax
-        have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
-        right; assumption
-      · have hmm := mem_of_max_eq lt hmax
-        have val_lt_a := lt_of_mem_right hs' (by constructor) hmm
-        have a_lt_b := lt_of_incomp_of_lt hmem val_lt_a
-        right; assumption
-      · exact t_ih_rchild hs_hs₂ hmax hmem
+  by classical
 #align rbnode.max_is_maximal Std.RBNode.max_is_maximal
 
 end Std.RBNode

8f6fd1b6

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2017 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
-import Mathbin.Data.Rbtree.Basic
+import Data.Rbtree.Basic
 
 #align_import data.rbtree.min_max from "leanprover-community/mathlib"@"8f6fd1b69096c6a587f745d354306c0d46396915"

8f6fd1b6

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2017 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
-
-! This file was ported from Lean 3 source module data.rbtree.min_max
-! leanprover-community/mathlib commit 8f6fd1b69096c6a587f745d354306c0d46396915
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Rbtree.Basic
 
+#align_import data.rbtree.min_max from "leanprover-community/mathlib"@"8f6fd1b69096c6a587f745d354306c0d46396915"
+
 universe u
 
 namespace Std.RBNode

8f6fd1b6

bump to nightly-2023-06-27-05

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

9377c86a

Diff

@@ -12,66 +12,70 @@ import Mathbin.Data.Rbtree.Basic
 
 universe u
 
-namespace Rbnode
+namespace Std.RBNode
 
 variable {α : Type u} {lt : α → α → Prop}
 
-theorem mem_of_min_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Rbnode α} :
-    t.min = some a → Mem lt a t := by
+theorem Std.RBNode.mem_of_min_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Std.RBNode α} :
+    t.min = some a → Std.RBNode.Mem lt a t :=
+  by
   induction t
   · intros; contradiction
   all_goals
-    cases t_lchild <;> simp [Rbnode.min] <;> intro h
+    cases t_lchild <;> simp [Std.RBNode.min] <;> intro h
     · subst t_val; simp [mem, irrefl_of lt a]
     all_goals rw [mem]; simp [t_ih_lchild h]
-#align rbnode.mem_of_min_eq Rbnode.mem_of_min_eq
+#align rbnode.mem_of_min_eq Std.RBNode.mem_of_min_eq
 
-theorem mem_of_max_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Rbnode α} :
-    t.max = some a → Mem lt a t := by
+theorem Std.RBNode.mem_of_max_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Std.RBNode α} :
+    t.max = some a → Std.RBNode.Mem lt a t :=
+  by
   induction t
   · intros; contradiction
   all_goals
-    cases t_rchild <;> simp [Rbnode.max] <;> intro h
+    cases t_rchild <;> simp [Std.RBNode.max] <;> intro h
     · subst t_val; simp [mem, irrefl_of lt a]
     all_goals rw [mem]; simp [t_ih_rchild h]
-#align rbnode.mem_of_max_eq Rbnode.mem_of_max_eq
+#align rbnode.mem_of_max_eq Std.RBNode.mem_of_max_eq
 
 variable [IsStrictWeakOrder α lt]
 
-theorem eq_leaf_of_min_eq_none {t : Rbnode α} : t.min = none → t = leaf :=
+theorem Std.RBNode.eq_nil_of_min_eq_none {t : Std.RBNode α} : t.min = none → t = Std.RBNode.nil :=
   by
   induction t
   · intros; rfl
   all_goals
-    cases t_lchild <;> simp [Rbnode.min, false_imp_iff] <;> intro h
+    cases t_lchild <;> simp [Std.RBNode.min, false_imp_iff] <;> intro h
     all_goals have := t_ih_lchild h; contradiction
-#align rbnode.eq_leaf_of_min_eq_none Rbnode.eq_leaf_of_min_eq_none
+#align rbnode.eq_leaf_of_min_eq_none Std.RBNode.eq_nil_of_min_eq_none
 
-theorem eq_leaf_of_max_eq_none {t : Rbnode α} : t.max = none → t = leaf :=
+theorem Std.RBNode.eq_nil_of_max_eq_none {t : Std.RBNode α} : t.max = none → t = Std.RBNode.nil :=
   by
   induction t
   · intros; rfl
   all_goals
-    cases t_rchild <;> simp [Rbnode.max, false_imp_iff] <;> intro h
+    cases t_rchild <;> simp [Std.RBNode.max, false_imp_iff] <;> intro h
     all_goals have := t_ih_rchild h; contradiction
-#align rbnode.eq_leaf_of_max_eq_none Rbnode.eq_leaf_of_max_eq_none
+#align rbnode.eq_leaf_of_max_eq_none Std.RBNode.eq_nil_of_max_eq_none
 
-theorem min_is_minimal {a : α} {t : Rbnode α} :
-    ∀ {lo hi}, IsSearchable lt t lo hi → t.min = some a → ∀ {b}, Mem lt b t → a ≈[lt]b ∨ lt a b :=
+theorem Std.RBNode.min_is_minimal {a : α} {t : Std.RBNode α} :
+    ∀ {lo hi},
+      Std.RBNode.IsSearchable lt t lo hi →
+        t.min = some a → ∀ {b}, Std.RBNode.Mem lt b t → a ≈[lt]b ∨ lt a b :=
   by
   classical
   induction t
   · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
   all_goals
     cases t_lchild <;> intro lo hi hs hmin b hmem
-    · simp [Rbnode.min] at hmin ; subst t_val
+    · simp [Std.RBNode.min] at hmin ; subst t_val
       simp [mem] at hmem ; cases' hmem with heqv hmem
       · left; exact heqv.swap
       · have := lt_of_mem_right hs (by constructor) hmem
         right; assumption
     all_goals
       have hs' := hs
-      cases hs; simp [Rbnode.min] at hmin 
+      cases hs; simp [Std.RBNode.min] at hmin 
       rw [mem] at hmem ; cases_type* or.1
       · exact t_ih_lchild hs_hs₁ hmin hmem
       · have hmm := mem_of_min_eq lt hmin
@@ -81,24 +85,26 @@ theorem min_is_minimal {a : α} {t : Rbnode α} :
       · have hmm := mem_of_min_eq lt hmin
         have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmm hmem
         right; assumption
-#align rbnode.min_is_minimal Rbnode.min_is_minimal
+#align rbnode.min_is_minimal Std.RBNode.min_is_minimal
 
-theorem max_is_maximal {a : α} {t : Rbnode α} :
-    ∀ {lo hi}, IsSearchable lt t lo hi → t.max = some a → ∀ {b}, Mem lt b t → a ≈[lt]b ∨ lt b a :=
+theorem Std.RBNode.max_is_maximal {a : α} {t : Std.RBNode α} :
+    ∀ {lo hi},
+      Std.RBNode.IsSearchable lt t lo hi →
+        t.max = some a → ∀ {b}, Std.RBNode.Mem lt b t → a ≈[lt]b ∨ lt b a :=
   by
   classical
   induction t
   · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
   all_goals
     cases t_rchild <;> intro lo hi hs hmax b hmem
-    · simp [Rbnode.max] at hmax ; subst t_val
+    · simp [Std.RBNode.max] at hmax ; subst t_val
       simp [mem] at hmem ; cases' hmem with hmem heqv
       · have := lt_of_mem_left hs (by constructor) hmem
         right; assumption
       · left; exact heqv.swap
     all_goals
       have hs' := hs
-      cases hs; simp [Rbnode.max] at hmax 
+      cases hs; simp [Std.RBNode.max] at hmax 
       rw [mem] at hmem ; cases_type* or.1
       · have hmm := mem_of_max_eq lt hmax
         have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
@@ -108,7 +114,7 @@ theorem max_is_maximal {a : α} {t : Rbnode α} :
         have a_lt_b := lt_of_incomp_of_lt hmem val_lt_a
         right; assumption
       · exact t_ih_rchild hs_hs₂ hmax hmem
-#align rbnode.max_is_maximal Rbnode.max_is_maximal
+#align rbnode.max_is_maximal Std.RBNode.max_is_maximal
 
-end Rbnode
+end Std.RBNode

8f6fd1b6

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -60,54 +60,54 @@ theorem min_is_minimal {a : α} {t : Rbnode α} :
     ∀ {lo hi}, IsSearchable lt t lo hi → t.min = some a → ∀ {b}, Mem lt b t → a ≈[lt]b ∨ lt a b :=
   by
   classical
-    induction t
-    · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
+  induction t
+  · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
+  all_goals
+    cases t_lchild <;> intro lo hi hs hmin b hmem
+    · simp [Rbnode.min] at hmin ; subst t_val
+      simp [mem] at hmem ; cases' hmem with heqv hmem
+      · left; exact heqv.swap
+      · have := lt_of_mem_right hs (by constructor) hmem
+        right; assumption
     all_goals
-      cases t_lchild <;> intro lo hi hs hmin b hmem
-      · simp [Rbnode.min] at hmin ; subst t_val
-        simp [mem] at hmem ; cases' hmem with heqv hmem
-        · left; exact heqv.swap
-        · have := lt_of_mem_right hs (by constructor) hmem
-          right; assumption
-      all_goals
-        have hs' := hs
-        cases hs; simp [Rbnode.min] at hmin 
-        rw [mem] at hmem ; cases_type*or.1
-        · exact t_ih_lchild hs_hs₁ hmin hmem
-        · have hmm := mem_of_min_eq lt hmin
-          have a_lt_val := lt_of_mem_left hs' (by constructor) hmm
-          have a_lt_b := lt_of_lt_of_incomp a_lt_val hmem.swap
-          right; assumption
-        · have hmm := mem_of_min_eq lt hmin
-          have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmm hmem
-          right; assumption
+      have hs' := hs
+      cases hs; simp [Rbnode.min] at hmin 
+      rw [mem] at hmem ; cases_type* or.1
+      · exact t_ih_lchild hs_hs₁ hmin hmem
+      · have hmm := mem_of_min_eq lt hmin
+        have a_lt_val := lt_of_mem_left hs' (by constructor) hmm
+        have a_lt_b := lt_of_lt_of_incomp a_lt_val hmem.swap
+        right; assumption
+      · have hmm := mem_of_min_eq lt hmin
+        have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmm hmem
+        right; assumption
 #align rbnode.min_is_minimal Rbnode.min_is_minimal
 
 theorem max_is_maximal {a : α} {t : Rbnode α} :
     ∀ {lo hi}, IsSearchable lt t lo hi → t.max = some a → ∀ {b}, Mem lt b t → a ≈[lt]b ∨ lt b a :=
   by
   classical
-    induction t
-    · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
+  induction t
+  · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
+  all_goals
+    cases t_rchild <;> intro lo hi hs hmax b hmem
+    · simp [Rbnode.max] at hmax ; subst t_val
+      simp [mem] at hmem ; cases' hmem with hmem heqv
+      · have := lt_of_mem_left hs (by constructor) hmem
+        right; assumption
+      · left; exact heqv.swap
     all_goals
-      cases t_rchild <;> intro lo hi hs hmax b hmem
-      · simp [Rbnode.max] at hmax ; subst t_val
-        simp [mem] at hmem ; cases' hmem with hmem heqv
-        · have := lt_of_mem_left hs (by constructor) hmem
-          right; assumption
-        · left; exact heqv.swap
-      all_goals
-        have hs' := hs
-        cases hs; simp [Rbnode.max] at hmax 
-        rw [mem] at hmem ; cases_type*or.1
-        · have hmm := mem_of_max_eq lt hmax
-          have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
-          right; assumption
-        · have hmm := mem_of_max_eq lt hmax
-          have val_lt_a := lt_of_mem_right hs' (by constructor) hmm
-          have a_lt_b := lt_of_incomp_of_lt hmem val_lt_a
-          right; assumption
-        · exact t_ih_rchild hs_hs₂ hmax hmem
+      have hs' := hs
+      cases hs; simp [Rbnode.max] at hmax 
+      rw [mem] at hmem ; cases_type* or.1
+      · have hmm := mem_of_max_eq lt hmax
+        have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
+        right; assumption
+      · have hmm := mem_of_max_eq lt hmax
+        have val_lt_a := lt_of_mem_right hs' (by constructor) hmm
+        have a_lt_b := lt_of_incomp_of_lt hmem val_lt_a
+        right; assumption
+      · exact t_ih_rchild hs_hs₂ hmax hmem
 #align rbnode.max_is_maximal Rbnode.max_is_maximal
 
 end Rbnode

8f6fd1b6

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -19,7 +19,7 @@ variable {α : Type u} {lt : α → α → Prop}
 theorem mem_of_min_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Rbnode α} :
     t.min = some a → Mem lt a t := by
   induction t
-  · intros ; contradiction
+  · intros; contradiction
   all_goals
     cases t_lchild <;> simp [Rbnode.min] <;> intro h
     · subst t_val; simp [mem, irrefl_of lt a]
@@ -29,7 +29,7 @@ theorem mem_of_min_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : R
 theorem mem_of_max_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Rbnode α} :
     t.max = some a → Mem lt a t := by
   induction t
-  · intros ; contradiction
+  · intros; contradiction
   all_goals
     cases t_rchild <;> simp [Rbnode.max] <;> intro h
     · subst t_val; simp [mem, irrefl_of lt a]
@@ -41,7 +41,7 @@ variable [IsStrictWeakOrder α lt]
 theorem eq_leaf_of_min_eq_none {t : Rbnode α} : t.min = none → t = leaf :=
   by
   induction t
-  · intros ; rfl
+  · intros; rfl
   all_goals
     cases t_lchild <;> simp [Rbnode.min, false_imp_iff] <;> intro h
     all_goals have := t_ih_lchild h; contradiction
@@ -50,7 +50,7 @@ theorem eq_leaf_of_min_eq_none {t : Rbnode α} : t.min = none → t = leaf :=
 theorem eq_leaf_of_max_eq_none {t : Rbnode α} : t.max = none → t = leaf :=
   by
   induction t
-  · intros ; rfl
+  · intros; rfl
   all_goals
     cases t_rchild <;> simp [Rbnode.max, false_imp_iff] <;> intro h
     all_goals have := t_ih_rchild h; contradiction
@@ -64,15 +64,15 @@ theorem min_is_minimal {a : α} {t : Rbnode α} :
     · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
     all_goals
       cases t_lchild <;> intro lo hi hs hmin b hmem
-      · simp [Rbnode.min] at hmin; subst t_val
-        simp [mem] at hmem; cases' hmem with heqv hmem
+      · simp [Rbnode.min] at hmin ; subst t_val
+        simp [mem] at hmem ; cases' hmem with heqv hmem
         · left; exact heqv.swap
         · have := lt_of_mem_right hs (by constructor) hmem
           right; assumption
       all_goals
         have hs' := hs
-        cases hs; simp [Rbnode.min] at hmin
-        rw [mem] at hmem; cases_type*or.1
+        cases hs; simp [Rbnode.min] at hmin 
+        rw [mem] at hmem ; cases_type*or.1
         · exact t_ih_lchild hs_hs₁ hmin hmem
         · have hmm := mem_of_min_eq lt hmin
           have a_lt_val := lt_of_mem_left hs' (by constructor) hmm
@@ -91,15 +91,15 @@ theorem max_is_maximal {a : α} {t : Rbnode α} :
     · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
     all_goals
       cases t_rchild <;> intro lo hi hs hmax b hmem
-      · simp [Rbnode.max] at hmax; subst t_val
-        simp [mem] at hmem; cases' hmem with hmem heqv
+      · simp [Rbnode.max] at hmax ; subst t_val
+        simp [mem] at hmem ; cases' hmem with hmem heqv
         · have := lt_of_mem_left hs (by constructor) hmem
           right; assumption
         · left; exact heqv.swap
       all_goals
         have hs' := hs
-        cases hs; simp [Rbnode.max] at hmax
-        rw [mem] at hmem; cases_type*or.1
+        cases hs; simp [Rbnode.max] at hmax 
+        rw [mem] at hmem ; cases_type*or.1
         · have hmm := mem_of_max_eq lt hmax
           have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
           right; assumption

8f6fd1b6

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -19,24 +19,20 @@ variable {α : Type u} {lt : α → α → Prop}
 theorem mem_of_min_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Rbnode α} :
     t.min = some a → Mem lt a t := by
   induction t
-  · intros
-    contradiction
+  · intros ; contradiction
   all_goals
     cases t_lchild <;> simp [Rbnode.min] <;> intro h
-    · subst t_val
-      simp [mem, irrefl_of lt a]
+    · subst t_val; simp [mem, irrefl_of lt a]
     all_goals rw [mem]; simp [t_ih_lchild h]
 #align rbnode.mem_of_min_eq Rbnode.mem_of_min_eq
 
 theorem mem_of_max_eq (lt : α → α → Prop) [IsIrrefl α lt] {a : α} {t : Rbnode α} :
     t.max = some a → Mem lt a t := by
   induction t
-  · intros
-    contradiction
+  · intros ; contradiction
   all_goals
     cases t_rchild <;> simp [Rbnode.max] <;> intro h
-    · subst t_val
-      simp [mem, irrefl_of lt a]
+    · subst t_val; simp [mem, irrefl_of lt a]
     all_goals rw [mem]; simp [t_ih_rchild h]
 #align rbnode.mem_of_max_eq Rbnode.mem_of_max_eq
 
@@ -45,8 +41,7 @@ variable [IsStrictWeakOrder α lt]
 theorem eq_leaf_of_min_eq_none {t : Rbnode α} : t.min = none → t = leaf :=
   by
   induction t
-  · intros
-    rfl
+  · intros ; rfl
   all_goals
     cases t_lchild <;> simp [Rbnode.min, false_imp_iff] <;> intro h
     all_goals have := t_ih_lchild h; contradiction
@@ -55,8 +50,7 @@ theorem eq_leaf_of_min_eq_none {t : Rbnode α} : t.min = none → t = leaf :=
 theorem eq_leaf_of_max_eq_none {t : Rbnode α} : t.max = none → t = leaf :=
   by
   induction t
-  · intros
-    rfl
+  · intros ; rfl
   all_goals
     cases t_rchild <;> simp [Rbnode.max, false_imp_iff] <;> intro h
     all_goals have := t_ih_rchild h; contradiction
@@ -67,20 +61,14 @@ theorem min_is_minimal {a : α} {t : Rbnode α} :
   by
   classical
     induction t
-    · simp [StrictWeakOrder.Equiv]
-      intro _ _ hs hmin b
-      contradiction
+    · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmin b; contradiction
     all_goals
       cases t_lchild <;> intro lo hi hs hmin b hmem
-      · simp [Rbnode.min] at hmin
-        subst t_val
-        simp [mem] at hmem
-        cases' hmem with heqv hmem
-        · left
-          exact heqv.swap
+      · simp [Rbnode.min] at hmin; subst t_val
+        simp [mem] at hmem; cases' hmem with heqv hmem
+        · left; exact heqv.swap
         · have := lt_of_mem_right hs (by constructor) hmem
-          right
-          assumption
+          right; assumption
       all_goals
         have hs' := hs
         cases hs; simp [Rbnode.min] at hmin
@@ -89,12 +77,10 @@ theorem min_is_minimal {a : α} {t : Rbnode α} :
         · have hmm := mem_of_min_eq lt hmin
           have a_lt_val := lt_of_mem_left hs' (by constructor) hmm
           have a_lt_b := lt_of_lt_of_incomp a_lt_val hmem.swap
-          right
-          assumption
+          right; assumption
         · have hmm := mem_of_min_eq lt hmin
           have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmm hmem
-          right
-          assumption
+          right; assumption
 #align rbnode.min_is_minimal Rbnode.min_is_minimal
 
 theorem max_is_maximal {a : α} {t : Rbnode α} :
@@ -102,33 +88,25 @@ theorem max_is_maximal {a : α} {t : Rbnode α} :
   by
   classical
     induction t
-    · simp [StrictWeakOrder.Equiv]
-      intro _ _ hs hmax b
-      contradiction
+    · simp [StrictWeakOrder.Equiv]; intro _ _ hs hmax b; contradiction
     all_goals
       cases t_rchild <;> intro lo hi hs hmax b hmem
-      · simp [Rbnode.max] at hmax
-        subst t_val
-        simp [mem] at hmem
-        cases' hmem with hmem heqv
+      · simp [Rbnode.max] at hmax; subst t_val
+        simp [mem] at hmem; cases' hmem with hmem heqv
         · have := lt_of_mem_left hs (by constructor) hmem
-          right
-          assumption
-        · left
-          exact heqv.swap
+          right; assumption
+        · left; exact heqv.swap
       all_goals
         have hs' := hs
         cases hs; simp [Rbnode.max] at hmax
         rw [mem] at hmem; cases_type*or.1
         · have hmm := mem_of_max_eq lt hmax
           have a_lt_b := lt_of_mem_left_right hs' (by constructor) hmem hmm
-          right
-          assumption
+          right; assumption
         · have hmm := mem_of_max_eq lt hmax
           have val_lt_a := lt_of_mem_right hs' (by constructor) hmm
           have a_lt_b := lt_of_incomp_of_lt hmem val_lt_a
-          right
-          assumption
+          right; assumption
         · exact t_ih_rchild hs_hs₂ hmax hmem
 #align rbnode.max_is_maximal Rbnode.max_is_maximal

8f6fd1b6

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

8f6fd1b6

chore: move #align_import out of comment (#6165)

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

1919f537

Diff

@@ -3,12 +3,13 @@ Copyright (c) 2017 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
+import Mathlib.Mathport.Rename
+
+#align_import data.rbtree.min_max from "leanprover-community/mathlib"@"8f6fd1b69096c6a587f745d354306c0d46396915"
 
 /-!
 # Porting note: essentially already ported to std4
 
-#align_import data.rbtree.min_max from "leanprover-community/mathlib"@"8f6fd1b69096c6a587f745d354306c0d46396915"
-
 https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Mathlib4.20porting.20meeting.20series/near/369848971
 
 -/

8f6fd1b6

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) 2017 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
-
-! This file was ported from Lean 3 source module data.rbtree.min_max
-! leanprover-community/mathlib commit 8f6fd1b69096c6a587f745d354306c0d46396915
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 
 /-!
 # Porting note: essentially already ported to std4
 
+#align_import data.rbtree.min_max from "leanprover-community/mathlib"@"8f6fd1b69096c6a587f745d354306c0d46396915"
+
 https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Mathlib4.20porting.20meeting.20series/near/369848971
 
 -/

8f6fd1b6

feat: "port" Rbmap and Rbtree files (#5504)

Cf. here. Incorporates #5479.

Co-authored-by: Johan Commelin <johan@commelin.net>

0171e873

`data.rbtree.min_max` ⟷ `Mathlib.Data.Rbtree.MinMax`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 6

data.rbtree.min_max ⟷ Mathlib.Data.Rbtree.MinMax

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 6

`data.rbtree.min_max` ⟷ `Mathlib.Data.Rbtree.MinMax`