ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordnode.all_node'
theorem all_node' {P l x r} : @All α P (node' l x r) ↔ All P l ∧ P x ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α}
Goal: Ordnode.All P (l.node' x r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P r
-- Ordnode.all_node3L
theorem all_node3L {P l x m y r} :
    @All α P (node3L l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α}
Goal: Ordnode.All P (l.node3L x m y r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P m ∧ P y ∧ Ordnode.All P r
-- Ordnode.all_node3R
theorem all_node3R {P l x m y r} :
    @All α P (node3R l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α}
Goal: Ordnode.All P (l.node3R x m y r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P m ∧ P y ∧ Ordnode.All P r
-- Ordnode.all_node4L
theorem all_node4L {P l x m y r} :
    @All α P (node4L l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α}
Goal: Ordnode.All P (l.node4L x m y r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P m ∧ P y ∧ Ordnode.All P r
-- Ordnode.all_node4R
theorem all_node4R {P l x m y r} :
    @All α P (node4R l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α}
Goal: Ordnode.All P (l.node4R x m y r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P m ∧ P y ∧ Ordnode.All P r
-- Ordnode.all_rotateL
theorem all_rotateL {P l x r} : @All α P (rotateL l x r) ↔ All P l ∧ P x ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α}
Goal: Ordnode.All P (l.rotateL x r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P r
-- Ordnode.all_rotateR
theorem all_rotateR {P l x r} : @All α P (rotateR l x r) ↔ All P l ∧ P x ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α}
Goal: Ordnode.All P (l.rotateR x r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P r
-- Ordnode.all_balance'
theorem all_balance' {P l x r} : @All α P (balance' l x r) ↔ All P l ∧ P x ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α}
Goal: Ordnode.All P (l.balance' x r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P r
-- Ordnode.foldr_cons_eq_toList
theorem foldr_cons_eq_toList : ∀ (t : Ordnode α) (r : List α), t.foldr List.cons r = toList t ++ r
  
Arguments: {α : Type u_1} (t : Ordnode α) (r : List α)
Goal: Ordnode.foldr List.cons t r = t.toList ++ r
-- Ordnode.toList_nil
@[simp]
theorem toList_nil : toList (@nil α) = [] 
Arguments: {α : Type u_1}
Goal: Ordnode.nil.toList = []
-- Ordnode.toList_node
@[simp]
theorem toList_node (s l x r) : toList (@node α s l x r) = toList l ++ x :: toList r 
Arguments: {α : Type u_1} (s : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: (Ordnode.node s l x r).toList = l.toList ++ x :: r.toList
-- Ordnode.emem_iff_mem_toList
theorem emem_iff_mem_toList {x : α} {t} : Emem x t ↔ x ∈ toList t 
Arguments: {α : Type u_1} {x : α} {t : Ordnode α}
Goal: Ordnode.Emem x t ↔ x ∈ t.toList
-- Ordnode.length_toList'
theorem length_toList' : ∀ t : Ordnode α, (toList t).length = t.realSize
  
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.toList.length = t.realSize
-- Ordnode.length_toList
theorem length_toList {t : Ordnode α} (h : Sized t) : (toList t).length = t.size 
Arguments: {α : Type u_1} {t : Ordnode α} (h : t.Sized)
Goal: t.toList.length = t.size
-- Ordnode.equiv_iff
theorem equiv_iff {t₁ t₂ : Ordnode α} (h₁ : Sized t₁) (h₂ : Sized t₂) :
    Equiv t₁ t₂ ↔ toList t₁ = toList t₂ 
Arguments: {α : Type u_1} {t₁ t₂ : Ordnode α} (h₁ : t₁.Sized) (h₂ : t₂.Sized)
Goal: t₁.Equiv t₂ ↔ t₁.toList = t₂.toList
-- Ordnode.pos_size_of_mem
theorem pos_size_of_mem [LE α] [@DecidableRel α (· ≤ ·)] {x : α} {t : Ordnode α} (h : Sized t)
    (h_mem : x ∈ t) : 0 < size t 
Arguments: {α : Type u_1} [LE α] [DecidableRel fun x x_1 => x ≤ x_1] {x : α} {t : Ordnode α} (h : t.Sized) (h_mem : x ∈ t)
Goal: 0 < t.size
-- Ordnode.findMin'_dual
theorem findMin'_dual : ∀ (t) (x : α), findMin' (dual t) x = findMax' x t
  
Arguments: {α : Type u_1} (t : Ordnode α) (x : α)
Goal: t.dual.findMin' x = Ordnode.findMax' x t
-- Ordnode.findMax'_dual
theorem findMax'_dual (t) (x : α) : findMax' x (dual t) = findMin' t x 
Arguments: {α : Type u_1} (t : Ordnode α) (x : α)
Goal: Ordnode.findMax' x t.dual = t.findMin' x
-- Ordnode.findMin_dual
theorem findMin_dual : ∀ t : Ordnode α, findMin (dual t) = findMax t
  
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.dual.findMin = t.findMax
-- Ordnode.findMax_dual
theorem findMax_dual (t : Ordnode α) : findMax (dual t) = findMin t 
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.dual.findMax = t.findMin
-- Ordnode.dual_eraseMin
theorem dual_eraseMin : ∀ t : Ordnode α, dual (eraseMin t) = eraseMax (dual t)
  
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.eraseMin.dual = t.dual.eraseMax
-- Ordnode.dual_eraseMax
theorem dual_eraseMax (t : Ordnode α) : dual (eraseMax t) = eraseMin (dual t) 
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.eraseMax.dual = t.dual.eraseMin
-- Ordnode.splitMin_eq
theorem splitMin_eq :
    ∀ (s l) (x : α) (r), splitMin' l x r = (findMin' l x, eraseMin (node s l x r))
  
Arguments: {α : Type u_1} (s : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: l.splitMin' x r = (l.findMin' x, (Ordnode.node s l x r).eraseMin)
-- Ordnode.splitMax_eq
theorem splitMax_eq :
    ∀ (s l) (x : α) (r), splitMax' l x r = (eraseMax (node s l x r), findMax' x r)
  
Arguments: {α : Type u_1} (s : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: l.splitMax' x r = ((Ordnode.node s l x r).eraseMax, Ordnode.findMax' x r)
-- Ordnode.findMin'_all
theorem findMin'_all {P : α → Prop} : ∀ (t) (x : α), All P t → P x → P (findMin' t x)
  
Arguments: {α : Type u_1} {P : α → Prop} (t : Ordnode α) (x : α)
Goal: Ordnode.All P t → P x → P (t.findMin' x)
-- Ordnode.findMax'_all
theorem findMax'_all {P : α → Prop} : ∀ (x : α) (t), P x → All P t → P (findMax' x t)
  
Arguments: {α : Type u_1} {P : α → Prop} (x : α) (t : Ordnode α)
Goal: P x → Ordnode.All P t → P (Ordnode.findMax' x t)
-- Ordnode.merge_nil_left
@[simp]
theorem merge_nil_left (t : Ordnode α) : merge t nil = t 
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.merge Ordnode.nil = t
-- Ordnode.merge_nil_right
@[simp]
theorem merge_nil_right (t : Ordnode α) : merge nil t = t 
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: Ordnode.nil.merge t = t
-- Ordnode.merge_node
@[simp]
theorem merge_node {ls ll lx lr rs rl rx rr} :
    merge (@node α ls ll lx lr) (node rs rl rx rr) =
      if delta * ls < rs then balanceL (merge (node ls ll lx lr) rl) rx rr
      else if delta * rs < ls then balanceR ll lx (merge lr (node rs rl rx rr))
      else glue (node ls ll lx lr) (node rs rl rx rr) 
Arguments: {α : Type u_1} {ls : ℕ} {ll : Ordnode α} {lx : α} {lr : Ordnode α} {rs : ℕ} {rl : Ordnode α} {rx : α} {rr : Ordnode α}
Goal: (Ordnode.node ls ll lx lr).merge (Ordnode.node rs rl rx rr) =
  if Ordnode.delta * ls < rs then ((Ordnode.node ls ll lx lr).merge rl).balanceL rx rr
  else
    if Ordnode.delta * rs < ls then ll.balanceR lx (lr.merge (Ordnode.node rs rl rx rr))
    else (Ordnode.node ls ll lx lr).glue (Ordnode.node rs rl rx rr)
-- Ordnode.dual_insert
theorem dual_insert [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)] (x : α) :
    ∀ t : Ordnode α, dual (Ordnode.insert x t) = @Ordnode.insert αᵒᵈ _ _ x (dual 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 α)
Goal: (Ordnode.insert x t).dual = Ordnode.insert x t.dual
-- Ordnode.balance_eq_balance'
theorem balance_eq_balance' {l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l)
    (sr : Sized r) : @balance α l x r = balance' l x r 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Balanced) (hr : r.Balanced) (sl : l.Sized) (sr : r.Sized)
Goal: l.balance x r = l.balance' x r
-- Ordnode.balanceL_eq_balance
theorem balanceL_eq_balance {l x r} (sl : Sized l) (sr : Sized r) (H1 : size l = 0 → size r ≤ 1)
    (H2 : 1 ≤ size l → 1 ≤ size r → size r ≤ delta * size l) :
    @balanceL α l x r = balance l x r 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (sl : l.Sized) (sr : r.Sized) (H1 : l.size = 0 → r.size ≤ 1) (H2 : 1 ≤ l.size → 1 ≤ r.size → r.size ≤ Ordnode.delta * l.size)
Goal: l.balanceL x r = l.balance x r
-- Ordnode.raised_iff
theorem raised_iff {n m} : Raised n m ↔ n ≤ m ∧ m ≤ n + 1 
Arguments: {n m : ℕ}
Goal: Ordnode.Raised n m ↔ n ≤ m ∧ m ≤ n + 1
-- Ordnode.Raised.dist_le
theorem Raised.dist_le {n m} (H : Raised n m) : Nat.dist n m ≤ 1 
Arguments: {n m : ℕ} (H : Ordnode.Raised n m)
Goal: n.dist m ≤ 1
-- Ordnode.Raised.dist_le'
theorem Raised.dist_le' {n m} (H : Raised n m) : Nat.dist m n ≤ 1 
Arguments: {n m : ℕ} (H : Ordnode.Raised n m)
Goal: m.dist n ≤ 1
-- Ordnode.Raised.add_left
theorem Raised.add_left (k) {n m} (H : Raised n m) : Raised (k + n) (k + m) 
Arguments: (k : ℕ) {n m : ℕ} (H : Ordnode.Raised n m)
Goal: Ordnode.Raised (k + n) (k + m)
-- Ordnode.Raised.add_right
theorem Raised.add_right (k) {n m} (H : Raised n m) : Raised (n + k) (m + k) 
Arguments: (k : ℕ) {n m : ℕ} (H : Ordnode.Raised n m)
Goal: Ordnode.Raised (n + k) (m + k)
-- Ordnode.Raised.right
theorem Raised.right {l x₁ x₂ r₁ r₂} (H : Raised (size r₁) (size r₂)) :
    Raised (size (@node' α l x₁ r₁)) (size (@node' α l x₂ r₂)) 
Arguments: {α : Type u_1} {l : Ordnode α} {x₁ x₂ : α} {r₁ r₂ : Ordnode α} (H : Ordnode.Raised r₁.size r₂.size)
Goal: Ordnode.Raised (l.node' x₁ r₁).size (l.node' x₂ r₂).size
-- Ordnode.balanceL_eq_balance'
theorem balanceL_eq_balance' {l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l)
    (sr : Sized r)
    (H :
      (∃ l', Raised l' (size l) ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised (size r) r' ∧ BalancedSz (size l) r') :
    @balanceL α l x r = balance' l x r 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Balanced) (hr : r.Balanced) (sl : l.Sized) (sr : r.Sized) (H :
  (∃ l', Ordnode.Raised l' l.size ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r.size r' ∧ Ordnode.BalancedSz l.size r')
Goal: l.balanceL x r = l.balance' x r
-- Ordnode.balance_sz_dual
theorem balance_sz_dual {l r}
    (H : (∃ l', Raised (@size α l) l' ∧ BalancedSz l' (@size α r)) ∨
        ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r') :
    (∃ l', Raised l' (size (dual r)) ∧ BalancedSz l' (size (dual l))) ∨
      ∃ r', Raised (size (dual l)) r' ∧ BalancedSz (size (dual r)) r' 
Arguments: {α : Type u_1} {l r : Ordnode α} (H :
  (∃ l', Ordnode.Raised l.size l' ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r' r.size ∧ Ordnode.BalancedSz l.size r')
Goal: (∃ l', Ordnode.Raised l' r.dual.size ∧ Ordnode.BalancedSz l' l.dual.size) ∨
  ∃ r', Ordnode.Raised l.dual.size r' ∧ Ordnode.BalancedSz r.dual.size r'
-- Ordnode.size_balanceL
theorem size_balanceL {l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
    (H : (∃ l', Raised l' (size l) ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised (size r) r' ∧ BalancedSz (size l) r') :
    size (@balanceL α l x r) = size l + size r + 1 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Balanced) (hr : r.Balanced) (sl : l.Sized) (sr : r.Sized) (H :
  (∃ l', Ordnode.Raised l' l.size ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r.size r' ∧ Ordnode.BalancedSz l.size r')
Goal: (l.balanceL x r).size = l.size + r.size + 1
-- Ordnode.all_balanceL
theorem all_balanceL {P l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
    (H :
      (∃ l', Raised l' (size l) ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised (size r) r' ∧ BalancedSz (size l) r') :
    All P (@balanceL α l x r) ↔ All P l ∧ P x ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Balanced) (hr : r.Balanced) (sl : l.Sized) (sr : r.Sized) (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.All P (l.balanceL x r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P r
-- Ordnode.balanceR_eq_balance'
theorem balanceR_eq_balance' {l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l)
    (sr : Sized r)
    (H : (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r') :
    @balanceR α l x r = balance' l x r 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Balanced) (hr : r.Balanced) (sl : l.Sized) (sr : r.Sized) (H :
  (∃ l', Ordnode.Raised l.size l' ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r' r.size ∧ Ordnode.BalancedSz l.size r')
Goal: l.balanceR x r = l.balance' x r
-- Ordnode.size_balanceR
theorem size_balanceR {l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
    (H : (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r') :
    size (@balanceR α l x r) = size l + size r + 1 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Balanced) (hr : r.Balanced) (sl : l.Sized) (sr : r.Sized) (H :
  (∃ l', Ordnode.Raised l.size l' ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r' r.size ∧ Ordnode.BalancedSz l.size r')
Goal: (l.balanceR x r).size = l.size + r.size + 1
-- Ordnode.all_balanceR
theorem all_balanceR {P l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
    (H :
      (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r') :
    All P (@balanceR α l x r) ↔ All P l ∧ P x ∧ All P r 
Arguments: {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Balanced) (hr : r.Balanced) (sl : l.Sized) (sr : r.Sized) (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.All P (l.balanceR x r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P r
-- Ordnode.Bounded.dual
theorem Bounded.dual :
    ∀ {t : Ordnode α} {o₁ o₂}, Bounded t o₁ o₂ → @Bounded αᵒᵈ _ (dual t) o₂ o₁
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: t.Bounded o₁ o₂ → t.dual.Bounded o₂ o₁
-- Ordnode.Bounded.dual_iff
theorem Bounded.dual_iff {t : Ordnode α} {o₁ o₂} :
    Bounded t o₁ o₂ ↔ @Bounded αᵒᵈ _ (.dual t) o₂ o₁ 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: t.Bounded o₁ o₂ ↔ t.dual.Bounded o₂ o₁
-- Ordnode.Bounded.weak_left
theorem Bounded.weak_left : ∀ {t : Ordnode α} {o₁ o₂}, Bounded t o₁ o₂ → Bounded t ⊥ o₂
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: t.Bounded o₁ o₂ → t.Bounded ⊥ o₂
-- Ordnode.Bounded.weak_right
theorem Bounded.weak_right : ∀ {t : Ordnode α} {o₁ o₂}, Bounded t o₁ o₂ → Bounded t o₁ ⊤
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: t.Bounded o₁ o₂ → t.Bounded o₁ ⊤
-- Ordnode.Bounded.weak
theorem Bounded.weak {t : Ordnode α} {o₁ o₂} (h : Bounded t o₁ o₂) : Bounded t ⊥ ⊤ 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (h : t.Bounded o₁ o₂)
Goal: t.Bounded ⊥ ⊤
-- Ordnode.Bounded.mono_left
theorem Bounded.mono_left {x y : α} (xy : x ≤ y) :
    ∀ {t : Ordnode α} {o}, Bounded t y o → Bounded t x o
  
Arguments: {α : Type u_1} [Preorder α] {x y : α} (xy : x ≤ y) {t : Ordnode α} {o : WithTop α}
Goal: t.Bounded (↑y) o → t.Bounded (↑x) o
-- Ordnode.Bounded.mono_right
theorem Bounded.mono_right {x y : α} (xy : x ≤ y) :
    ∀ {t : Ordnode α} {o}, Bounded t o x → Bounded t o y
  
Arguments: {α : Type u_1} [Preorder α] {x y : α} (xy : x ≤ y) {t : Ordnode α} {o : WithBot α}
Goal: t.Bounded o ↑x → t.Bounded o ↑y
-- Ordnode.Bounded.to_lt
theorem Bounded.to_lt : ∀ {t : Ordnode α} {x y : α}, Bounded t x y → x < y
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {x y : α}
Goal: t.Bounded ↑x ↑y → x < y
-- Ordnode.Bounded.to_nil
theorem Bounded.to_nil {t : Ordnode α} : ∀ {o₁ o₂}, Bounded t o₁ o₂ → Bounded nil o₁ o₂
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: t.Bounded o₁ o₂ → Ordnode.nil.Bounded o₁ o₂
-- Ordnode.Bounded.trans_left
theorem Bounded.trans_left {t₁ t₂ : Ordnode α} {x : α} :
    ∀ {o₁ o₂}, Bounded t₁ o₁ x → Bounded t₂ x o₂ → Bounded t₂ o₁ o₂
  
Arguments: {α : Type u_1} [Preorder α] {t₁ t₂ : Ordnode α} {x : α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: t₁.Bounded o₁ ↑x → t₂.Bounded (↑x) o₂ → t₂.Bounded o₁ o₂
-- Ordnode.Bounded.trans_right
theorem Bounded.trans_right {t₁ t₂ : Ordnode α} {x : α} :
    ∀ {o₁ o₂}, Bounded t₁ o₁ x → Bounded t₂ x o₂ → Bounded t₁ o₁ o₂
  
Arguments: {α : Type u_1} [Preorder α] {t₁ t₂ : Ordnode α} {x : α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: t₁.Bounded o₁ ↑x → t₂.Bounded (↑x) o₂ → t₁.Bounded o₁ o₂
-- Ordnode.Bounded.mem_lt
theorem Bounded.mem_lt : ∀ {t o} {x : α}, Bounded t o x → All (· < x) t
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o : WithBot α} {x : α}
Goal: t.Bounded o ↑x → Ordnode.All (fun x_1 => x_1 < x) t
-- Ordnode.Bounded.mem_gt
theorem Bounded.mem_gt : ∀ {t o} {x : α}, Bounded t x o → All (· > x) t
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o : WithTop α} {x : α}
Goal: t.Bounded (↑x) o → Ordnode.All (fun x_1 => x_1 > x) t
-- Ordnode.Bounded.of_lt
theorem Bounded.of_lt :
    ∀ {t o₁ o₂} {x : α}, Bounded t o₁ o₂ → Bounded nil o₁ x → All (· < x) t → Bounded t o₁ x
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} {x : α}
Goal: t.Bounded o₁ o₂ → Ordnode.nil.Bounded o₁ ↑x → Ordnode.All (fun x_1 => x_1 < x) t → t.Bounded o₁ ↑x
-- Ordnode.Bounded.of_gt
theorem Bounded.of_gt :
    ∀ {t o₁ o₂} {x : α}, Bounded t o₁ o₂ → Bounded nil x o₂ → All (· > x) t → Bounded t x o₂
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} {x : α}
Goal: t.Bounded o₁ o₂ → Ordnode.nil.Bounded (↑x) o₂ → Ordnode.All (fun x_1 => x_1 > x) t → t.Bounded (↑x) o₂
-- Ordnode.Bounded.to_sep
theorem Bounded.to_sep {t₁ t₂ o₁ o₂} {x : α}
    (h₁ : Bounded t₁ o₁ (x : WithTop α)) (h₂ : Bounded t₂ (x : WithBot α) o₂) :
    t₁.All fun y => t₂.All fun z : α => y < z 
Arguments: {α : Type u_1} [Preorder α] {t₁ t₂ : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} {x : α} (h₁ : t₁.Bounded o₁ ↑x) (h₂ : t₂.Bounded (↑x) o₂)
Goal: Ordnode.All (fun y => Ordnode.All (fun z => y < z) t₂) t₁
-- Ordnode.Valid'.ord
structure Valid' (lo : WithBot α) (t : Ordnode α) (hi : WithTop α) : Prop where
  ord : t.Bounded lo hi
  sz : t.Sized
  bal : t.Balanced
Arguments: {α : Type u_1} [Preorder α] {lo : WithBot α} {t : Ordnode α} {hi : WithTop α} (self : Ordnode.Valid' lo t hi)
Goal: t.Bounded lo hi
-- Ordnode.Valid'.bal
structure Valid' (lo : WithBot α) (t : Ordnode α) (hi : WithTop α) : Prop where
  ord : t.Bounded lo hi
  sz : t.Sized
  bal : t.Balanced
Arguments: {α : Type u_1} [Preorder α] {lo : WithBot α} {t : Ordnode α} {hi : WithTop α} (self : Ordnode.Valid' lo t hi)
Goal: t.Balanced
-- Ordnode.Valid'.sz
structure Valid' (lo : WithBot α) (t : Ordnode α) (hi : WithTop α) : Prop where
  ord : t.Bounded lo hi
  sz : t.Sized
  bal : t.Balanced
Arguments: {α : Type u_1} [Preorder α] {lo : WithBot α} {t : Ordnode α} {hi : WithTop α} (self : Ordnode.Valid' lo t hi)
Goal: t.Sized
-- Ordnode.Valid'.mono_left
theorem Valid'.mono_left {x y : α} (xy : x ≤ y) {t : Ordnode α} {o} (h : Valid' y t o) :
    Valid' x t o 
Arguments: {α : Type u_1} [Preorder α] {x y : α} (xy : x ≤ y) {t : Ordnode α} {o : WithTop α} (h : Ordnode.Valid' (↑y) t o)
Goal: Ordnode.Valid' (↑x) t o
-- Ordnode.Valid'.mono_right
theorem Valid'.mono_right {x y : α} (xy : x ≤ y) {t : Ordnode α} {o} (h : Valid' o t x) :
    Valid' o t y 
Arguments: {α : Type u_1} [Preorder α] {x y : α} (xy : x ≤ y) {t : Ordnode α} {o : WithBot α} (h : Ordnode.Valid' o t ↑x)
Goal: Ordnode.Valid' o t ↑y
-- Ordnode.Valid'.trans_left
theorem Valid'.trans_left {t₁ t₂ : Ordnode α} {x : α} {o₁ o₂} (h : Bounded t₁ o₁ x)
    (H : Valid' x t₂ o₂) : Valid' o₁ t₂ o₂ 
Arguments: {α : Type u_1} [Preorder α] {t₁ t₂ : Ordnode α} {x : α} {o₁ : WithBot α} {o₂ : WithTop α} (h : t₁.Bounded o₁ ↑x) (H : Ordnode.Valid' (↑x) t₂ o₂)
Goal: Ordnode.Valid' o₁ t₂ o₂
-- Ordnode.Valid'.trans_right
theorem Valid'.trans_right {t₁ t₂ : Ordnode α} {x : α} {o₁ o₂} (H : Valid' o₁ t₁ x)
    (h : Bounded t₂ x o₂) : Valid' o₁ t₁ o₂ 
Arguments: {α : Type u_1} [Preorder α] {t₁ t₂ : Ordnode α} {x : α} {o₁ : WithBot α} {o₂ : WithTop α} (H : Ordnode.Valid' o₁ t₁ ↑x) (h : t₂.Bounded (↑x) o₂)
Goal: Ordnode.Valid' o₁ t₁ o₂
-- Ordnode.Valid'.of_lt
theorem Valid'.of_lt {t : Ordnode α} {x : α} {o₁ o₂} (H : Valid' o₁ t o₂) (h₁ : Bounded nil o₁ x)
    (h₂ : All (· < x) t) : Valid' o₁ t x 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {x : α} {o₁ : WithBot α} {o₂ : WithTop α} (H : Ordnode.Valid' o₁ t o₂) (h₁ : Ordnode.nil.Bounded o₁ ↑x) (h₂ : Ordnode.All (fun x_1 => x_1 < x) t)
Goal: Ordnode.Valid' o₁ t ↑x
-- Ordnode.Valid'.of_gt
theorem Valid'.of_gt {t : Ordnode α} {x : α} {o₁ o₂} (H : Valid' o₁ t o₂) (h₁ : Bounded nil x o₂)
    (h₂ : All (· > x) t) : Valid' x t o₂ 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {x : α} {o₁ : WithBot α} {o₂ : WithTop α} (H : Ordnode.Valid' o₁ t o₂) (h₁ : Ordnode.nil.Bounded (↑x) o₂) (h₂ : Ordnode.All (fun x_1 => x_1 > x) t)
Goal: Ordnode.Valid' (↑x) t o₂
-- Ordnode.Valid'.valid
theorem Valid'.valid {t o₁ o₂} (h : @Valid' α _ o₁ t o₂) : Valid t 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α} (h : Ordnode.Valid' o₁ t o₂)
Goal: t.Valid
-- Ordnode.valid'_nil
theorem valid'_nil {o₁ o₂} (h : Bounded nil o₁ o₂) : Valid' o₁ (@nil α) o₂ 
Arguments: {α : Type u_1} [Preorder α] {o₁ : WithBot α} {o₂ : WithTop α} (h : Ordnode.nil.Bounded o₁ o₂)
Goal: Ordnode.Valid' o₁ Ordnode.nil o₂
-- Ordnode.valid_nil
theorem valid_nil : Valid (@nil α) 
Arguments: {α : Type u_1} [Preorder α]
Goal: Ordnode.nil.Valid
-- Ordnode.Valid'.node
theorem Valid'.node {s l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : BalancedSz (size l) (size r)) (hs : s = size l + size r + 1) :
    Valid' o₁ (@node α s l x r) o₂ 
Arguments: {α : Type u_1} [Preorder α] {s : ℕ} {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) (hs : s = l.size + r.size + 1)
Goal: Ordnode.Valid' o₁ (Ordnode.node s l x r) o₂
-- Ordnode.Valid'.dual
theorem Valid'.dual : ∀ {t : Ordnode α} {o₁ o₂}, Valid' o₁ t o₂ → @Valid' αᵒᵈ _ o₂ (dual t) o₁
  
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: Ordnode.Valid' o₁ t o₂ → Ordnode.Valid' o₂ t.dual o₁
-- Ordnode.Valid'.dual_iff
theorem Valid'.dual_iff {t : Ordnode α} {o₁ o₂} : Valid' o₁ t o₂ ↔ @Valid' αᵒᵈ _ o₂ (.dual t) o₁ 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α}
Goal: Ordnode.Valid' o₁ t o₂ ↔ Ordnode.Valid' o₂ t.dual o₁
-- Ordnode.Valid.dual
theorem Valid.dual {t : Ordnode α} : Valid t → @Valid αᵒᵈ _ (.dual t) 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α}
Goal: t.Valid → t.dual.Valid
-- Ordnode.Valid.dual_iff
theorem Valid.dual_iff {t : Ordnode α} : Valid t ↔ @Valid αᵒᵈ _ (.dual t) 
Arguments: {α : Type u_1} [Preorder α] {t : Ordnode α}
Goal: t.Valid ↔ t.dual.Valid
-- Ordnode.Valid'.left
theorem Valid'.left {s l x r o₁ o₂} (H : Valid' o₁ (@Ordnode.node α s l x r) o₂) : Valid' o₁ l x 
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 ↑x
-- Ordnode.Valid'.right
theorem Valid'.right {s l x r o₁ o₂} (H : Valid' o₁ (@Ordnode.node α s l x r) o₂) : Valid' x r o₂ 
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' (↑x) r o₂