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

4d416710

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

4d416710

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -491,12 +491,12 @@ theorem Std.RBNode.find?_ins_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt]
       (hlt₂ : Std.RBNode.Lift lt (some x) hi),
       Std.RBNode.find? lt (Std.RBNode.ins lt t x) y = some x :=
   by
-  simp [StrictWeakOrder.Equiv] at he 
+  simp [StrictWeakOrder.Equiv] at he
   apply ins.induction lt t x <;> intros
   ·
     run_tac
       simp_fi
-  all_goals simp at hc ; cases hs
+  all_goals simp at hc; cases hs
   · have := lt_of_incomp_of_lt he.swap hc
     have := ih hs_hs₁ hlt₁ hc
     run_tac
@@ -817,7 +817,7 @@ theorem Std.RBNode.find?_ins_of_disj {x y : α} {t : Std.RBNode α} (hn : lt x y
   apply ins.induction lt t x <;> intros
   · cases hn
     all_goals simp [find, ins, cmpUsing, *]
-  all_goals simp at hc ; cases hs
+  all_goals simp at hc; cases hs
   · have := ih hs_hs₁ hlt₁ hc;
     run_tac
       simp_fi
@@ -833,7 +833,7 @@ theorem Std.RBNode.find?_ins_of_disj {x y : α} {t : Std.RBNode α} (hn : lt x y
       simp_fi
   · have ih := ih hs_hs₁ hlt₁ hc
     cases hn
-    · cases hc' : cmpUsing lt y y_1 <;> simp at hc' 
+    · cases hc' : cmpUsing lt y y_1 <;> simp at hc'
       · have hsi := is_searchable_ins lt hs_hs₁ hlt₁ (trans_of lt hn hc')
         have := find_balance1_node_lt lt hc' hsi hs_hs₂
         run_tac
@@ -874,7 +874,7 @@ theorem Std.RBNode.find?_ins_of_disj {x y : α} {t : Std.RBNode α} (hn : lt x y
         simp_fi
     · run_tac
         simp_fi
-      cases hc' : cmpUsing lt y y_1 <;> simp at hc' 
+      cases hc' : cmpUsing lt y y_1 <;> simp at hc'
       · have hsi := is_searchable_ins lt hs_hs₂ hc hlt₂
         have := find_balance2_node_lt lt hc' hsi hs_hs₁
         run_tac
@@ -914,7 +914,7 @@ theorem Std.RBNode.find?_insert_of_not_eqv [DecidableRel lt] [IsStrictWeakOrder
   simp [insert, find_mk_insert_result]
   have he : lt x y ∨ lt y x :=
     by
-    simp [StrictWeakOrder.Equiv, Decidable.not_and_iff_or_not, Decidable.not_not_iff] at hn 
+    simp [StrictWeakOrder.Equiv, Decidable.not_and_iff_or_not, Decidable.not_not_iff] at hn
     assumption
   apply find_ins_of_disj lt he hs <;> simp
 #align rbnode.find_insert_of_not_eqv Std.RBNode.find?_insert_of_not_eqv
@@ -982,12 +982,12 @@ variable {lt : α → α → Prop} [DecidableRel lt]
 
 theorem Std.RBNode.of_getColor_eq_red {t : Std.RBNode α} {c n} :
     Std.RBNode.getColor t = red → Std.RBNode.IsRedBlack t c n → c = red := by intro h₁ h₂;
-  cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
+  cases h₂ <;> simp only [get_color] at h₁ <;> contradiction
 #align rbnode.of_get_color_eq_red Std.RBNode.of_getColor_eq_red
 
 theorem Std.RBNode.of_getColor_ne_red {t : Std.RBNode α} {c n} :
     Std.RBNode.getColor t ≠ red → Std.RBNode.IsRedBlack t c n → c = black := by intro h₁ h₂;
-  cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
+  cases h₂ <;> simp only [get_color] at h₁ <;> contradiction
 #align rbnode.of_get_color_ne_red Std.RBNode.of_getColor_ne_red
 
 variable (lt)
@@ -1028,7 +1028,7 @@ theorem Std.RBNode.insert_rb {t : Std.RBNode α} (x) {c n} (h : Std.RBNode.IsRed
   simp [insert]
   have hi := ins_rb lt x h
   generalize he : ins lt t x = r
-  simp [he] at hi 
+  simp [he] at hi
   cases h <;> simp [get_color, ins_rb_result, insert_rb_result, mk_insert_result] at *
   assumption'
   · cases hi; simp [mk_insert_result]; constructor <;> assumption
@@ -1039,7 +1039,7 @@ theorem Std.RBNode.insert_isRedBlack {t : Std.RBNode α} {c n} (x) :
   by
   intro h
   have := insert_rb lt x h
-  cases c <;> simp [insert_rb_result] at this 
+  cases c <;> simp [insert_rb_result] at this
   · constructor; constructor; assumption
   · cases this; constructor; constructor; assumption
 #align rbnode.insert_is_red_black Std.RBNode.insert_isRedBlack

4d416710

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -228,7 +228,12 @@ theorem Std.RBNode.isSearchableIns [DecidableRel lt] {t x} [IsStrictWeakOrder α
 theorem Std.RBNode.isSearchableMkInsertResult {c t} :
     Std.RBNode.IsSearchable lt t none none →
       Std.RBNode.IsSearchable lt (Std.RBNode.mkInsertResult c t) none none :=
-  by classical
+  by
+  classical
+  cases c <;> cases t <;> simp [mk_insert_result]
+  · intro h;
+    run_tac
+      is_searchable_tactic
 #align rbnode.is_searchable_mk_insert_result Std.RBNode.isSearchableMkInsertResult
 
 theorem Std.RBNode.isSearchableInsert [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :

4d416710

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -228,12 +228,7 @@ theorem Std.RBNode.isSearchableIns [DecidableRel lt] {t x} [IsStrictWeakOrder α
 theorem Std.RBNode.isSearchableMkInsertResult {c t} :
     Std.RBNode.IsSearchable lt t none none →
       Std.RBNode.IsSearchable lt (Std.RBNode.mkInsertResult c t) none none :=
-  by
-  classical
-  cases c <;> cases t <;> simp [mk_insert_result]
-  · intro h;
-    run_tac
-      is_searchable_tactic
+  by classical
 #align rbnode.is_searchable_mk_insert_result Std.RBNode.isSearchableMkInsertResult
 
 theorem Std.RBNode.isSearchableInsert [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :

4d416710

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.Find
+import Data.Rbtree.Find
 
 #align_import data.rbtree.insert from "leanprover-community/mathlib"@"4d4167104581a21259f7f448e1972a63a4546be7"
 
@@ -472,7 +472,7 @@ theorem Std.RBNode.ite_eq_of_not_lt [DecidableRel lt] [IsStrictOrder α lt] {a b
 
 attribute [local simp] ite_eq_of_not_lt
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:337:4: warning: unsupported (TODO): `[tacs] -/
 private unsafe def simp_fi : tactic Unit :=
   sorry
 
@@ -605,7 +605,7 @@ theorem Std.RBNode.find?_balance1_lt {l r t v x y lo hi} (h : lt x y)
     · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
 #align rbnode.find_balance1_lt Std.RBNode.find?_balance1_lt
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:337:4: warning: unsupported (TODO): `[tacs] -/
 unsafe def ins_ne_leaf_tac :=
   sorry
 #align rbnode.ins_ne_leaf_tac rbnode.ins_ne_leaf_tac

4d416710

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.insert
-! leanprover-community/mathlib commit 4d4167104581a21259f7f448e1972a63a4546be7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Rbtree.Find
 
+#align_import data.rbtree.insert from "leanprover-community/mathlib"@"4d4167104581a21259f7f448e1972a63a4546be7"
+
 universe u v
 
 attribute [local simp] Std.RBNode.Lift

4d416710

bump to nightly-2023-06-27-05

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

9377c86a

Diff

@@ -12,106 +12,120 @@ import Mathbin.Data.Rbtree.Find
 
 universe u v
 
-attribute [local simp] Rbnode.Lift
+attribute [local simp] Std.RBNode.Lift
 
-namespace Rbnode
+namespace Std.RBNode
 
 variable {α : Type u}
 
 open Color
 
 @[simp]
-theorem balance1_eq₁ (l : Rbnode α) (x r₁ y r₂ v t) :
-    balance1 (red_node l x r₁) y r₂ v t = red_node (black_node l x r₁) y (black_node r₂ v t) := by
-  cases r₂ <;> rfl
-#align rbnode.balance1_eq₁ Rbnode.balance1_eq₁
+theorem Std.RBNode.balance1_eq₁ (l : Std.RBNode α) (x r₁ y r₂ v t) :
+    Std.RBNode.balance1 (Std.RBNode.node l x r₁) y r₂ v t =
+      Std.RBNode.node (black_node l x r₁) y (black_node r₂ v t) :=
+  by cases r₂ <;> rfl
+#align rbnode.balance1_eq₁ Std.RBNode.balance1_eq₁
 
 @[simp]
-theorem balance1_eq₂ (l₁ : Rbnode α) (y l₂ x r v t) :
-    getColor l₁ ≠ red →
-      balance1 l₁ y (red_node l₂ x r) v t = red_node (black_node l₁ y l₂) x (black_node r v t) :=
+theorem Std.RBNode.balance1_eq₂ (l₁ : Std.RBNode α) (y l₂ x r v t) :
+    Std.RBNode.getColor l₁ ≠ red →
+      Std.RBNode.balance1 l₁ y (Std.RBNode.node l₂ x r) v t =
+        Std.RBNode.node (black_node l₁ y l₂) x (black_node r v t) :=
   by cases l₁ <;> simp [get_color, balance1, false_imp_iff]
-#align rbnode.balance1_eq₂ Rbnode.balance1_eq₂
+#align rbnode.balance1_eq₂ Std.RBNode.balance1_eq₂
 
 @[simp]
-theorem balance1_eq₃ (l : Rbnode α) (y r v t) :
-    getColor l ≠ red → getColor r ≠ red → balance1 l y r v t = black_node (red_node l y r) v t := by
-  cases l <;> cases r <;> simp [get_color, balance1, false_imp_iff]
-#align rbnode.balance1_eq₃ Rbnode.balance1_eq₃
+theorem Std.RBNode.balance1_eq₃ (l : Std.RBNode α) (y r v t) :
+    Std.RBNode.getColor l ≠ red →
+      Std.RBNode.getColor r ≠ red →
+        Std.RBNode.balance1 l y r v t = black_node (Std.RBNode.node l y r) v t :=
+  by cases l <;> cases r <;> simp [get_color, balance1, false_imp_iff]
+#align rbnode.balance1_eq₃ Std.RBNode.balance1_eq₃
 
 @[simp]
-theorem balance2_eq₁ (l : Rbnode α) (x₁ r₁ y r₂ v t) :
-    balance2 (red_node l x₁ r₁) y r₂ v t = red_node (black_node t v l) x₁ (black_node r₁ y r₂) := by
-  cases r₂ <;> rfl
-#align rbnode.balance2_eq₁ Rbnode.balance2_eq₁
+theorem Std.RBNode.balance2_eq₁ (l : Std.RBNode α) (x₁ r₁ y r₂ v t) :
+    Std.RBNode.balance2 (Std.RBNode.node l x₁ r₁) y r₂ v t =
+      Std.RBNode.node (black_node t v l) x₁ (black_node r₁ y r₂) :=
+  by cases r₂ <;> rfl
+#align rbnode.balance2_eq₁ Std.RBNode.balance2_eq₁
 
 @[simp]
-theorem balance2_eq₂ (l₁ : Rbnode α) (y l₂ x₂ r₂ v t) :
-    getColor l₁ ≠ red →
-      balance2 l₁ y (red_node l₂ x₂ r₂) v t =
-        red_node (black_node t v l₁) y (black_node l₂ x₂ r₂) :=
+theorem Std.RBNode.balance2_eq₂ (l₁ : Std.RBNode α) (y l₂ x₂ r₂ v t) :
+    Std.RBNode.getColor l₁ ≠ red →
+      Std.RBNode.balance2 l₁ y (Std.RBNode.node l₂ x₂ r₂) v t =
+        Std.RBNode.node (black_node t v l₁) y (black_node l₂ x₂ r₂) :=
   by cases l₁ <;> simp [get_color, balance2, false_imp_iff]
-#align rbnode.balance2_eq₂ Rbnode.balance2_eq₂
+#align rbnode.balance2_eq₂ Std.RBNode.balance2_eq₂
 
 @[simp]
-theorem balance2_eq₃ (l : Rbnode α) (y r v t) :
-    getColor l ≠ red → getColor r ≠ red → balance2 l y r v t = black_node t v (red_node l y r) := by
-  cases l <;> cases r <;> simp [get_color, balance2, false_imp_iff]
-#align rbnode.balance2_eq₃ Rbnode.balance2_eq₃
+theorem Std.RBNode.balance2_eq₃ (l : Std.RBNode α) (y r v t) :
+    Std.RBNode.getColor l ≠ red →
+      Std.RBNode.getColor r ≠ red →
+        Std.RBNode.balance2 l y r v t = black_node t v (Std.RBNode.node l y r) :=
+  by cases l <;> cases r <;> simp [get_color, balance2, false_imp_iff]
+#align rbnode.balance2_eq₃ Std.RBNode.balance2_eq₃
 
 -- We can use the same induction principle for balance1 and balance2
-theorem Balance.cases {p : Rbnode α → α → Rbnode α → Prop} (l y r)
-    (red_left : ∀ l x r₁ y r₂, p (red_node l x r₁) y r₂)
-    (red_right : ∀ l₁ y l₂ x r, getColor l₁ ≠ red → p l₁ y (red_node l₂ x r))
-    (other : ∀ l y r, getColor l ≠ red → getColor r ≠ red → p l y r) : p l y r :=
-  by
+theorem Std.RBNode.Balance.cases {p : Std.RBNode α → α → Std.RBNode α → Prop} (l y r)
+    (red_left : ∀ l x r₁ y r₂, p (Std.RBNode.node l x r₁) y r₂)
+    (red_right : ∀ l₁ y l₂ x r, Std.RBNode.getColor l₁ ≠ red → p l₁ y (Std.RBNode.node l₂ x r))
+    (other : ∀ l y r, Std.RBNode.getColor l ≠ red → Std.RBNode.getColor r ≠ red → p l y r) :
+    p l y r := by
   cases l <;> cases r
   any_goals apply red_left
   any_goals apply red_right <;> simp [get_color] <;> contradiction <;> done
   any_goals apply other <;> simp [get_color] <;> contradiction <;> done
-#align rbnode.balance.cases Rbnode.Balance.cases
+#align rbnode.balance.cases Std.RBNode.Balance.cases
 
-theorem balance1_ne_leaf (l : Rbnode α) (x r v t) : balance1 l x r v t ≠ leaf := by
+theorem Std.RBNode.balance1_ne_nil (l : Std.RBNode α) (x r v t) :
+    Std.RBNode.balance1 l x r v t ≠ Std.RBNode.nil := by
   apply balance.cases l x r <;> intros <;> simp [*] <;> contradiction
-#align rbnode.balance1_ne_leaf Rbnode.balance1_ne_leaf
+#align rbnode.balance1_ne_leaf Std.RBNode.balance1_ne_nil
 
-theorem balance1Node_ne_leaf {s : Rbnode α} (a : α) (t : Rbnode α) :
-    s ≠ leaf → balance1Node s a t ≠ leaf := by
+theorem Std.RBNode.balance1Node_ne_nil {s : Std.RBNode α} (a : α) (t : Std.RBNode α) :
+    s ≠ Std.RBNode.nil → Std.RBNode.balance1Node s a t ≠ Std.RBNode.nil :=
+  by
   intro h; cases s
   · contradiction
   all_goals simp [balance1_node]; apply balance1_ne_leaf
-#align rbnode.balance1_node_ne_leaf Rbnode.balance1Node_ne_leaf
+#align rbnode.balance1_node_ne_leaf Std.RBNode.balance1Node_ne_nil
 
-theorem balance2_ne_leaf (l : Rbnode α) (x r v t) : balance2 l x r v t ≠ leaf := by
+theorem Std.RBNode.balance2_ne_nil (l : Std.RBNode α) (x r v t) :
+    Std.RBNode.balance2 l x r v t ≠ Std.RBNode.nil := by
   apply balance.cases l x r <;> intros <;> simp [*] <;> contradiction
-#align rbnode.balance2_ne_leaf Rbnode.balance2_ne_leaf
+#align rbnode.balance2_ne_leaf Std.RBNode.balance2_ne_nil
 
-theorem balance2Node_ne_leaf {s : Rbnode α} (a : α) (t : Rbnode α) :
-    s ≠ leaf → balance2Node s a t ≠ leaf := by
+theorem Std.RBNode.balance2Node_ne_nil {s : Std.RBNode α} (a : α) (t : Std.RBNode α) :
+    s ≠ Std.RBNode.nil → Std.RBNode.balance2Node s a t ≠ Std.RBNode.nil :=
+  by
   intro h; cases s
   · contradiction
   all_goals simp [balance2_node]; apply balance2_ne_leaf
-#align rbnode.balance2_node_ne_leaf Rbnode.balance2Node_ne_leaf
+#align rbnode.balance2_node_ne_leaf Std.RBNode.balance2Node_ne_nil
 
 variable (lt : α → α → Prop)
 
 @[elab_as_elim]
-theorem ins.induction [DecidableRel lt] {p : Rbnode α → Prop} (t x) (is_leaf : p leaf)
-    (is_red_lt : ∀ (a y b) (hc : cmpUsing lt x y = Ordering.lt) (ih : p a), p (red_node a y b))
-    (is_red_eq : ∀ (a y b) (hc : cmpUsing lt x y = Ordering.eq), p (red_node a y b))
-    (is_red_gt : ∀ (a y b) (hc : cmpUsing lt x y = Ordering.gt) (ih : p b), p (red_node a y b))
+theorem Std.RBNode.ins.induction [DecidableRel lt] {p : Std.RBNode α → Prop} (t x)
+    (is_leaf : p Std.RBNode.nil)
+    (is_red_lt :
+      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.lt) (ih : p a), p (Std.RBNode.node a y b))
+    (is_red_eq : ∀ (a y b) (hc : cmpUsing lt x y = Ordering.eq), p (Std.RBNode.node a y b))
+    (is_red_gt :
+      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.gt) (ih : p b), p (Std.RBNode.node a y b))
     (is_black_lt_red :
-      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.lt) (hr : getColor a = red) (ih : p a),
+      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.lt) (hr : Std.RBNode.getColor a = red) (ih : p a),
         p (black_node a y b))
     (is_black_lt_not_red :
-      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.lt) (hnr : getColor a ≠ red) (ih : p a),
+      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.lt) (hnr : Std.RBNode.getColor a ≠ red) (ih : p a),
         p (black_node a y b))
     (is_black_eq : ∀ (a y b) (hc : cmpUsing lt x y = Ordering.eq), p (black_node a y b))
     (is_black_gt_red :
-      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.gt) (hr : getColor b = red) (ih : p b),
+      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.gt) (hr : Std.RBNode.getColor b = red) (ih : p b),
         p (black_node a y b))
     (is_black_gt_not_red :
-      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.gt) (hnr : getColor b ≠ red) (ih : p b),
+      ∀ (a y b) (hc : cmpUsing lt x y = Ordering.gt) (hnr : Std.RBNode.getColor b ≠ red) (ih : p b),
         p (black_node a y b)) :
     p t := by
   induction t
@@ -132,24 +146,26 @@ theorem ins.induction [DecidableRel lt] {p : Rbnode α → Prop} (t x) (is_leaf
       by_cases get_color b = red
       · apply is_black_gt_red <;> assumption
       · apply is_black_gt_not_red <;> assumption
-#align rbnode.ins.induction Rbnode.ins.induction
+#align rbnode.ins.induction Std.RBNode.ins.induction
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem isSearchable_balance1 {l y r v t lo hi} :
-    IsSearchable lt l lo (some y) →
-      IsSearchable lt r (some y) (some v) →
-        IsSearchable lt t (some v) hi → IsSearchable lt (balance1 l y r v t) lo hi :=
+theorem Std.RBNode.isSearchableBalance1 {l y r v t lo hi} :
+    Std.RBNode.IsSearchable lt l lo (some y) →
+      Std.RBNode.IsSearchable lt r (some y) (some v) →
+        Std.RBNode.IsSearchable lt t (some v) hi →
+          Std.RBNode.IsSearchable lt (Std.RBNode.balance1 l y r v t) lo hi :=
   by
   apply balance.cases l y r <;> intros <;> simp [*] <;>
     run_tac
       is_searchable_tactic
-#align rbnode.is_searchable_balance1 Rbnode.isSearchable_balance1
+#align rbnode.is_searchable_balance1 Std.RBNode.isSearchableBalance1
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem isSearchable_balance1Node {t} [IsTrans α lt] :
+theorem Std.RBNode.isSearchableBalance1Node {t} [IsTrans α lt] :
     ∀ {y s lo hi},
-      IsSearchable lt t lo (some y) →
-        IsSearchable lt s (some y) hi → IsSearchable lt (balance1Node t y s) lo hi :=
+      Std.RBNode.IsSearchable lt t lo (some y) →
+        Std.RBNode.IsSearchable lt s (some y) hi →
+          Std.RBNode.IsSearchable lt (Std.RBNode.balance1Node t y s) lo hi :=
   by
   cases t <;> simp! <;> intros <;>
     run_tac
@@ -158,24 +174,26 @@ theorem isSearchable_balance1Node {t} [IsTrans α lt] :
     · apply is_searchable_none_low_of_is_searchable_some_low; assumption
     · simp at *; apply is_searchable_some_low_of_is_searchable_of_lt <;> assumption
   all_goals apply is_searchable_balance1 <;> assumption
-#align rbnode.is_searchable_balance1_node Rbnode.isSearchable_balance1Node
+#align rbnode.is_searchable_balance1_node Std.RBNode.isSearchableBalance1Node
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem isSearchable_balance2 {l y r v t lo hi} :
-    IsSearchable lt t lo (some v) →
-      IsSearchable lt l (some v) (some y) →
-        IsSearchable lt r (some y) hi → IsSearchable lt (balance2 l y r v t) lo hi :=
+theorem Std.RBNode.isSearchableBalance2 {l y r v t lo hi} :
+    Std.RBNode.IsSearchable lt t lo (some v) →
+      Std.RBNode.IsSearchable lt l (some v) (some y) →
+        Std.RBNode.IsSearchable lt r (some y) hi →
+          Std.RBNode.IsSearchable lt (Std.RBNode.balance2 l y r v t) lo hi :=
   by
   apply balance.cases l y r <;> intros <;> simp [*] <;>
     run_tac
       is_searchable_tactic
-#align rbnode.is_searchable_balance2 Rbnode.isSearchable_balance2
+#align rbnode.is_searchable_balance2 Std.RBNode.isSearchableBalance2
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem isSearchable_balance2Node {t} [IsTrans α lt] :
+theorem Std.RBNode.isSearchableBalance2Node {t} [IsTrans α lt] :
     ∀ {y s lo hi},
-      IsSearchable lt s lo (some y) →
-        IsSearchable lt t (some y) hi → IsSearchable lt (balance2Node t y s) lo hi :=
+      Std.RBNode.IsSearchable lt s lo (some y) →
+        Std.RBNode.IsSearchable lt t (some y) hi →
+          Std.RBNode.IsSearchable lt (Std.RBNode.balance2Node t y s) lo hi :=
   by
   induction t <;> simp! <;> intros <;>
     run_tac
@@ -184,12 +202,13 @@ theorem isSearchable_balance2Node {t} [IsTrans α lt] :
     · apply is_searchable_none_high_of_is_searchable_some_high; assumption
     · simp at *; apply is_searchable_some_high_of_is_searchable_of_lt; assumption'
   all_goals apply is_searchable_balance2; assumption'
-#align rbnode.is_searchable_balance2_node Rbnode.isSearchable_balance2Node
+#align rbnode.is_searchable_balance2_node Std.RBNode.isSearchableBalance2Node
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem isSearchable_ins [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
-    ∀ {lo hi} (h : IsSearchable lt t lo hi),
-      Lift lt lo (some x) → Lift lt (some x) hi → IsSearchable lt (ins lt t x) lo hi :=
+theorem Std.RBNode.isSearchableIns [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
+    ∀ {lo hi} (h : Std.RBNode.IsSearchable lt t lo hi),
+      Std.RBNode.Lift lt lo (some x) →
+        Std.RBNode.Lift lt (some x) hi → Std.RBNode.IsSearchable lt (Std.RBNode.ins lt t x) lo hi :=
   by
   apply ins.induction lt t x <;> intros <;> simp_all! (config := { eta := false }) <;>
     run_tac
@@ -206,31 +225,34 @@ theorem isSearchable_ins [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
   · apply is_searchable_balance2_node; assumption; apply ih h_hs₂; simp [*]
     assumption
   · apply ih h_hs₂; assumption; simp [*]
-#align rbnode.is_searchable_ins Rbnode.isSearchable_ins
+#align rbnode.is_searchable_ins Std.RBNode.isSearchableIns
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem isSearchable_mkInsertResult {c t} :
-    IsSearchable lt t none none → IsSearchable lt (mkInsertResult c t) none none := by
+theorem Std.RBNode.isSearchableMkInsertResult {c t} :
+    Std.RBNode.IsSearchable lt t none none →
+      Std.RBNode.IsSearchable lt (Std.RBNode.mkInsertResult c t) none none :=
+  by
   classical
   cases c <;> cases t <;> simp [mk_insert_result]
   · intro h;
     run_tac
       is_searchable_tactic
-#align rbnode.is_searchable_mk_insert_result Rbnode.isSearchable_mkInsertResult
+#align rbnode.is_searchable_mk_insert_result Std.RBNode.isSearchableMkInsertResult
 
-theorem isSearchable_insert [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
-    IsSearchable lt t none none → IsSearchable lt (insert lt t x) none none := by intro h;
-  simp [insert]; apply is_searchable_mk_insert_result;
+theorem Std.RBNode.isSearchableInsert [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
+    Std.RBNode.IsSearchable lt t none none →
+      Std.RBNode.IsSearchable lt (Std.RBNode.insert lt t x) none none :=
+  by intro h; simp [insert]; apply is_searchable_mk_insert_result;
   apply is_searchable_ins <;>
     ·
       first
       | assumption
       | simp
-#align rbnode.is_searchable_insert Rbnode.isSearchable_insert
+#align rbnode.is_searchable_insert Std.RBNode.isSearchableInsert
 
-end Rbnode
+end Std.RBNode
 
-namespace Rbnode
+namespace Std.RBNode
 
 section MembershipLemmas
 
@@ -238,80 +260,83 @@ parameter {α : Type u} (lt : α → α → Prop)
 
 attribute [local simp] mem balance1_node balance2_node
 
-local infixl:0 " ∈ " => Mem lt
+local infixl:0 " ∈ " => Std.RBNode.Mem lt
 
-theorem mem_balance1Node_of_mem_left {x s} (v) (t : Rbnode α) :
-    (x ∈ s) → (x ∈ balance1Node s v t) :=
+theorem Std.RBNode.mem_balance1Node_of_mem_left {x s} (v) (t : Std.RBNode α) :
+    (x ∈ s) → (x ∈ Std.RBNode.balance1Node s v t) :=
   by
   cases s <;> simp [false_imp_iff]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp at * <;> cases_type* or.1 <;>
       simp [*]
-#align rbnode.mem_balance1_node_of_mem_left Rbnode.mem_balance1Node_of_mem_left
+#align rbnode.mem_balance1_node_of_mem_left Std.RBNode.mem_balance1Node_of_mem_left
 
-theorem mem_balance2Node_of_mem_left {x s} (v) (t : Rbnode α) :
-    (x ∈ s) → (x ∈ balance2Node s v t) :=
+theorem Std.RBNode.mem_balance2Node_of_mem_left {x s} (v) (t : Std.RBNode α) :
+    (x ∈ s) → (x ∈ Std.RBNode.balance2Node s v t) :=
   by
   cases s <;> simp [false_imp_iff]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp at * <;> cases_type* or.1 <;>
       simp [*]
-#align rbnode.mem_balance2_node_of_mem_left Rbnode.mem_balance2Node_of_mem_left
+#align rbnode.mem_balance2_node_of_mem_left Std.RBNode.mem_balance2Node_of_mem_left
 
-theorem mem_balance1Node_of_mem_right {x t} (v) (s : Rbnode α) :
-    (x ∈ t) → (x ∈ balance1Node s v t) := by
+theorem Std.RBNode.mem_balance1Node_of_mem_right {x t} (v) (s : Std.RBNode α) :
+    (x ∈ t) → (x ∈ Std.RBNode.balance1Node s v t) :=
+  by
   intros; cases s <;> simp [*]
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
-#align rbnode.mem_balance1_node_of_mem_right Rbnode.mem_balance1Node_of_mem_right
+#align rbnode.mem_balance1_node_of_mem_right Std.RBNode.mem_balance1Node_of_mem_right
 
-theorem mem_balance2Node_of_mem_right {x t} (v) (s : Rbnode α) :
-    (x ∈ t) → (x ∈ balance2Node s v t) := by
+theorem Std.RBNode.mem_balance2Node_of_mem_right {x t} (v) (s : Std.RBNode α) :
+    (x ∈ t) → (x ∈ Std.RBNode.balance2Node s v t) :=
+  by
   intros; cases s <;> simp [*]
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
-#align rbnode.mem_balance2_node_of_mem_right Rbnode.mem_balance2Node_of_mem_right
+#align rbnode.mem_balance2_node_of_mem_right Std.RBNode.mem_balance2Node_of_mem_right
 
-theorem mem_balance1Node_of_incomp {x v} (s t) :
-    ¬lt x v ∧ ¬lt v x → s ≠ leaf → (x ∈ balance1Node s v t) :=
+theorem Std.RBNode.mem_balance1Node_of_incomp {x v} (s t) :
+    ¬lt x v ∧ ¬lt v x → s ≠ Std.RBNode.nil → (x ∈ Std.RBNode.balance1Node s v t) :=
   by
   intros; cases s <;> simp
   · contradiction
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
-#align rbnode.mem_balance1_node_of_incomp Rbnode.mem_balance1Node_of_incomp
+#align rbnode.mem_balance1_node_of_incomp Std.RBNode.mem_balance1Node_of_incomp
 
-theorem mem_balance2Node_of_incomp {x v} (s t) :
-    ¬lt v x ∧ ¬lt x v → s ≠ leaf → (x ∈ balance2Node s v t) :=
+theorem Std.RBNode.mem_balance2Node_of_incomp {x v} (s t) :
+    ¬lt v x ∧ ¬lt x v → s ≠ Std.RBNode.nil → (x ∈ Std.RBNode.balance2Node s v t) :=
   by
   intros; cases s <;> simp
   · contradiction
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
-#align rbnode.mem_balance2_node_of_incomp Rbnode.mem_balance2Node_of_incomp
+#align rbnode.mem_balance2_node_of_incomp Std.RBNode.mem_balance2Node_of_incomp
 
-theorem ins_ne_leaf [DecidableRel lt] (t : Rbnode α) (x : α) : t.ins lt x ≠ leaf :=
-  by
+theorem Std.RBNode.ins_ne_nil [DecidableRel lt] (t : Std.RBNode α) (x : α) :
+    t.ins lt x ≠ Std.RBNode.nil := by
   apply ins.induction lt t x
   any_goals intros; simp [ins, *]
   · intros; apply balance1_node_ne_leaf; assumption
   · intros; apply balance2_node_ne_leaf; assumption
-#align rbnode.ins_ne_leaf Rbnode.ins_ne_leaf
+#align rbnode.ins_ne_leaf Std.RBNode.ins_ne_nil
 
-theorem insert_ne_leaf [DecidableRel lt] (t : Rbnode α) (x : α) : insert lt t x ≠ leaf :=
+theorem Std.RBNode.insert_ne_nil [DecidableRel lt] (t : Std.RBNode α) (x : α) :
+    Std.RBNode.insert lt t x ≠ Std.RBNode.nil :=
   by
   simp [insert]
   cases he : ins lt t x <;> cases get_color t <;> simp [mk_insert_result]
   · have := ins_ne_leaf lt t x; contradiction
   · exact absurd he (ins_ne_leaf _ _ _)
-#align rbnode.insert_ne_leaf Rbnode.insert_ne_leaf
+#align rbnode.insert_ne_leaf Std.RBNode.insert_ne_nil
 
-theorem mem_ins_of_incomp [DecidableRel lt] (t : Rbnode α) {x y : α} :
+theorem Std.RBNode.mem_ins_of_incomp [DecidableRel lt] (t : Std.RBNode α) {x y : α} :
     ∀ h : ¬lt x y ∧ ¬lt y x, x ∈ t.ins lt y :=
   by
   apply ins.induction lt t y <;> intros <;> simp [ins, *]
   · have := ih h; apply mem_balance1_node_of_mem_left; assumption
   · have := ih h; apply mem_balance2_node_of_mem_left; assumption
-#align rbnode.mem_ins_of_incomp Rbnode.mem_ins_of_incomp
+#align rbnode.mem_ins_of_incomp Std.RBNode.mem_ins_of_incomp
 
-theorem mem_ins_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t : Rbnode α} (z : α) :
-    ∀ {x} (h : x ∈ t), x ∈ t.ins lt z :=
+theorem Std.RBNode.mem_ins_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t : Std.RBNode α}
+    (z : α) : ∀ {x} (h : x ∈ t), x ∈ t.ins lt z :=
   by
   apply ins.induction lt t z <;> intros <;> simp_all [ins] <;> try contradiction <;>
     cases_type* or.1
@@ -326,47 +351,51 @@ theorem mem_ins_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t : Rbnode 
   · have := ins_ne_leaf lt a z; apply mem_balance2_node_of_incomp; cases h; simp [*]
     apply ins_ne_leaf
   · apply mem_balance2_node_of_mem_left; apply ih h
-#align rbnode.mem_ins_of_mem Rbnode.mem_ins_of_mem
+#align rbnode.mem_ins_of_mem Std.RBNode.mem_ins_of_mem
 
-theorem mem_mkInsertResult {a t} (c) : Mem lt a t → Mem lt a (mkInsertResult c t) := by
+theorem Std.RBNode.mem_mkInsertResult {a t} (c) :
+    Std.RBNode.Mem lt a t → Std.RBNode.Mem lt a (Std.RBNode.mkInsertResult c t) := by
   intros <;> cases c <;> cases t <;> simp_all [mk_insert_result, mem]
-#align rbnode.mem_mk_insert_result Rbnode.mem_mkInsertResult
+#align rbnode.mem_mk_insert_result Std.RBNode.mem_mkInsertResult
 
-theorem mem_of_mem_mkInsertResult {a t c} : Mem lt a (mkInsertResult c t) → Mem lt a t := by
+theorem Std.RBNode.mem_of_mem_mkInsertResult {a t c} :
+    Std.RBNode.Mem lt a (Std.RBNode.mkInsertResult c t) → Std.RBNode.Mem lt a t := by
   cases t <;> cases c <;> simp [mk_insert_result, mem] <;> intros <;> assumption
-#align rbnode.mem_of_mem_mk_insert_result Rbnode.mem_of_mem_mkInsertResult
+#align rbnode.mem_of_mem_mk_insert_result Std.RBNode.mem_of_mem_mkInsertResult
 
-theorem mem_insert_of_incomp [DecidableRel lt] (t : Rbnode α) {x y : α} :
+theorem Std.RBNode.mem_insert_of_incomp [DecidableRel lt] (t : Std.RBNode α) {x y : α} :
     ∀ h : ¬lt x y ∧ ¬lt y x, x ∈ t.insert lt y := by
   intros <;> unfold insert <;> apply mem_mk_insert_result <;> apply mem_ins_of_incomp <;> assumption
-#align rbnode.mem_insert_of_incomp Rbnode.mem_insert_of_incomp
+#align rbnode.mem_insert_of_incomp Std.RBNode.mem_insert_of_incomp
 
-theorem mem_insert_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t x} (z) :
+#print Std.RBNode.mem_insert_of_mem /-
+theorem Std.RBNode.mem_insert_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t x} (z) :
     (x ∈ t) → (x ∈ t.insert lt z) := by
   intros <;> apply mem_mk_insert_result <;> apply mem_ins_of_mem <;> assumption
-#align rbnode.mem_insert_of_mem Rbnode.mem_insert_of_mem
+#align rbnode.mem_insert_of_mem Std.RBNode.mem_insert_of_mem
+-/
 
-theorem of_mem_balance1Node {x s v t} :
-    (x ∈ balance1Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
+theorem Std.RBNode.of_mem_balance1Node {x s v t} :
+    (x ∈ Std.RBNode.balance1Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
   by
   cases s <;> simp
   · intros; simp [*]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
-#align rbnode.of_mem_balance1_node Rbnode.of_mem_balance1Node
+#align rbnode.of_mem_balance1_node Std.RBNode.of_mem_balance1Node
 
-theorem of_mem_balance2Node {x s v t} :
-    (x ∈ balance2Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
+theorem Std.RBNode.of_mem_balance2Node {x s v t} :
+    (x ∈ Std.RBNode.balance2Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
   by
   cases s <;> simp
   · intros; simp [*]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
-#align rbnode.of_mem_balance2_node Rbnode.of_mem_balance2Node
+#align rbnode.of_mem_balance2_node Std.RBNode.of_mem_balance2Node
 
-theorem equiv_or_mem_of_mem_ins [DecidableRel lt] {t : Rbnode α} {x z} :
+theorem Std.RBNode.equiv_or_mem_of_mem_ins [DecidableRel lt] {t : Std.RBNode α} {x z} :
     ∀ h : x ∈ t.ins lt z, x ≈[lt]z ∨ (x ∈ t) :=
   by
   apply ins.induction lt t z <;> intros <;> simp_all [ins, StrictWeakOrder.Equiv] <;>
@@ -379,38 +408,39 @@ theorem equiv_or_mem_of_mem_ins [DecidableRel lt] {t : Rbnode α} {x z} :
   · have h' := of_mem_balance2_node lt h; cases_type* or.1
     have := ih h'; cases_type* or.1
     all_goals simp [h, *]
-#align rbnode.equiv_or_mem_of_mem_ins Rbnode.equiv_or_mem_of_mem_ins
+#align rbnode.equiv_or_mem_of_mem_ins Std.RBNode.equiv_or_mem_of_mem_ins
 
-theorem equiv_or_mem_of_mem_insert [DecidableRel lt] {t : Rbnode α} {x z} :
+theorem Std.RBNode.equiv_or_mem_of_mem_insert [DecidableRel lt] {t : Std.RBNode α} {x z} :
     ∀ h : x ∈ t.insert lt z, x ≈[lt]z ∨ (x ∈ t) := by simp [insert]; intros;
   apply equiv_or_mem_of_mem_ins; exact mem_of_mem_mk_insert_result lt h
-#align rbnode.equiv_or_mem_of_mem_insert Rbnode.equiv_or_mem_of_mem_insert
+#align rbnode.equiv_or_mem_of_mem_insert Std.RBNode.equiv_or_mem_of_mem_insert
 
 attribute [local simp] mem_exact
 
-theorem memExact_balance1Node_of_memExact {x s} (v) (t : Rbnode α) :
-    MemExact x s → MemExact x (balance1Node s v t) :=
+theorem Std.RBNode.memExact_balance1Node_of_memExact {x s} (v) (t : Std.RBNode α) :
+    Std.RBNode.MemExact x s → Std.RBNode.MemExact x (Std.RBNode.balance1Node s v t) :=
   by
   cases s <;> simp [false_imp_iff]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
-#align rbnode.mem_exact_balance1_node_of_mem_exact Rbnode.memExact_balance1Node_of_memExact
+#align rbnode.mem_exact_balance1_node_of_mem_exact Std.RBNode.memExact_balance1Node_of_memExact
 
-theorem memExact_balance2Node_of_memExact {x s} (v) (t : Rbnode α) :
-    MemExact x s → MemExact x (balance2Node s v t) :=
+theorem Std.RBNode.memExact_balance2Node_of_memExact {x s} (v) (t : Std.RBNode α) :
+    Std.RBNode.MemExact x s → Std.RBNode.MemExact x (Std.RBNode.balance2Node s v t) :=
   by
   cases s <;> simp [false_imp_iff]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
-#align rbnode.mem_exact_balance2_node_of_mem_exact Rbnode.memExact_balance2Node_of_memExact
+#align rbnode.mem_exact_balance2_node_of_mem_exact Std.RBNode.memExact_balance2Node_of_memExact
 
-theorem find_balance1Node [DecidableRel lt] [IsStrictWeakOrder α lt] {x y z t s} :
+theorem Std.RBNode.find?_balance1Node [DecidableRel lt] [IsStrictWeakOrder α lt] {x y z t s} :
     ∀ {lo hi},
-      IsSearchable lt t lo (some z) →
-        IsSearchable lt s (some z) hi →
-          find lt t y = some x → y ≈[lt]x → find lt (balance1Node t z s) y = some x :=
+      Std.RBNode.IsSearchable lt t lo (some z) →
+        Std.RBNode.IsSearchable lt s (some z) hi →
+          Std.RBNode.find? lt t y = some x →
+            y ≈[lt]x → Std.RBNode.find? lt (Std.RBNode.balance1Node t z s) y = some x :=
   by
   intro _ _ hs₁ hs₂ heq heqv
   have hs := is_searchable_balance1_node lt hs₁ hs₂
@@ -419,13 +449,15 @@ theorem find_balance1Node [DecidableRel lt] [IsStrictWeakOrder α lt] {x y z t s
   have := mem_exact_balance1_node_of_mem_exact z s this
   have := Iff.mp (find_correct_exact hs) this
   exact Eq.trans (find_eq_find_of_eqv hs heqv) this
-#align rbnode.find_balance1_node Rbnode.find_balance1Node
+#align rbnode.find_balance1_node Std.RBNode.find?_balance1Node
 
-theorem find_balance2Node [DecidableRel lt] [IsStrictWeakOrder α lt] {x y z s t} [IsTrans α lt] :
+theorem Std.RBNode.find?_balance2Node [DecidableRel lt] [IsStrictWeakOrder α lt] {x y z s t}
+    [IsTrans α lt] :
     ∀ {lo hi},
-      IsSearchable lt s lo (some z) →
-        IsSearchable lt t (some z) hi →
-          find lt t y = some x → y ≈[lt]x → find lt (balance2Node t z s) y = some x :=
+      Std.RBNode.IsSearchable lt s lo (some z) →
+        Std.RBNode.IsSearchable lt t (some z) hi →
+          Std.RBNode.find? lt t y = some x →
+            y ≈[lt]x → Std.RBNode.find? lt (Std.RBNode.balance2Node t z s) y = some x :=
   by
   intro _ _ hs₁ hs₂ heq heqv
   have hs := is_searchable_balance2_node lt hs₁ hs₂
@@ -434,12 +466,12 @@ theorem find_balance2Node [DecidableRel lt] [IsStrictWeakOrder α lt] {x y z s t
   have := mem_exact_balance2_node_of_mem_exact z s this
   have := Iff.mp (find_correct_exact hs) this
   exact Eq.trans (find_eq_find_of_eqv hs heqv) this
-#align rbnode.find_balance2_node Rbnode.find_balance2Node
+#align rbnode.find_balance2_node Std.RBNode.find?_balance2Node
 
 -- Auxiliary lemma
-theorem ite_eq_of_not_lt [DecidableRel lt] [IsStrictOrder α lt] {a b} {β : Type v} (t s : β)
-    (h : lt b a) : (if lt a b then t else s) = s := by have := not_lt_of_lt h; simp [*]
-#align rbnode.ite_eq_of_not_lt Rbnode.ite_eq_of_not_lt
+theorem Std.RBNode.ite_eq_of_not_lt [DecidableRel lt] [IsStrictOrder α lt] {a b} {β : Type v}
+    (t s : β) (h : lt b a) : (if lt a b then t else s) = s := by have := not_lt_of_lt h; simp [*]
+#align rbnode.ite_eq_of_not_lt Std.RBNode.ite_eq_of_not_lt
 
 attribute [local simp] ite_eq_of_not_lt
 
@@ -456,10 +488,11 @@ private unsafe def simp_fi : tactic Unit :=
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-theorem find_ins_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {t : Rbnode α}
-    (he : x ≈[lt]y) :
-    ∀ {lo hi} (hs : IsSearchable lt t lo hi) (hlt₁ : Lift lt lo (some x))
-      (hlt₂ : Lift lt (some x) hi), find lt (ins lt t x) y = some x :=
+theorem Std.RBNode.find?_ins_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α}
+    {t : Std.RBNode α} (he : x ≈[lt]y) :
+    ∀ {lo hi} (hs : Std.RBNode.IsSearchable lt t lo hi) (hlt₁ : Std.RBNode.Lift lt lo (some x))
+      (hlt₂ : Std.RBNode.Lift lt (some x) hi),
+      Std.RBNode.find? lt (Std.RBNode.ins lt t x) y = some x :=
   by
   simp [StrictWeakOrder.Equiv] at he 
   apply ins.induction lt t x <;> intros
@@ -497,24 +530,26 @@ theorem find_ins_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {
     have := ih hs_hs₂ hc hlt₂
     run_tac
       simp_fi
-#align rbnode.find_ins_of_eqv Rbnode.find_ins_of_eqv
+#align rbnode.find_ins_of_eqv Std.RBNode.find?_ins_of_eqv
 
-theorem find_mkInsertResult [DecidableRel lt] (c : Color) (t : Rbnode α) (x : α) :
-    find lt (mkInsertResult c t) x = find lt t x :=
+theorem Std.RBNode.find?_mkInsertResult [DecidableRel lt] (c : RBColor) (t : Std.RBNode α) (x : α) :
+    Std.RBNode.find? lt (Std.RBNode.mkInsertResult c t) x = Std.RBNode.find? lt t x :=
   by
   cases t <;> cases c <;> simp [mk_insert_result]
   · simp [find]; cases cmpUsing lt x t_val <;> simp [find]
-#align rbnode.find_mk_insert_result Rbnode.find_mkInsertResult
+#align rbnode.find_mk_insert_result Std.RBNode.find?_mkInsertResult
 
-theorem find_insert_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {t : Rbnode α}
-    (he : x ≈[lt]y) : IsSearchable lt t none none → find lt (insert lt t x) y = some x :=
+theorem Std.RBNode.find?_insert_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α}
+    {t : Std.RBNode α} (he : x ≈[lt]y) :
+    Std.RBNode.IsSearchable lt t none none →
+      Std.RBNode.find? lt (Std.RBNode.insert lt t x) y = some x :=
   by
   intro hs
   simp [insert, find_mk_insert_result]
   apply find_ins_of_eqv lt he hs <;> simp
-#align rbnode.find_insert_of_eqv Rbnode.find_insert_of_eqv
+#align rbnode.find_insert_of_eqv Std.RBNode.find?_insert_of_eqv
 
-theorem weak_trichotomous (x y) {p : Prop} (is_lt : ∀ h : lt x y, p)
+theorem Std.RBNode.weak_trichotomous (x y) {p : Prop} (is_lt : ∀ h : lt x y, p)
     (is_eqv : ∀ h : ¬lt x y ∧ ¬lt y x, p) (is_gt : ∀ h : lt y x, p) : p :=
   by
   by_cases lt x y
@@ -522,28 +557,30 @@ theorem weak_trichotomous (x y) {p : Prop} (is_lt : ∀ h : lt x y, p)
   by_cases lt y x
   · apply is_gt; assumption
   · apply is_eqv; constructor <;> assumption
-#align rbnode.weak_trichotomous Rbnode.weak_trichotomous
+#align rbnode.weak_trichotomous Std.RBNode.weak_trichotomous
 
 section FindInsOfNotEqv
 
 section SimpAuxLemmas
 
-theorem find_black_eq_find_red [DecidableRel lt] {l y r x} :
-    find lt (black_node l y r) x = find lt (red_node l y r) x := by simp [find];
-  all_goals cases cmpUsing lt x y <;> simp [find]
-#align rbnode.find_black_eq_find_red Rbnode.find_black_eq_find_red
+theorem Std.RBNode.find?_black_eq_find?_red [DecidableRel lt] {l y r x} :
+    Std.RBNode.find? lt (black_node l y r) x = Std.RBNode.find? lt (Std.RBNode.node l y r) x := by
+  simp [find]; all_goals cases cmpUsing lt x y <;> simp [find]
+#align rbnode.find_black_eq_find_red Std.RBNode.find?_black_eq_find?_red
 
-theorem find_red_of_lt [DecidableRel lt] {l y r x} (h : lt x y) :
-    find lt (red_node l y r) x = find lt l x := by simp [find, cmpUsing, *]
-#align rbnode.find_red_of_lt Rbnode.find_red_of_lt
+theorem Std.RBNode.find?_red_of_lt [DecidableRel lt] {l y r x} (h : lt x y) :
+    Std.RBNode.find? lt (Std.RBNode.node l y r) x = Std.RBNode.find? lt l x := by
+  simp [find, cmpUsing, *]
+#align rbnode.find_red_of_lt Std.RBNode.find?_red_of_lt
 
-theorem find_red_of_gt [DecidableRel lt] [IsStrictOrder α lt] {l y r x} (h : lt y x) :
-    find lt (red_node l y r) x = find lt r x := by have := not_lt_of_lt h; simp [find, cmpUsing, *]
-#align rbnode.find_red_of_gt Rbnode.find_red_of_gt
+theorem Std.RBNode.find?_red_of_gt [DecidableRel lt] [IsStrictOrder α lt] {l y r x} (h : lt y x) :
+    Std.RBNode.find? lt (Std.RBNode.node l y r) x = Std.RBNode.find? lt r x := by
+  have := not_lt_of_lt h; simp [find, cmpUsing, *]
+#align rbnode.find_red_of_gt Std.RBNode.find?_red_of_gt
 
-theorem find_red_of_incomp [DecidableRel lt] {l y r x} (h : ¬lt x y ∧ ¬lt y x) :
-    find lt (red_node l y r) x = some y := by simp [find, cmpUsing, *]
-#align rbnode.find_red_of_incomp Rbnode.find_red_of_incomp
+theorem Std.RBNode.find?_red_of_incomp [DecidableRel lt] {l y r x} (h : ¬lt x y ∧ ¬lt y x) :
+    Std.RBNode.find? lt (Std.RBNode.node l y r) x = some y := by simp [find, cmpUsing, *]
+#align rbnode.find_red_of_incomp Std.RBNode.find?_red_of_incomp
 
 end SimpAuxLemmas
 
@@ -553,9 +590,12 @@ attribute [local simp] find_black_eq_find_red find_red_of_lt find_red_of_lt find
 variable [IsStrictWeakOrder α lt] [DecidableRel lt]
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem find_balance1_lt {l r t v x y lo hi} (h : lt x y) (hl : IsSearchable lt l lo (some v))
-    (hr : IsSearchable lt r (some v) (some y)) (ht : IsSearchable lt t (some y) hi) :
-    find lt (balance1 l v r y t) x = find lt (red_node l v r) x :=
+theorem Std.RBNode.find?_balance1_lt {l r t v x y lo hi} (h : lt x y)
+    (hl : Std.RBNode.IsSearchable lt l lo (some v))
+    (hr : Std.RBNode.IsSearchable lt r (some v) (some y))
+    (ht : Std.RBNode.IsSearchable lt t (some y) hi) :
+    Std.RBNode.find? lt (Std.RBNode.balance1 l v r y t) x =
+      Std.RBNode.find? lt (Std.RBNode.node l v r) x :=
   by
   revert hl hr ht;
   apply balance.cases l v r <;> intros <;> simp [*] <;>
@@ -566,7 +606,7 @@ theorem find_balance1_lt {l r t v x y lo hi} (h : lt x y) (hl : IsSearchable lt
     · have := trans_of lt (lo_lt_hi hr_hs₁) h'; simp [*]
     · have : lt y_1 x := lt_of_lt_of_incomp (lo_lt_hi hr_hs₁) h'; simp [*]
     · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
-#align rbnode.find_balance1_lt Rbnode.find_balance1_lt
+#align rbnode.find_balance1_lt Std.RBNode.find?_balance1_lt
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 unsafe def ins_ne_leaf_tac :=
@@ -575,12 +615,12 @@ unsafe def ins_ne_leaf_tac :=
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
-theorem find_balance1Node_lt {t s x y lo hi} (hlt : lt y x) (ht : IsSearchable lt t lo (some x))
-    (hs : IsSearchable lt s (some x) hi)
-    (hne : t ≠ leaf := by
+theorem Std.RBNode.find?_balance1Node_lt {t s x y lo hi} (hlt : lt y x)
+    (ht : Std.RBNode.IsSearchable lt t lo (some x)) (hs : Std.RBNode.IsSearchable lt s (some x) hi)
+    (hne : t ≠ Std.RBNode.nil := by
       run_tac
         ins_ne_leaf_tac) :
-    find lt (balance1Node t x s) y = find lt t y :=
+    Std.RBNode.find? lt (Std.RBNode.balance1Node t x s) y = Std.RBNode.find? lt t y :=
   by
   cases t <;> simp [balance1_node]
   · contradiction
@@ -588,12 +628,14 @@ theorem find_balance1Node_lt {t s x y lo hi} (hlt : lt y x) (ht : IsSearchable l
     run_tac
       is_searchable_tactic;
     apply find_balance1_lt; assumption'
-#align rbnode.find_balance1_node_lt Rbnode.find_balance1Node_lt
+#align rbnode.find_balance1_node_lt Std.RBNode.find?_balance1Node_lt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem find_balance1_gt {l r t v x y lo hi} (h : lt y x) (hl : IsSearchable lt l lo (some v))
-    (hr : IsSearchable lt r (some v) (some y)) (ht : IsSearchable lt t (some y) hi) :
-    find lt (balance1 l v r y t) x = find lt t x :=
+theorem Std.RBNode.find?_balance1_gt {l r t v x y lo hi} (h : lt y x)
+    (hl : Std.RBNode.IsSearchable lt l lo (some v))
+    (hr : Std.RBNode.IsSearchable lt r (some v) (some y))
+    (ht : Std.RBNode.IsSearchable lt t (some y) hi) :
+    Std.RBNode.find? lt (Std.RBNode.balance1 l v r y t) x = Std.RBNode.find? lt t x :=
   by
   revert hl hr ht;
   apply balance.cases l v r <;> intros <;> simp [*] <;>
@@ -601,28 +643,30 @@ theorem find_balance1_gt {l r t v x y lo hi} (h : lt y x) (hl : IsSearchable lt
       is_searchable_tactic
   · have := trans_of lt (lo_lt_hi hr) h; simp [*]
   · have := trans_of lt (lo_lt_hi hr_hs₂) h; simp [*]
-#align rbnode.find_balance1_gt Rbnode.find_balance1_gt
+#align rbnode.find_balance1_gt Std.RBNode.find?_balance1_gt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
-theorem find_balance1Node_gt {t s x y lo hi} (h : lt x y) (ht : IsSearchable lt t lo (some x))
-    (hs : IsSearchable lt s (some x) hi)
-    (hne : t ≠ leaf := by
+theorem Std.RBNode.find?_balance1Node_gt {t s x y lo hi} (h : lt x y)
+    (ht : Std.RBNode.IsSearchable lt t lo (some x)) (hs : Std.RBNode.IsSearchable lt s (some x) hi)
+    (hne : t ≠ Std.RBNode.nil := by
       run_tac
         ins_ne_leaf_tac) :
-    find lt (balance1Node t x s) y = find lt s y :=
+    Std.RBNode.find? lt (Std.RBNode.balance1Node t x s) y = Std.RBNode.find? lt s y :=
   by
   cases t <;> simp [balance1_node]
   all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance1_gt; assumption'
-#align rbnode.find_balance1_node_gt Rbnode.find_balance1Node_gt
+#align rbnode.find_balance1_node_gt Std.RBNode.find?_balance1Node_gt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem find_balance1_eqv {l r t v x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
-    (hl : IsSearchable lt l lo (some v)) (hr : IsSearchable lt r (some v) (some y))
-    (ht : IsSearchable lt t (some y) hi) : find lt (balance1 l v r y t) x = some y :=
+theorem Std.RBNode.find?_balance1_eqv {l r t v x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
+    (hl : Std.RBNode.IsSearchable lt l lo (some v))
+    (hr : Std.RBNode.IsSearchable lt r (some v) (some y))
+    (ht : Std.RBNode.IsSearchable lt t (some y) hi) :
+    Std.RBNode.find? lt (Std.RBNode.balance1 l v r y t) x = some y :=
   by
   revert hl hr ht;
   apply balance.cases l v r <;> intros <;> simp [*] <;>
@@ -632,16 +676,16 @@ theorem find_balance1_eqv {l r t v x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     simp [*]
   · have : lt x_1 x := lt_of_lt_of_incomp (lo_lt_hi hr_hs₂) h.swap
     simp [*]
-#align rbnode.find_balance1_eqv Rbnode.find_balance1_eqv
+#align rbnode.find_balance1_eqv Std.RBNode.find?_balance1_eqv
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
-theorem find_balance1Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
-    (ht : IsSearchable lt t lo (some y)) (hs : IsSearchable lt s (some y) hi)
-    (hne : t ≠ leaf := by
+theorem Std.RBNode.find?_balance1Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
+    (ht : Std.RBNode.IsSearchable lt t lo (some y)) (hs : Std.RBNode.IsSearchable lt s (some y) hi)
+    (hne : t ≠ Std.RBNode.nil := by
       run_tac
         ins_ne_leaf_tac) :
-    find lt (balance1Node t y s) x = some y :=
+    Std.RBNode.find? lt (Std.RBNode.balance1Node t y s) x = some y :=
   by
   cases t <;> simp [balance1_node]
   · contradiction
@@ -649,12 +693,14 @@ theorem find_balance1Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     run_tac
       is_searchable_tactic;
     apply find_balance1_eqv; assumption'
-#align rbnode.find_balance1_node_eqv Rbnode.find_balance1Node_eqv
+#align rbnode.find_balance1_node_eqv Std.RBNode.find?_balance1Node_eqv
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem find_balance2_lt {l v r t x y lo hi} (h : lt x y) (hl : IsSearchable lt l (some y) (some v))
-    (hr : IsSearchable lt r (some v) hi) (ht : IsSearchable lt t lo (some y)) :
-    find lt (balance2 l v r y t) x = find lt t x :=
+theorem Std.RBNode.find?_balance2_lt {l v r t x y lo hi} (h : lt x y)
+    (hl : Std.RBNode.IsSearchable lt l (some y) (some v))
+    (hr : Std.RBNode.IsSearchable lt r (some v) hi)
+    (ht : Std.RBNode.IsSearchable lt t lo (some y)) :
+    Std.RBNode.find? lt (Std.RBNode.balance2 l v r y t) x = Std.RBNode.find? lt t x :=
   by
   revert hl hr ht;
   apply balance.cases l v r <;> intros <;> simp [*] <;>
@@ -662,28 +708,31 @@ theorem find_balance2_lt {l v r t x y lo hi} (h : lt x y) (hl : IsSearchable lt
       is_searchable_tactic
   · have := trans h (lo_lt_hi hl_hs₁); simp [*]
   · have := trans h (lo_lt_hi hl); simp [*]
-#align rbnode.find_balance2_lt Rbnode.find_balance2_lt
+#align rbnode.find_balance2_lt Std.RBNode.find?_balance2_lt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
-theorem find_balance2Node_lt {s t x y lo hi} (h : lt x y) (ht : IsSearchable lt t (some y) hi)
-    (hs : IsSearchable lt s lo (some y))
-    (hne : t ≠ leaf := by
+theorem Std.RBNode.find?_balance2Node_lt {s t x y lo hi} (h : lt x y)
+    (ht : Std.RBNode.IsSearchable lt t (some y) hi) (hs : Std.RBNode.IsSearchable lt s lo (some y))
+    (hne : t ≠ Std.RBNode.nil := by
       run_tac
         ins_ne_leaf_tac) :
-    find lt (balance2Node t y s) x = find lt s x :=
+    Std.RBNode.find? lt (Std.RBNode.balance2Node t y s) x = Std.RBNode.find? lt s x :=
   by
   cases t <;> simp [balance2_node]
   all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance2_lt; assumption'
-#align rbnode.find_balance2_node_lt Rbnode.find_balance2Node_lt
+#align rbnode.find_balance2_node_lt Std.RBNode.find?_balance2Node_lt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem find_balance2_gt {l v r t x y lo hi} (h : lt y x) (hl : IsSearchable lt l (some y) (some v))
-    (hr : IsSearchable lt r (some v) hi) (ht : IsSearchable lt t lo (some y)) :
-    find lt (balance2 l v r y t) x = find lt (red_node l v r) x :=
+theorem Std.RBNode.find?_balance2_gt {l v r t x y lo hi} (h : lt y x)
+    (hl : Std.RBNode.IsSearchable lt l (some y) (some v))
+    (hr : Std.RBNode.IsSearchable lt r (some v) hi)
+    (ht : Std.RBNode.IsSearchable lt t lo (some y)) :
+    Std.RBNode.find? lt (Std.RBNode.balance2 l v r y t) x =
+      Std.RBNode.find? lt (Std.RBNode.node l v r) x :=
   by
   revert hl hr ht;
   apply balance.cases l v r <;> intros <;> simp [*] <;>
@@ -694,16 +743,16 @@ theorem find_balance2_gt {l v r t x y lo hi} (h : lt y x) (hl : IsSearchable lt
     · have : lt x _ := lt_of_incomp_of_lt h'.swap (lo_lt_hi hl_hs₂); simp [*]
     · have := trans h' (lo_lt_hi hl_hs₂); simp [*]
   · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
-#align rbnode.find_balance2_gt Rbnode.find_balance2_gt
+#align rbnode.find_balance2_gt Std.RBNode.find?_balance2_gt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
-theorem find_balance2Node_gt {s t x y lo hi} (h : lt y x) (ht : IsSearchable lt t (some y) hi)
-    (hs : IsSearchable lt s lo (some y))
-    (hne : t ≠ leaf := by
+theorem Std.RBNode.find?_balance2Node_gt {s t x y lo hi} (h : lt y x)
+    (ht : Std.RBNode.IsSearchable lt t (some y) hi) (hs : Std.RBNode.IsSearchable lt s lo (some y))
+    (hne : t ≠ Std.RBNode.nil := by
       run_tac
         ins_ne_leaf_tac) :
-    find lt (balance2Node t y s) x = find lt t x :=
+    Std.RBNode.find? lt (Std.RBNode.balance2Node t y s) x = Std.RBNode.find? lt t x :=
   by
   cases t <;> simp [balance2_node]
   · contradiction
@@ -711,12 +760,14 @@ theorem find_balance2Node_gt {s t x y lo hi} (h : lt y x) (ht : IsSearchable lt
     run_tac
       is_searchable_tactic;
     apply find_balance2_gt; assumption'
-#align rbnode.find_balance2_node_gt Rbnode.find_balance2Node_gt
+#align rbnode.find_balance2_node_gt Std.RBNode.find?_balance2Node_gt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-theorem find_balance2_eqv {l v r t x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
-    (hl : IsSearchable lt l (some y) (some v)) (hr : IsSearchable lt r (some v) hi)
-    (ht : IsSearchable lt t lo (some y)) : find lt (balance2 l v r y t) x = some y :=
+theorem Std.RBNode.find?_balance2_eqv {l v r t x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
+    (hl : Std.RBNode.IsSearchable lt l (some y) (some v))
+    (hr : Std.RBNode.IsSearchable lt r (some v) hi)
+    (ht : Std.RBNode.IsSearchable lt t lo (some y)) :
+    Std.RBNode.find? lt (Std.RBNode.balance2 l v r y t) x = some y :=
   by
   revert hl hr ht;
   apply balance.cases l v r <;> intros <;> simp [*] <;>
@@ -724,16 +775,16 @@ theorem find_balance2_eqv {l v r t x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
       is_searchable_tactic
   · have := lt_of_incomp_of_lt h (lo_lt_hi hl_hs₁); simp [*]
   · have := lt_of_incomp_of_lt h (lo_lt_hi hl); simp [*]
-#align rbnode.find_balance2_eqv Rbnode.find_balance2_eqv
+#align rbnode.find_balance2_eqv Std.RBNode.find?_balance2_eqv
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
-theorem find_balance2Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
-    (ht : IsSearchable lt t (some y) hi) (hs : IsSearchable lt s lo (some y))
-    (hne : t ≠ leaf := by
+theorem Std.RBNode.find?_balance2Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
+    (ht : Std.RBNode.IsSearchable lt t (some y) hi) (hs : Std.RBNode.IsSearchable lt s lo (some y))
+    (hne : t ≠ Std.RBNode.nil := by
       run_tac
         ins_ne_leaf_tac) :
-    find lt (balance2Node t y s) x = some y :=
+    Std.RBNode.find? lt (Std.RBNode.balance2Node t y s) x = some y :=
   by
   cases t <;> simp [balance2_node]
   · contradiction
@@ -741,7 +792,7 @@ theorem find_balance2Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     run_tac
       is_searchable_tactic;
     apply find_balance2_eqv; assumption'
-#align rbnode.find_balance2_node_eqv Rbnode.find_balance2Node_eqv
+#align rbnode.find_balance2_node_eqv Std.RBNode.find?_balance2Node_eqv
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
@@ -761,9 +812,10 @@ theorem find_balance2Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
-    ∀ {lo hi} (hs : IsSearchable lt t lo hi) (hlt₁ : Lift lt lo (some x))
-      (hlt₂ : Lift lt (some x) hi), find lt (ins lt t x) y = find lt t y :=
+theorem Std.RBNode.find?_ins_of_disj {x y : α} {t : Std.RBNode α} (hn : lt x y ∨ lt y x) :
+    ∀ {lo hi} (hs : Std.RBNode.IsSearchable lt t lo hi) (hlt₁ : Std.RBNode.Lift lt lo (some x))
+      (hlt₂ : Std.RBNode.Lift lt (some x) hi),
+      Std.RBNode.find? lt (Std.RBNode.ins lt t x) y = Std.RBNode.find? lt t y :=
   by
   apply ins.induction lt t x <;> intros
   · cases hn
@@ -842,21 +894,24 @@ theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
   · have ih := ih hs_hs₂ hc hlt₂
     run_tac
       simp_fi
-#align rbnode.find_ins_of_disj Rbnode.find_ins_of_disj
+#align rbnode.find_ins_of_disj Std.RBNode.find?_ins_of_disj
 
 end FindInsOfNotEqv
 
-theorem find_insert_of_disj [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {t : Rbnode α}
-    (hd : lt x y ∨ lt y x) :
-    IsSearchable lt t none none → find lt (insert lt t x) y = find lt t y :=
+theorem Std.RBNode.find?_insert_of_disj [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α}
+    {t : Std.RBNode α} (hd : lt x y ∨ lt y x) :
+    Std.RBNode.IsSearchable lt t none none →
+      Std.RBNode.find? lt (Std.RBNode.insert lt t x) y = Std.RBNode.find? lt t y :=
   by
   intro hs
   simp [insert, find_mk_insert_result]
   apply find_ins_of_disj lt hd hs <;> simp
-#align rbnode.find_insert_of_disj Rbnode.find_insert_of_disj
+#align rbnode.find_insert_of_disj Std.RBNode.find?_insert_of_disj
 
-theorem find_insert_of_not_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {t : Rbnode α}
-    (hn : ¬x ≈[lt]y) : IsSearchable lt t none none → find lt (insert lt t x) y = find lt t y :=
+theorem Std.RBNode.find?_insert_of_not_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α}
+    {t : Std.RBNode α} (hn : ¬x ≈[lt]y) :
+    Std.RBNode.IsSearchable lt t none none →
+      Std.RBNode.find? lt (Std.RBNode.insert lt t x) y = Std.RBNode.find? lt t y :=
   by
   intro hs
   simp [insert, find_mk_insert_result]
@@ -865,7 +920,7 @@ theorem find_insert_of_not_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y
     simp [StrictWeakOrder.Equiv, Decidable.not_and_iff_or_not, Decidable.not_not_iff] at hn 
     assumption
   apply find_ins_of_disj lt he hs <;> simp
-#align rbnode.find_insert_of_not_eqv Rbnode.find_insert_of_not_eqv
+#align rbnode.find_insert_of_not_eqv Std.RBNode.find?_insert_of_not_eqv
 
 end MembershipLemmas
 
@@ -875,62 +930,73 @@ variable {α : Type u}
 
 open Nat Color
 
-inductive IsBadRedBlack : Rbnode α → Nat → Prop
+inductive Std.RBNode.IsBadRedBlack : Std.RBNode α → Nat → Prop
   |
-  bad_red {c₁ c₂ n l r v} (rb_l : IsRedBlack l c₁ n) (rb_r : IsRedBlack r c₂ n) :
-    is_bad_red_black (red_node l v r) n
-#align rbnode.is_bad_red_black Rbnode.IsBadRedBlack
-
-theorem balance1_rb {l r t : Rbnode α} {y v : α} {c_l c_r c_t n} :
-    IsRedBlack l c_l n →
-      IsRedBlack r c_r n → IsRedBlack t c_t n → ∃ c, IsRedBlack (balance1 l y r v t) c (succ n) :=
+  bad_red {c₁ c₂ n l r v} (rb_l : Std.RBNode.IsRedBlack l c₁ n)
+    (rb_r : Std.RBNode.IsRedBlack r c₂ n) : is_bad_red_black (Std.RBNode.node l v r) n
+#align rbnode.is_bad_red_black Std.RBNode.IsBadRedBlack
+
+theorem Std.RBNode.balance1_rb {l r t : Std.RBNode α} {y v : α} {c_l c_r c_t n} :
+    Std.RBNode.IsRedBlack l c_l n →
+      Std.RBNode.IsRedBlack r c_r n →
+        Std.RBNode.IsRedBlack t c_t n →
+          ∃ c, Std.RBNode.IsRedBlack (Std.RBNode.balance1 l y r v t) c (succ n) :=
   by
   intro h₁ h₂ _ <;> cases h₁ <;> cases h₂ <;>
     repeat'
       first
       | assumption
       | constructor
-#align rbnode.balance1_rb Rbnode.balance1_rb
+#align rbnode.balance1_rb Std.RBNode.balance1_rb
 
-theorem balance2_rb {l r t : Rbnode α} {y v : α} {c_l c_r c_t n} :
-    IsRedBlack l c_l n →
-      IsRedBlack r c_r n → IsRedBlack t c_t n → ∃ c, IsRedBlack (balance2 l y r v t) c (succ n) :=
+theorem Std.RBNode.balance2_rb {l r t : Std.RBNode α} {y v : α} {c_l c_r c_t n} :
+    Std.RBNode.IsRedBlack l c_l n →
+      Std.RBNode.IsRedBlack r c_r n →
+        Std.RBNode.IsRedBlack t c_t n →
+          ∃ c, Std.RBNode.IsRedBlack (Std.RBNode.balance2 l y r v t) c (succ n) :=
   by
   intro h₁ h₂ _ <;> cases h₁ <;> cases h₂ <;>
     repeat'
       first
       | assumption
       | constructor
-#align rbnode.balance2_rb Rbnode.balance2_rb
-
-theorem balance1Node_rb {t s : Rbnode α} {y : α} {c n} :
-    IsBadRedBlack t n → IsRedBlack s c n → ∃ c, IsRedBlack (balance1Node t y s) c (succ n) := by
-  intro h _ <;> cases h <;> simp [balance1_node] <;> apply balance1_rb <;> assumption'
-#align rbnode.balance1_node_rb Rbnode.balance1Node_rb
-
-theorem balance2Node_rb {t s : Rbnode α} {y : α} {c n} :
-    IsBadRedBlack t n → IsRedBlack s c n → ∃ c, IsRedBlack (balance2Node t y s) c (succ n) := by
-  intro h _ <;> cases h <;> simp [balance2_node] <;> apply balance2_rb <;> assumption'
-#align rbnode.balance2_node_rb Rbnode.balance2Node_rb
-
-def InsRbResult : Rbnode α → Color → Nat → Prop
-  | t, red, n => IsBadRedBlack t n
-  | t, black, n => ∃ c, IsRedBlack t c n
-#align rbnode.ins_rb_result Rbnode.InsRbResult
+#align rbnode.balance2_rb Std.RBNode.balance2_rb
+
+theorem Std.RBNode.balance1Node_rb {t s : Std.RBNode α} {y : α} {c n} :
+    Std.RBNode.IsBadRedBlack t n →
+      Std.RBNode.IsRedBlack s c n →
+        ∃ c, Std.RBNode.IsRedBlack (Std.RBNode.balance1Node t y s) c (succ n) :=
+  by intro h _ <;> cases h <;> simp [balance1_node] <;> apply balance1_rb <;> assumption'
+#align rbnode.balance1_node_rb Std.RBNode.balance1Node_rb
+
+theorem Std.RBNode.balance2Node_rb {t s : Std.RBNode α} {y : α} {c n} :
+    Std.RBNode.IsBadRedBlack t n →
+      Std.RBNode.IsRedBlack s c n →
+        ∃ c, Std.RBNode.IsRedBlack (Std.RBNode.balance2Node t y s) c (succ n) :=
+  by intro h _ <;> cases h <;> simp [balance2_node] <;> apply balance2_rb <;> assumption'
+#align rbnode.balance2_node_rb Std.RBNode.balance2Node_rb
+
+def Std.RBNode.InsRbResult : Std.RBNode α → RBColor → Nat → Prop
+  | t, red, n => Std.RBNode.IsBadRedBlack t n
+  | t, black, n => ∃ c, Std.RBNode.IsRedBlack t c n
+#align rbnode.ins_rb_result Std.RBNode.InsRbResult
 
 variable {lt : α → α → Prop} [DecidableRel lt]
 
-theorem of_getColor_eq_red {t : Rbnode α} {c n} : getColor t = red → IsRedBlack t c n → c = red :=
-  by intro h₁ h₂; cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
-#align rbnode.of_get_color_eq_red Rbnode.of_getColor_eq_red
+theorem Std.RBNode.of_getColor_eq_red {t : Std.RBNode α} {c n} :
+    Std.RBNode.getColor t = red → Std.RBNode.IsRedBlack t c n → c = red := by intro h₁ h₂;
+  cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
+#align rbnode.of_get_color_eq_red Std.RBNode.of_getColor_eq_red
 
-theorem of_getColor_ne_red {t : Rbnode α} {c n} : getColor t ≠ red → IsRedBlack t c n → c = black :=
-  by intro h₁ h₂; cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
-#align rbnode.of_get_color_ne_red Rbnode.of_getColor_ne_red
+theorem Std.RBNode.of_getColor_ne_red {t : Std.RBNode α} {c n} :
+    Std.RBNode.getColor t ≠ red → Std.RBNode.IsRedBlack t c n → c = black := by intro h₁ h₂;
+  cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
+#align rbnode.of_get_color_ne_red Std.RBNode.of_getColor_ne_red
 
 variable (lt)
 
-theorem ins_rb {t : Rbnode α} (x) : ∀ {c n} (h : IsRedBlack t c n), InsRbResult (ins lt t x) c n :=
+theorem Std.RBNode.ins_rb {t : Std.RBNode α} (x) :
+    ∀ {c n} (h : Std.RBNode.IsRedBlack t c n), Std.RBNode.InsRbResult (Std.RBNode.ins lt t x) c n :=
   by
   apply ins.induction lt t x <;> intros <;> cases h <;> simp [ins, *, ins_rb_result]
   · repeat' constructor
@@ -952,15 +1018,16 @@ theorem ins_rb {t : Rbnode α} (x) : ∀ {c n} (h : IsRedBlack t c n), InsRbResu
     cases of_get_color_ne_red hnr h_rb_r
     cases ih
     constructor; constructor <;> assumption
-#align rbnode.ins_rb Rbnode.ins_rb
+#align rbnode.ins_rb Std.RBNode.ins_rb
 
-def InsertRbResult : Rbnode α → Color → Nat → Prop
-  | t, red, n => IsRedBlack t black (succ n)
-  | t, black, n => ∃ c, IsRedBlack t c n
-#align rbnode.insert_rb_result Rbnode.InsertRbResult
+def Std.RBNode.InsertRbResult : Std.RBNode α → RBColor → Nat → Prop
+  | t, red, n => Std.RBNode.IsRedBlack t black (succ n)
+  | t, black, n => ∃ c, Std.RBNode.IsRedBlack t c n
+#align rbnode.insert_rb_result Std.RBNode.InsertRbResult
 
-theorem insert_rb {t : Rbnode α} (x) {c n} (h : IsRedBlack t c n) :
-    InsertRbResult (insert lt t x) c n := by
+theorem Std.RBNode.insert_rb {t : Std.RBNode α} (x) {c n} (h : Std.RBNode.IsRedBlack t c n) :
+    Std.RBNode.InsertRbResult (Std.RBNode.insert lt t x) c n :=
+  by
   simp [insert]
   have hi := ins_rb lt x h
   generalize he : ins lt t x = r
@@ -968,19 +1035,19 @@ theorem insert_rb {t : Rbnode α} (x) {c n} (h : IsRedBlack t c n) :
   cases h <;> simp [get_color, ins_rb_result, insert_rb_result, mk_insert_result] at *
   assumption'
   · cases hi; simp [mk_insert_result]; constructor <;> assumption
-#align rbnode.insert_rb Rbnode.insert_rb
+#align rbnode.insert_rb Std.RBNode.insert_rb
 
-theorem insert_isRedBlack {t : Rbnode α} {c n} (x) :
-    IsRedBlack t c n → ∃ c n, IsRedBlack (insert lt t x) c n :=
+theorem Std.RBNode.insert_isRedBlack {t : Std.RBNode α} {c n} (x) :
+    Std.RBNode.IsRedBlack t c n → ∃ c n, Std.RBNode.IsRedBlack (Std.RBNode.insert lt t x) c n :=
   by
   intro h
   have := insert_rb lt x h
   cases c <;> simp [insert_rb_result] at this 
   · constructor; constructor; assumption
   · cases this; constructor; constructor; assumption
-#align rbnode.insert_is_red_black Rbnode.insert_isRedBlack
+#align rbnode.insert_is_red_black Std.RBNode.insert_isRedBlack
 
 end IsRedBlack
 
-end Rbnode
+end Std.RBNode

4d416710

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -238,7 +238,6 @@ parameter {α : Type u} (lt : α → α → Prop)
 
 attribute [local simp] mem balance1_node balance2_node
 
--- mathport name: mem
 local infixl:0 " ∈ " => Mem lt
 
 theorem mem_balance1Node_of_mem_left {x s} (v) (t : Rbnode α) :

4d416710

bump to nightly-2023-06-09-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

16afdc39

Diff

@@ -444,7 +444,7 @@ theorem ite_eq_of_not_lt [DecidableRel lt] [IsStrictOrder α lt] {a b} {β : Typ
 
 attribute [local simp] ite_eq_of_not_lt
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 private unsafe def simp_fi : tactic Unit :=
   sorry
 
@@ -569,7 +569,7 @@ theorem find_balance1_lt {l r t v x y lo hi} (h : lt x y) (hl : IsSearchable lt
     · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
 #align rbnode.find_balance1_lt Rbnode.find_balance1_lt
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 unsafe def ins_ne_leaf_tac :=
   sorry
 #align rbnode.ins_ne_leaf_tac rbnode.ins_ne_leaf_tac

4d416710

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -212,10 +212,10 @@ theorem isSearchable_ins [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
 theorem isSearchable_mkInsertResult {c t} :
     IsSearchable lt t none none → IsSearchable lt (mkInsertResult c t) none none := by
   classical
-    cases c <;> cases t <;> simp [mk_insert_result]
-    · intro h;
-      run_tac
-        is_searchable_tactic
+  cases c <;> cases t <;> simp [mk_insert_result]
+  · intro h;
+    run_tac
+      is_searchable_tactic
 #align rbnode.is_searchable_mk_insert_result Rbnode.isSearchable_mkInsertResult
 
 theorem isSearchable_insert [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
@@ -234,7 +234,7 @@ namespace Rbnode
 
 section MembershipLemmas
 
-parameter {α : Type u}(lt : α → α → Prop)
+parameter {α : Type u} (lt : α → α → Prop)
 
 attribute [local simp] mem balance1_node balance2_node
 
@@ -246,7 +246,7 @@ theorem mem_balance1Node_of_mem_left {x s} (v) (t : Rbnode α) :
   by
   cases s <;> simp [false_imp_iff]
   all_goals
-    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp at * <;> cases_type*or.1 <;>
+    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp at * <;> cases_type* or.1 <;>
       simp [*]
 #align rbnode.mem_balance1_node_of_mem_left Rbnode.mem_balance1Node_of_mem_left
 
@@ -255,7 +255,7 @@ theorem mem_balance2Node_of_mem_left {x s} (v) (t : Rbnode α) :
   by
   cases s <;> simp [false_imp_iff]
   all_goals
-    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp at * <;> cases_type*or.1 <;>
+    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp at * <;> cases_type* or.1 <;>
       simp [*]
 #align rbnode.mem_balance2_node_of_mem_left Rbnode.mem_balance2Node_of_mem_left
 
@@ -314,7 +314,8 @@ theorem mem_ins_of_incomp [DecidableRel lt] (t : Rbnode α) {x y : α} :
 theorem mem_ins_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t : Rbnode α} (z : α) :
     ∀ {x} (h : x ∈ t), x ∈ t.ins lt z :=
   by
-  apply ins.induction lt t z <;> intros <;> simp_all [ins] <;> try contradiction <;> cases_type*or.1
+  apply ins.induction lt t z <;> intros <;> simp_all [ins] <;> try contradiction <;>
+    cases_type* or.1
   any_goals intros; simp [h]; done
   any_goals intros; simp [ih h]; done
   · have := incomp_trans_of lt h ⟨hc.2, hc.1⟩; simp [this]
@@ -352,7 +353,7 @@ theorem of_mem_balance1Node {x s v t} :
   cases s <;> simp
   · intros; simp [*]
   all_goals
-    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
+    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
 #align rbnode.of_mem_balance1_node Rbnode.of_mem_balance1Node
 
@@ -362,7 +363,7 @@ theorem of_mem_balance2Node {x s v t} :
   cases s <;> simp
   · intros; simp [*]
   all_goals
-    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
+    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
 #align rbnode.of_mem_balance2_node Rbnode.of_mem_balance2Node
 
@@ -370,14 +371,14 @@ theorem equiv_or_mem_of_mem_ins [DecidableRel lt] {t : Rbnode α} {x z} :
     ∀ h : x ∈ t.ins lt z, x ≈[lt]z ∨ (x ∈ t) :=
   by
   apply ins.induction lt t z <;> intros <;> simp_all [ins, StrictWeakOrder.Equiv] <;>
-    cases_type*or.1
+    cases_type* or.1
   any_goals intros; simp [h]
   any_goals intros; have ih := ih h; cases ih <;> simp [*]; done
-  · have h' := of_mem_balance1_node lt h; cases_type*or.1
-    have := ih h'; cases_type*or.1
+  · have h' := of_mem_balance1_node lt h; cases_type* or.1
+    have := ih h'; cases_type* or.1
     all_goals simp [h, *]
-  · have h' := of_mem_balance2_node lt h; cases_type*or.1
-    have := ih h'; cases_type*or.1
+  · have h' := of_mem_balance2_node lt h; cases_type* or.1
+    have := ih h'; cases_type* or.1
     all_goals simp [h, *]
 #align rbnode.equiv_or_mem_of_mem_ins Rbnode.equiv_or_mem_of_mem_ins
 
@@ -393,7 +394,7 @@ theorem memExact_balance1Node_of_memExact {x s} (v) (t : Rbnode α) :
   by
   cases s <;> simp [false_imp_iff]
   all_goals
-    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
+    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
 #align rbnode.mem_exact_balance1_node_of_mem_exact Rbnode.memExact_balance1Node_of_memExact
 
@@ -402,7 +403,7 @@ theorem memExact_balance2Node_of_memExact {x s} (v) (t : Rbnode α) :
   by
   cases s <;> simp [false_imp_iff]
   all_goals
-    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
+    apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type* or.1 <;>
       simp [*]
 #align rbnode.mem_exact_balance2_node_of_mem_exact Rbnode.memExact_balance2Node_of_memExact

4d416710

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -221,7 +221,11 @@ theorem isSearchable_mkInsertResult {c t} :
 theorem isSearchable_insert [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
     IsSearchable lt t none none → IsSearchable lt (insert lt t x) none none := by intro h;
   simp [insert]; apply is_searchable_mk_insert_result;
-  apply is_searchable_ins <;> · first |assumption|simp
+  apply is_searchable_ins <;>
+    ·
+      first
+      | assumption
+      | simp
 #align rbnode.is_searchable_insert Rbnode.isSearchable_insert
 
 end Rbnode
@@ -257,20 +261,20 @@ theorem mem_balance2Node_of_mem_left {x s} (v) (t : Rbnode α) :
 
 theorem mem_balance1Node_of_mem_right {x t} (v) (s : Rbnode α) :
     (x ∈ t) → (x ∈ balance1Node s v t) := by
-  intros ; cases s <;> simp [*]
+  intros; cases s <;> simp [*]
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
 #align rbnode.mem_balance1_node_of_mem_right Rbnode.mem_balance1Node_of_mem_right
 
 theorem mem_balance2Node_of_mem_right {x t} (v) (s : Rbnode α) :
     (x ∈ t) → (x ∈ balance2Node s v t) := by
-  intros ; cases s <;> simp [*]
+  intros; cases s <;> simp [*]
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
 #align rbnode.mem_balance2_node_of_mem_right Rbnode.mem_balance2Node_of_mem_right
 
 theorem mem_balance1Node_of_incomp {x v} (s t) :
     ¬lt x v ∧ ¬lt v x → s ≠ leaf → (x ∈ balance1Node s v t) :=
   by
-  intros ; cases s <;> simp
+  intros; cases s <;> simp
   · contradiction
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
 #align rbnode.mem_balance1_node_of_incomp Rbnode.mem_balance1Node_of_incomp
@@ -278,7 +282,7 @@ theorem mem_balance1Node_of_incomp {x v} (s t) :
 theorem mem_balance2Node_of_incomp {x v} (s t) :
     ¬lt v x ∧ ¬lt x v → s ≠ leaf → (x ∈ balance2Node s v t) :=
   by
-  intros ; cases s <;> simp
+  intros; cases s <;> simp
   · contradiction
   all_goals apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp [*]
 #align rbnode.mem_balance2_node_of_incomp Rbnode.mem_balance2Node_of_incomp
@@ -286,9 +290,9 @@ theorem mem_balance2Node_of_incomp {x v} (s t) :
 theorem ins_ne_leaf [DecidableRel lt] (t : Rbnode α) (x : α) : t.ins lt x ≠ leaf :=
   by
   apply ins.induction lt t x
-  any_goals intros ; simp [ins, *]
-  · intros ; apply balance1_node_ne_leaf; assumption
-  · intros ; apply balance2_node_ne_leaf; assumption
+  any_goals intros; simp [ins, *]
+  · intros; apply balance1_node_ne_leaf; assumption
+  · intros; apply balance2_node_ne_leaf; assumption
 #align rbnode.ins_ne_leaf Rbnode.ins_ne_leaf
 
 theorem insert_ne_leaf [DecidableRel lt] (t : Rbnode α) (x : α) : insert lt t x ≠ leaf :=
@@ -311,8 +315,8 @@ theorem mem_ins_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t : Rbnode 
     ∀ {x} (h : x ∈ t), x ∈ t.ins lt z :=
   by
   apply ins.induction lt t z <;> intros <;> simp_all [ins] <;> try contradiction <;> cases_type*or.1
-  any_goals intros ; simp [h]; done
-  any_goals intros ; simp [ih h]; done
+  any_goals intros; simp [h]; done
+  any_goals intros; simp [ih h]; done
   · have := incomp_trans_of lt h ⟨hc.2, hc.1⟩; simp [this]
   · apply mem_balance1_node_of_mem_left; apply ih h
   · apply mem_balance1_node_of_incomp; cases h; all_goals simp [*, ins_ne_leaf lt a z]
@@ -346,7 +350,7 @@ theorem of_mem_balance1Node {x s v t} :
     (x ∈ balance1Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
   by
   cases s <;> simp
-  · intros ; simp [*]
+  · intros; simp [*]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
       simp [*]
@@ -356,7 +360,7 @@ theorem of_mem_balance2Node {x s v t} :
     (x ∈ balance2Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
   by
   cases s <;> simp
-  · intros ; simp [*]
+  · intros; simp [*]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
       simp [*]
@@ -367,8 +371,8 @@ theorem equiv_or_mem_of_mem_ins [DecidableRel lt] {t : Rbnode α} {x z} :
   by
   apply ins.induction lt t z <;> intros <;> simp_all [ins, StrictWeakOrder.Equiv] <;>
     cases_type*or.1
-  any_goals intros ; simp [h]
-  any_goals intros ; have ih := ih h; cases ih <;> simp [*]; done
+  any_goals intros; simp [h]
+  any_goals intros; have ih := ih h; cases ih <;> simp [*]; done
   · have h' := of_mem_balance1_node lt h; cases_type*or.1
     have := ih h'; cases_type*or.1
     all_goals simp [h, *]
@@ -378,7 +382,7 @@ theorem equiv_or_mem_of_mem_ins [DecidableRel lt] {t : Rbnode α} {x z} :
 #align rbnode.equiv_or_mem_of_mem_ins Rbnode.equiv_or_mem_of_mem_ins
 
 theorem equiv_or_mem_of_mem_insert [DecidableRel lt] {t : Rbnode α} {x z} :
-    ∀ h : x ∈ t.insert lt z, x ≈[lt]z ∨ (x ∈ t) := by simp [insert]; intros ;
+    ∀ h : x ∈ t.insert lt z, x ≈[lt]z ∨ (x ∈ t) := by simp [insert]; intros;
   apply equiv_or_mem_of_mem_ins; exact mem_of_mem_mk_insert_result lt h
 #align rbnode.equiv_or_mem_of_mem_insert Rbnode.equiv_or_mem_of_mem_insert
 
@@ -457,12 +461,12 @@ theorem find_ins_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {
     ∀ {lo hi} (hs : IsSearchable lt t lo hi) (hlt₁ : Lift lt lo (some x))
       (hlt₂ : Lift lt (some x) hi), find lt (ins lt t x) y = some x :=
   by
-  simp [StrictWeakOrder.Equiv] at he
+  simp [StrictWeakOrder.Equiv] at he 
   apply ins.induction lt t x <;> intros
   ·
     run_tac
       simp_fi
-  all_goals simp at hc; cases hs
+  all_goals simp at hc ; cases hs
   · have := lt_of_incomp_of_lt he.swap hc
     have := ih hs_hs₁ hlt₁ hc
     run_tac
@@ -543,8 +547,8 @@ theorem find_red_of_incomp [DecidableRel lt] {l y r x} (h : ¬lt x y ∧ ¬lt y
 
 end SimpAuxLemmas
 
-attribute [local simp]
-  find_black_eq_find_red find_red_of_lt find_red_of_lt find_red_of_gt find_red_of_incomp
+attribute [local simp] find_black_eq_find_red find_red_of_lt find_red_of_lt find_red_of_gt
+  find_red_of_incomp
 
 variable [IsStrictWeakOrder α lt] [DecidableRel lt]
 
@@ -580,7 +584,7 @@ theorem find_balance1Node_lt {t s x y lo hi} (hlt : lt y x) (ht : IsSearchable l
   by
   cases t <;> simp [balance1_node]
   · contradiction
-  all_goals intros ;
+  all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance1_lt; assumption'
@@ -609,7 +613,7 @@ theorem find_balance1Node_gt {t s x y lo hi} (h : lt x y) (ht : IsSearchable lt
     find lt (balance1Node t x s) y = find lt s y :=
   by
   cases t <;> simp [balance1_node]
-  all_goals intros ;
+  all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance1_gt; assumption'
@@ -641,7 +645,7 @@ theorem find_balance1Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
   by
   cases t <;> simp [balance1_node]
   · contradiction
-  all_goals intros ;
+  all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance1_eqv; assumption'
@@ -670,7 +674,7 @@ theorem find_balance2Node_lt {s t x y lo hi} (h : lt x y) (ht : IsSearchable lt
     find lt (balance2Node t y s) x = find lt s x :=
   by
   cases t <;> simp [balance2_node]
-  all_goals intros ;
+  all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance2_lt; assumption'
@@ -703,7 +707,7 @@ theorem find_balance2Node_gt {s t x y lo hi} (h : lt y x) (ht : IsSearchable lt
   by
   cases t <;> simp [balance2_node]
   · contradiction
-  all_goals intros ;
+  all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance2_gt; assumption'
@@ -733,7 +737,7 @@ theorem find_balance2Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
   by
   cases t <;> simp [balance2_node]
   · contradiction
-  all_goals intros ;
+  all_goals intros;
     run_tac
       is_searchable_tactic;
     apply find_balance2_eqv; assumption'
@@ -764,7 +768,7 @@ theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
   apply ins.induction lt t x <;> intros
   · cases hn
     all_goals simp [find, ins, cmpUsing, *]
-  all_goals simp at hc; cases hs
+  all_goals simp at hc ; cases hs
   · have := ih hs_hs₁ hlt₁ hc;
     run_tac
       simp_fi
@@ -780,7 +784,7 @@ theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
       simp_fi
   · have ih := ih hs_hs₁ hlt₁ hc
     cases hn
-    · cases hc' : cmpUsing lt y y_1 <;> simp at hc'
+    · cases hc' : cmpUsing lt y y_1 <;> simp at hc' 
       · have hsi := is_searchable_ins lt hs_hs₁ hlt₁ (trans_of lt hn hc')
         have := find_balance1_node_lt lt hc' hsi hs_hs₂
         run_tac
@@ -821,7 +825,7 @@ theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
         simp_fi
     · run_tac
         simp_fi
-      cases hc' : cmpUsing lt y y_1 <;> simp at hc'
+      cases hc' : cmpUsing lt y y_1 <;> simp at hc' 
       · have hsi := is_searchable_ins lt hs_hs₂ hc hlt₂
         have := find_balance2_node_lt lt hc' hsi hs_hs₁
         run_tac
@@ -858,7 +862,7 @@ theorem find_insert_of_not_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y
   simp [insert, find_mk_insert_result]
   have he : lt x y ∨ lt y x :=
     by
-    simp [StrictWeakOrder.Equiv, Decidable.not_and_iff_or_not, Decidable.not_not_iff] at hn
+    simp [StrictWeakOrder.Equiv, Decidable.not_and_iff_or_not, Decidable.not_not_iff] at hn 
     assumption
   apply find_ins_of_disj lt he hs <;> simp
 #align rbnode.find_insert_of_not_eqv Rbnode.find_insert_of_not_eqv
@@ -880,13 +884,23 @@ inductive IsBadRedBlack : Rbnode α → Nat → Prop
 theorem balance1_rb {l r t : Rbnode α} {y v : α} {c_l c_r c_t n} :
     IsRedBlack l c_l n →
       IsRedBlack r c_r n → IsRedBlack t c_t n → ∃ c, IsRedBlack (balance1 l y r v t) c (succ n) :=
-  by intro h₁ h₂ _ <;> cases h₁ <;> cases h₂ <;> repeat' first |assumption|constructor
+  by
+  intro h₁ h₂ _ <;> cases h₁ <;> cases h₂ <;>
+    repeat'
+      first
+      | assumption
+      | constructor
 #align rbnode.balance1_rb Rbnode.balance1_rb
 
 theorem balance2_rb {l r t : Rbnode α} {y v : α} {c_l c_r c_t n} :
     IsRedBlack l c_l n →
       IsRedBlack r c_r n → IsRedBlack t c_t n → ∃ c, IsRedBlack (balance2 l y r v t) c (succ n) :=
-  by intro h₁ h₂ _ <;> cases h₁ <;> cases h₂ <;> repeat' first |assumption|constructor
+  by
+  intro h₁ h₂ _ <;> cases h₁ <;> cases h₂ <;>
+    repeat'
+      first
+      | assumption
+      | constructor
 #align rbnode.balance2_rb Rbnode.balance2_rb
 
 theorem balance1Node_rb {t s : Rbnode α} {y : α} {c n} :
@@ -907,11 +921,11 @@ def InsRbResult : Rbnode α → Color → Nat → Prop
 variable {lt : α → α → Prop} [DecidableRel lt]
 
 theorem of_getColor_eq_red {t : Rbnode α} {c n} : getColor t = red → IsRedBlack t c n → c = red :=
-  by intro h₁ h₂; cases h₂ <;> simp only [get_color] at h₁ <;> contradiction
+  by intro h₁ h₂; cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
 #align rbnode.of_get_color_eq_red Rbnode.of_getColor_eq_red
 
 theorem of_getColor_ne_red {t : Rbnode α} {c n} : getColor t ≠ red → IsRedBlack t c n → c = black :=
-  by intro h₁ h₂; cases h₂ <;> simp only [get_color] at h₁ <;> contradiction
+  by intro h₁ h₂; cases h₂ <;> simp only [get_color] at h₁  <;> contradiction
 #align rbnode.of_get_color_ne_red Rbnode.of_getColor_ne_red
 
 variable (lt)
@@ -950,7 +964,7 @@ theorem insert_rb {t : Rbnode α} (x) {c n} (h : IsRedBlack t c n) :
   simp [insert]
   have hi := ins_rb lt x h
   generalize he : ins lt t x = r
-  simp [he] at hi
+  simp [he] at hi 
   cases h <;> simp [get_color, ins_rb_result, insert_rb_result, mk_insert_result] at *
   assumption'
   · cases hi; simp [mk_insert_result]; constructor <;> assumption
@@ -961,7 +975,7 @@ theorem insert_isRedBlack {t : Rbnode α} {c n} (x) :
   by
   intro h
   have := insert_rb lt x h
-  cases c <;> simp [insert_rb_result] at this
+  cases c <;> simp [insert_rb_result] at this 
   · constructor; constructor; assumption
   · cases this; constructor; constructor; assumption
 #align rbnode.insert_is_red_black Rbnode.insert_isRedBlack

4d416710

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -155,10 +155,8 @@ theorem isSearchable_balance1Node {t} [IsTrans α lt] :
     run_tac
       is_searchable_tactic
   · cases lo
-    · apply is_searchable_none_low_of_is_searchable_some_low
-      assumption
-    · simp at *
-      apply is_searchable_some_low_of_is_searchable_of_lt <;> assumption
+    · apply is_searchable_none_low_of_is_searchable_some_low; assumption
+    · simp at *; apply is_searchable_some_low_of_is_searchable_of_lt <;> assumption
   all_goals apply is_searchable_balance1 <;> assumption
 #align rbnode.is_searchable_balance1_node Rbnode.isSearchable_balance1Node
 
@@ -183,11 +181,8 @@ theorem isSearchable_balance2Node {t} [IsTrans α lt] :
     run_tac
       is_searchable_tactic
   · cases hi
-    · apply is_searchable_none_high_of_is_searchable_some_high
-      assumption
-    · simp at *
-      apply is_searchable_some_high_of_is_searchable_of_lt
-      assumption'
+    · apply is_searchable_none_high_of_is_searchable_some_high; assumption
+    · simp at *; apply is_searchable_some_high_of_is_searchable_of_lt; assumption'
   all_goals apply is_searchable_balance2; assumption'
 #align rbnode.is_searchable_balance2_node Rbnode.isSearchable_balance2Node
 
@@ -199,36 +194,18 @@ theorem isSearchable_ins [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
   apply ins.induction lt t x <;> intros <;> simp_all! (config := { eta := false }) <;>
     run_tac
       is_searchable_tactic
-  · apply ih h_hs₁
+  · apply ih h_hs₁; assumption; simp [*]
+  · apply is_searchable_of_is_searchable_of_incomp hc; assumption
+  · apply is_searchable_of_incomp_of_is_searchable hc; assumption
+  · apply ih h_hs₂; cases hi <;> simp [*]; assumption
+  · apply is_searchable_balance1_node; apply ih h_hs₁; assumption; simp [*]
     assumption
-    simp [*]
-  · apply is_searchable_of_is_searchable_of_incomp hc
-    assumption
-  · apply is_searchable_of_incomp_of_is_searchable hc
-    assumption
-  · apply ih h_hs₂
-    cases hi <;> simp [*]
-    assumption
-  · apply is_searchable_balance1_node
-    apply ih h_hs₁
-    assumption
-    simp [*]
-    assumption
-  · apply ih h_hs₁
-    assumption
-    simp [*]
-  · apply is_searchable_of_is_searchable_of_incomp hc
-    assumption
-  · apply is_searchable_of_incomp_of_is_searchable hc
-    assumption
-  · apply is_searchable_balance2_node
-    assumption
-    apply ih h_hs₂
-    simp [*]
-    assumption
-  · apply ih h_hs₂
+  · apply ih h_hs₁; assumption; simp [*]
+  · apply is_searchable_of_is_searchable_of_incomp hc; assumption
+  · apply is_searchable_of_incomp_of_is_searchable hc; assumption
+  · apply is_searchable_balance2_node; assumption; apply ih h_hs₂; simp [*]
     assumption
-    simp [*]
+  · apply ih h_hs₂; assumption; simp [*]
 #align rbnode.is_searchable_ins Rbnode.isSearchable_ins
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
@@ -236,7 +213,7 @@ theorem isSearchable_mkInsertResult {c t} :
     IsSearchable lt t none none → IsSearchable lt (mkInsertResult c t) none none := by
   classical
     cases c <;> cases t <;> simp [mk_insert_result]
-    · intro h
+    · intro h;
       run_tac
         is_searchable_tactic
 #align rbnode.is_searchable_mk_insert_result Rbnode.isSearchable_mkInsertResult
@@ -310,20 +287,15 @@ theorem ins_ne_leaf [DecidableRel lt] (t : Rbnode α) (x : α) : t.ins lt x ≠
   by
   apply ins.induction lt t x
   any_goals intros ; simp [ins, *]
-  · intros
-    apply balance1_node_ne_leaf
-    assumption
-  · intros
-    apply balance2_node_ne_leaf
-    assumption
+  · intros ; apply balance1_node_ne_leaf; assumption
+  · intros ; apply balance2_node_ne_leaf; assumption
 #align rbnode.ins_ne_leaf Rbnode.ins_ne_leaf
 
 theorem insert_ne_leaf [DecidableRel lt] (t : Rbnode α) (x : α) : insert lt t x ≠ leaf :=
   by
   simp [insert]
   cases he : ins lt t x <;> cases get_color t <;> simp [mk_insert_result]
-  · have := ins_ne_leaf lt t x
-    contradiction
+  · have := ins_ne_leaf lt t x; contradiction
   · exact absurd he (ins_ne_leaf _ _ _)
 #align rbnode.insert_ne_leaf Rbnode.insert_ne_leaf
 
@@ -331,12 +303,8 @@ theorem mem_ins_of_incomp [DecidableRel lt] (t : Rbnode α) {x y : α} :
     ∀ h : ¬lt x y ∧ ¬lt y x, x ∈ t.ins lt y :=
   by
   apply ins.induction lt t y <;> intros <;> simp [ins, *]
-  · have := ih h
-    apply mem_balance1_node_of_mem_left
-    assumption
-  · have := ih h
-    apply mem_balance2_node_of_mem_left
-    assumption
+  · have := ih h; apply mem_balance1_node_of_mem_left; assumption
+  · have := ih h; apply mem_balance2_node_of_mem_left; assumption
 #align rbnode.mem_ins_of_incomp Rbnode.mem_ins_of_incomp
 
 theorem mem_ins_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t : Rbnode α} (z : α) :
@@ -345,26 +313,15 @@ theorem mem_ins_of_mem [DecidableRel lt] [IsStrictWeakOrder α lt] {t : Rbnode 
   apply ins.induction lt t z <;> intros <;> simp_all [ins] <;> try contradiction <;> cases_type*or.1
   any_goals intros ; simp [h]; done
   any_goals intros ; simp [ih h]; done
-  · have := incomp_trans_of lt h ⟨hc.2, hc.1⟩
-    simp [this]
-  · apply mem_balance1_node_of_mem_left
-    apply ih h
-  · apply mem_balance1_node_of_incomp
-    cases h
-    all_goals simp [*, ins_ne_leaf lt a z]
-  · apply mem_balance1_node_of_mem_right
-    assumption
-  · have := incomp_trans_of lt hc ⟨h.2, h.1⟩
-    simp [this]
-  · apply mem_balance2_node_of_mem_right
-    assumption
-  · have := ins_ne_leaf lt a z
-    apply mem_balance2_node_of_incomp
-    cases h
-    simp [*]
+  · have := incomp_trans_of lt h ⟨hc.2, hc.1⟩; simp [this]
+  · apply mem_balance1_node_of_mem_left; apply ih h
+  · apply mem_balance1_node_of_incomp; cases h; all_goals simp [*, ins_ne_leaf lt a z]
+  · apply mem_balance1_node_of_mem_right; assumption
+  · have := incomp_trans_of lt hc ⟨h.2, h.1⟩; simp [this]
+  · apply mem_balance2_node_of_mem_right; assumption
+  · have := ins_ne_leaf lt a z; apply mem_balance2_node_of_incomp; cases h; simp [*]
     apply ins_ne_leaf
-  · apply mem_balance2_node_of_mem_left
-    apply ih h
+  · apply mem_balance2_node_of_mem_left; apply ih h
 #align rbnode.mem_ins_of_mem Rbnode.mem_ins_of_mem
 
 theorem mem_mkInsertResult {a t} (c) : Mem lt a t → Mem lt a (mkInsertResult c t) := by
@@ -389,8 +346,7 @@ theorem of_mem_balance1Node {x s v t} :
     (x ∈ balance1Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
   by
   cases s <;> simp
-  · intros
-    simp [*]
+  · intros ; simp [*]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
       simp [*]
@@ -400,8 +356,7 @@ theorem of_mem_balance2Node {x s v t} :
     (x ∈ balance2Node s v t) → (x ∈ s) ∨ ¬lt x v ∧ ¬lt v x ∨ (x ∈ t) :=
   by
   cases s <;> simp
-  · intros
-    simp [*]
+  · intros ; simp [*]
   all_goals
     apply balance.cases s_lchild s_val s_rchild <;> intros <;> simp_all <;> cases_type*or.1 <;>
       simp [*]
@@ -414,15 +369,11 @@ theorem equiv_or_mem_of_mem_ins [DecidableRel lt] {t : Rbnode α} {x z} :
     cases_type*or.1
   any_goals intros ; simp [h]
   any_goals intros ; have ih := ih h; cases ih <;> simp [*]; done
-  · have h' := of_mem_balance1_node lt h
-    cases_type*or.1
-    have := ih h'
-    cases_type*or.1
+  · have h' := of_mem_balance1_node lt h; cases_type*or.1
+    have := ih h'; cases_type*or.1
     all_goals simp [h, *]
-  · have h' := of_mem_balance2_node lt h
-    cases_type*or.1
-    have := ih h'
-    cases_type*or.1
+  · have h' := of_mem_balance2_node lt h; cases_type*or.1
+    have := ih h'; cases_type*or.1
     all_goals simp [h, *]
 #align rbnode.equiv_or_mem_of_mem_ins Rbnode.equiv_or_mem_of_mem_ins
 
@@ -548,8 +499,7 @@ theorem find_mkInsertResult [DecidableRel lt] (c : Color) (t : Rbnode α) (x : 
     find lt (mkInsertResult c t) x = find lt t x :=
   by
   cases t <;> cases c <;> simp [mk_insert_result]
-  · simp [find]
-    cases cmpUsing lt x t_val <;> simp [find]
+  · simp [find]; cases cmpUsing lt x t_val <;> simp [find]
 #align rbnode.find_mk_insert_result Rbnode.find_mkInsertResult
 
 theorem find_insert_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {t : Rbnode α}
@@ -564,13 +514,10 @@ theorem weak_trichotomous (x y) {p : Prop} (is_lt : ∀ h : lt x y, p)
     (is_eqv : ∀ h : ¬lt x y ∧ ¬lt y x, p) (is_gt : ∀ h : lt y x, p) : p :=
   by
   by_cases lt x y
-  · apply is_lt
-    assumption
+  · apply is_lt; assumption
   by_cases lt y x
-  · apply is_gt
-    assumption
-  · apply is_eqv
-    constructor <;> assumption
+  · apply is_gt; assumption
+  · apply is_eqv; constructor <;> assumption
 #align rbnode.weak_trichotomous Rbnode.weak_trichotomous
 
 section FindInsOfNotEqv
@@ -612,10 +559,8 @@ theorem find_balance1_lt {l r t v x y lo hi} (h : lt x y) (hl : IsSearchable lt
       is_searchable_tactic
   · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
   · apply weak_trichotomous lt x_1 x <;> intro h'
-    · have := trans_of lt (lo_lt_hi hr_hs₁) h'
-      simp [*]
-    · have : lt y_1 x := lt_of_lt_of_incomp (lo_lt_hi hr_hs₁) h'
-      simp [*]
+    · have := trans_of lt (lo_lt_hi hr_hs₁) h'; simp [*]
+    · have : lt y_1 x := lt_of_lt_of_incomp (lo_lt_hi hr_hs₁) h'; simp [*]
     · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
 #align rbnode.find_balance1_lt Rbnode.find_balance1_lt
 
@@ -650,10 +595,8 @@ theorem find_balance1_gt {l r t v x y lo hi} (h : lt y x) (hl : IsSearchable lt
   apply balance.cases l v r <;> intros <;> simp [*] <;>
     run_tac
       is_searchable_tactic
-  · have := trans_of lt (lo_lt_hi hr) h
-    simp [*]
-  · have := trans_of lt (lo_lt_hi hr_hs₂) h
-    simp [*]
+  · have := trans_of lt (lo_lt_hi hr) h; simp [*]
+  · have := trans_of lt (lo_lt_hi hr_hs₂) h; simp [*]
 #align rbnode.find_balance1_gt Rbnode.find_balance1_gt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
@@ -713,10 +656,8 @@ theorem find_balance2_lt {l v r t x y lo hi} (h : lt x y) (hl : IsSearchable lt
   apply balance.cases l v r <;> intros <;> simp [*] <;>
     run_tac
       is_searchable_tactic
-  · have := trans h (lo_lt_hi hl_hs₁)
-    simp [*]
-  · have := trans h (lo_lt_hi hl)
-    simp [*]
+  · have := trans h (lo_lt_hi hl_hs₁); simp [*]
+  · have := trans h (lo_lt_hi hl); simp [*]
 #align rbnode.find_balance2_lt Rbnode.find_balance2_lt
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
@@ -746,10 +687,8 @@ theorem find_balance2_gt {l v r t x y lo hi} (h : lt y x) (hl : IsSearchable lt
       is_searchable_tactic
   · apply weak_trichotomous lt x_1 x <;> intro h' <;> simp [*]
     · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
-    · have : lt x _ := lt_of_incomp_of_lt h'.swap (lo_lt_hi hl_hs₂)
-      simp [*]
-    · have := trans h' (lo_lt_hi hl_hs₂)
-      simp [*]
+    · have : lt x _ := lt_of_incomp_of_lt h'.swap (lo_lt_hi hl_hs₂); simp [*]
+    · have := trans h' (lo_lt_hi hl_hs₂); simp [*]
   · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
 #align rbnode.find_balance2_gt Rbnode.find_balance2_gt
 
@@ -779,10 +718,8 @@ theorem find_balance2_eqv {l v r t x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
   apply balance.cases l v r <;> intros <;> simp [*] <;>
     run_tac
       is_searchable_tactic
-  · have := lt_of_incomp_of_lt h (lo_lt_hi hl_hs₁)
-    simp [*]
-  · have := lt_of_incomp_of_lt h (lo_lt_hi hl)
-    simp [*]
+  · have := lt_of_incomp_of_lt h (lo_lt_hi hl_hs₁); simp [*]
+  · have := lt_of_incomp_of_lt h (lo_lt_hi hl); simp [*]
 #align rbnode.find_balance2_eqv Rbnode.find_balance2_eqv
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
@@ -828,7 +765,7 @@ theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
   · cases hn
     all_goals simp [find, ins, cmpUsing, *]
   all_goals simp at hc; cases hs
-  · have := ih hs_hs₁ hlt₁ hc
+  · have := ih hs_hs₁ hlt₁ hc;
     run_tac
       simp_fi
   · cases hn
@@ -855,7 +792,7 @@ theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
           simp_fi
       · have hsi := is_searchable_ins lt hs_hs₁ hlt₁ hc
         have := find_balance1_node_gt lt hc' hsi hs_hs₂
-        simp [*]
+        simp [*];
         run_tac
           simp_fi
     · have hlt := trans hn hc
@@ -863,19 +800,19 @@ theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
       have := find_balance1_node_lt lt hlt hsi hs_hs₂
       run_tac
         simp_fi
-  · have := ih hs_hs₁ hlt₁ hc
+  · have := ih hs_hs₁ hlt₁ hc;
     run_tac
       simp_fi
   · cases hn
-    · have := lt_of_incomp_of_lt hc.swap hn
+    · have := lt_of_incomp_of_lt hc.swap hn;
       run_tac
         simp_fi
-    · have := lt_of_lt_of_incomp hn hc
+    · have := lt_of_lt_of_incomp hn hc;
       run_tac
         simp_fi
   · have ih := ih hs_hs₂ hc hlt₂
     cases hn
-    · have hlt := trans hc hn
+    · have hlt := trans hc hn;
       run_tac
         simp_fi
       have hsi := is_searchable_ins lt hs_hs₂ hc hlt₂
@@ -983,31 +920,24 @@ theorem ins_rb {t : Rbnode α} (x) : ∀ {c n} (h : IsRedBlack t c n), InsRbResu
   by
   apply ins.induction lt t x <;> intros <;> cases h <;> simp [ins, *, ins_rb_result]
   · repeat' constructor
-  · specialize ih h_rb_l
-    cases ih
-    constructor <;> assumption
+  · specialize ih h_rb_l; cases ih; constructor <;> assumption
   · constructor <;> assumption
-  · specialize ih h_rb_r
-    cases ih
-    constructor <;> assumption
+  · specialize ih h_rb_r; cases ih; constructor <;> assumption
   · specialize ih h_rb_l
     cases of_get_color_eq_red hr h_rb_l
     apply balance1_node_rb <;> assumption
   · specialize ih h_rb_l
     cases of_get_color_ne_red hnr h_rb_l
     cases ih
-    constructor
-    constructor <;> assumption
-  · constructor
-    constructor <;> assumption
+    constructor; constructor <;> assumption
+  · constructor; constructor <;> assumption
   · specialize ih h_rb_r
     cases of_get_color_eq_red hr h_rb_r
     apply balance2_node_rb <;> assumption
   · specialize ih h_rb_r
     cases of_get_color_ne_red hnr h_rb_r
     cases ih
-    constructor
-    constructor <;> assumption
+    constructor; constructor <;> assumption
 #align rbnode.ins_rb Rbnode.ins_rb
 
 def InsertRbResult : Rbnode α → Color → Nat → Prop
@@ -1023,9 +953,7 @@ theorem insert_rb {t : Rbnode α} (x) {c n} (h : IsRedBlack t c n) :
   simp [he] at hi
   cases h <;> simp [get_color, ins_rb_result, insert_rb_result, mk_insert_result] at *
   assumption'
-  · cases hi
-    simp [mk_insert_result]
-    constructor <;> assumption
+  · cases hi; simp [mk_insert_result]; constructor <;> assumption
 #align rbnode.insert_rb Rbnode.insert_rb
 
 theorem insert_isRedBlack {t : Rbnode α} {c n} (x) :
@@ -1034,13 +962,8 @@ theorem insert_isRedBlack {t : Rbnode α} {c n} (x) :
   intro h
   have := insert_rb lt x h
   cases c <;> simp [insert_rb_result] at this
-  · constructor
-    constructor
-    assumption
-  · cases this
-    constructor
-    constructor
-    assumption
+  · constructor; constructor; assumption
+  · cases this; constructor; constructor; assumption
 #align rbnode.insert_is_red_black Rbnode.insert_isRedBlack
 
 end IsRedBlack

4d416710

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -491,7 +491,6 @@ attribute [local simp] ite_eq_of_not_lt
 /- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 private unsafe def simp_fi : tactic Unit :=
   sorry
-#align rbnode.simp_fi rbnode.simp_fi
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/

4d416710

bump to nightly-2023-03-01-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

20cadee0

Diff

@@ -134,7 +134,7 @@ theorem ins.induction [DecidableRel lt] {p : Rbnode α → Prop} (t x) (is_leaf
       · apply is_black_gt_not_red <;> assumption
 #align rbnode.ins.induction Rbnode.ins.induction
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem isSearchable_balance1 {l y r v t lo hi} :
     IsSearchable lt l lo (some y) →
       IsSearchable lt r (some y) (some v) →
@@ -145,7 +145,7 @@ theorem isSearchable_balance1 {l y r v t lo hi} :
       is_searchable_tactic
 #align rbnode.is_searchable_balance1 Rbnode.isSearchable_balance1
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem isSearchable_balance1Node {t} [IsTrans α lt] :
     ∀ {y s lo hi},
       IsSearchable lt t lo (some y) →
@@ -162,7 +162,7 @@ theorem isSearchable_balance1Node {t} [IsTrans α lt] :
   all_goals apply is_searchable_balance1 <;> assumption
 #align rbnode.is_searchable_balance1_node Rbnode.isSearchable_balance1Node
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem isSearchable_balance2 {l y r v t lo hi} :
     IsSearchable lt t lo (some v) →
       IsSearchable lt l (some v) (some y) →
@@ -173,7 +173,7 @@ theorem isSearchable_balance2 {l y r v t lo hi} :
       is_searchable_tactic
 #align rbnode.is_searchable_balance2 Rbnode.isSearchable_balance2
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem isSearchable_balance2Node {t} [IsTrans α lt] :
     ∀ {y s lo hi},
       IsSearchable lt s lo (some y) →
@@ -191,7 +191,7 @@ theorem isSearchable_balance2Node {t} [IsTrans α lt] :
   all_goals apply is_searchable_balance2; assumption'
 #align rbnode.is_searchable_balance2_node Rbnode.isSearchable_balance2Node
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem isSearchable_ins [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
     ∀ {lo hi} (h : IsSearchable lt t lo hi),
       Lift lt lo (some x) → Lift lt (some x) hi → IsSearchable lt (ins lt t x) lo hi :=
@@ -231,7 +231,7 @@ theorem isSearchable_ins [DecidableRel lt] {t x} [IsStrictWeakOrder α lt] :
     simp [*]
 #align rbnode.is_searchable_ins Rbnode.isSearchable_ins
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem isSearchable_mkInsertResult {c t} :
     IsSearchable lt t none none → IsSearchable lt (mkInsertResult c t) none none := by
   classical
@@ -488,20 +488,20 @@ theorem ite_eq_of_not_lt [DecidableRel lt] [IsStrictOrder α lt] {a b} {β : Typ
 
 attribute [local simp] ite_eq_of_not_lt
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:334:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 private unsafe def simp_fi : tactic Unit :=
   sorry
 #align rbnode.simp_fi rbnode.simp_fi
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 theorem find_ins_of_eqv [DecidableRel lt] [IsStrictWeakOrder α lt] {x y : α} {t : Rbnode α}
     (he : x ≈[lt]y) :
     ∀ {lo hi} (hs : IsSearchable lt t lo hi) (hlt₁ : Lift lt lo (some x))
@@ -602,7 +602,7 @@ attribute [local simp]
 
 variable [IsStrictWeakOrder α lt] [DecidableRel lt]
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem find_balance1_lt {l r t v x y lo hi} (h : lt x y) (hl : IsSearchable lt l lo (some v))
     (hr : IsSearchable lt r (some v) (some y)) (ht : IsSearchable lt t (some y) hi) :
     find lt (balance1 l v r y t) x = find lt (red_node l v r) x :=
@@ -620,13 +620,13 @@ theorem find_balance1_lt {l r t v x y lo hi} (h : lt x y) (hl : IsSearchable lt
     · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
 #align rbnode.find_balance1_lt Rbnode.find_balance1_lt
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:334:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 unsafe def ins_ne_leaf_tac :=
   sorry
 #align rbnode.ins_ne_leaf_tac rbnode.ins_ne_leaf_tac
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
 theorem find_balance1Node_lt {t s x y lo hi} (hlt : lt y x) (ht : IsSearchable lt t lo (some x))
     (hs : IsSearchable lt s (some x) hi)
     (hne : t ≠ leaf := by
@@ -642,7 +642,7 @@ theorem find_balance1Node_lt {t s x y lo hi} (hlt : lt y x) (ht : IsSearchable l
     apply find_balance1_lt; assumption'
 #align rbnode.find_balance1_node_lt Rbnode.find_balance1Node_lt
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem find_balance1_gt {l r t v x y lo hi} (h : lt y x) (hl : IsSearchable lt l lo (some v))
     (hr : IsSearchable lt r (some v) (some y)) (ht : IsSearchable lt t (some y) hi) :
     find lt (balance1 l v r y t) x = find lt t x :=
@@ -657,8 +657,8 @@ theorem find_balance1_gt {l r t v x y lo hi} (h : lt y x) (hl : IsSearchable lt
     simp [*]
 #align rbnode.find_balance1_gt Rbnode.find_balance1_gt
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
 theorem find_balance1Node_gt {t s x y lo hi} (h : lt x y) (ht : IsSearchable lt t lo (some x))
     (hs : IsSearchable lt s (some x) hi)
     (hne : t ≠ leaf := by
@@ -673,7 +673,7 @@ theorem find_balance1Node_gt {t s x y lo hi} (h : lt x y) (ht : IsSearchable lt
     apply find_balance1_gt; assumption'
 #align rbnode.find_balance1_node_gt Rbnode.find_balance1Node_gt
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem find_balance1_eqv {l r t v x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     (hl : IsSearchable lt l lo (some v)) (hr : IsSearchable lt r (some v) (some y))
     (ht : IsSearchable lt t (some y) hi) : find lt (balance1 l v r y t) x = some y :=
@@ -688,8 +688,8 @@ theorem find_balance1_eqv {l r t v x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     simp [*]
 #align rbnode.find_balance1_eqv Rbnode.find_balance1_eqv
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
 theorem find_balance1Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     (ht : IsSearchable lt t lo (some y)) (hs : IsSearchable lt s (some y) hi)
     (hne : t ≠ leaf := by
@@ -705,7 +705,7 @@ theorem find_balance1Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     apply find_balance1_eqv; assumption'
 #align rbnode.find_balance1_node_eqv Rbnode.find_balance1Node_eqv
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem find_balance2_lt {l v r t x y lo hi} (h : lt x y) (hl : IsSearchable lt l (some y) (some v))
     (hr : IsSearchable lt r (some v) hi) (ht : IsSearchable lt t lo (some y)) :
     find lt (balance2 l v r y t) x = find lt t x :=
@@ -720,8 +720,8 @@ theorem find_balance2_lt {l v r t x y lo hi} (h : lt x y) (hl : IsSearchable lt
     simp [*]
 #align rbnode.find_balance2_lt Rbnode.find_balance2_lt
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
 theorem find_balance2Node_lt {s t x y lo hi} (h : lt x y) (ht : IsSearchable lt t (some y) hi)
     (hs : IsSearchable lt s lo (some y))
     (hne : t ≠ leaf := by
@@ -736,7 +736,7 @@ theorem find_balance2Node_lt {s t x y lo hi} (h : lt x y) (ht : IsSearchable lt
     apply find_balance2_lt; assumption'
 #align rbnode.find_balance2_node_lt Rbnode.find_balance2Node_lt
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem find_balance2_gt {l v r t x y lo hi} (h : lt y x) (hl : IsSearchable lt l (some y) (some v))
     (hr : IsSearchable lt r (some v) hi) (ht : IsSearchable lt t lo (some y)) :
     find lt (balance2 l v r y t) x = find lt (red_node l v r) x :=
@@ -754,8 +754,8 @@ theorem find_balance2_gt {l v r t x y lo hi} (h : lt y x) (hl : IsSearchable lt
   · apply weak_trichotomous lt y_1 x <;> intros <;> simp [*]
 #align rbnode.find_balance2_gt Rbnode.find_balance2_gt
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
 theorem find_balance2Node_gt {s t x y lo hi} (h : lt y x) (ht : IsSearchable lt t (some y) hi)
     (hs : IsSearchable lt s lo (some y))
     (hne : t ≠ leaf := by
@@ -771,7 +771,7 @@ theorem find_balance2Node_gt {s t x y lo hi} (h : lt y x) (ht : IsSearchable lt
     apply find_balance2_gt; assumption'
 #align rbnode.find_balance2_node_gt Rbnode.find_balance2Node_gt
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
 theorem find_balance2_eqv {l v r t x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     (hl : IsSearchable lt l (some y) (some v)) (hr : IsSearchable lt r (some v) hi)
     (ht : IsSearchable lt t lo (some y)) : find lt (balance2 l v r y t) x = some y :=
@@ -786,8 +786,8 @@ theorem find_balance2_eqv {l v r t x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     simp [*]
 #align rbnode.find_balance2_eqv Rbnode.find_balance2_eqv
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic rbnode.is_searchable_tactic -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic ins_ne_leaf_tac -/
 theorem find_balance2Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     (ht : IsSearchable lt t (some y) hi) (hs : IsSearchable lt s lo (some y))
     (hne : t ≠ leaf := by
@@ -803,24 +803,24 @@ theorem find_balance2Node_eqv {t s x y lo hi} (h : ¬lt x y ∧ ¬lt y x)
     apply find_balance2_eqv; assumption'
 #align rbnode.find_balance2_node_eqv Rbnode.find_balance2Node_eqv
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic _private.3968712505.simp_fi -/
 theorem find_ins_of_disj {x y : α} {t : Rbnode α} (hn : lt x y ∨ lt y x) :
     ∀ {lo hi} (hs : IsSearchable lt t lo hi) (hlt₁ : Lift lt lo (some x))
       (hlt₂ : Lift lt (some x) hi), find lt (ins lt t x) y = find lt t y :=

4d416710

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

4d416710

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.insert from "leanprover-community/mathlib"@"4d4167104581a21259f7f448e1972a63a4546be7"
 
 /-!
 # Porting note: essentially already ported to std4
 
-#align_import data.rbtree.insert from "leanprover-community/mathlib"@"4d4167104581a21259f7f448e1972a63a4546be7"
-
 https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Mathlib4.20porting.20meeting.20series/near/369848971
 
 -/

4d416710

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.insert
-! leanprover-community/mathlib commit 4d4167104581a21259f7f448e1972a63a4546be7
-! 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.insert from "leanprover-community/mathlib"@"4d4167104581a21259f7f448e1972a63a4546be7"
+
 https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Mathlib4.20porting.20meeting.20series/near/369848971
 
 -/

4d416710

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

Cf. here. Incorporates #5479.

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

0171e873

`data.rbtree.insert` ⟷ `Mathlib.Data.Rbtree.Insert`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 7

data.rbtree.insert ⟷ Mathlib.Data.Rbtree.Insert

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 7

`data.rbtree.insert` ⟷ `Mathlib.Data.Rbtree.Insert`