ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.le_of_lt_add_one
theorem le_of_lt_add_one {a b : Int} (H : a < b + 1) : a ≤ b 
Arguments: {a b : Int} (H : a < b + 1)
Goal: a ≤ b
-- Int.sub_one_lt_of_le
theorem sub_one_lt_of_le {a b : Int} (H : a ≤ b) : a - 1 < b 
Arguments: {a b : Int} (H : a ≤ b)
Goal: a - 1 < b
-- Int.le_of_sub_one_lt
theorem le_of_sub_one_lt {a b : Int} (H : a - 1 < b) : a ≤ b 
Arguments: {a b : Int} (H : a - 1 < b)
Goal: a ≤ b
-- Int.le_sub_one_of_lt
theorem le_sub_one_of_lt {a b : Int} (H : a < b) : a ≤ b - 1 
Arguments: {a b : Int} (H : a < b)
Goal: a ≤ b - 1
-- Int.lt_of_le_sub_one
theorem lt_of_le_sub_one {a b : Int} (H : a ≤ b - 1) : a < b 
Arguments: {a b : Int} (H : a ≤ b - 1)
Goal: a < b
-- Int.mul_lt_mul
protected theorem mul_lt_mul {a b c d : Int}
    (h₁ : a < c) (h₂ : b ≤ d) (h₃ : 0 < b) (h₄ : 0 ≤ c) : a * b < c * d 
Arguments: {a b c d : Int} (h₁ : a < c) (h₂ : b ≤ d) (h₃ : 0 < b) (h₄ : 0 ≤ c)
Goal: a * b < c * d
-- Int.mul_lt_mul'
protected theorem mul_lt_mul' {a b c d : Int}
    (h₁ : a ≤ c) (h₂ : b < d) (h₃ : 0 ≤ b) (h₄ : 0 < c) : a * b < c * d 
Arguments: {a b c d : Int} (h₁ : a ≤ c) (h₂ : b < d) (h₃ : 0 ≤ b) (h₄ : 0 < c)
Goal: a * b < c * d
-- Int.mul_neg_of_pos_of_neg
protected theorem mul_neg_of_pos_of_neg {a b : Int} (ha : 0 < a) (hb : b < 0) : a * b < 0 
Arguments: {a b : Int} (ha : 0 < a) (hb : b < 0)
Goal: a * b < 0
-- Int.mul_neg_of_neg_of_pos
protected theorem mul_neg_of_neg_of_pos {a b : Int} (ha : a < 0) (hb : 0 < b) : a * b < 0 
Arguments: {a b : Int} (ha : a < 0) (hb : 0 < b)
Goal: a * b < 0
-- Int.mul_nonneg_of_nonpos_of_nonpos
protected theorem mul_nonneg_of_nonpos_of_nonpos {a b : Int}
  (ha : a ≤ 0) (hb : b ≤ 0) : 0 ≤ a * b 
Arguments: {a b : Int} (ha : a ≤ 0) (hb : b ≤ 0)
Goal: 0 ≤ a * b
-- Int.mul_lt_mul_of_neg_left
protected theorem mul_lt_mul_of_neg_left {a b c : Int} (h : b < a) (hc : c < 0) : c * a < c * b 
Arguments: {a b c : Int} (h : b < a) (hc : c < 0)
Goal: c * a < c * b
-- Int.mul_lt_mul_of_neg_right
protected theorem mul_lt_mul_of_neg_right {a b c : Int} (h : b < a) (hc : c < 0) : a * c < b * c 
Arguments: {a b c : Int} (h : b < a) (hc : c < 0)
Goal: a * c < b * c
-- Int.mul_pos_of_neg_of_neg
protected theorem mul_pos_of_neg_of_neg {a b : Int} (ha : a < 0) (hb : b < 0) : 0 < a * b 
Arguments: {a b : Int} (ha : a < 0) (hb : b < 0)
Goal: 0 < a * b
-- Int.mul_self_le_mul_self
protected theorem mul_self_le_mul_self {a b : Int} (h1 : 0 ≤ a) (h2 : a ≤ b) : a * a ≤ b * b 
Arguments: {a b : Int} (h1 : 0 ≤ a) (h2 : a ≤ b)
Goal: a * a ≤ b * b
-- Int.mul_self_lt_mul_self
protected theorem mul_self_lt_mul_self {a b : Int} (h1 : 0 ≤ a) (h2 : a < b) : a * a < b * b 
Arguments: {a b : Int} (h1 : 0 ≤ a) (h2 : a < b)
Goal: a * a < b * b
-- Int.sign_zero
@[simp] theorem sign_zero : sign 0 = 0 
Goal: Int.sign 0 = 0
-- Int.sign_one
@[simp] theorem sign_one : sign 1 = 1 
Goal: Int.sign 1 = 1
-- Int.sign_neg_one
theorem sign_neg_one : sign (-1) = -1 
Goal: (-1).sign = -1
-- Int.sign_of_add_one
@[simp] theorem sign_of_add_one (x : Nat) : Int.sign (x + 1) = 1 
Arguments: (x : Nat)
Goal: (↑x + 1).sign = 1
-- Int.sign_negSucc
@[simp] theorem sign_negSucc (x : Nat) : Int.sign (Int.negSucc x) = -1 
Arguments: (x : Nat)
Goal: (Int.negSucc x).sign = -1
-- Int.natAbs_sign
theorem natAbs_sign (z : Int) : z.sign.natAbs = if z = 0 then 0 else 1 
Arguments: (z : Int)
Goal: z.sign.natAbs = if z = 0 then 0 else 1
-- Int.natAbs_sign_of_nonzero
theorem natAbs_sign_of_nonzero {z : Int} (hz : z ≠ 0) : z.sign.natAbs = 1 
Arguments: {z : Int} (hz : z ≠ 0)
Goal: z.sign.natAbs = 1
-- Int.sign_ofNat_of_nonzero
theorem sign_ofNat_of_nonzero {n : Nat} (hn : n ≠ 0) : Int.sign n = 1 
Arguments: {n : Nat} (hn : n ≠ 0)
Goal: (↑n).sign = 1
-- Int.sign_neg
@[simp] theorem sign_neg (z : Int) : Int.sign (-z) = -Int.sign z 
Arguments: (z : Int)
Goal: (-z).sign = -z.sign
-- Int.sign_mul_natAbs
theorem sign_mul_natAbs : ∀ a : Int, sign a * natAbs a = a
  
Arguments: (a : Int)
Goal: a.sign * ↑a.natAbs = a
-- Int.sign_mul
@[simp] theorem sign_mul : ∀ a b, sign (a * b) = sign a * sign b
  
Arguments: (a b : Int)
Goal: (a * b).sign = a.sign * b.sign
-- Int.sign_eq_one_of_pos
theorem sign_eq_one_of_pos {a : Int} (h : 0 < a) : sign a = 1 
Arguments: {a : Int} (h : 0 < a)
Goal: a.sign = 1
-- Int.sign_eq_neg_one_of_neg
theorem sign_eq_neg_one_of_neg {a : Int} (h : a < 0) : sign a = -1 
Arguments: {a : Int} (h : a < 0)
Goal: a.sign = -1
-- Int.eq_zero_of_sign_eq_zero
theorem eq_zero_of_sign_eq_zero : ∀ {a : Int}, sign a = 0 → a = 0
  
Arguments: {a : Int}
Goal: a.sign = 0 → a = 0
-- Int.pos_of_sign_eq_one
theorem pos_of_sign_eq_one : ∀ {a : Int}, sign a = 1 → 0 < a
  
Arguments: {a : Int}
Goal: a.sign = 1 → 0 < a
-- Int.neg_of_sign_eq_neg_one
theorem neg_of_sign_eq_neg_one : ∀ {a : Int}, sign a = -1 → a < 0
  
Arguments: {a : Int}
Goal: a.sign = -1 → a < 0
-- Int.sign_eq_one_iff_pos
theorem sign_eq_one_iff_pos (a : Int) : sign a = 1 ↔ 0 < a 
Arguments: (a : Int)
Goal: a.sign = 1 ↔ 0 < a
-- Int.sign_eq_neg_one_iff_neg
theorem sign_eq_neg_one_iff_neg (a : Int) : sign a = -1 ↔ a < 0 
Arguments: (a : Int)
Goal: a.sign = -1 ↔ a < 0
-- Int.sign_eq_zero_iff_zero
@[simp] theorem sign_eq_zero_iff_zero (a : Int) : sign a = 0 ↔ a = 0 
Arguments: (a : Int)
Goal: a.sign = 0 ↔ a = 0
-- Int.sign_sign
@[simp] theorem sign_sign : sign (sign x) = sign x 
Arguments: {x : Int}
Goal: x.sign.sign = x.sign
-- Int.sign_nonneg
@[simp] theorem sign_nonneg : 0 ≤ sign x ↔ 0 ≤ x 
Arguments: {x : Int}
Goal: 0 ≤ x.sign ↔ 0 ≤ x
-- Int.mul_sign
theorem mul_sign : ∀ i : Int, i * sign i = natAbs i
  
Arguments: (i : Int)
Goal: i * i.sign = ↑i.natAbs
-- Int.natAbs_ne_zero
theorem natAbs_ne_zero {a : Int} : a.natAbs ≠ 0 ↔ a ≠ 0 
Arguments: {a : Int}
Goal: a.natAbs ≠ 0 ↔ a ≠ 0
-- Int.natAbs_mul_self
theorem natAbs_mul_self : ∀ {a : Int}, ↑(natAbs a * natAbs a) = a * a
  
Arguments: {a : Int}
Goal: ↑(a.natAbs * a.natAbs) = a * a
-- Int.eq_nat_or_neg
theorem eq_nat_or_neg (a : Int) : ∃ n : Nat, a = n ∨ a = -↑n 
Arguments: (a : Int)
Goal: ∃ n, a = ↑n ∨ a = -↑n
-- Int.natAbs_mul_natAbs_eq
theorem natAbs_mul_natAbs_eq {a b : Int} {c : Nat}
    (h : a * b = (c : Int)) : a.natAbs * b.natAbs = c 
Arguments: {a b : Int} {c : Nat} (h : a * b = ↑c)
Goal: a.natAbs * b.natAbs = c
-- Int.natAbs_mul_self'
@[simp] theorem natAbs_mul_self' (a : Int) : (natAbs a * natAbs a : Int) = a * a 
Arguments: (a : Int)
Goal: ↑a.natAbs * ↑a.natAbs = a * a
-- Int.natAbs_eq_iff
theorem natAbs_eq_iff {a : Int} {n : Nat} : a.natAbs = n ↔ a = n ∨ a = -↑n 
Arguments: {a : Int} {n : Nat}
Goal: a.natAbs = n ↔ a = ↑n ∨ a = -↑n
-- Int.natAbs_add_le
theorem natAbs_add_le (a b : Int) : natAbs (a + b) ≤ natAbs a + natAbs b 
Arguments: (a b : Int)
Goal: (a + b).natAbs ≤ a.natAbs + b.natAbs
-- Int.natAbs_sub_le
theorem natAbs_sub_le (a b : Int) : natAbs (a - b) ≤ natAbs a + natAbs b 
Arguments: (a b : Int)
Goal: (a - b).natAbs ≤ a.natAbs + b.natAbs
-- Int.negSucc_eq'
theorem negSucc_eq' (m : Nat) : -[m+1] = -m - 1 
Arguments: (m : Nat)
Goal: Int.negSucc m = -↑m - 1
-- Int.natAbs_lt_natAbs_of_nonneg_of_lt
theorem natAbs_lt_natAbs_of_nonneg_of_lt {a b : Int}
    (w₁ : 0 ≤ a) (w₂ : a < b) : a.natAbs < b.natAbs 
Arguments: {a b : Int} (w₁ : 0 ≤ a) (w₂ : a < b)
Goal: a.natAbs < b.natAbs
-- Int.eq_natAbs_iff_mul_eq_zero
theorem eq_natAbs_iff_mul_eq_zero : natAbs a = n ↔ (a - n) * (a + n) = 0 
Arguments: {a : Int} {n : Nat}
Goal: a.natAbs = n ↔ (a - ↑n) * (a + ↑n) = 0
-- Nat.bitwise_rec_lemma
theorem bitwise_rec_lemma {n : Nat} (hNe : n ≠ 0) : n / 2 < n 
Arguments: {n : Nat} (hNe : n ≠ 0)
Goal: n / 2 < n
-- Nat.shiftLeft_eq
theorem shiftLeft_eq (a b : Nat) : a <<< b = a * 2 ^ b 
Arguments: (a b : Nat)
Goal: a <<< b = a * 2 ^ b
-- Nat.shiftRight_zero
@[simp] theorem shiftRight_zero : n >>> 0 = n 
Arguments: {n : Nat}
Goal: n >>> 0 = n
-- Nat.shiftRight_succ
theorem shiftRight_succ (m n) : m >>> (n + 1) = (m >>> n) / 2 
Arguments: (m n : Nat)
Goal: m >>> (n + 1) = m >>> n / 2
-- Nat.shiftRight_add
theorem shiftRight_add (m n : Nat) : ∀ k, m >>> (n + k) = (m >>> n) >>> k
  
Arguments: (m n k : Nat)
Goal: m >>> (n + k) = m >>> n >>> k
-- Nat.shiftRight_eq_div_pow
theorem shiftRight_eq_div_pow (m : Nat) : ∀ n, m >>> n = m / 2 ^ n
  
Arguments: (m n : Nat)
Goal: m >>> n = m / 2 ^ n
-- Option.mem_iff
theorem mem_iff {a : α} {b : Option α} : a ∈ b ↔ b = a 
Arguments: {α : Type u_1} {a : α} {b : Option α}
Goal: a ∈ b ↔ b = some a
-- Option.some_ne_none
theorem some_ne_none (x : α) : some x ≠ none 
Arguments: {α : Type u_1} (x : α)
Goal: some x ≠ none
-- Option.forall
protected theorem «forall» {p : Option α → Prop} : (∀ x, p x) ↔ p none ∧ ∀ x, p (some x) 
Arguments: {α : Type u_1} {p : Option α → Prop}
Goal: (∀ (x : Option α), p x) ↔ p none ∧ ∀ (x : α), p (some x)
-- Option.exists
protected theorem «exists» {p : Option α → Prop} :
    (∃ x, p x) ↔ p none ∨ ∃ x, p (some x) 
Arguments: {α : Type u_1} {p : Option α → Prop}
Goal: (∃ x, p x) ↔ p none ∨ ∃ x, p (some x)
-- Option.get_mem
theorem get_mem : ∀ {o : Option α} (h : isSome o), o.get h ∈ o
  
Arguments: {α : Type u_1} {o : Option α} (h : o.isSome = true)
Goal: o.get h ∈ o
-- Option.get_of_mem
theorem get_of_mem : ∀ {o : Option α} (h : isSome o), a ∈ o → o.get h = a
  
Arguments: {α : Type u_1} {a : α} {o : Option α} (h : o.isSome = true)
Goal: a ∈ o → o.get h = a
-- Option.not_mem_none
theorem not_mem_none (a : α) : a ∉ (none : Option α) 
Arguments: {α : Type u_1} (a : α)
Goal: ¬a ∈ none
-- Option.some_get
@[simp] theorem some_get : ∀ {x : Option α} (h : isSome x), some (x.get h) = x

Arguments: {α : Type u_1} {x : Option α} (h : x.isSome = true)
Goal: some (x.get h) = x
-- Option.get_some
@[simp] theorem get_some (x : α) (h : isSome (some x)) : (some x).get h = x 
Arguments: {α : Type u_1} (x : α) (h : (some x).isSome = true)
Goal: (some x).get h = x
-- Option.getD_of_ne_none
theorem getD_of_ne_none {x : Option α} (hx : x ≠ none) (y : α) : some (x.getD y) = x 
Arguments: {α : Type u_1} {x : Option α} (hx : x ≠ none) (y : α)
Goal: some (x.getD y) = x
-- Option.getD_eq_iff
theorem getD_eq_iff {o : Option α} {a b} : o.getD a = b ↔ (o = some b ∨ o = none ∧ a = b) 
Arguments: {α : Type u_1} {o : Option α} {a b : α}
Goal: o.getD a = b ↔ o = some b ∨ o = none ∧ a = b
-- Option.mem_unique
theorem mem_unique {o : Option α} {a b : α} (ha : a ∈ o) (hb : b ∈ o) : a = b 
Arguments: {α : Type u_1} {o : Option α} {a b : α} (ha : a ∈ o) (hb : b ∈ o)
Goal: a = b
-- Option.ext
@[ext] theorem ext : ∀ {o₁ o₂ : Option α}, (∀ a, a ∈ o₁ ↔ a ∈ o₂) → o₁ = o₂
  
Arguments: {α : Type u_1} {o₁ o₂ : Option α}
Goal: (∀ (a : α), a ∈ o₁ ↔ a ∈ o₂) → o₁ = o₂
-- Option.eq_none_iff_forall_not_mem
theorem eq_none_iff_forall_not_mem : o = none ↔ ∀ a, a ∉ o 
Goal: ∀ {α : Type u_1} {o : Option α}, o = none ↔ ∀ (a : α), ¬a ∈ o
-- Option.isSome_none
@[simp] theorem isSome_none : @isSome α none = false 
Arguments: {α : Type u_1}
Goal: none.isSome = false
-- Option.isSome_some
@[simp] theorem isSome_some : isSome (some a) = true 
Goal: ∀ {α : Type u_1} {a : α}, (some a).isSome = true
-- Option.isSome_iff_exists
theorem isSome_iff_exists : isSome x ↔ ∃ a, x = some a 
Goal: ∀ {α : Type u_1} {x : Option α}, x.isSome = true ↔ ∃ a, x = some a
-- Option.isNone_none
@[simp] theorem isNone_none : @isNone α none = true 
Arguments: {α : Type u_1}
Goal: none.isNone = true
-- Option.isNone_some
@[simp] theorem isNone_some : isNone (some a) = false 
Goal: ∀ {α : Type u_1} {a : α}, (some a).isNone = false
-- Option.not_isSome
@[simp] theorem not_isSome : isSome a = false ↔ a.isNone = true 
Goal: ∀ {α : Type u_1} {a : Option α}, a.isSome = false ↔ a.isNone = true
-- Option.eq_some_iff_get_eq
theorem eq_some_iff_get_eq : o = some a ↔ ∃ h : o.isSome, o.get h = a 
Goal: ∀ {α : Type u_1} {o : Option α} {a : α}, o = some a ↔ ∃ h, o.get h = a
-- Option.eq_some_of_isSome
theorem eq_some_of_isSome : ∀ {o : Option α} (h : o.isSome), o = some (o.get h)
  
Arguments: {α : Type u_1} {o : Option α} (h : o.isSome = true)
Goal: o = some (o.get h)
-- Option.not_isSome_iff_eq_none
theorem not_isSome_iff_eq_none : ¬o.isSome ↔ o = none 
Goal: ∀ {α : Type u_1} {o : Option α}, ¬o.isSome = true ↔ o = none
-- Option.ne_none_iff_isSome
theorem ne_none_iff_isSome : o ≠ none ↔ o.isSome 
Goal: ∀ {α : Type u_1} {o : Option α}, o ≠ none ↔ o.isSome = true
-- Option.ne_none_iff_exists
theorem ne_none_iff_exists : o ≠ none ↔ ∃ x, some x = o 
Goal: ∀ {α : Type u_1} {o : Option α}, o ≠ none ↔ ∃ x, some x = o
-- Option.ne_none_iff_exists'
theorem ne_none_iff_exists' : o ≠ none ↔ ∃ x, o = some x 
Goal: ∀ {α : Type u_1} {o : Option α}, o ≠ none ↔ ∃ x, o = some x
-- Option.bex_ne_none
theorem bex_ne_none {p : Option α → Prop} : (∃ x, ∃ (_ : x ≠ none), p x) ↔ ∃ x, p (some x) 
Arguments: {α : Type u_1} {p : Option α → Prop}
Goal: (∃ x x_1, p x) ↔ ∃ x, p (some x)
-- Option.ball_ne_none
theorem ball_ne_none {p : Option α → Prop} : (∀ x (_ : x ≠ none), p x) ↔ ∀ x, p (some x) 
Arguments: {α : Type u_1} {p : Option α → Prop}
Goal: (∀ (x : Option α), x ≠ none → p x) ↔ ∀ (x : α), p (some x)
-- Option.pure_def
@[simp] theorem pure_def : pure = @some α 
Arguments: {α : Type u_1}
Goal: pure = some
-- Option.bind_eq_bind
@[simp] theorem bind_eq_bind : bind = @Option.bind α β 
Arguments: {α β : Type u_1}
Goal: bind = Option.bind
-- Option.bind_some
@[simp] theorem bind_some (x : Option α) : x.bind some = x 
Arguments: {α : Type u_1} (x : Option α)
Goal: x.bind some = x
-- Option.bind_none
@[simp] theorem bind_none (x : Option α) : x.bind (fun _ => none (α := β)) = none 
Arguments: {α : Type u_1} {β : Type u_2} (x : Option α)
Goal: (x.bind fun x => none) = none
-- Option.bind_eq_some
theorem bind_eq_some : x.bind f = some b ↔ ∃ a, x = some a ∧ f a = some b 
Goal: ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → Option α},
  x.bind f = some b ↔ ∃ a, x = some a ∧ f a = some b
-- Option.bind_eq_none
@[simp] theorem bind_eq_none {o : Option α} {f : α → Option β} :
    o.bind f = none ↔ ∀ a, o = some a → f a = none 
Arguments: {α : Type u_1} {β : Type u_2} {o : Option α} {f : α → Option β}
Goal: o.bind f = none ↔ ∀ (a : α), o = some a → f a = none
-- Option.bind_eq_none'
theorem bind_eq_none' {o : Option α} {f : α → Option β} :
    o.bind f = none ↔ ∀ b a, a ∈ o → b ∉ f a 
Arguments: {α : Type u_1} {β : Type u_2} {o : Option α} {f : α → Option β}
Goal: o.bind f = none ↔ ∀ (b : β) (a : α), a ∈ o → ¬b ∈ f a
-- Option.bind_comm
theorem bind_comm {f : α → β → Option γ} (a : Option α) (b : Option β) :
    (a.bind fun x => b.bind (f x)) = b.bind fun y => a.bind fun x => f x y 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → Option γ} (a : Option α) (b : Option β)
Goal: (a.bind fun x => b.bind (f x)) = b.bind fun y => a.bind fun x => f x y
-- Option.bind_assoc
theorem bind_assoc (x : Option α) (f : α → Option β) (g : β → Option γ) :
    (x.bind f).bind g = x.bind fun y => (f y).bind g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (x : Option α) (f : α → Option β) (g : β → Option γ)
Goal: (x.bind f).bind g = x.bind fun y => (f y).bind g
-- Option.join_eq_some
theorem join_eq_some : x.join = some a ↔ x = some (some a) 
Goal: ∀ {α : Type u_1} {a : α} {x : Option (Option α)}, x.join = some a ↔ x = some (some a)
-- Option.join_ne_none
theorem join_ne_none : x.join ≠ none ↔ ∃ z, x = some (some z) 
Goal: ∀ {α : Type u_1} {x : Option (Option α)}, x.join ≠ none ↔ ∃ z, x = some (some z)
-- Option.join_ne_none'
theorem join_ne_none' : ¬x.join = none ↔ ∃ z, x = some (some z) 
Goal: ∀ {α : Type u_1} {x : Option (Option α)}, ¬x.join = none ↔ ∃ z, x = some (some z)
-- Option.join_eq_none
theorem join_eq_none : o.join = none ↔ o = none ∨ o = some none 
Goal: ∀ {α : Type u_1} {o : Option (Option α)}, o.join = none ↔ o = none ∨ o = some none
-- Option.bind_id_eq_join
theorem bind_id_eq_join {x : Option (Option α)} : x.bind id = x.join 
Arguments: {α : Type u_1} {x : Option (Option α)}
Goal: x.bind id = x.join
-- Option.map_eq_map
@[simp] theorem map_eq_map : Functor.map f = Option.map f 
Goal: ∀ {α α_1 : Type u_1} {f : α → α_1}, Functor.map f = Option.map f
-- Option.map_none
theorem map_none : f <$> none = none 
Goal: ∀ {α α_1 : Type u_1} {f : α → α_1}, f <$> none = none
-- Option.map_some
theorem map_some : f <$> some a = some (f a) 
Goal: ∀ {α α_1 : Type u_1} {f : α → α_1} {a : α}, f <$> some a = some (f a)
-- Option.map_eq_some'
@[simp] theorem map_eq_some' : x.map f = some b ↔ ∃ a, x = some a ∧ f a = b 
Goal: ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
  Option.map f x = some b ↔ ∃ a, x = some a ∧ f a = b
-- Option.map_eq_some
theorem map_eq_some : f <$> x = some b ↔ ∃ a, x = some a ∧ f a = b 
Goal: ∀ {α α_1 : Type u_1} {f : α → α_1} {x : Option α} {b : α_1}, f <$> x = some b ↔ ∃ a, x = some a ∧ f a = b
-- Option.map_eq_none'
@[simp] theorem map_eq_none' : x.map f = none ↔ x = none 
Goal: ∀ {α : Type u_1} {x : Option α} {α_1 : Type u_2} {f : α → α_1}, Option.map f x = none ↔ x = none
-- Option.map_eq_none
theorem map_eq_none : f <$> x = none ↔ x = none 
Goal: ∀ {α α_1 : Type u_1} {f : α → α_1} {x : Option α}, f <$> x = none ↔ x = none
-- Option.map_eq_bind
theorem map_eq_bind {x : Option α} : x.map f = x.bind (some ∘ f) 
Arguments: {α : Type u_1}
Goal: ∀ {α_1 : Type u_2} {f : α → α_1} {x : Option α}, Option.map f x = x.bind (some ∘ f)
-- Option.map_congr
theorem map_congr {x : Option α} (h : ∀ a, a ∈ x → f a = g a) : x.map f = x.map g 
Arguments: {α : Type u_1}
Goal: ∀ {α_1 : Type u_2} {f g : α → α_1} {x : Option α}, (∀ (a : α), a ∈ x → f a = g a) → Option.map f x = Option.map g x
-- Option.map_id'
@[simp] theorem map_id' : Option.map (@id α) = id 
Arguments: {α : Type u_1}
Goal: Option.map id = id
-- Option.map_id''
@[simp] theorem map_id'' {x : Option α} : (x.map fun a => a) = x 
Arguments: {α : Type u_1} {x : Option α}
Goal: Option.map (fun a => a) x = x
-- Option.map_map
@[simp] theorem map_map (h : β → γ) (g : α → β) (x : Option α) :
    (x.map g).map h = x.map (h ∘ g) 
Arguments: {β : Type u_1} {γ : Type u_2} {α : Type u_3} (h : β → γ) (g : α → β) (x : Option α)
Goal: Option.map h (Option.map g x) = Option.map (h ∘ g) x
-- Option.comp_map
theorem comp_map (h : β → γ) (g : α → β) (x : Option α) : x.map (h ∘ g) = (x.map g).map h 
Arguments: {β : Type u_1} {γ : Type u_2} {α : Type u_3} (h : β → γ) (g : α → β) (x : Option α)
Goal: Option.map (h ∘ g) x = Option.map h (Option.map g x)
-- Option.map_comp_map
@[simp] theorem map_comp_map (f : α → β) (g : β → γ) :
    Option.map g ∘ Option.map f = Option.map (g ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → γ)
Goal: Option.map g ∘ Option.map f = Option.map (g ∘ f)
-- Option.mem_map_of_mem
theorem mem_map_of_mem (g : α → β) (h : a ∈ x) : g a ∈ Option.map g x 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {x : Option α} (g : α → β) (h : a ∈ x)
Goal: g a ∈ Option.map g x
-- Option.bind_map_comm
theorem bind_map_comm {α β} {x : Option (Option α)} {f : α → β} :
    x.bind (Option.map f) = (x.map (Option.map f)).bind id 
Arguments: {α : Type u_1} {β : Type u_2} {x : Option (Option α)} {f : α → β}
Goal: x.bind (Option.map f) = (Option.map (Option.map f) x).bind id
-- Option.join_map_eq_map_join
theorem join_map_eq_map_join {f : α → β} {x : Option (Option α)} :
    (x.map (Option.map f)).join = x.join.map f 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {x : Option (Option α)}
Goal: (Option.map (Option.map f) x).join = Option.map f x.join
-- Option.join_join
theorem join_join {x : Option (Option (Option α))} : x.join.join = (x.map join).join 
Arguments: {α : Type u_1} {x : Option (Option (Option α))}
Goal: x.join.join = (Option.map Option.join x).join
-- Option.mem_of_mem_join
theorem mem_of_mem_join {a : α} {x : Option (Option α)} (h : a ∈ x.join) : some a ∈ x 
Arguments: {α : Type u_1} {a : α} {x : Option (Option α)} (h : a ∈ x.join)
Goal: some a ∈ x
-- Option.some_orElse
@[simp] theorem some_orElse (a : α) (x : Option α) : (some a <|> x) = some a 
Arguments: {α : Type u_1} (a : α) (x : Option α)
Goal: (HOrElse.hOrElse (some a) fun x_1 => x) = some a
-- Option.none_orElse
@[simp] theorem none_orElse (x : Option α) : (none <|> x) = x 
Arguments: {α : Type u_1} (x : Option α)
Goal: (HOrElse.hOrElse none fun x_1 => x) = x
-- Option.orElse_none
@[simp] theorem orElse_none (x : Option α) : (x <|> none) = x 
Arguments: {α : Type u_1} (x : Option α)
Goal: (HOrElse.hOrElse x fun x => none) = x
-- Option.map_orElse
theorem map_orElse {x y : Option α} : (x <|> y).map f = (x.map f <|> y.map f) 
Arguments: {α : Type u_1}
Goal: ∀ {α_1 : Type u_2} {f : α → α_1} {x y : Option α},
  Option.map f (HOrElse.hOrElse x fun x => y) = HOrElse.hOrElse (Option.map f x) fun x => Option.map f y
-- Option.guard_eq_some
@[simp] theorem guard_eq_some [DecidablePred p] : guard p a = some b ↔ a = b ∧ p a 
Goal: ∀ {α : Type u_1} {p : α → Prop} {a b : α} [inst : DecidablePred p], Option.guard p a = some b ↔ a = b ∧ p a
-- Option.liftOrGet_eq_or_eq
theorem liftOrGet_eq_or_eq {f : α → α → α} (h : ∀ a b, f a b = a ∨ f a b = b) :
    ∀ o₁ o₂, liftOrGet f o₁ o₂ = o₁ ∨ liftOrGet f o₁ o₂ = o₂
  
Arguments: {α : Type u_1} {f : α → α → α} (h : ∀ (a b : α), f a b = a ∨ f a b = b) (o₁ o₂ : Option α)
Goal: Option.liftOrGet f o₁ o₂ = o₁ ∨ Option.liftOrGet f o₁ o₂ = o₂
-- Option.liftOrGet_none_left
@[simp] theorem liftOrGet_none_left {f} {b : Option α} : liftOrGet f none b = b 
Arguments: {α : Type u_1} {f : α → α → α} {b : Option α}
Goal: Option.liftOrGet f none b = b
-- Option.liftOrGet_none_right
@[simp] theorem liftOrGet_none_right {f} {a : Option α} : liftOrGet f a none = a 
Arguments: {α : Type u_1} {f : α → α → α} {a : Option α}
Goal: Option.liftOrGet f a none = a
-- Option.liftOrGet_some_some
@[simp] theorem liftOrGet_some_some {f} {a b : α} :
  liftOrGet f (some a) (some b) = f a b 
Arguments: {α : Type u_1} {f : α → α → α} {a b : α}
Goal: Option.liftOrGet f (some a) (some b) = some (f a b)
-- Option.elim_none
@[simp] theorem elim_none (x : β) (f : α → β) : none.elim x f = x 
Arguments: {β : Sort u_1} {α : Type u_2} (x : β) (f : α → β)
Goal: none.elim x f = x
-- Option.elim_some
@[simp] theorem elim_some (x : β) (f : α → β) (a : α) : (some a).elim x f = f a 
Arguments: {β : Sort u_1} {α : Type u_2} (x : β) (f : α → β) (a : α)
Goal: (some a).elim x f = f a
-- Option.getD_map
@[simp] theorem getD_map (f : α → β) (x : α) (o : Option α) :
  (o.map f).getD (f x) = f (getD o x) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : α) (o : Option α)
Goal: (Option.map f o).getD (f x) = f (o.getD x)
-- Option.choice_eq
theorem choice_eq {α : Type _} [Subsingleton α] (a : α) : choice α = some a 
Arguments: {α : Type u_1} [Subsingleton α] (a : α)
Goal: Option.choice α = some a
-- Option.choice_isSome_iff_nonempty
theorem choice_isSome_iff_nonempty {α : Type _} : (choice α).isSome ↔ Nonempty α 
Arguments: {α : Type u_1}
Goal: (Option.choice α).isSome = true ↔ Nonempty α
-- Option.toList_some
@[simp] theorem toList_some (a : α) : (a : Option α).toList = [a] 
Arguments: {α : Type u_1} (a : α)
Goal: (some a).toList = [a]
-- Option.toList_none
@[simp] theorem toList_none (α : Type _) : (none : Option α).toList = [] 
Arguments: (α : Type u_1)
Goal: none.toList = []
-- Nat.min_eq_min
protected theorem min_eq_min (a : Nat) : Nat.min a b = min a b 
Arguments: {b : Nat} (a : Nat)
Goal: a.min b = min a b
-- Nat.min_comm
protected theorem min_comm (a b : Nat) : min a b = min b a 
Arguments: (a b : Nat)
Goal: min a b = min b a
-- Nat.min_le_right
protected theorem min_le_right (a b : Nat) : min a b ≤ b 
Arguments: (a b : Nat)
Goal: min a b ≤ b
-- Nat.min_le_left
protected theorem min_le_left (a b : Nat) : min a b ≤ a 
Arguments: (a b : Nat)
Goal: min a b ≤ a
-- Nat.min_eq_left
protected theorem min_eq_left {a b : Nat} (h : a ≤ b) : min a b = a 
Arguments: {a b : Nat} (h : a ≤ b)
Goal: min a b = a
-- Nat.min_eq_right
protected theorem min_eq_right {a b : Nat} (h : b ≤ a) : min a b = b 
Arguments: {a b : Nat} (h : b ≤ a)
Goal: min a b = b
-- Nat.le_min_of_le_of_le
protected theorem le_min_of_le_of_le {a b c : Nat} : a ≤ b → a ≤ c → a ≤ min b c 
Arguments: {a b c : Nat}
Goal: a ≤ b → a ≤ c → a ≤ min b c
-- Nat.le_min
protected theorem le_min {a b c : Nat} : a ≤ min b c ↔ a ≤ b ∧ a ≤ c 
Arguments: {a b c : Nat}
Goal: a ≤ min b c ↔ a ≤ b ∧ a ≤ c
-- Nat.lt_min
protected theorem lt_min {a b c : Nat} : a < min b c ↔ a < b ∧ a < c 
Arguments: {a b c : Nat}
Goal: a < min b c ↔ a < b ∧ a < c