ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordnode.Valid.left
nonrec theorem Valid.left {s l x r} (H : Valid (@node α s l x r)) : Valid l 
Arguments: {α : Type u_1} [Preorder α] {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} (H : (Ordnode.node s l x r).Valid)
Goal: l.Valid
-- Ordnode.Valid.right
nonrec theorem Valid.right {s l x r} (H : Valid (@node α s l x r)) : Valid r 
Arguments: {α : Type u_1} [Preorder α] {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} (H : (Ordnode.node s l x r).Valid)
Goal: r.Valid
-- Ordnode.Valid.size_eq
theorem Valid.size_eq {s l x r} (H : Valid (@node α s l x r)) :
    size (@node α s l x r) = size l + size r + 1 
Arguments: {α : Type u_1} [Preorder α] {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} (H : (Ordnode.node s l x r).Valid)
Goal: (Ordnode.node s l x r).size = l.size + r.size + 1
-- Ordnode.Valid'.node'
theorem Valid'.node' {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : BalancedSz (size l) (size r)) : Valid' o₁ (@node' α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H : Ordnode.BalancedSz l.size r.size)
Goal: Ordnode.Valid' o₁ (l.node' x r) o₂
-- Ordnode.valid'_singleton
theorem valid'_singleton {x : α} {o₁ o₂} (h₁ : Bounded nil o₁ x) (h₂ : Bounded nil x o₂) :
    Valid' o₁ (singleton x : Ordnode α) o₂ 
Arguments: {α : Type u_1} [Preorder α] {x : α} {o₁ : WithBot α} {o₂ : WithTop α} (h₁ : Ordnode.nil.Bounded o₁ ↑x) (h₂ : Ordnode.nil.Bounded (↑x) o₂)
Goal: Ordnode.Valid' o₁ {x} o₂
-- Ordnode.valid_singleton
theorem valid_singleton {x : α} : Valid (singleton x : Ordnode α) 
Arguments: {α : Type u_1} [Preorder α] {x : α}
Goal: {x}.Valid
-- Ordnode.Valid'.node3L
theorem Valid'.node3L {l} {x : α} {m} {y : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hm : Valid' x m y)
    (hr : Valid' y r o₂) (H1 : BalancedSz (size l) (size m))
    (H2 : BalancedSz (size l + size m + 1) (size r)) : Valid' o₁ (@node3L α l x m y r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hm : Ordnode.Valid' (↑x) m ↑y) (hr : Ordnode.Valid' (↑y) r o₂) (H1 : Ordnode.BalancedSz l.size m.size) (H2 : Ordnode.BalancedSz (l.size + m.size + 1) r.size)
Goal: Ordnode.Valid' o₁ (l.node3L x m y r) o₂
-- Ordnode.Valid'.node3R
theorem Valid'.node3R {l} {x : α} {m} {y : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hm : Valid' x m y)
    (hr : Valid' y r o₂) (H1 : BalancedSz (size l) (size m + size r + 1))
    (H2 : BalancedSz (size m) (size r)) : Valid' o₁ (@node3R α l x m y r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hm : Ordnode.Valid' (↑x) m ↑y) (hr : Ordnode.Valid' (↑y) r o₂) (H1 : Ordnode.BalancedSz l.size (m.size + r.size + 1)) (H2 : Ordnode.BalancedSz m.size r.size)
Goal: Ordnode.Valid' o₁ (l.node3R x m y r) o₂
-- Ordnode.Valid'.node4L_lemma₁
theorem Valid'.node4L_lemma₁ {a b c d : ℕ} (lr₂ : 3 * (b + c + 1 + d) ≤ 16 * a + 9)
    (mr₂ : b + c + 1 ≤ 3 * d) (mm₁ : b ≤ 3 * c) : b < 3 * a + 1 
Arguments: {a b c d : ℕ} (lr₂ : 3 * (b + c + 1 + d) ≤ 16 * a + 9) (mr₂ : b + c + 1 ≤ 3 * d) (mm₁ : b ≤ 3 * c)
Goal: b < 3 * a + 1
-- Ordnode.Valid'.node4L_lemma₂
theorem Valid'.node4L_lemma₂ {b c d : ℕ} (mr₂ : b + c + 1 ≤ 3 * d) : c ≤ 3 * d 
Arguments: {b c d : ℕ} (mr₂ : b + c + 1 ≤ 3 * d)
Goal: c ≤ 3 * d
-- Ordnode.Valid'.node4L_lemma₃
theorem Valid'.node4L_lemma₃ {b c d : ℕ} (mr₁ : 2 * d ≤ b + c + 1) (mm₁ : b ≤ 3 * c) :
    d ≤ 3 * c 
Arguments: {b c d : ℕ} (mr₁ : 2 * d ≤ b + c + 1) (mm₁ : b ≤ 3 * c)
Goal: d ≤ 3 * c
-- Ordnode.Valid'.node4L_lemma₄
theorem Valid'.node4L_lemma₄ {a b c d : ℕ} (lr₁ : 3 * a ≤ b + c + 1 + d) (mr₂ : b + c + 1 ≤ 3 * d)
    (mm₁ : b ≤ 3 * c) : a + b + 1 ≤ 3 * (c + d + 1) 
Arguments: {a b c d : ℕ} (lr₁ : 3 * a ≤ b + c + 1 + d) (mr₂ : b + c + 1 ≤ 3 * d) (mm₁ : b ≤ 3 * c)
Goal: a + b + 1 ≤ 3 * (c + d + 1)
-- Ordnode.Valid'.node4L_lemma₅
theorem Valid'.node4L_lemma₅ {a b c d : ℕ} (lr₂ : 3 * (b + c + 1 + d) ≤ 16 * a + 9)
    (mr₁ : 2 * d ≤ b + c + 1) (mm₂ : c ≤ 3 * b) : c + d + 1 ≤ 3 * (a + b + 1) 
Arguments: {a b c d : ℕ} (lr₂ : 3 * (b + c + 1 + d) ≤ 16 * a + 9) (mr₁ : 2 * d ≤ b + c + 1) (mm₂ : c ≤ 3 * b)
Goal: c + d + 1 ≤ 3 * (a + b + 1)
-- Ordnode.Valid'.node4L
theorem Valid'.node4L {l} {x : α} {m} {y : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hm : Valid' x m y)
    (hr : Valid' (↑y) r o₂) (Hm : 0 < size m)
    (H : size l = 0 ∧ size m = 1 ∧ size r ≤ 1 ∨
        0 < size l ∧
          ratio * size r ≤ size m ∧
            delta * size l ≤ size m + size r ∧
              3 * (size m + size r) ≤ 16 * size l + 9 ∧ size m ≤ delta * size r) :
    Valid' o₁ (@node4L α l x m y r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hm : Ordnode.Valid' (↑x) m ↑y) (hr : Ordnode.Valid' (↑y) r o₂) (Hm : 0 < m.size) (H :
  l.size = 0 ∧ m.size = 1 ∧ r.size ≤ 1 ∨
    0 < l.size ∧
      Ordnode.ratio * r.size ≤ m.size ∧
        Ordnode.delta * l.size ≤ m.size + r.size ∧
          3 * (m.size + r.size) ≤ 16 * l.size + 9 ∧ m.size ≤ Ordnode.delta * r.size)
Goal: Ordnode.Valid' o₁ (l.node4L x m y r) o₂
-- Ordnode.Valid'.rotateL_lemma₁
theorem Valid'.rotateL_lemma₁ {a b c : ℕ} (H2 : 3 * a ≤ b + c) (hb₂ : c ≤ 3 * b) : a ≤ 3 * b 
Arguments: {a b c : ℕ} (H2 : 3 * a ≤ b + c) (hb₂ : c ≤ 3 * b)
Goal: a ≤ 3 * b
-- Ordnode.Valid'.rotateL_lemma₂
theorem Valid'.rotateL_lemma₂ {a b c : ℕ} (H3 : 2 * (b + c) ≤ 9 * a + 3) (h : b < 2 * c) :
    b < 3 * a + 1 
Arguments: {a b c : ℕ} (H3 : 2 * (b + c) ≤ 9 * a + 3) (h : b < 2 * c)
Goal: b < 3 * a + 1
-- Ordnode.Valid'.rotateL_lemma₃
theorem Valid'.rotateL_lemma₃ {a b c : ℕ} (H2 : 3 * a ≤ b + c) (h : b < 2 * c) : a + b < 3 * c 
Arguments: {a b c : ℕ} (H2 : 3 * a ≤ b + c) (h : b < 2 * c)
Goal: a + b < 3 * c
-- Ordnode.Valid'.rotateL_lemma₄
theorem Valid'.rotateL_lemma₄ {a b : ℕ} (H3 : 2 * b ≤ 9 * a + 3) : 3 * b ≤ 16 * a + 9 
Arguments: {a b : ℕ} (H3 : 2 * b ≤ 9 * a + 3)
Goal: 3 * b ≤ 16 * a + 9
-- Ordnode.Valid'.rotateL
theorem Valid'.rotateL {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H1 : ¬size l + size r ≤ 1) (H2 : delta * size l < size r)
    (H3 : 2 * size r ≤ 9 * size l + 5 ∨ size r ≤ 3) : Valid' o₁ (@rotateL α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H1 : ¬l.size + r.size ≤ 1) (H2 : Ordnode.delta * l.size < r.size) (H3 : 2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3)
Goal: Ordnode.Valid' o₁ (l.rotateL x r) o₂
-- Ordnode.Valid'.rotateR
theorem Valid'.rotateR {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H1 : ¬size l + size r ≤ 1) (H2 : delta * size r < size l)
    (H3 : 2 * size l ≤ 9 * size r + 5 ∨ size l ≤ 3) : Valid' o₁ (@rotateR α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H1 : ¬l.size + r.size ≤ 1) (H2 : Ordnode.delta * r.size < l.size) (H3 : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3)
Goal: Ordnode.Valid' o₁ (l.rotateR x r) o₂
-- Ordnode.Valid'.balance'_aux
theorem Valid'.balance'_aux {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H₁ : 2 * @size α r ≤ 9 * size l + 5 ∨ size r ≤ 3)
    (H₂ : 2 * @size α l ≤ 9 * size r + 5 ∨ size l ≤ 3) : Valid' o₁ (@balance' α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H₁ : 2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3) (H₂ : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3)
Goal: Ordnode.Valid' o₁ (l.balance' x r) o₂
-- Ordnode.Valid'.balance'_lemma
theorem Valid'.balance'_lemma {α l l' r r'} (H1 : BalancedSz l' r')
    (H2 : Nat.dist (@size α l) l' ≤ 1 ∧ size r = r' ∨ Nat.dist (size r) r' ≤ 1 ∧ size l = l') :
    2 * @size α r ≤ 9 * size l + 5 ∨ size r ≤ 3 
Arguments: {α : Type u_2} {l : Ordnode α} {l' : ℕ} {r : Ordnode α} {r' : ℕ} (H1 : Ordnode.BalancedSz l' r') (H2 : l.size.dist l' ≤ 1 ∧ r.size = r' ∨ r.size.dist r' ≤ 1 ∧ l.size = l')
Goal: 2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3
-- Ordnode.Valid'.balance'
theorem Valid'.balance' {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : ∃ l' r', BalancedSz l' r' ∧
          (Nat.dist (size l) l' ≤ 1 ∧ size r = r' ∨ Nat.dist (size r) r' ≤ 1 ∧ size l = l')) :
    Valid' o₁ (@balance' α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H : ∃ l' r', Ordnode.BalancedSz l' r' ∧ (l.size.dist l' ≤ 1 ∧ r.size = r' ∨ r.size.dist r' ≤ 1 ∧ l.size = l'))
Goal: Ordnode.Valid' o₁ (l.balance' x r) o₂
-- Ordnode.Valid'.balance
theorem Valid'.balance {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : ∃ l' r', BalancedSz l' r' ∧
          (Nat.dist (size l) l' ≤ 1 ∧ size r = r' ∨ Nat.dist (size r) r' ≤ 1 ∧ size l = l')) :
    Valid' o₁ (@balance α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H : ∃ l' r', Ordnode.BalancedSz l' r' ∧ (l.size.dist l' ≤ 1 ∧ r.size = r' ∨ r.size.dist r' ≤ 1 ∧ l.size = l'))
Goal: Ordnode.Valid' o₁ (l.balance x r) o₂
-- Ordnode.Valid'.balanceL_aux
theorem Valid'.balanceL_aux {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H₁ : size l = 0 → size r ≤ 1) (H₂ : 1 ≤ size l → 1 ≤ size r → size r ≤ delta * size l)
    (H₃ : 2 * @size α l ≤ 9 * size r + 5 ∨ size l ≤ 3) : Valid' o₁ (@balanceL α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H₁ : l.size = 0 → r.size ≤ 1) (H₂ : 1 ≤ l.size → 1 ≤ r.size → r.size ≤ Ordnode.delta * l.size) (H₃ : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3)
Goal: Ordnode.Valid' o₁ (l.balanceL x r) o₂
-- Ordnode.Valid'.balanceL
theorem Valid'.balanceL {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : (∃ l', Raised l' (size l) ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised (size r) r' ∧ BalancedSz (size l) r') :
    Valid' o₁ (@balanceL α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H :
  (∃ l', Ordnode.Raised l' l.size ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r.size r' ∧ Ordnode.BalancedSz l.size r')
Goal: Ordnode.Valid' o₁ (l.balanceL x r) o₂
-- Ordnode.Valid'.balanceR_aux
theorem Valid'.balanceR_aux {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H₁ : size r = 0 → size l ≤ 1) (H₂ : 1 ≤ size r → 1 ≤ size l → size l ≤ delta * size r)
    (H₃ : 2 * @size α r ≤ 9 * size l + 5 ∨ size r ≤ 3) : Valid' o₁ (@balanceR α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H₁ : r.size = 0 → l.size ≤ 1) (H₂ : 1 ≤ r.size → 1 ≤ l.size → l.size ≤ Ordnode.delta * r.size) (H₃ : 2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3)
Goal: Ordnode.Valid' o₁ (l.balanceR x r) o₂
-- Ordnode.Valid'.balanceR
theorem Valid'.balanceR {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r') :
    Valid' o₁ (@balanceR α l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂) (H :
  (∃ l', Ordnode.Raised l.size l' ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r' r.size ∧ Ordnode.BalancedSz l.size r')
Goal: Ordnode.Valid' o₁ (l.balanceR x r) o₂
-- Ordnode.Valid'.eraseMax_aux
theorem Valid'.eraseMax_aux {s l x r o₁ o₂} (H : Valid' o₁ (.node s l x r) o₂) :
    Valid' o₁ (@eraseMax α (.node' l x r)) ↑(findMax' x r) ∧
      size (.node' l x r) = size (eraseMax (.node' l x r)) + 1 
Arguments: {α : Type u_1} [Preorder α] {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (H : Ordnode.Valid' o₁ (Ordnode.node s l x r) o₂)
Goal: Ordnode.Valid' o₁ (l.node' x r).eraseMax ↑(Ordnode.findMax' x r) ∧ (l.node' x r).size = (l.node' x r).eraseMax.size + 1
-- Ordnode.Valid'.eraseMin_aux
theorem Valid'.eraseMin_aux {s l} {x : α} {r o₁ o₂} (H : Valid' o₁ (.node s l x r) o₂) :
    Valid' ↑(findMin' l x) (@eraseMin α (.node' l x r)) o₂ ∧
      size (.node' l x r) = size (eraseMin (.node' l x r)) + 1 
Arguments: {α : Type u_1} [Preorder α] {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (H : Ordnode.Valid' o₁ (Ordnode.node s l x r) o₂)
Goal: Ordnode.Valid' (↑(l.findMin' x)) (l.node' x r).eraseMin o₂ ∧ (l.node' x r).size = (l.node' x r).eraseMin.size + 1
-- Ordnode.eraseMin.valid
theorem eraseMin.valid : ∀ {t}, @Valid α _ t → Valid (eraseMin t)
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α}
Goal: t.Valid → t.eraseMin.Valid
-- Ordnode.eraseMax.valid
theorem eraseMax.valid {t} (h : @Valid α _ t) : Valid (eraseMax t) 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} (h : t.Valid)
Goal: t.eraseMax.Valid
-- Ordnode.Valid'.glue_aux
theorem Valid'.glue_aux {l r o₁ o₂} (hl : Valid' o₁ l o₂) (hr : Valid' o₁ r o₂)
    (sep : l.All fun x => r.All fun y => x < y) (bal : BalancedSz (size l) (size r)) :
    Valid' o₁ (@glue α l r) o₂ ∧ size (glue l r) = size l + size r 
Arguments: {α : Type u_1} [Preorder α] {l r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l o₂) (hr : Ordnode.Valid' o₁ r o₂) (sep : Ordnode.All (fun x => Ordnode.All (fun y => x < y) r) l) (bal : Ordnode.BalancedSz l.size r.size)
Goal: Ordnode.Valid' o₁ (l.glue r) o₂ ∧ (l.glue r).size = l.size + r.size
-- Ordnode.Valid'.glue
theorem Valid'.glue {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂) :
    BalancedSz (size l) (size r) →
      Valid' o₁ (@glue α l r) o₂ ∧ size (@glue α l r) = size l + size r 
Arguments: {α : Type u_1} [Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l ↑x) (hr : Ordnode.Valid' (↑x) r o₂)
Goal: Ordnode.BalancedSz l.size r.size → Ordnode.Valid' o₁ (l.glue r) o₂ ∧ (l.glue r).size = l.size + r.size
-- Ordnode.Valid'.merge_lemma
theorem Valid'.merge_lemma {a b c : ℕ} (h₁ : 3 * a < b + c + 1) (h₂ : b ≤ 3 * c) :
    2 * (a + b) ≤ 9 * c + 5 
Arguments: {a b c : ℕ} (h₁ : 3 * a < b + c + 1) (h₂ : b ≤ 3 * c)
Goal: 2 * (a + b) ≤ 9 * c + 5
-- Ordnode.Valid'.merge_aux₁
theorem Valid'.merge_aux₁ {o₁ o₂ ls ll lx lr rs rl rx rr t}
    (hl : Valid' o₁ (@Ordnode.node α ls ll lx lr) o₂) (hr : Valid' o₁ (.node rs rl rx rr) o₂)
    (h : delta * ls < rs) (v : Valid' o₁ t rx) (e : size t = ls + size rl) :
    Valid' o₁ (.balanceL t rx rr) o₂ ∧ size (.balanceL t rx rr) = ls + rs 
Arguments: {α : Type u_1} [Preorder α] {o₁ : WithBot α} {o₂ : WithTop α} {ls : ℕ} {ll : Ordnode α} {lx : α} {lr : Ordnode α} {rs : ℕ} {rl : Ordnode α} {rx : α} {rr t : Ordnode α} (hl : Ordnode.Valid' o₁ (Ordnode.node ls ll lx lr) o₂) (hr : Ordnode.Valid' o₁ (Ordnode.node rs rl rx rr) o₂) (h : Ordnode.delta * ls < rs) (v : Ordnode.Valid' o₁ t ↑rx) (e : t.size = ls + rl.size)
Goal: Ordnode.Valid' o₁ (t.balanceL rx rr) o₂ ∧ (t.balanceL rx rr).size = ls + rs
-- Ordnode.Valid'.merge_aux
theorem Valid'.merge_aux {l r o₁ o₂} (hl : Valid' o₁ l o₂) (hr : Valid' o₁ r o₂)
    (sep : l.All fun x => r.All fun y => x < y) :
    Valid' o₁ (@merge α l r) o₂ ∧ size (merge l r) = size l + size r 
Arguments: {α : Type u_1} [Preorder α] {l r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (hl : Ordnode.Valid' o₁ l o₂) (hr : Ordnode.Valid' o₁ r o₂) (sep : Ordnode.All (fun x => Ordnode.All (fun y => x < y) r) l)
Goal: Ordnode.Valid' o₁ (l.merge r) o₂ ∧ (l.merge r).size = l.size + r.size
-- Ordnode.Valid.merge
theorem Valid.merge {l r} (hl : Valid l) (hr : Valid r)
    (sep : l.All fun x => r.All fun y => x < y) : Valid (@merge α l r) 
Arguments: {α : Type u_1} [Preorder α] {l r : Ordnode α} (hl : l.Valid) (hr : r.Valid) (sep : Ordnode.All (fun x => Ordnode.All (fun y => x < y) r) l)
Goal: (l.merge r).Valid
-- Ordnode.insertWith.valid_aux
theorem insertWith.valid_aux [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)] (f : α → α) (x : α)
    (hf : ∀ y, x ≤ y ∧ y ≤ x → x ≤ f y ∧ f y ≤ x) :
    ∀ {t o₁ o₂},
      Valid' o₁ t o₂ →
        Bounded nil o₁ x →
          Bounded nil x o₂ →
            Valid' o₁ (insertWith f x t) o₂ ∧ Raised (size t) (size (insertWith f x t))
  
Arguments: {α : Type u_1} [Preorder α] [IsTotal α fun x x_1 => x ≤ x_1] [DecidableRel fun x x_1 => x ≤ x_1] (f : α → α) (x : α) (hf : ∀ (y : α), x ≤ y ∧ y ≤ x → x ≤ f y ∧ f y ≤ x) {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: Ordnode.Valid' o₁ t o₂ →
  Ordnode.nil.Bounded o₁ ↑x →
    Ordnode.nil.Bounded (↑x) o₂ →
      Ordnode.Valid' o₁ (Ordnode.insertWith f x t) o₂ ∧ Ordnode.Raised t.size (Ordnode.insertWith f x t).size
-- Ordnode.insertWith.valid
theorem insertWith.valid [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)] (f : α → α) (x : α)
    (hf : ∀ y, x ≤ y ∧ y ≤ x → x ≤ f y ∧ f y ≤ x) {t} (h : Valid t) : Valid (insertWith f x t) 
Arguments: {α : Type u_1} [Preorder α] [IsTotal α fun x x_1 => x ≤ x_1] [DecidableRel fun x x_1 => x ≤ x_1] (f : α → α) (x : α) (hf : ∀ (y : α), x ≤ y ∧ y ≤ x → x ≤ f y ∧ f y ≤ x) {t : Ordnode α} (h : t.Valid)
Goal: (Ordnode.insertWith f x t).Valid
-- Ordnode.insert_eq_insertWith
theorem insert_eq_insertWith [@DecidableRel α (· ≤ ·)] (x : α) :
    ∀ t, Ordnode.insert x t = insertWith (fun _ => x) x t
  
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] (x : α) (t : Ordnode α)
Goal: Ordnode.insert x t = Ordnode.insertWith (fun x_1 => x) x t
-- Ordnode.insert.valid
theorem insert.valid [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)] (x : α) {t} (h : Valid t) :
    Valid (Ordnode.insert x t) 
Arguments: {α : Type u_1} [Preorder α] [IsTotal α fun x x_1 => x ≤ x_1] [DecidableRel fun x x_1 => x ≤ x_1] (x : α) {t : Ordnode α} (h : t.Valid)
Goal: (Ordnode.insert x t).Valid
-- Ordnode.insert'_eq_insertWith
theorem insert'_eq_insertWith [@DecidableRel α (· ≤ ·)] (x : α) :
    ∀ t, insert' x t = insertWith id x t
  
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] (x : α) (t : Ordnode α)
Goal: Ordnode.insert' x t = Ordnode.insertWith id x t
-- Ordnode.insert'.valid
theorem insert'.valid [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)] (x : α) {t} (h : Valid t) :
    Valid (insert' x t) 
Arguments: {α : Type u_1} [Preorder α] [IsTotal α fun x x_1 => x ≤ x_1] [DecidableRel fun x x_1 => x ≤ x_1] (x : α) {t : Ordnode α} (h : t.Valid)
Goal: (Ordnode.insert' x t).Valid
-- Ordnode.Valid'.map_aux
theorem Valid'.map_aux {β} [Preorder β] {f : α → β} (f_strict_mono : StrictMono f) {t a₁ a₂}
    (h : Valid' a₁ t a₂) :
    Valid' (Option.map f a₁) (map f t) (Option.map f a₂) ∧ (map f t).size = t.size 
Arguments: {α : Type u_1} [Preorder α] {β : Type u_2} [Preorder β] {f : α → β} (f_strict_mono : StrictMono f) {t : Ordnode α} {a₁ : WithBot α} {a₂ : WithTop α} (h : Ordnode.Valid' a₁ t a₂)
Goal: Ordnode.Valid' (Option.map f a₁) (Ordnode.map f t) (Option.map f a₂) ∧ (Ordnode.map f t).size = t.size
-- Ordnode.map.valid
theorem map.valid {β} [Preorder β] {f : α → β} (f_strict_mono : StrictMono f) {t} (h : Valid t) :
    Valid (map f t) 
Arguments: {α : Type u_1} [Preorder α] {β : Type u_2} [Preorder β] {f : α → β} (f_strict_mono : StrictMono f) {t : Ordnode α} (h : t.Valid)
Goal: (Ordnode.map f t).Valid
-- Ordnode.Valid'.erase_aux
theorem Valid'.erase_aux [@DecidableRel α (· ≤ ·)] (x : α) {t a₁ a₂} (h : Valid' a₁ t a₂) :
    Valid' a₁ (erase x t) a₂ ∧ Raised (erase x t).size t.size 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] (x : α) {t : Ordnode α} {a₁ : WithBot α} {a₂ : WithTop α} (h : Ordnode.Valid' a₁ t a₂)
Goal: Ordnode.Valid' a₁ (Ordnode.erase x t) a₂ ∧ Ordnode.Raised (Ordnode.erase x t).size t.size
-- Ordnode.erase.valid
theorem erase.valid [@DecidableRel α (· ≤ ·)] (x : α) {t} (h : Valid t) : Valid (erase x t) 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] (x : α) {t : Ordnode α} (h : t.Valid)
Goal: (Ordnode.erase x t).Valid
-- Ordnode.size_erase_of_mem
theorem size_erase_of_mem [@DecidableRel α (· ≤ ·)] {x : α} {t a₁ a₂} (h : Valid' a₁ t a₂)
    (h_mem : x ∈ t) : size (erase x t) = size t - 1 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] {x : α} {t : Ordnode α} {a₁ : WithBot α} {a₂ : WithTop α} (h : Ordnode.Valid' a₁ t a₂) (h_mem : x ∈ t)
Goal: (Ordnode.erase x t).size = t.size - 1
-- Ordset.empty_iff
theorem empty_iff {s : Ordset α} : s = ∅ ↔ s.1.empty 
Arguments: {α : Type u_1} [Preorder α] {s : Ordset α}
Goal: s = ∅ ↔ (↑s).empty = true
-- Ordset.pos_size_of_mem
theorem pos_size_of_mem {x : α} {t : Ordset α} (h_mem : x ∈ t) : 0 < size t 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] {x : α} {t : Ordset α} (h_mem : x ∈ t)
Goal: 0 < t.size
-- CauSeq.Completion.ofRat_rat
@[simp]
theorem ofRat_rat {abv : ℚ → ℚ} [IsAbsoluteValue abv] (q : ℚ) :
    ofRat (q : ℚ) = (q : Cauchy abv) 
Arguments: {abv : ℚ → ℚ} [IsAbsoluteValue abv] (q : ℚ)
Goal: CauSeq.Completion.ofRat q = ↑q
-- Real.ext_cauchy_iff
theorem ext_cauchy_iff : ∀ {x y : Real}, x = y ↔ x.cauchy = y.cauchy
  
Arguments: {x y : ℝ}
Goal: x = y ↔ x.cauchy = y.cauchy
-- Real.ext_cauchy
theorem ext_cauchy {x y : Real} : x.cauchy = y.cauchy → x = y 
Arguments: {x y : ℝ}
Goal: x.cauchy = y.cauchy → x = y
-- _private.Mathlib.Data.Real.Basic.0.Real.zero_def
private irreducible_def zero : ℝ 
Goal: Real.zero = { cauchy := 0 }
-- _private.Mathlib.Data.Real.Basic.0.Real.one_def
private irreducible_def one : ℝ 
Goal: Real.one = { cauchy := 1 }
-- _private.Mathlib.Data.Real.Basic.0.Real.add_def
private irreducible_def add : ℝ → ℝ → ℝ
  
Goal: ∀ (x x_1 : ℝ),
  Real.add x x_1 =
    match x, x_1 with
    | { cauchy := a }, { cauchy := b } => { cauchy := a + b }
-- _private.Mathlib.Data.Real.Basic.0.Real.neg_def
private irreducible_def neg : ℝ → ℝ
  
Goal: ∀ (x : ℝ),
  Real.neg x =
    match x with
    | { cauchy := a } => { cauchy := -a }
-- _private.Mathlib.Data.Real.Basic.0.Real.mul_def
private irreducible_def mul : ℝ → ℝ → ℝ
  
Goal: ∀ (x x_1 : ℝ),
  Real.mul x x_1 =
    match x, x_1 with
    | { cauchy := a }, { cauchy := b } => { cauchy := a * b }
-- _private.Mathlib.Data.Real.Basic.0.Real.inv'_def
private noncomputable irreducible_def inv' : ℝ → ℝ
  
Goal: ∀ (x : ℝ),
  Real.inv' x =
    match x with
    | { cauchy := a } => { cauchy := a⁻¹ }
-- Real.ofCauchy_zero
theorem ofCauchy_zero : (⟨0⟩ : ℝ) = 0 
Goal: { cauchy := 0 } = 0
-- Real.ofCauchy_one
theorem ofCauchy_one : (⟨1⟩ : ℝ) = 1 
Goal: { cauchy := 1 } = 1
-- Real.ofCauchy_add
theorem ofCauchy_add (a b) : (⟨a + b⟩ : ℝ) = ⟨a⟩ + ⟨b⟩ 
Arguments: (a b : CauSeq.Completion.Cauchy abs)
Goal: { cauchy := a + b } = { cauchy := a } + { cauchy := b }
-- Real.ofCauchy_neg
theorem ofCauchy_neg (a) : (⟨-a⟩ : ℝ) = -⟨a⟩ 
Arguments: (a : CauSeq.Completion.Cauchy abs)
Goal: { cauchy := -a } = -{ cauchy := a }
-- Real.ofCauchy_sub
theorem ofCauchy_sub (a b) : (⟨a - b⟩ : ℝ) = ⟨a⟩ - ⟨b⟩ 
Arguments: (a b : CauSeq.Completion.Cauchy abs)
Goal: { cauchy := a - b } = { cauchy := a } - { cauchy := b }
-- Real.ofCauchy_mul
theorem ofCauchy_mul (a b) : (⟨a * b⟩ : ℝ) = ⟨a⟩ * ⟨b⟩ 
Arguments: (a b : CauSeq.Completion.Cauchy abs)
Goal: { cauchy := a * b } = { cauchy := a } * { cauchy := b }
-- Real.ofCauchy_inv
theorem ofCauchy_inv {f} : (⟨f⁻¹⟩ : ℝ) = ⟨f⟩⁻¹ 
Arguments: {f : CauSeq.Completion.Cauchy abs}
Goal: { cauchy := f⁻¹ } = { cauchy := f }⁻¹
-- Real.cauchy_zero
theorem cauchy_zero : (0 : ℝ).cauchy = 0 
Goal: Real.cauchy 0 = 0
-- Real.cauchy_one
theorem cauchy_one : (1 : ℝ).cauchy = 1 
Goal: Real.cauchy 1 = 1