ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SignType.nonpos_iff_ne_one
theorem nonpos_iff_ne_one {a : SignType} : a ≤ 0 ↔ a ≠ 1 
Arguments: {a : SignType}
Goal: a ≤ 0 ↔ a ≠ 1
-- SignType.lt_one_iff
theorem lt_one_iff {a : SignType} : a < 1 ↔ a ≤ 0 
Arguments: {a : SignType}
Goal: a < 1 ↔ a ≤ 0
-- SignType.neg_iff
@[simp]
theorem neg_iff {a : SignType} : a < 0 ↔ a = -1 
Arguments: {a : SignType}
Goal: a < 0 ↔ a = -1
-- SignType.le_neg_one_iff
@[simp]
theorem le_neg_one_iff {a : SignType} : a ≤ -1 ↔ a = -1 
Arguments: {a : SignType}
Goal: a ≤ -1 ↔ a = -1
-- SignType.pos_iff
@[simp]
theorem pos_iff {a : SignType} : 0 < a ↔ a = 1 
Arguments: {a : SignType}
Goal: 0 < a ↔ a = 1
-- SignType.one_le_iff
@[simp]
theorem one_le_iff {a : SignType} : 1 ≤ a ↔ a = 1 
Arguments: {a : SignType}
Goal: 1 ≤ a ↔ a = 1
-- SignType.neg_one_le
@[simp]
theorem neg_one_le (a : SignType) : -1 ≤ a 
Arguments: (a : SignType)
Goal: -1 ≤ a
-- SignType.le_one
@[simp]
theorem le_one (a : SignType) : a ≤ 1 
Arguments: (a : SignType)
Goal: a ≤ 1
-- SignType.not_lt_neg_one
@[simp]
theorem not_lt_neg_one (a : SignType) : ¬a < -1 
Arguments: (a : SignType)
Goal: ¬a < -1
-- SignType.not_one_lt
@[simp]
theorem not_one_lt (a : SignType) : ¬1 < a 
Arguments: (a : SignType)
Goal: ¬1 < a
-- SignType.self_eq_neg_iff
@[simp]
theorem self_eq_neg_iff (a : SignType) : a = -a ↔ a = 0 
Arguments: (a : SignType)
Goal: a = -a ↔ a = 0
-- SignType.neg_eq_self_iff
@[simp]
theorem neg_eq_self_iff (a : SignType) : -a = a ↔ a = 0 
Arguments: (a : SignType)
Goal: -a = a ↔ a = 0
-- SignType.neg_one_lt_one
@[simp]
theorem neg_one_lt_one : (-1 : SignType) < 1 
Goal: -1 < 1
-- SignType.map_cast'
lemma map_cast' {β : Type*} [One β] [Neg β] [Zero β]
    (f : α → β) (h₁ : f 1 = 1) (h₂ : f 0 = 0) (h₃ : f (-1) = -1) (s : SignType) :
    f s = s 
Arguments: {α : Type u_1} [Zero α] [One α] [Neg α] {β : Type u_2} [One β] [Neg β] [Zero β] (f : α → β) (h₁ : f 1 = 1) (h₂ : f 0 = 0) (h₃ : f (-1) = -1) (s : SignType)
Goal: f ↑s = ↑s
-- SignType.map_cast
lemma map_cast {α β F : Type*} [AddGroupWithOne α] [One β] [SubtractionMonoid β]
    [FunLike F α β] [AddMonoidHomClass F α β] [OneHomClass F α β] (f : F) (s : SignType) :
    f s = s 
Arguments: {α : Type u_2} {β : Type u_3} {F : Type u_4} [AddGroupWithOne α] [One β] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] [OneHomClass F α β] (f : F) (s : SignType)
Goal: f ↑s = ↑s
-- SignType.coe_zero
@[simp]
theorem coe_zero : ↑(0 : SignType) = (0 : α) 
Arguments: {α : Type u_1} [Zero α] [One α] [Neg α]
Goal: ↑0 = 0
-- SignType.coe_one
@[simp]
theorem coe_one : ↑(1 : SignType) = (1 : α) 
Arguments: {α : Type u_1} [Zero α] [One α] [Neg α]
Goal: ↑1 = 1
-- SignType.coe_neg_one
@[simp]
theorem coe_neg_one : ↑(-1 : SignType) = (-1 : α) 
Arguments: {α : Type u_1} [Zero α] [One α] [Neg α]
Goal: ↑(-1) = -1
-- SignType.coe_neg
@[simp, norm_cast]
lemma coe_neg {α : Type*} [One α] [SubtractionMonoid α] (s : SignType) :
    (↑(-s) : α) = -↑s 
Arguments: {α : Type u_2} [One α] [SubtractionMonoid α] (s : SignType)
Goal: ↑(-s) = -↑s
-- SignType.intCast_cast
@[simp, norm_cast]
lemma intCast_cast {α : Type*} [AddGroupWithOne α] (s : SignType) : ((s : ℤ) : α) = s 
Arguments: {α : Type u_2} [AddGroupWithOne α] (s : SignType)
Goal: ↑↑s = ↑s
-- SignType.castHom_apply
@[simps]
def castHom {α} [MulZeroOneClass α] [HasDistribNeg α] : SignType →*₀ α 
Arguments: {α : Type u_1} [MulZeroOneClass α] [HasDistribNeg α]
Goal: ∀ (a : SignType), SignType.castHom a = ↑a
-- SignType.univ_eq
theorem univ_eq : (Finset.univ : Finset SignType) = {0, -1, 1} 
Goal: Finset.univ = {0, -1, 1}
-- SignType.range_eq
theorem range_eq {α} (f : SignType → α) : Set.range f = {f zero, f neg, f pos} 
Arguments: {α : Type u_1} (f : SignType → α)
Goal: Set.range f = {f SignType.zero, f SignType.neg, f SignType.pos}
-- SignType.coe_mul
@[simp, norm_cast] lemma coe_mul {α} [MulZeroOneClass α] [HasDistribNeg α] (a b : SignType) :
    ↑(a * b) = (a : α) * b 
Arguments: {α : Type u_1} [MulZeroOneClass α] [HasDistribNeg α] (a b : SignType)
Goal: ↑(a * b) = ↑a * ↑b
-- SignType.coe_pow
@[simp, norm_cast] lemma coe_pow {α} [MonoidWithZero α] [HasDistribNeg α] (a : SignType) (k : ℕ) :
    ↑(a ^ k) = (a : α) ^ k 
Arguments: {α : Type u_1} [MonoidWithZero α] [HasDistribNeg α] (a : SignType) (k : ℕ)
Goal: ↑(a ^ k) = ↑a ^ k
-- SignType.coe_zpow
@[simp, norm_cast] lemma coe_zpow {α} [GroupWithZero α] [HasDistribNeg α] (a : SignType) (k : ℤ) :
    ↑(a ^ k) = (a : α) ^ k 
Arguments: {α : Type u_1} [GroupWithZero α] [HasDistribNeg α] (a : SignType) (k : ℤ)
Goal: ↑(a ^ k) = ↑a ^ k
-- sign_apply
theorem sign_apply : sign a = ite (0 < a) 1 (ite (a < 0) (-1) 0) 
Arguments: {α : Type u_1} [Zero α] [Preorder α] [DecidableRel fun x x_1 => x < x_1] {a : α}
Goal: SignType.sign a = if 0 < a then 1 else if a < 0 then -1 else 0
-- sign_zero
@[simp]
theorem sign_zero : sign (0 : α) = 0 
Arguments: {α : Type u_1} [Zero α] [Preorder α] [DecidableRel fun x x_1 => x < x_1]
Goal: SignType.sign 0 = 0
-- sign_pos
@[simp]
theorem sign_pos (ha : 0 < a) : sign a = 1 
Arguments: {α : Type u_1} [Zero α] [Preorder α] [DecidableRel fun x x_1 => x < x_1] {a : α} (ha : 0 < a)
Goal: SignType.sign a = 1
-- sign_neg
@[simp]
theorem sign_neg (ha : a < 0) : sign a = -1 
Arguments: {α : Type u_1} [Zero α] [Preorder α] [DecidableRel fun x x_1 => x < x_1] {a : α} (ha : a < 0)
Goal: SignType.sign a = -1
-- sign_eq_one_iff
theorem sign_eq_one_iff : sign a = 1 ↔ 0 < a 
Arguments: {α : Type u_1} [Zero α] [Preorder α] [DecidableRel fun x x_1 => x < x_1] {a : α}
Goal: SignType.sign a = 1 ↔ 0 < a
-- sign_eq_neg_one_iff
theorem sign_eq_neg_one_iff : sign a = -1 ↔ a < 0 
Arguments: {α : Type u_1} [Zero α] [Preorder α] [DecidableRel fun x x_1 => x < x_1] {a : α}
Goal: SignType.sign a = -1 ↔ a < 0
-- StrictMono.sign_comp
lemma StrictMono.sign_comp {β F : Type*} [Zero β] [Preorder β] [DecidableRel ((· < ·) : β → β → _)]
    [FunLike F α β] [ZeroHomClass F α β] {f : F} (hf : StrictMono f) (a : α) :
    sign (f a) = sign a 
Arguments: {α : Type u_1} [Zero α] [LinearOrder α] {β : Type u_2} {F : Type u_3} [Zero β] [Preorder β] [DecidableRel fun x x_1 => x < x_1] [FunLike F α β] [ZeroHomClass F α β] {f : F} (hf : StrictMono ⇑f) (a : α)
Goal: SignType.sign (f a) = SignType.sign a
-- sign_eq_zero_iff
@[simp]
theorem sign_eq_zero_iff : sign a = 0 ↔ a = 0 
Arguments: {α : Type u_1} [Zero α] [LinearOrder α] {a : α}
Goal: SignType.sign a = 0 ↔ a = 0
-- sign_ne_zero
theorem sign_ne_zero : sign a ≠ 0 ↔ a ≠ 0 
Arguments: {α : Type u_1} [Zero α] [LinearOrder α] {a : α}
Goal: SignType.sign a ≠ 0 ↔ a ≠ 0
-- sign_nonneg_iff
@[simp]
theorem sign_nonneg_iff : 0 ≤ sign a ↔ 0 ≤ a 
Arguments: {α : Type u_1} [Zero α] [LinearOrder α] {a : α}
Goal: 0 ≤ SignType.sign a ↔ 0 ≤ a
-- sign_nonpos_iff
@[simp]
theorem sign_nonpos_iff : sign a ≤ 0 ↔ a ≤ 0 
Arguments: {α : Type u_1} [Zero α] [LinearOrder α] {a : α}
Goal: SignType.sign a ≤ 0 ↔ a ≤ 0
-- sign_one
theorem sign_one : sign (1 : α) = 1 
Arguments: {α : Type u_1} [OrderedSemiring α] [DecidableRel fun x x_1 => x < x_1] [Nontrivial α]
Goal: SignType.sign 1 = 1
-- sign_intCast
@[simp]
lemma sign_intCast {α : Type*} [OrderedRing α] [Nontrivial α]
    [DecidableRel ((· < ·) : α → α → Prop)] (n : ℤ) :
    sign (n : α) = sign n 
Arguments: {α : Type u_2} [OrderedRing α] [Nontrivial α] [DecidableRel fun x x_1 => x < x_1] (n : ℤ)
Goal: SignType.sign ↑n = SignType.sign n
-- sign_mul
theorem sign_mul (x y : α) : sign (x * y) = sign x * sign y 
Arguments: {α : Type u_1} [LinearOrderedRing α] (x y : α)
Goal: SignType.sign (x * y) = SignType.sign x * SignType.sign y
-- sign_mul_abs
@[simp] theorem sign_mul_abs (x : α) : (sign x * |x| : α) = x 
Arguments: {α : Type u_1} [LinearOrderedRing α] (x : α)
Goal: ↑(SignType.sign x) * |x| = x
-- abs_mul_sign
@[simp] theorem abs_mul_sign (x : α) : (|x| * sign x : α) = x 
Arguments: {α : Type u_1} [LinearOrderedRing α] (x : α)
Goal: |x| * ↑(SignType.sign x) = x
-- sign_mul_self
@[simp]
theorem sign_mul_self (x : α) : sign x * x = |x| 
Arguments: {α : Type u_1} [LinearOrderedRing α] (x : α)
Goal: ↑(SignType.sign x) * x = |x|
-- self_mul_sign
@[simp]
theorem self_mul_sign (x : α) : x * sign x = |x| 
Arguments: {α : Type u_1} [LinearOrderedRing α] (x : α)
Goal: x * ↑(SignType.sign x) = |x|
-- sign_pow
theorem sign_pow (x : α) (n : ℕ) : sign (x ^ n) = sign x ^ n 
Arguments: {α : Type u_1} [LinearOrderedRing α] (x : α) (n : ℕ)
Goal: SignType.sign (x ^ n) = SignType.sign x ^ n
-- Left.sign_neg
theorem Left.sign_neg [CovariantClass α α (· + ·) (· < ·)] (a : α) : sign (-a) = -sign a 
Arguments: {α : Type u_1} [AddGroup α] [Preorder α] [DecidableRel fun x x_1 => x < x_1] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α)
Goal: SignType.sign (-a) = -SignType.sign a
-- Right.sign_neg
theorem Right.sign_neg [CovariantClass α α (Function.swap (· + ·)) (· < ·)] (a : α) :
    sign (-a) = -sign a 
Arguments: {α : Type u_1} [AddGroup α] [Preorder α] [DecidableRel fun x x_1 => x < x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1] (a : α)
Goal: SignType.sign (-a) = -SignType.sign a
-- sign_sum
theorem sign_sum {ι : Type*} {s : Finset ι} {f : ι → α} (hs : s.Nonempty) (t : SignType)
    (h : ∀ i ∈ s, sign (f i) = t) : sign (∑ i ∈ s, f i) = t 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {ι : Type u_2} {s : Finset ι} {f : ι → α} (hs : s.Nonempty) (t : SignType) (h : ∀ i ∈ s, SignType.sign (f i) = t)
Goal: SignType.sign (∑ i ∈ s, f i) = t
-- Int.sign_eq_sign
theorem sign_eq_sign (n : ℤ) : Int.sign n = SignType.sign n 
Arguments: (n : ℤ)
Goal: n.sign = ↑(SignType.sign n)
-- _private.Mathlib.Data.Sign.0.exists_signed_sum_aux
private theorem exists_signed_sum_aux {α : Type u_1} [DecidableEq α] (s : Finset α) (f : α → ℤ) :
    ∃ (β : Type u_1) (t : Finset β) (sgn : β → SignType) (g : β → α),
      (∀ b, g b ∈ s) ∧
        (t.card = ∑ a ∈ s, (f a).natAbs) ∧
          ∀ a ∈ s, (∑ b ∈ t, if g b = a then (sgn b : ℤ) else 0) = f a 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) (f : α → ℤ)
Goal: ∃ β t sgn g,
  (∀ (b : β), g b ∈ s) ∧ t.card = ∑ a ∈ s, (f a).natAbs ∧ ∀ a ∈ s, (∑ b ∈ t, if g b = a then ↑(sgn b) else 0) = f a
-- exists_signed_sum
theorem exists_signed_sum {α : Type u_1} [DecidableEq α] (s : Finset α) (f : α → ℤ) :
    ∃ (β : Type u_1) (_ : Fintype β) (sgn : β → SignType) (g : β → α),
      (∀ b, g b ∈ s) ∧
        (Fintype.card β = ∑ a ∈ s, (f a).natAbs) ∧
          ∀ a ∈ s, (∑ b, if g b = a then (sgn b : ℤ) else 0) = f a 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) (f : α → ℤ)
Goal: ∃ β x sgn g,
  (∀ (b : β), g b ∈ s) ∧
    Fintype.card β = ∑ a ∈ s, (f a).natAbs ∧ ∀ a ∈ s, (∑ b : β, if g b = a then ↑(sgn b) else 0) = f a
-- exists_signed_sum'
theorem exists_signed_sum' {α : Type u_1} [Nonempty α] [DecidableEq α] (s : Finset α) (f : α → ℤ)
    (n : ℕ) (h : (∑ i ∈ s, (f i).natAbs) ≤ n) :
    ∃ (β : Type u_1) (_ : Fintype β) (sgn : β → SignType) (g : β → α),
      (∀ b, g b ∉ s → sgn b = 0) ∧
        Fintype.card β = n ∧ ∀ a ∈ s, (∑ i, if g i = a then (sgn i : ℤ) else 0) = f a 
Arguments: {α : Type u_1} [Nonempty α] [DecidableEq α] (s : Finset α) (f : α → ℤ) (n : ℕ) (h : ∑ i ∈ s, (f i).natAbs ≤ n)
Goal: ∃ β x sgn g,
  (∀ (b : β), g b ∉ s → sgn b = 0) ∧ Fintype.card β = n ∧ ∀ a ∈ s, (∑ i : β, if g i = a then ↑(sgn i) else 0) = f a
-- Ordnode.not_le_delta
theorem not_le_delta {s} (H : 1 ≤ s) : ¬s ≤ delta * 0 
Arguments: {s : ℕ} (H : 1 ≤ s)
Goal: ¬s ≤ Ordnode.delta * 0
-- Ordnode.delta_lt_false
theorem delta_lt_false {a b : ℕ} (h₁ : delta * a < b) (h₂ : delta * b < a) : False 
Arguments: {a b : ℕ} (h₁ : Ordnode.delta * a < b) (h₂ : Ordnode.delta * b < a)
Goal: False
-- Ordnode.Sized.node'
theorem Sized.node' {l x r} (hl : @Sized α l) (hr : Sized r) : Sized (node' l x r) 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Sized) (hr : r.Sized)
Goal: (l.node' x r).Sized
-- Ordnode.Sized.eq_node'
theorem Sized.eq_node' {s l x r} (h : @Sized α (node s l x r)) : node s l x r = .node' l x r 
Arguments: {α : Type u_1} {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} (h : (Ordnode.node s l x r).Sized)
Goal: Ordnode.node s l x r = l.node' x r
-- Ordnode.Sized.size_eq
theorem Sized.size_eq {s l x r} (H : Sized (@node α s l x r)) :
    size (@node α s l x r) = size l + size r + 1 
Arguments: {α : Type u_1} {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} (H : (Ordnode.node s l x r).Sized)
Goal: (Ordnode.node s l x r).size = l.size + r.size + 1
-- Ordnode.Sized.induction
@[elab_as_elim]
theorem Sized.induction {t} (hl : @Sized α t) {C : Ordnode α → Prop} (H0 : C nil)
    (H1 : ∀ l x r, C l → C r → C (.node' l x r)) : C t 
Arguments: {α : Type u_1} {t : Ordnode α} (hl : t.Sized) {C : Ordnode α → Prop} (H0 : C Ordnode.nil) (H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r))
Goal: C t
-- Ordnode.size_eq_realSize
theorem size_eq_realSize : ∀ {t : Ordnode α}, Sized t → size t = realSize t
  
Arguments: {α : Type u_1} {t : Ordnode α}
Goal: t.Sized → t.size = t.realSize
-- Ordnode.Sized.size_eq_zero
@[simp]
theorem Sized.size_eq_zero {t : Ordnode α} (ht : Sized t) : size t = 0 ↔ t = nil 
Arguments: {α : Type u_1} {t : Ordnode α} (ht : t.Sized)
Goal: t.size = 0 ↔ t = Ordnode.nil
-- Ordnode.Sized.pos
theorem Sized.pos {s l x r} (h : Sized (@node α s l x r)) : 0 < s 
Arguments: {α : Type u_1} {s : ℕ} {l : Ordnode α} {x : α} {r : Ordnode α} (h : (Ordnode.node s l x r).Sized)
Goal: 0 < s
-- Ordnode.dual_dual
theorem dual_dual : ∀ t : Ordnode α, dual (dual t) = t
  
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.dual.dual = t
-- Ordnode.size_dual
@[simp]
theorem size_dual (t : Ordnode α) : size (dual t) = size t 
Arguments: {α : Type u_1} (t : Ordnode α)
Goal: t.dual.size = t.size
-- Ordnode.BalancedSz.symm
@[symm]
theorem BalancedSz.symm {l r : ℕ} : BalancedSz l r → BalancedSz r l 
Arguments: {l r : ℕ}
Goal: Ordnode.BalancedSz l r → Ordnode.BalancedSz r l
-- Ordnode.balancedSz_zero
theorem balancedSz_zero {l : ℕ} : BalancedSz l 0 ↔ l ≤ 1 
Arguments: {l : ℕ}
Goal: Ordnode.BalancedSz l 0 ↔ l ≤ 1
-- Ordnode.balancedSz_up
theorem balancedSz_up {l r₁ r₂ : ℕ} (h₁ : r₁ ≤ r₂) (h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ delta * l)
    (H : BalancedSz l r₁) : BalancedSz l r₂ 
Arguments: {l r₁ r₂ : ℕ} (h₁ : r₁ ≤ r₂) (h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ Ordnode.delta * l) (H : Ordnode.BalancedSz l r₁)
Goal: Ordnode.BalancedSz l r₂
-- Ordnode.balancedSz_down
theorem balancedSz_down {l r₁ r₂ : ℕ} (h₁ : r₁ ≤ r₂) (h₂ : l + r₂ ≤ 1 ∨ l ≤ delta * r₁)
    (H : BalancedSz l r₂) : BalancedSz l r₁ 
Arguments: {l r₁ r₂ : ℕ} (h₁ : r₁ ≤ r₂) (h₂ : l + r₂ ≤ 1 ∨ l ≤ Ordnode.delta * r₁) (H : Ordnode.BalancedSz l r₂)
Goal: Ordnode.BalancedSz l r₁
-- Ordnode.Balanced.dual
theorem Balanced.dual : ∀ {t : Ordnode α}, Balanced t → Balanced (dual t)
  
Arguments: {α : Type u_1} {t : Ordnode α}
Goal: t.Balanced → t.dual.Balanced
-- Ordnode.rotateL_node
theorem rotateL_node (l : Ordnode α) (x : α) (sz : ℕ) (m : Ordnode α) (y : α) (r : Ordnode α) :
    rotateL l x (node sz m y r) =
      if size m < ratio * size r then node3L l x m y r else node4L l x m y r 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (sz : ℕ) (m : Ordnode α) (y : α) (r : Ordnode α)
Goal: l.rotateL x (Ordnode.node sz m y r) = if m.size < Ordnode.ratio * r.size then l.node3L x m y r else l.node4L x m y r
-- Ordnode.rotateL_nil
theorem rotateL_nil (l : Ordnode α) (x : α) : rotateL l x nil = node' l x nil 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α)
Goal: l.rotateL x Ordnode.nil = l.node' x Ordnode.nil
-- Ordnode.rotateR_node
theorem rotateR_node (sz : ℕ) (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α) :
    rotateR (node sz l x m) y r =
      if size m < ratio * size l then node3R l x m y r else node4R l x m y r 
Arguments: {α : Type u_1} (sz : ℕ) (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α)
Goal: (Ordnode.node sz l x m).rotateR y r = if m.size < Ordnode.ratio * l.size then l.node3R x m y r else l.node4R x m y r
-- Ordnode.rotateR_nil
theorem rotateR_nil (y : α) (r : Ordnode α) : rotateR nil y r = node' nil y r 
Arguments: {α : Type u_1} (y : α) (r : Ordnode α)
Goal: Ordnode.nil.rotateR y r = Ordnode.nil.node' y r
-- Ordnode.dual_node'
theorem dual_node' (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (node' l x r) = node' (dual r) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: (l.node' x r).dual = r.dual.node' x l.dual
-- Ordnode.dual_node3L
theorem dual_node3L (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α) :
    dual (node3L l x m y r) = node3R (dual r) y (dual m) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α)
Goal: (l.node3L x m y r).dual = r.dual.node3R y m.dual x l.dual
-- Ordnode.dual_node3R
theorem dual_node3R (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α) :
    dual (node3R l x m y r) = node3L (dual r) y (dual m) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α)
Goal: (l.node3R x m y r).dual = r.dual.node3L y m.dual x l.dual
-- Ordnode.dual_node4L
theorem dual_node4L (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α) :
    dual (node4L l x m y r) = node4R (dual r) y (dual m) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α)
Goal: (l.node4L x m y r).dual = r.dual.node4R y m.dual x l.dual
-- Ordnode.dual_node4R
theorem dual_node4R (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α) :
    dual (node4R l x m y r) = node4L (dual r) y (dual m) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (m : Ordnode α) (y : α) (r : Ordnode α)
Goal: (l.node4R x m y r).dual = r.dual.node4L y m.dual x l.dual
-- Ordnode.dual_rotateL
theorem dual_rotateL (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (rotateL l x r) = rotateR (dual r) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: (l.rotateL x r).dual = r.dual.rotateR x l.dual
-- Ordnode.dual_rotateR
theorem dual_rotateR (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (rotateR l x r) = rotateL (dual r) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: (l.rotateR x r).dual = r.dual.rotateL x l.dual
-- Ordnode.dual_balance'
theorem dual_balance' (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (balance' l x r) = balance' (dual r) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: (l.balance' x r).dual = r.dual.balance' x l.dual
-- Ordnode.dual_balanceL
theorem dual_balanceL (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (balanceL l x r) = balanceR (dual r) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: (l.balanceL x r).dual = r.dual.balanceR x l.dual
-- Ordnode.dual_balanceR
theorem dual_balanceR (l : Ordnode α) (x : α) (r : Ordnode α) :
    dual (balanceR l x r) = balanceL (dual r) x (dual l) 
Arguments: {α : Type u_1} (l : Ordnode α) (x : α) (r : Ordnode α)
Goal: (l.balanceR x r).dual = r.dual.balanceL x l.dual
-- Ordnode.Sized.node3L
theorem Sized.node3L {l x m y r} (hl : @Sized α l) (hm : Sized m) (hr : Sized r) :
    Sized (node3L l x m y r) 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α} (hl : l.Sized) (hm : m.Sized) (hr : r.Sized)
Goal: (l.node3L x m y r).Sized
-- Ordnode.Sized.node3R
theorem Sized.node3R {l x m y r} (hl : @Sized α l) (hm : Sized m) (hr : Sized r) :
    Sized (node3R l x m y r) 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α} (hl : l.Sized) (hm : m.Sized) (hr : r.Sized)
Goal: (l.node3R x m y r).Sized
-- Ordnode.Sized.node4L
theorem Sized.node4L {l x m y r} (hl : @Sized α l) (hm : Sized m) (hr : Sized r) :
    Sized (node4L l x m y r) 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α} (hl : l.Sized) (hm : m.Sized) (hr : r.Sized)
Goal: (l.node4L x m y r).Sized
-- Ordnode.node3L_size
theorem node3L_size {l x m y r} : size (@node3L α l x m y r) = size l + size m + size r + 2 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α}
Goal: (l.node3L x m y r).size = l.size + m.size + r.size + 2
-- Ordnode.node3R_size
theorem node3R_size {l x m y r} : size (@node3R α l x m y r) = size l + size m + size r + 2 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α}
Goal: (l.node3R x m y r).size = l.size + m.size + r.size + 2
-- Ordnode.node4L_size
theorem node4L_size {l x m y r} (hm : Sized m) :
    size (@node4L α l x m y r) = size l + size m + size r + 2 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α} (hm : m.Sized)
Goal: (l.node4L x m y r).size = l.size + m.size + r.size + 2
-- Ordnode.Sized.dual
theorem Sized.dual : ∀ {t : Ordnode α}, Sized t → Sized (dual t)
  
Arguments: {α : Type u_1} {t : Ordnode α}
Goal: t.Sized → t.dual.Sized
-- Ordnode.Sized.dual_iff
theorem Sized.dual_iff {t : Ordnode α} : Sized (.dual t) ↔ Sized t 
Arguments: {α : Type u_1} {t : Ordnode α}
Goal: t.dual.Sized ↔ t.Sized
-- Ordnode.Sized.rotateL
theorem Sized.rotateL {l x r} (hl : @Sized α l) (hr : Sized r) : Sized (rotateL l x r) 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Sized) (hr : r.Sized)
Goal: (l.rotateL x r).Sized
-- Ordnode.Sized.rotateR
theorem Sized.rotateR {l x r} (hl : @Sized α l) (hr : Sized r) : Sized (rotateR l x r) 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Sized) (hr : r.Sized)
Goal: (l.rotateR x r).Sized
-- Ordnode.Sized.rotateL_size
theorem Sized.rotateL_size {l x r} (hm : Sized r) :
    size (@Ordnode.rotateL α l x r) = size l + size r + 1 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hm : r.Sized)
Goal: (l.rotateL x r).size = l.size + r.size + 1
-- Ordnode.Sized.rotateR_size
theorem Sized.rotateR_size {l x r} (hl : Sized l) :
    size (@Ordnode.rotateR α l x r) = size l + size r + 1 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Sized)
Goal: (l.rotateR x r).size = l.size + r.size + 1
-- Ordnode.Sized.balance'
theorem Sized.balance' {l x r} (hl : @Sized α l) (hr : Sized r) : Sized (balance' l x r) 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Sized) (hr : r.Sized)
Goal: (l.balance' x r).Sized
-- Ordnode.size_balance'
theorem size_balance' {l x r} (hl : @Sized α l) (hr : Sized r) :
    size (@balance' α l x r) = size l + size r + 1 
Arguments: {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α} (hl : l.Sized) (hr : r.Sized)
Goal: (l.balance' x r).size = l.size + r.size + 1
-- Ordnode.All.imp
theorem All.imp {P Q : α → Prop} (H : ∀ a, P a → Q a) : ∀ {t}, All P t → All Q t
  
Arguments: {α : Type u_1} {P Q : α → Prop} (H : ∀ (a : α), P a → Q a) {t : Ordnode α}
Goal: Ordnode.All P t → Ordnode.All Q t
-- Ordnode.Any.imp
theorem Any.imp {P Q : α → Prop} (H : ∀ a, P a → Q a) : ∀ {t}, Any P t → Any Q t
  
Arguments: {α : Type u_1} {P Q : α → Prop} (H : ∀ (a : α), P a → Q a) {t : Ordnode α}
Goal: Ordnode.Any P t → Ordnode.Any Q t
-- Ordnode.all_singleton
theorem all_singleton {P : α → Prop} {x : α} : All P (singleton x) ↔ P x 
Arguments: {α : Type u_1} {P : α → Prop} {x : α}
Goal: Ordnode.All P {x} ↔ P x
-- Ordnode.any_singleton
theorem any_singleton {P : α → Prop} {x : α} : Any P (singleton x) ↔ P x 
Arguments: {α : Type u_1} {P : α → Prop} {x : α}
Goal: Ordnode.Any P {x} ↔ P x
-- Ordnode.all_dual
theorem all_dual {P : α → Prop} : ∀ {t : Ordnode α}, All P (dual t) ↔ All P t
  
Arguments: {α : Type u_1} {P : α → Prop} {t : Ordnode α}
Goal: Ordnode.All P t.dual ↔ Ordnode.All P t
-- Ordnode.all_iff_forall
theorem all_iff_forall {P : α → Prop} : ∀ {t}, All P t ↔ ∀ x, Emem x t → P x
  
Arguments: {α : Type u_1} {P : α → Prop} {t : Ordnode α}
Goal: Ordnode.All P t ↔ ∀ (x : α), Ordnode.Emem x t → P x
-- Ordnode.any_iff_exists
theorem any_iff_exists {P : α → Prop} : ∀ {t}, Any P t ↔ ∃ x, Emem x t ∧ P x
  
Arguments: {α : Type u_1} {P : α → Prop} {t : Ordnode α}
Goal: Ordnode.Any P t ↔ ∃ x, Ordnode.Emem x t ∧ P x
-- Ordnode.emem_iff_all
theorem emem_iff_all {x : α} {t} : Emem x t ↔ ∀ P, All P t → P x 
Arguments: {α : Type u_1} {x : α} {t : Ordnode α}
Goal: Ordnode.Emem x t ↔ ∀ (P : α → Prop), Ordnode.All P t → P x