ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Computation.bind_congr
theorem bind_congr {s1 s2 : Computation α} {f1 f2 : α → Computation β} (h1 : s1 ~ s2)
    (h2 : ∀ a, f1 a ~ f2 a) : bind s1 f1 ~ bind s2 f2 
Arguments: {α : Type u} {β : Type v} {s1 s2 : Computation α} {f1 f2 : α → Computation β} (h1 : s1.Equiv s2) (h2 : ∀ (a : α), (f1 a).Equiv (f2 a))
Goal: (s1.bind f1).Equiv (s2.bind f2)
-- Computation.equiv_pure_of_mem
theorem equiv_pure_of_mem {s : Computation α} {a} (h : a ∈ s) : s ~ pure a 
Arguments: {α : Type u} {s : Computation α} {a : α} (h : a ∈ s)
Goal: s.Equiv (Computation.pure a)
-- Computation.LiftRel.swap
theorem LiftRel.swap (R : α → β → Prop) (ca : Computation α) (cb : Computation β) :
    LiftRel (swap R) cb ca ↔ LiftRel R ca cb 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β)
Goal: Computation.LiftRel (Function.swap R) cb ca ↔ Computation.LiftRel R ca cb
-- Computation.lift_eq_iff_equiv
theorem lift_eq_iff_equiv (c₁ c₂ : Computation α) : LiftRel (· = ·) c₁ c₂ ↔ c₁ ~ c₂ 
Arguments: {α : Type u} (c₁ c₂ : Computation α)
Goal: Computation.LiftRel (fun x x_1 => x = x_1) c₁ c₂ ↔ c₁.Equiv c₂
-- Computation.LiftRel.refl
theorem LiftRel.refl (R : α → α → Prop) (H : Reflexive R) : Reflexive (LiftRel R) 
Arguments: {α : Type u} (R : α → α → Prop) (H : Reflexive R)
Goal: Reflexive (Computation.LiftRel R)
-- Computation.LiftRel.symm
theorem LiftRel.symm (R : α → α → Prop) (H : Symmetric R) : Symmetric (LiftRel R) 
Arguments: {α : Type u} (R : α → α → Prop) (H : Symmetric R)
Goal: Symmetric (Computation.LiftRel R)
-- Computation.LiftRel.trans
theorem LiftRel.trans (R : α → α → Prop) (H : Transitive R) : Transitive (LiftRel R) 
Arguments: {α : Type u} (R : α → α → Prop) (H : Transitive R)
Goal: Transitive (Computation.LiftRel R)
-- Computation.LiftRel.equiv
theorem LiftRel.equiv (R : α → α → Prop) : Equivalence R → Equivalence (LiftRel R)
  
Arguments: {α : Type u} (R : α → α → Prop)
Goal: Equivalence R → Equivalence (Computation.LiftRel R)
-- Computation.LiftRel.imp
theorem LiftRel.imp {R S : α → β → Prop} (H : ∀ {a b}, R a b → S a b) (s t) :
    LiftRel R s t → LiftRel S s t
  
Arguments: {α : Type u} {β : Type v} {R S : α → β → Prop} (H : ∀ {a : α} {b : β}, R a b → S a b) (s : Computation α) (t : Computation β)
Goal: Computation.LiftRel R s t → Computation.LiftRel S s t
-- Computation.terminates_of_liftRel
theorem terminates_of_liftRel {R : α → β → Prop} {s t} :
    LiftRel R s t → (Terminates s ↔ Terminates t)
  
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {s : Computation α} {t : Computation β}
Goal: Computation.LiftRel R s t → (s.Terminates ↔ t.Terminates)
-- Computation.rel_of_liftRel
theorem rel_of_liftRel {R : α → β → Prop} {ca cb} :
    LiftRel R ca cb → ∀ {a b}, a ∈ ca → b ∈ cb → R a b
  
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {ca : Computation α} {cb : Computation β}
Goal: Computation.LiftRel R ca cb → ∀ {a : α} {b : β}, a ∈ ca → b ∈ cb → R a b
-- Computation.liftRel_of_mem
theorem liftRel_of_mem {R : α → β → Prop} {a b ca cb} (ma : a ∈ ca) (mb : b ∈ cb) (ab : R a b) :
    LiftRel R ca cb 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {a : α} {b : β} {ca : Computation α} {cb : Computation β} (ma : a ∈ ca) (mb : b ∈ cb) (ab : R a b)
Goal: Computation.LiftRel R ca cb
-- Computation.exists_of_liftRel_left
theorem exists_of_liftRel_left {R : α → β → Prop} {ca cb} (H : LiftRel R ca cb) {a} (h : a ∈ ca) :
    ∃ b, b ∈ cb ∧ R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {ca : Computation α} {cb : Computation β} (H : Computation.LiftRel R ca cb) {a : α} (h : a ∈ ca)
Goal: ∃ b, b ∈ cb ∧ R a b
-- Computation.exists_of_liftRel_right
theorem exists_of_liftRel_right {R : α → β → Prop} {ca cb} (H : LiftRel R ca cb) {b} (h : b ∈ cb) :
    ∃ a, a ∈ ca ∧ R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {ca : Computation α} {cb : Computation β} (H : Computation.LiftRel R ca cb) {b : β} (h : b ∈ cb)
Goal: ∃ a, a ∈ ca ∧ R a b
-- Computation.liftRel_def
theorem liftRel_def {R : α → β → Prop} {ca cb} :
    LiftRel R ca cb ↔ (Terminates ca ↔ Terminates cb) ∧ ∀ {a b}, a ∈ ca → b ∈ cb → R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {ca : Computation α} {cb : Computation β}
Goal: Computation.LiftRel R ca cb ↔ (ca.Terminates ↔ cb.Terminates) ∧ ∀ {a : α} {b : β}, a ∈ ca → b ∈ cb → R a b
-- Computation.liftRel_bind
theorem liftRel_bind {δ} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : Computation α}
    {s2 : Computation β} {f1 : α → Computation γ} {f2 : β → Computation δ} (h1 : LiftRel R s1 s2)
    (h2 : ∀ {a b}, R a b → LiftRel S (f1 a) (f2 b)) : LiftRel S (bind s1 f1) (bind s2 f2) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : Computation α} {s2 : Computation β} {f1 : α → Computation γ} {f2 : β → Computation δ} (h1 : Computation.LiftRel R s1 s2) (h2 : ∀ {a : α} {b : β}, R a b → Computation.LiftRel S (f1 a) (f2 b))
Goal: Computation.LiftRel S (s1.bind f1) (s2.bind f2)
-- Computation.liftRel_pure_left
@[simp]
theorem liftRel_pure_left (R : α → β → Prop) (a : α) (cb : Computation β) :
    LiftRel R (pure a) cb ↔ ∃ b, b ∈ cb ∧ R a b 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (a : α) (cb : Computation β)
Goal: Computation.LiftRel R (Computation.pure a) cb ↔ ∃ b, b ∈ cb ∧ R a b
-- Computation.liftRel_pure_right
@[simp]
theorem liftRel_pure_right (R : α → β → Prop) (ca : Computation α) (b : β) :
    LiftRel R ca (pure b) ↔ ∃ a, a ∈ ca ∧ R a b 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (b : β)
Goal: Computation.LiftRel R ca (Computation.pure b) ↔ ∃ a, a ∈ ca ∧ R a b
-- Computation.liftRel_pure
@[simp, nolint simpNF]
theorem liftRel_pure (R : α → β → Prop) (a : α) (b : β) :
    LiftRel R (pure a) (pure b) ↔ R a b 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (a : α) (b : β)
Goal: Computation.LiftRel R (Computation.pure a) (Computation.pure b) ↔ R a b
-- Computation.liftRel_think_left
@[simp]
theorem liftRel_think_left (R : α → β → Prop) (ca : Computation α) (cb : Computation β) :
    LiftRel R (think ca) cb ↔ LiftRel R ca cb 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β)
Goal: Computation.LiftRel R ca.think cb ↔ Computation.LiftRel R ca cb
-- Computation.liftRel_think_right
@[simp]
theorem liftRel_think_right (R : α → β → Prop) (ca : Computation α) (cb : Computation β) :
    LiftRel R ca (think cb) ↔ LiftRel R ca cb 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β)
Goal: Computation.LiftRel R ca cb.think ↔ Computation.LiftRel R ca cb
-- Computation.liftRel_mem_cases
theorem liftRel_mem_cases {R : α → β → Prop} {ca cb} (Ha : ∀ a ∈ ca, LiftRel R ca cb)
    (Hb : ∀ b ∈ cb, LiftRel R ca cb) : LiftRel R ca cb 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {ca : Computation α} {cb : Computation β} (Ha : ∀ (a : α), a ∈ ca → Computation.LiftRel R ca cb) (Hb : ∀ (b : β), b ∈ cb → Computation.LiftRel R ca cb)
Goal: Computation.LiftRel R ca cb
-- Computation.liftRel_congr
theorem liftRel_congr {R : α → β → Prop} {ca ca' : Computation α} {cb cb' : Computation β}
    (ha : ca ~ ca') (hb : cb ~ cb') : LiftRel R ca cb ↔ LiftRel R ca' cb' 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {ca ca' : Computation α} {cb cb' : Computation β} (ha : ca.Equiv ca') (hb : cb.Equiv cb')
Goal: Computation.LiftRel R ca cb ↔ Computation.LiftRel R ca' cb'
-- Computation.liftRel_map
theorem liftRel_map {δ} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : Computation α}
    {s2 : Computation β} {f1 : α → γ} {f2 : β → δ} (h1 : LiftRel R s1 s2)
    (h2 : ∀ {a b}, R a b → S (f1 a) (f2 b)) : LiftRel S (map f1 s1) (map f2 s2) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : Computation α} {s2 : Computation β} {f1 : α → γ} {f2 : β → δ} (h1 : Computation.LiftRel R s1 s2) (h2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b))
Goal: Computation.LiftRel S (Computation.map f1 s1) (Computation.map f2 s2)
-- Computation.map_congr
theorem map_congr {s1 s2 : Computation α} {f : α → β}
    (h1 : s1 ~ s2) : map f s1 ~ map f s2 
Arguments: {α : Type u} {β : Type v} {s1 s2 : Computation α} {f : α → β} (h1 : s1.Equiv s2)
Goal: (Computation.map f s1).Equiv (Computation.map f s2)
-- Computation.liftRelAux_inl_inl
@[simp] lemma liftRelAux_inl_inl {a : α} {b : β} :
  LiftRelAux R C (Sum.inl a) (Sum.inl b) = R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {C : Computation α → Computation β → Prop} {a : α} {b : β}
Goal: Computation.LiftRelAux R C (Sum.inl a) (Sum.inl b) = R a b
-- Computation.liftRelAux_inl_inr
@[simp] lemma liftRelAux_inl_inr {a : α} {cb} :
    LiftRelAux R C (Sum.inl a) (Sum.inr cb) = ∃ b, b ∈ cb ∧ R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {C : Computation α → Computation β → Prop} {a : α} {cb : Computation β}
Goal: Computation.LiftRelAux R C (Sum.inl a) (Sum.inr cb) = ∃ b, b ∈ cb ∧ R a b
-- Computation.liftRelAux_inr_inl
@[simp] lemma liftRelAux_inr_inl {b : β} {ca} :
    LiftRelAux R C (Sum.inr ca) (Sum.inl b) = ∃ a, a ∈ ca ∧ R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {C : Computation α → Computation β → Prop} {b : β} {ca : Computation α}
Goal: Computation.LiftRelAux R C (Sum.inr ca) (Sum.inl b) = ∃ a, a ∈ ca ∧ R a b
-- Computation.liftRelAux_inr_inr
@[simp] lemma liftRelAux_inr_inr {ca cb} :
    LiftRelAux R C (Sum.inr ca) (Sum.inr cb) = C ca cb 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {C : Computation α → Computation β → Prop} {ca : Computation α} {cb : Computation β}
Goal: Computation.LiftRelAux R C (Sum.inr ca) (Sum.inr cb) = C ca cb
-- Computation.LiftRelAux.ret_left
@[simp]
theorem LiftRelAux.ret_left (R : α → β → Prop) (C : Computation α → Computation β → Prop) (a cb) :
    LiftRelAux R C (Sum.inl a) (destruct cb) ↔ ∃ b, b ∈ cb ∧ R a b 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (C : Computation α → Computation β → Prop) (a : α) (cb : Computation β)
Goal: Computation.LiftRelAux R C (Sum.inl a) cb.destruct ↔ ∃ b, b ∈ cb ∧ R a b
-- Computation.LiftRelAux.swap
theorem LiftRelAux.swap (R : α → β → Prop) (C) (a b) :
    LiftRelAux (swap R) (swap C) b a = LiftRelAux R C a b 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (C : Computation α → Computation β → Prop) (a : α ⊕ Computation α) (b : β ⊕ Computation β)
Goal: Computation.LiftRelAux (Function.swap R) (Function.swap C) b a = Computation.LiftRelAux R C a b
-- Computation.LiftRelAux.ret_right
@[simp]
theorem LiftRelAux.ret_right (R : α → β → Prop) (C : Computation α → Computation β → Prop) (b ca) :
    LiftRelAux R C (destruct ca) (Sum.inl b) ↔ ∃ a, a ∈ ca ∧ R a b 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (C : Computation α → Computation β → Prop) (b : β) (ca : Computation α)
Goal: Computation.LiftRelAux R C ca.destruct (Sum.inl b) ↔ ∃ a, a ∈ ca ∧ R a b
-- Computation.LiftRelRec.lem
theorem LiftRelRec.lem {R : α → β → Prop} (C : Computation α → Computation β → Prop)
    (H : ∀ {ca cb}, C ca cb → LiftRelAux R C (destruct ca) (destruct cb)) (ca cb) (Hc : C ca cb) (a)
    (ha : a ∈ ca) : LiftRel R ca cb 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} (C : Computation α → Computation β → Prop) (H : ∀ {ca : Computation α} {cb : Computation β}, C ca cb → Computation.LiftRelAux R C ca.destruct cb.destruct) (ca : Computation α) (cb : Computation β) (Hc : C ca cb) (a : α) (ha : a ∈ ca)
Goal: Computation.LiftRel R ca cb
-- Computation.liftRel_rec
theorem liftRel_rec {R : α → β → Prop} (C : Computation α → Computation β → Prop)
    (H : ∀ {ca cb}, C ca cb → LiftRelAux R C (destruct ca) (destruct cb)) (ca cb) (Hc : C ca cb) :
    LiftRel R ca cb 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} (C : Computation α → Computation β → Prop) (H : ∀ {ca : Computation α} {cb : Computation β}, C ca cb → Computation.LiftRelAux R C ca.destruct cb.destruct) (ca : Computation α) (cb : Computation β) (Hc : C ca cb)
Goal: Computation.LiftRel R ca cb
-- Rat.floor_def'
protected theorem floor_def' (a : ℚ) : a.floor = a.num / a.den 
Arguments: (a : ℚ)
Goal: a.floor = a.num / ↑a.den
-- Rat.le_floor
protected theorem le_floor {z : ℤ} : ∀ {r : ℚ}, z ≤ Rat.floor r ↔ (z : ℚ) ≤ r
  
Arguments: {z : ℤ} {r : ℚ}
Goal: z ≤ r.floor ↔ ↑z ≤ r
-- Rat.floor_def
protected theorem floor_def {q : ℚ} : ⌊q⌋ = q.num / q.den 
Arguments: {q : ℚ}
Goal: ⌊q⌋ = q.num / ↑q.den
-- Rat.floor_int_div_nat_eq_div
theorem floor_int_div_nat_eq_div {n : ℤ} {d : ℕ} : ⌊(↑n : ℚ) / (↑d : ℚ)⌋ = n / (↑d : ℤ) 
Arguments: {n : ℤ} {d : ℕ}
Goal: ⌊↑n / ↑d⌋ = n / ↑d
-- Rat.floor_cast
@[simp, norm_cast]
theorem floor_cast (x : ℚ) : ⌊(x : α)⌋ = ⌊x⌋ 
Arguments: {α : Type u_1} [LinearOrderedField α] [FloorRing α] (x : ℚ)
Goal: ⌊↑x⌋ = ⌊x⌋
-- Rat.ceil_cast
@[simp, norm_cast]
theorem ceil_cast (x : ℚ) : ⌈(x : α)⌉ = ⌈x⌉ 
Arguments: {α : Type u_1} [LinearOrderedField α] [FloorRing α] (x : ℚ)
Goal: ⌈↑x⌉ = ⌈x⌉
-- Rat.round_cast
@[simp, norm_cast]
theorem round_cast (x : ℚ) : round (x : α) = round x 
Arguments: {α : Type u_1} [LinearOrderedField α] [FloorRing α] (x : ℚ)
Goal: round ↑x = round x
-- Rat.cast_fract
@[simp, norm_cast]
theorem cast_fract (x : ℚ) : (↑(fract x) : α) = fract (x : α) 
Arguments: {α : Type u_1} [LinearOrderedField α] [FloorRing α] (x : ℚ)
Goal: ↑(Int.fract x) = Int.fract ↑x
-- Int.mod_nat_eq_sub_mul_floor_rat_div
theorem Int.mod_nat_eq_sub_mul_floor_rat_div {n : ℤ} {d : ℕ} : n % d = n - d * ⌊(n : ℚ) / d⌋ 
Arguments: {n : ℤ} {d : ℕ}
Goal: n % ↑d = n - ↑d * ⌊↑n / ↑d⌋
-- Nat.coprime_sub_mul_floor_rat_div_of_coprime
theorem Nat.coprime_sub_mul_floor_rat_div_of_coprime {n d : ℕ} (n_coprime_d : n.Coprime d) :
    ((n : ℤ) - d * ⌊(n : ℚ) / d⌋).natAbs.Coprime d 
Arguments: {n d : ℕ} (n_coprime_d : n.Coprime d)
Goal: (↑n - ↑d * ⌊↑n / ↑d⌋).natAbs.Coprime d
-- Rat.num_lt_succ_floor_mul_den
theorem num_lt_succ_floor_mul_den (q : ℚ) : q.num < (⌊q⌋ + 1) * q.den 
Arguments: (q : ℚ)
Goal: q.num < (⌊q⌋ + 1) * ↑q.den
-- Rat.fract_inv_num_lt_num_of_pos
theorem fract_inv_num_lt_num_of_pos {q : ℚ} (q_pos : 0 < q) : (fract q⁻¹).num < q.num 
Arguments: {q : ℚ} (q_pos : 0 < q)
Goal: (Int.fract q⁻¹).num < q.num
-- PosNum.minFacAux_to_nat
theorem minFacAux_to_nat {fuel : ℕ} {n k : PosNum} (h : Nat.sqrt n < fuel + k.bit1) :
    (minFacAux n fuel k : ℕ) = Nat.minFacAux n k.bit1 
Arguments: {fuel : ℕ} {n k : PosNum} (h : (↑n).sqrt < fuel + ↑k.bit1)
Goal: ↑(n.minFacAux fuel k) = (↑n).minFacAux ↑k.bit1
-- PosNum.minFac_to_nat
@[simp]
theorem minFac_to_nat (n : PosNum) : (minFac n : ℕ) = Nat.minFac n 
Arguments: (n : PosNum)
Goal: ↑n.minFac = (↑n).minFac
-- Num.minFac_to_nat
@[simp]
theorem minFac_to_nat : ∀ n : Num, (minFac n : ℕ) = Nat.minFac n
  
Arguments: (n : Num)
Goal: ↑n.minFac = (↑n).minFac
-- Complex.ofReal_prod
@[simp, norm_cast]
theorem ofReal_prod (f : α → ℝ) : ((∏ i ∈ s, f i : ℝ) : ℂ) = ∏ i ∈ s, (f i : ℂ) 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℝ)
Goal: ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)
-- Complex.ofReal_sum
@[simp, norm_cast]
theorem ofReal_sum (f : α → ℝ) : ((∑ i ∈ s, f i : ℝ) : ℂ) = ∑ i ∈ s, (f i : ℂ) 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℝ)
Goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)
-- Complex.re_sum
@[simp]
theorem re_sum (f : α → ℂ) : (∑ i ∈ s, f i).re = ∑ i ∈ s, (f i).re 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℂ)
Goal: (∑ i ∈ s, f i).re = ∑ i ∈ s, (f i).re
-- Complex.im_sum
@[simp]
theorem im_sum (f : α → ℂ) : (∑ i ∈ s, f i).im = ∑ i ∈ s, (f i).im 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℂ)
Goal: (∑ i ∈ s, f i).im = ∑ i ∈ s, (f i).im
-- PosNum.lor_eq_or
@[simp] lemma lor_eq_or (p q : PosNum) : p.lor q = p ||| q 
Arguments: (p q : PosNum)
Goal: p.lor q = p ||| q
-- PosNum.land_eq_and
@[simp] lemma land_eq_and (p q : PosNum) : p.land q = p &&& q 
Arguments: (p q : PosNum)
Goal: p.land q = p &&& q
-- PosNum.lxor_eq_xor
@[simp] lemma lxor_eq_xor (p q : PosNum) : p.lxor q = p ^^^ q 
Arguments: (p q : PosNum)
Goal: p.lxor q = p ^^^ q
-- PosNum.shiftl_eq_shiftLeft
@[simp] lemma shiftl_eq_shiftLeft (p : PosNum) (n : Nat) : p.shiftl n = p <<< n 
Arguments: (p : PosNum) (n : ℕ)
Goal: p.shiftl n = p <<< n
-- PosNum.shiftl_succ_eq_bit0_shiftl
theorem shiftl_succ_eq_bit0_shiftl : ∀ (p : PosNum) (n : Nat), p <<< n.succ = bit0 (p <<< n)
  
Arguments: (p : PosNum) (n : ℕ)
Goal: p <<< n.succ = (p <<< n).bit0
-- PosNum.shiftr_eq_shiftRight
@[simp] lemma shiftr_eq_shiftRight (p : PosNum) (n : Nat) : p.shiftr n = p >>> n 
Arguments: (p : PosNum) (n : ℕ)
Goal: p.shiftr n = p >>> n
-- Num.lor_eq_or
@[simp] lemma lor_eq_or (p q : Num) : p.lor q = p ||| q 
Arguments: (p q : Num)
Goal: p.lor q = p ||| q
-- Num.land_eq_and
@[simp] lemma land_eq_and (p q : Num) : p.land q = p &&& q 
Arguments: (p q : Num)
Goal: p.land q = p &&& q
-- Num.lxor_eq_xor
@[simp] lemma lxor_eq_xor (p q : Num) : p.lxor q = p ^^^ q 
Arguments: (p q : Num)
Goal: p.lxor q = p ^^^ q
-- Num.shiftl_eq_shiftLeft
@[simp] lemma shiftl_eq_shiftLeft (p : Num) (n : Nat) : p.shiftl n = p <<< n 
Arguments: (p : Num) (n : ℕ)
Goal: p.shiftl n = p <<< n
-- Num.shiftr_eq_shiftRight
@[simp] lemma shiftr_eq_shiftRight (p : Num) (n : Nat) : p.shiftr n = p >>> n 
Arguments: (p : Num) (n : ℕ)
Goal: p.shiftr n = p >>> n
-- SNum.bit_zero
theorem bit_zero (b : Bool) : (b :: zero b) = zero b 
Arguments: (b : Bool)
Goal: SNum.bit b (SNum.zero b) = SNum.zero b
-- SNum.bit_one
theorem bit_one (b : Bool) : (b :: zero (Not b)) = msb b 
Arguments: (b : Bool)
Goal: SNum.bit b (SNum.zero (decide ¬b = true)) = SNum.nz (NzsNum.msb b)
-- Complex.finrank_real_complex
@[simp]
theorem finrank_real_complex : finrank ℝ ℂ = 2 
Goal: FiniteDimensional.finrank ℝ ℂ = 2
-- Complex.rank_real_complex
@[simp]
theorem rank_real_complex : Module.rank ℝ ℂ = 2 
Goal: Module.rank ℝ ℂ = 2
-- Complex.rank_real_complex'
theorem rank_real_complex'.{u} : Cardinal.lift.{u} (Module.rank ℝ ℂ) = 2 
Goal: Cardinal.lift.{u, 0} (Module.rank ℝ ℂ) = 2
-- Complex.finrank_real_complex_fact
theorem finrank_real_complex_fact : Fact (finrank ℝ ℂ = 2) 
Goal: Fact (FiniteDimensional.finrank ℝ ℂ = 2)
-- rank_real_of_complex
theorem rank_real_of_complex (E : Type*) [AddCommGroup E] [Module ℂ E] :
    Module.rank ℝ E = 2 * Module.rank ℂ E 
Arguments: (E : Type u_1) [AddCommGroup E] [Module ℂ E]
Goal: Module.rank ℝ E = 2 * Module.rank ℂ E
-- finrank_real_of_complex
theorem finrank_real_of_complex (E : Type*) [AddCommGroup E] [Module ℂ E] :
    FiniteDimensional.finrank ℝ E = 2 * FiniteDimensional.finrank ℂ E 
Arguments: (E : Type u_1) [AddCommGroup E] [Module ℂ E]
Goal: FiniteDimensional.finrank ℝ E = 2 * FiniteDimensional.finrank ℂ E
-- Real.rank_rat_real
@[simp]
lemma Real.rank_rat_real : Module.rank ℚ ℝ = continuum 
Goal: Module.rank ℚ ℝ = Cardinal.continuum
-- Complex.rank_rat_complex
@[simp]
lemma Complex.rank_rat_complex : Module.rank ℚ ℂ = continuum 
Goal: Module.rank ℚ ℂ = Cardinal.continuum
-- Complex.nonempty_linearEquiv_real
theorem Complex.nonempty_linearEquiv_real : Nonempty (ℂ ≃ₗ[ℚ] ℝ) 
Goal: Nonempty (ℂ ≃ₗ[ℚ] ℝ)
-- Complex.det_conjAe
@[simp]
theorem det_conjAe : LinearMap.det conjAe.toLinearMap = -1 
Goal: LinearMap.det Complex.conjAe.toLinearMap = -1
-- Complex.linearEquiv_det_conjAe
@[simp]
theorem linearEquiv_det_conjAe : LinearEquiv.det conjAe.toLinearEquiv = -1 
Goal: LinearEquiv.det Complex.conjAe.toLinearEquiv = -1
-- Complex.le_def
theorem le_def {z w : ℂ} : z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im 
Arguments: {z w : ℂ}
Goal: z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im
-- Complex.lt_def
theorem lt_def {z w : ℂ} : z < w ↔ z.re < w.re ∧ z.im = w.im 
Arguments: {z w : ℂ}
Goal: z < w ↔ z.re < w.re ∧ z.im = w.im
-- Complex.nonneg_iff
theorem nonneg_iff {z : ℂ} : 0 ≤ z ↔ 0 ≤ z.re ∧ 0 = z.im 
Arguments: {z : ℂ}
Goal: 0 ≤ z ↔ 0 ≤ z.re ∧ 0 = z.im
-- Complex.pos_iff
theorem pos_iff {z : ℂ} : 0 < z ↔ 0 < z.re ∧ 0 = z.im 
Arguments: {z : ℂ}
Goal: 0 < z ↔ 0 < z.re ∧ 0 = z.im
-- Complex.real_le_real
@[simp, norm_cast]
theorem real_le_real {x y : ℝ} : (x : ℂ) ≤ (y : ℂ) ↔ x ≤ y 
Arguments: {x y : ℝ}
Goal: ↑x ≤ ↑y ↔ x ≤ y
-- Complex.real_lt_real
@[simp, norm_cast]
theorem real_lt_real {x y : ℝ} : (x : ℂ) < (y : ℂ) ↔ x < y 
Arguments: {x y : ℝ}
Goal: ↑x < ↑y ↔ x < y
-- Complex.zero_le_real
@[simp, norm_cast]
theorem zero_le_real {x : ℝ} : (0 : ℂ) ≤ (x : ℂ) ↔ 0 ≤ x 
Arguments: {x : ℝ}
Goal: 0 ≤ ↑x ↔ 0 ≤ x
-- Complex.zero_lt_real
@[simp, norm_cast]
theorem zero_lt_real {x : ℝ} : (0 : ℂ) < (x : ℂ) ↔ 0 < x 
Arguments: {x : ℝ}
Goal: 0 < ↑x ↔ 0 < x
-- Complex.not_le_iff
theorem not_le_iff {z w : ℂ} : ¬z ≤ w ↔ w.re < z.re ∨ z.im ≠ w.im 
Arguments: {z w : ℂ}
Goal: ¬z ≤ w ↔ w.re < z.re ∨ z.im ≠ w.im
-- Complex.not_lt_iff
theorem not_lt_iff {z w : ℂ} : ¬z < w ↔ w.re ≤ z.re ∨ z.im ≠ w.im 
Arguments: {z w : ℂ}
Goal: ¬z < w ↔ w.re ≤ z.re ∨ z.im ≠ w.im
-- Complex.not_le_zero_iff
theorem not_le_zero_iff {z : ℂ} : ¬z ≤ 0 ↔ 0 < z.re ∨ z.im ≠ 0 
Arguments: {z : ℂ}
Goal: ¬z ≤ 0 ↔ 0 < z.re ∨ z.im ≠ 0
-- Complex.not_lt_zero_iff
theorem not_lt_zero_iff {z : ℂ} : ¬z < 0 ↔ 0 ≤ z.re ∨ z.im ≠ 0 
Arguments: {z : ℂ}
Goal: ¬z < 0 ↔ 0 ≤ z.re ∨ z.im ≠ 0
-- Complex.eq_re_of_ofReal_le
theorem eq_re_of_ofReal_le {r : ℝ} {z : ℂ} (hz : (r : ℂ) ≤ z) : z = z.re 
Arguments: {r : ℝ} {z : ℂ} (hz : ↑r ≤ z)
Goal: z = ↑z.re
-- Complex.re_eq_abs
@[simp]
lemma re_eq_abs {z : ℂ} : z.re = abs z ↔ 0 ≤ z 
Arguments: {z : ℂ}
Goal: z.re = Complex.abs z ↔ 0 ≤ z
-- Complex.neg_re_eq_abs
@[simp]
lemma neg_re_eq_abs {z : ℂ} : -z.re = abs z ↔ z ≤ 0 
Arguments: {z : ℂ}
Goal: -z.re = Complex.abs z ↔ z ≤ 0
-- Complex.re_eq_neg_abs
@[simp]
lemma re_eq_neg_abs {z : ℂ} : z.re = -abs z ↔ z ≤ 0 
Arguments: {z : ℂ}
Goal: z.re = -Complex.abs z ↔ z ≤ 0
-- Complex.monotone_ofReal
lemma monotone_ofReal : Monotone ofReal' 
Goal: Monotone Complex.ofReal'
-- mk_complex
@[simp]
theorem mk_complex : #ℂ = 𝔠 
Goal: #ℂ = 𝔠
-- mk_univ_complex
-- @[simp] -- Porting note (#10618): simp can prove this
theorem mk_univ_complex : #(Set.univ : Set ℂ) = 𝔠 
Goal: #↑Set.univ = 𝔠
-- not_countable_complex
theorem not_countable_complex : ¬(Set.univ : Set ℂ).Countable 
Goal: ¬Set.univ.Countable
-- Rat.num_dvd
theorem num_dvd (a) {b : ℤ} (b0 : b ≠ 0) : (a /. b).num ∣ a 
Arguments: (a : ℤ) {b : ℤ} (b0 : b ≠ 0)
Goal: (Rat.divInt a b).num ∣ a
-- Rat.den_dvd
theorem den_dvd (a b : ℤ) : ((a /. b).den : ℤ) ∣ b 
Arguments: (a b : ℤ)
Goal: ↑(Rat.divInt a b).den ∣ b
-- Rat.num_den_mk
theorem num_den_mk {q : ℚ} {n d : ℤ} (hd : d ≠ 0) (qdf : q = n /. d) :
    ∃ c : ℤ, n = c * q.num ∧ d = c * q.den 
Arguments: {q : ℚ} {n d : ℤ} (hd : d ≠ 0) (qdf : q = Rat.divInt n d)
Goal: ∃ c, n = c * q.num ∧ d = c * ↑q.den
-- Rat.num_mk
theorem num_mk (n d : ℤ) : (n /. d).num = d.sign * n / n.gcd d 
Arguments: (n d : ℤ)
Goal: (Rat.divInt n d).num = d.sign * n / ↑(n.gcd d)
-- Rat.den_mk
theorem den_mk (n d : ℤ) : (n /. d).den = if d = 0 then 1 else d.natAbs / n.gcd d 
Arguments: (n d : ℤ)
Goal: (Rat.divInt n d).den = if d = 0 then 1 else d.natAbs / n.gcd d
-- Rat.add_den_dvd
theorem add_den_dvd (q₁ q₂ : ℚ) : (q₁ + q₂).den ∣ q₁.den * q₂.den 
Arguments: (q₁ q₂ : ℚ)
Goal: (q₁ + q₂).den ∣ q₁.den * q₂.den
-- Rat.mul_den_dvd
theorem mul_den_dvd (q₁ q₂ : ℚ) : (q₁ * q₂).den ∣ q₁.den * q₂.den 
Arguments: (q₁ q₂ : ℚ)
Goal: (q₁ * q₂).den ∣ q₁.den * q₂.den
-- Rat.mul_num
theorem mul_num (q₁ q₂ : ℚ) :
    (q₁ * q₂).num = q₁.num * q₂.num / Nat.gcd (q₁.num * q₂.num).natAbs (q₁.den * q₂.den) 
Arguments: (q₁ q₂ : ℚ)
Goal: (q₁ * q₂).num = q₁.num * q₂.num / ↑((q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den))
-- Rat.mul_den
theorem mul_den (q₁ q₂ : ℚ) :
    (q₁ * q₂).den =
      q₁.den * q₂.den / Nat.gcd (q₁.num * q₂.num).natAbs (q₁.den * q₂.den) 
Arguments: (q₁ q₂ : ℚ)
Goal: (q₁ * q₂).den = q₁.den * q₂.den / (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den)
-- Rat.mul_self_num
theorem mul_self_num (q : ℚ) : (q * q).num = q.num * q.num 
Arguments: (q : ℚ)
Goal: (q * q).num = q.num * q.num
-- Rat.mul_self_den
theorem mul_self_den (q : ℚ) : (q * q).den = q.den * q.den 
Arguments: (q : ℚ)
Goal: (q * q).den = q.den * q.den
-- Rat.add_num_den
theorem add_num_den (q r : ℚ) :
    q + r = (q.num * r.den + q.den * r.num : ℤ) /. (↑q.den * ↑r.den : ℤ) 
Arguments: (q r : ℚ)
Goal: q + r = Rat.divInt (q.num * ↑r.den + ↑q.den * r.num) (↑q.den * ↑r.den)
-- Rat.isSquare_iff
theorem isSquare_iff {q : ℚ} : IsSquare q ↔ IsSquare q.num ∧ IsSquare q.den 
Arguments: {q : ℚ}
Goal: IsSquare q ↔ IsSquare q.num ∧ IsSquare q.den