ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Rat/Init.lean

full_name: _aux_Mathlib_Data_Rat_Init___macroRules_termℚ_1
code: @[inherit_doc] notation "ℚ" => Rat
goal: Lean.Macro

full_name: _aux_Mathlib_Data_Rat_Init___unexpand_Rat_1
code: @[inherit_doc] notation "ℚ" => Rat
goal: Lean.PrettyPrinter.Unexpander

full_name: NNRat
code: /-- Nonnegative rational numbers. -/
def NNRat 
goal: Type

full_name: «_aux_Mathlib_Data_Rat_Init___macroRules_termℚ≥0_1»
code: @[inherit_doc] notation "ℚ≥0" => NNRat
goal: Lean.Macro

full_name: _aux_Mathlib_Data_Rat_Init___unexpand_NNRat_1
code: @[inherit_doc] notation "ℚ≥0" => NNRat
goal: Lean.PrettyPrinter.Unexpander

full_name: NNRatCast.nnratCast
code: /-- Typeclass for the canonical homomorphism `ℚ≥0 → K`.

This should be considered as a notation typeclass. The sole purpose of this typeclass is to be
extended by `DivisionSemiring`. -/
class NNRatCast (K : Type*) where
  /-- The canonical homomorphism `ℚ≥0 → K`.

  Do not use directly. Use the coercion instead. -/
  protected nnratCast : ℚ≥0 → K
goal: ℚ≥0 → K

full_name: NNRatCast
code: /-- Typeclass for the canonical homomorphism `ℚ≥0 → K`.

This should be considered as a notation typeclass. The sole purpose of this typeclass is to be
extended by `DivisionSemiring`. -/
class NNRatCast (K : Type*) where
  /-- The canonical homomorphism `ℚ≥0 → K`.

  Do not use directly. Use the coercion instead. -/
  protected nnratCast : ℚ≥0 → K
goal: Type u_1

full_name: NNRat.instNNRatCast
code: instance NNRat.instNNRatCast : NNRatCast ℚ≥0 
goal: NNRatCast ℚ≥0

full_name: NNRat.cast
code: /-- Canonical homomorphism from `ℚ≥0` to a division semiring `K`.

This is just the bare function in order to aid in creating instances of `DivisionSemiring`. -/
@[coe, reducible, match_pattern] protected def NNRat.cast : ℚ≥0 → K 
goal: ℚ≥0 → K

full_name: NNRatCast.toCoeTail
code: instance NNRatCast.toCoeTail [NNRatCast K] : CoeTail ℚ≥0 K 
goal: CoeTail ℚ≥0 K

full_name: NNRatCast.toCoeHTCT
code: instance NNRatCast.toCoeHTCT [NNRatCast K] : CoeHTCT ℚ≥0 K 
goal: CoeHTCT ℚ≥0 K

full_name: Rat.instNNRatCast
code: instance Rat.instNNRatCast : NNRatCast ℚ 
goal: NNRatCast ℚ

full_name: NNRat.num
code: /-- The numerator of a nonnegative rational. -/
def num (q : ℚ≥0) : ℕ 
goal: ℕ

full_name: NNRat.den
code: /-- The denominator of a nonnegative rational. -/
def den (q : ℚ≥0) : ℕ 
goal: ℕ

full_name: NNRat.num_mk
code: @[simp] lemma num_mk (q : ℚ) (hq : 0 ≤ q) : num ⟨q, hq⟩ = q.num.natAbs 
goal: NNRat.num ⟨q, hq⟩ = q.num.natAbs

full_name: NNRat.den_mk
code: @[simp] lemma den_mk (q : ℚ) (hq : 0 ≤ q) : den ⟨q, hq⟩ = q.den 
goal: NNRat.den ⟨q, hq⟩ = q.den

full_name: NNRat.cast_id
code: @[norm_cast] lemma cast_id (n : ℚ≥0) : NNRat.cast n = n 
goal: ↑n = n

full_name: NNRat.cast_eq_id
code: @[simp] lemma cast_eq_id : NNRat.cast = id 
goal: NNRat.cast = id

full_name: Rat.cast_id
code: @[norm_cast] lemma cast_id (n : ℚ) : Rat.cast n = n 
goal: ↑n = n

full_name: Rat.cast_eq_id
code: @[simp] lemma cast_eq_id : Rat.cast = id 
goal: Rat.cast = id
File: Mathlib/Data/Rat/Cast/CharZero.lean

full_name: Rat.cast_inj
code: @[simp, norm_cast]
theorem cast_inj [CharZero α] : ∀ {m n : ℚ}, (m : α) = n ↔ m = n
  
goal: ↑m = ↑n ↔ m = n

full_name: Rat.cast_injective
code: theorem cast_injective [CharZero α] : Function.Injective ((↑) : ℚ → α)
  
goal: Function.Injective Rat.cast

full_name: Rat.cast_eq_zero
code: @[simp]
theorem cast_eq_zero [CharZero α] {n : ℚ} : (n : α) = 0 ↔ n = 0 
goal: ↑n = 0 ↔ n = 0

full_name: Rat.cast_ne_zero
code: theorem cast_ne_zero [CharZero α] {n : ℚ} : (n : α) ≠ 0 ↔ n ≠ 0 
goal: ↑n ≠ 0 ↔ n ≠ 0

full_name: Rat.cast_add
code: @[simp, norm_cast]
theorem cast_add [CharZero α] (m n) : ((m + n : ℚ) : α) = m + n 
goal: ↑(m + n) = ↑m + ↑n

full_name: Rat.cast_sub
code: @[simp, norm_cast]
theorem cast_sub [CharZero α] (m n) : ((m - n : ℚ) : α) = m - n 
goal: ↑(m - n) = ↑m - ↑n

full_name: Rat.cast_mul
code: @[simp, norm_cast]
theorem cast_mul [CharZero α] (m n) : ((m * n : ℚ) : α) = m * n 
goal: ↑(m * n) = ↑m * ↑n

full_name: Rat.castHom
code: /-- Coercion `ℚ → α` as a `RingHom`. -/
def castHom : ℚ →+* α 
goal: ℚ →+* α

full_name: Rat.coe_cast_hom
code: @[simp]
theorem coe_cast_hom : ⇑(castHom α) = ((↑) : ℚ → α) 
goal: ⇑(Rat.castHom α) = Rat.cast

full_name: Rat.cast_inv
code: @[simp, norm_cast]
theorem cast_inv (n) : ((n⁻¹ : ℚ) : α) = (n : α)⁻¹ 
goal: ↑n⁻¹ = (↑n)⁻¹

full_name: Rat.cast_div
code: @[simp, norm_cast]
theorem cast_div (m n) : ((m / n : ℚ) : α) = m / n 
goal: ↑(m / n) = ↑m / ↑n

full_name: Rat.cast_zpow
code: @[simp, norm_cast]
theorem cast_zpow (q : ℚ) (n : ℤ) : ((q ^ n : ℚ) : α) = (q : α) ^ n 
goal: ↑(q ^ n) = ↑q ^ n

full_name: Rat.cast_mk
code: @[norm_cast]
theorem cast_mk (a b : ℤ) : (a /. b : α) = a / b 
goal: ↑(Rat.divInt a b) = ↑a / ↑b

full_name: Rat.cast_pow
code: @[simp, norm_cast]
theorem cast_pow (q : ℚ) (k : ℕ) : ↑(q ^ k) = (q : α) ^ k 
goal: ↑(q ^ k) = ↑q ^ k
File: Mathlib/Data/Rat/Denumerable.lean

full_name: Rat.instInfinite
code: instance : Infinite ℚ 
goal: Infinite ℚ

full_name: _private.Mathlib.Data.Rat.Denumerable.0.Rat.denumerable_aux
code: private def denumerable_aux : ℚ ≃ { x : ℤ × ℕ // 0 < x.2 ∧ x.1.natAbs.Coprime x.2 } 
goal: ℚ ≃ { x // 0 < x.2 ∧ x.1.natAbs.Coprime x.2 }

full_name: Rat.instDenumerable
code: /-- **Denumerability of the Rational Numbers** -/
instance instDenumerable : Denumerable ℚ 
goal: Denumerable ℚ

full_name: Cardinal.mkRat
code: theorem Cardinal.mkRat : #ℚ = ℵ₀ 
goal: #ℚ = ℵ₀
File: Mathlib/Data/Rat/Encodable.lean

full_name: Rat.instEncodable
code: instance : Encodable ℚ 
goal: Encodable ℚ
File: Mathlib/Data/Rat/Sqrt.lean

full_name: Rat.sqrt
code: /-- Square root function on rational numbers, defined by taking the (integer) square root of the
numerator and the square root (on natural numbers) of the denominator. -/
@[pp_nodot]
def sqrt (q : ℚ) : ℚ 
goal: ℚ

full_name: Rat.sqrt_eq
code: theorem sqrt_eq (q : ℚ) : Rat.sqrt (q * q) = |q| 
goal: Rat.sqrt (q * q) = |q|

full_name: Rat.exists_mul_self
code: theorem exists_mul_self (x : ℚ) : (∃ q, q * q = x) ↔ Rat.sqrt x * Rat.sqrt x = x 
goal: (∃ q, q * q = x) ↔ Rat.sqrt x * Rat.sqrt x = x

full_name: Rat.sqrt_nonneg
code: lemma sqrt_nonneg (q : ℚ) : 0 ≤ Rat.sqrt q 
goal: 0 ≤ Rat.sqrt q

full_name: Rat.instDecidablePredIsSquare
code: /-- `IsSquare` can be decided on `ℚ` by checking against the square root. -/
instance : DecidablePred (IsSquare : ℚ → Prop) 
goal: DecidablePred IsSquare

full_name: Rat.sqrt_intCast
code: @[simp, norm_cast]
theorem sqrt_intCast (z : ℤ) : Rat.sqrt (z : ℚ) = Int.sqrt z 
goal: Rat.sqrt ↑z = ↑(Int.sqrt z)

full_name: Rat.sqrt_natCast
code: @[simp, norm_cast]
theorem sqrt_natCast (n : ℕ) : Rat.sqrt (n : ℚ) = Nat.sqrt n 
goal: Rat.sqrt ↑n = ↑n.sqrt

full_name: Rat.sqrt_ofNat
code: @[simp]
theorem sqrt_ofNat (n : ℕ) : Rat.sqrt (no_index (OfNat.ofNat n) : ℚ) = Nat.sqrt (OfNat.ofNat n) 
goal: Rat.sqrt (OfNat.ofNat n) = ↑(Nat.sqrt (OfNat.ofNat n))
File: Mathlib/Data/Rat/Star.lean

full_name: NNRat.addSubmonoid_closure_range_pow
code: @[simp] lemma addSubmonoid_closure_range_pow {n : ℕ} (hn₀ : n ≠ 0) :
    closure (range fun x : ℚ≥0 ↦ x ^ n) = ⊤ 
goal: AddSubmonoid.closure (Set.range fun x => x ^ n) = ⊤

full_name: NNRat.addSubmonoid_closure_range_mul_self
code: @[simp] lemma addSubmonoid_closure_range_mul_self : closure (range fun x : ℚ≥0 ↦ x * x) = ⊤ 
goal: AddSubmonoid.closure (Set.range fun x => x * x) = ⊤

full_name: NNRat.instStarOrderedRing
code: instance instStarOrderedRing : StarOrderedRing ℚ≥0 
goal: StarOrderedRing ℚ≥0

full_name: Rat.addSubmonoid_closure_range_pow
code: @[simp] lemma addSubmonoid_closure_range_pow {n : ℕ} (hn₀ : n ≠ 0) (hn : Even n) :
    closure (range fun x : ℚ ↦ x ^ n) = nonneg _ 
goal: AddSubmonoid.closure (Set.range fun x => x ^ n) = AddSubmonoid.nonneg ℚ

full_name: Rat.addSubmonoid_closure_range_mul_self
code: @[simp]
lemma addSubmonoid_closure_range_mul_self : closure (range fun x : ℚ ↦ x * x) = nonneg _ 
goal: AddSubmonoid.closure (Set.range fun x => x * x) = AddSubmonoid.nonneg ℚ

full_name: Rat.instStarOrderedRing
code: instance instStarOrderedRing : StarOrderedRing ℚ 
goal: StarOrderedRing ℚ
File: Mathlib/Data/Complex/Orientation.lean

full_name: Complex.orientation
code: /-- The standard orientation on `ℂ`. -/
protected noncomputable def orientation : Orientation ℝ ℂ (Fin 2) 
goal: Orientation ℝ ℂ (Fin 2)
File: Mathlib/Data/Rat/Floor.lean

full_name: Rat.floor_def'
code: protected theorem floor_def' (a : ℚ) : a.floor = a.num / a.den 
goal: a.floor = a.num / ↑a.den

full_name: Rat.le_floor
code: protected theorem le_floor {z : ℤ} : ∀ {r : ℚ}, z ≤ Rat.floor r ↔ (z : ℚ) ≤ r
  
goal: z ≤ r.floor ↔ ↑z ≤ r

full_name: Rat.instFloorRing
code: instance : FloorRing ℚ 
goal: FloorRing ℚ

full_name: Rat.floor_def
code: protected theorem floor_def {q : ℚ} : ⌊q⌋ = q.num / q.den 
goal: ⌊q⌋ = q.num / ↑q.den

full_name: Rat.floor_int_div_nat_eq_div
code: theorem floor_int_div_nat_eq_div {n : ℤ} {d : ℕ} : ⌊(↑n : ℚ) / (↑d : ℚ)⌋ = n / (↑d : ℤ) 
goal: ⌊↑n / ↑d⌋ = n / ↑d

full_name: Rat.floor_cast
code: @[simp, norm_cast]
theorem floor_cast (x : ℚ) : ⌊(x : α)⌋ = ⌊x⌋ 
goal: ⌊↑x⌋ = ⌊x⌋

full_name: Rat.ceil_cast
code: @[simp, norm_cast]
theorem ceil_cast (x : ℚ) : ⌈(x : α)⌉ = ⌈x⌉ 
goal: ⌈↑x⌉ = ⌈x⌉

full_name: Rat.round_cast
code: @[simp, norm_cast]
theorem round_cast (x : ℚ) : round (x : α) = round x 
goal: round ↑x = round x

full_name: Rat.cast_fract
code: @[simp, norm_cast]
theorem cast_fract (x : ℚ) : (↑(fract x) : α) = fract (x : α) 
goal: ↑(Int.fract x) = Int.fract ↑x

full_name: Int.mod_nat_eq_sub_mul_floor_rat_div
code: theorem Int.mod_nat_eq_sub_mul_floor_rat_div {n : ℤ} {d : ℕ} : n % d = n - d * ⌊(n : ℚ) / d⌋ 
goal: n % ↑d = n - ↑d * ⌊↑n / ↑d⌋

full_name: Nat.coprime_sub_mul_floor_rat_div_of_coprime
code: 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 
goal: (↑n - ↑d * ⌊↑n / ↑d⌋).natAbs.Coprime d

full_name: Rat.num_lt_succ_floor_mul_den
code: theorem num_lt_succ_floor_mul_den (q : ℚ) : q.num < (⌊q⌋ + 1) * q.den 
goal: q.num < (⌊q⌋ + 1) * ↑q.den

full_name: Rat.fract_inv_num_lt_num_of_pos
code: theorem fract_inv_num_lt_num_of_pos {q : ℚ} (q_pos : 0 < q) : (fract q⁻¹).num < q.num 
goal: (Int.fract q⁻¹).num < q.num
File: Mathlib/Data/Num/Prime.lean

full_name: PosNum.minFacAux
code: /-- Auxiliary function for computing the smallest prime factor of a `PosNum`. Unlike
`Nat.minFacAux`, we use a natural number `fuel` variable that is set to an upper bound on the
number of iterations. It is initialized to the number `n` we are determining primality for. Even
though this is exponential in the input (since it is a `Nat`, not a `Num`), it will get lazily
evaluated during kernel reduction, so we will only require about `sqrt n` unfoldings, for the
`sqrt n` iterations of the loop. -/
def minFacAux (n : PosNum) : ℕ → PosNum → PosNum
  
goal: ℕ → PosNum → PosNum

full_name: PosNum.minFacAux_to_nat
code: theorem minFacAux_to_nat {fuel : ℕ} {n k : PosNum} (h : Nat.sqrt n < fuel + k.bit1) :
    (minFacAux n fuel k : ℕ) = Nat.minFacAux n k.bit1 
goal: ↑(n.minFacAux fuel k) = (↑n).minFacAux ↑k.bit1

full_name: PosNum.minFac
code: /-- Returns the smallest prime factor of `n ≠ 1`. -/
def minFac : PosNum → PosNum
  
goal: PosNum → PosNum

full_name: PosNum.minFac_to_nat
code: @[simp]
theorem minFac_to_nat (n : PosNum) : (minFac n : ℕ) = Nat.minFac n 
goal: ↑n.minFac = (↑n).minFac

full_name: PosNum.Prime
code: /-- Primality predicate for a `PosNum`. -/
@[simp]
def Prime (n : PosNum) : Prop 
goal: Prop

full_name: PosNum.decidablePrime
code: instance decidablePrime : DecidablePred PosNum.Prime
  
goal: DecidablePred PosNum.Prime

full_name: Num.minFac
code: /-- Returns the smallest prime factor of `n ≠ 1`. -/
def minFac : Num → PosNum
  
goal: Num → PosNum

full_name: Num.minFac_to_nat
code: @[simp]
theorem minFac_to_nat : ∀ n : Num, (minFac n : ℕ) = Nat.minFac n
  
goal: ↑n.minFac = (↑n).minFac

full_name: Num.Prime
code: /-- Primality predicate for a `Num`. -/
@[simp]
def Prime (n : Num) : Prop 
goal: Prop

full_name: Num.decidablePrime
code: instance decidablePrime : DecidablePred Num.Prime
  
goal: DecidablePred Num.Prime
File: Mathlib/Data/Complex/BigOperators.lean

full_name: Complex.ofReal_prod
code: @[simp, norm_cast]
theorem ofReal_prod (f : α → ℝ) : ((∏ i ∈ s, f i : ℝ) : ℂ) = ∏ i ∈ s, (f i : ℂ) 
goal: ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)

full_name: Complex.ofReal_sum
code: @[simp, norm_cast]
theorem ofReal_sum (f : α → ℝ) : ((∑ i ∈ s, f i : ℝ) : ℂ) = ∑ i ∈ s, (f i : ℂ) 
goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

full_name: Complex.re_sum
code: @[simp]
theorem re_sum (f : α → ℂ) : (∑ i ∈ s, f i).re = ∑ i ∈ s, (f i).re 
goal: (∑ i ∈ s, f i).re = ∑ i ∈ s, (f i).re

full_name: Complex.im_sum
code: @[simp]
theorem im_sum (f : α → ℂ) : (∑ i ∈ s, f i).im = ∑ i ∈ s, (f i).im 
goal: (∑ i ∈ s, f i).im = ∑ i ∈ s, (f i).im
File: Mathlib/Data/Complex/FiniteDimensional.lean

full_name: Complex.instFiniteDimensionalReal
code: instance : FiniteDimensional ℝ ℂ 
goal: FiniteDimensional ℝ ℂ

full_name: Complex.finrank_real_complex
code: @[simp]
theorem finrank_real_complex : finrank ℝ ℂ = 2 
goal: FiniteDimensional.finrank ℝ ℂ = 2

full_name: Complex.rank_real_complex
code: @[simp]
theorem rank_real_complex : Module.rank ℝ ℂ = 2 
goal: Module.rank ℝ ℂ = 2

full_name: Complex.rank_real_complex'
code: theorem rank_real_complex'.{u} : Cardinal.lift.{u} (Module.rank ℝ ℂ) = 2 
goal: Cardinal.lift.{u, 0} (Module.rank ℝ ℂ) = 2

full_name: Complex.finrank_real_complex_fact
code: /-- `Fact` version of the dimension of `ℂ` over `ℝ`, locally useful in the definition of the
circle. -/
theorem finrank_real_complex_fact : Fact (finrank ℝ ℂ = 2) 
goal: Fact (FiniteDimensional.finrank ℝ ℂ = 2)

full_name: FiniteDimensional.complexToReal
code: instance (priority := 100) FiniteDimensional.complexToReal (E : Type*) [AddCommGroup E]
    [Module ℂ E] [FiniteDimensional ℂ E] : FiniteDimensional ℝ E 
goal: FiniteDimensional ℝ E

full_name: rank_real_of_complex
code: theorem rank_real_of_complex (E : Type*) [AddCommGroup E] [Module ℂ E] :
    Module.rank ℝ E = 2 * Module.rank ℂ E 
goal: Module.rank ℝ E = 2 * Module.rank ℂ E

full_name: finrank_real_of_complex
code: theorem finrank_real_of_complex (E : Type*) [AddCommGroup E] [Module ℂ E] :
    FiniteDimensional.finrank ℝ E = 2 * FiniteDimensional.finrank ℂ E 
goal: FiniteDimensional.finrank ℝ E = 2 * FiniteDimensional.finrank ℂ E

full_name: Real.rank_rat_real
code: @[simp]
lemma Real.rank_rat_real : Module.rank ℚ ℝ = continuum 
goal: Module.rank ℚ ℝ = Cardinal.continuum

full_name: Complex.rank_rat_complex
code: @[simp]
lemma Complex.rank_rat_complex : Module.rank ℚ ℂ = continuum 
goal: Module.rank ℚ ℂ = Cardinal.continuum

full_name: Complex.nonempty_linearEquiv_real
code: /-- `ℂ` and `ℝ` are isomorphic as vector spaces over `ℚ`, or equivalently,
as additive groups. -/
theorem Complex.nonempty_linearEquiv_real : Nonempty (ℂ ≃ₗ[ℚ] ℝ) 
goal: Nonempty (ℂ ≃ₗ[ℚ] ℝ)
File: Mathlib/Data/Complex/Determinant.lean

full_name: Complex.det_conjAe
code: /-- The determinant of `conjAe`, as a linear map. -/
@[simp]
theorem det_conjAe : LinearMap.det conjAe.toLinearMap = -1 
goal: LinearMap.det Complex.conjAe.toLinearMap = -1

full_name: Complex.linearEquiv_det_conjAe
code: /-- The determinant of `conjAe`, as a linear equiv. -/
@[simp]
theorem linearEquiv_det_conjAe : LinearEquiv.det conjAe.toLinearEquiv = -1 
goal: LinearEquiv.det Complex.conjAe.toLinearEquiv = -1
File: Mathlib/Data/Complex/Order.lean

full_name: Complex.partialOrder
code: /-- We put a partial order on ℂ so that `z ≤ w` exactly if `w - z` is real and nonnegative.
Complex numbers with different imaginary parts are incomparable.
-/
protected def partialOrder : PartialOrder ℂ 
goal: PartialOrder ℂ

full_name: Complex.le_def
code: theorem le_def {z w : ℂ} : z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im 
goal: z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im

full_name: Complex.lt_def
code: theorem lt_def {z w : ℂ} : z < w ↔ z.re < w.re ∧ z.im = w.im 
goal: z < w ↔ z.re < w.re ∧ z.im = w.im

full_name: Complex.nonneg_iff
code: theorem nonneg_iff {z : ℂ} : 0 ≤ z ↔ 0 ≤ z.re ∧ 0 = z.im 
goal: 0 ≤ z ↔ 0 ≤ z.re ∧ 0 = z.im

full_name: Complex.pos_iff
code: theorem pos_iff {z : ℂ} : 0 < z ↔ 0 < z.re ∧ 0 = z.im 
goal: 0 < z ↔ 0 < z.re ∧ 0 = z.im

full_name: Complex.real_le_real
code: @[simp, norm_cast]
theorem real_le_real {x y : ℝ} : (x : ℂ) ≤ (y : ℂ) ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: Complex.real_lt_real
code: @[simp, norm_cast]
theorem real_lt_real {x y : ℝ} : (x : ℂ) < (y : ℂ) ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: Complex.zero_le_real
code: @[simp, norm_cast]
theorem zero_le_real {x : ℝ} : (0 : ℂ) ≤ (x : ℂ) ↔ 0 ≤ x 
goal: 0 ≤ ↑x ↔ 0 ≤ x

full_name: Complex.zero_lt_real
code: @[simp, norm_cast]
theorem zero_lt_real {x : ℝ} : (0 : ℂ) < (x : ℂ) ↔ 0 < x 
goal: 0 < ↑x ↔ 0 < x

full_name: Complex.not_le_iff
code: theorem not_le_iff {z w : ℂ} : ¬z ≤ w ↔ w.re < z.re ∨ z.im ≠ w.im 
goal: ¬z ≤ w ↔ w.re < z.re ∨ z.im ≠ w.im

full_name: Complex.not_lt_iff
code: theorem not_lt_iff {z w : ℂ} : ¬z < w ↔ w.re ≤ z.re ∨ z.im ≠ w.im 
goal: ¬z < w ↔ w.re ≤ z.re ∨ z.im ≠ w.im

full_name: Complex.not_le_zero_iff
code: theorem not_le_zero_iff {z : ℂ} : ¬z ≤ 0 ↔ 0 < z.re ∨ z.im ≠ 0 
goal: ¬z ≤ 0 ↔ 0 < z.re ∨ z.im ≠ 0

full_name: Complex.not_lt_zero_iff
code: theorem not_lt_zero_iff {z : ℂ} : ¬z < 0 ↔ 0 ≤ z.re ∨ z.im ≠ 0 
goal: ¬z < 0 ↔ 0 ≤ z.re ∨ z.im ≠ 0

full_name: Complex.eq_re_of_ofReal_le
code: theorem eq_re_of_ofReal_le {r : ℝ} {z : ℂ} (hz : (r : ℂ) ≤ z) : z = z.re 
goal: z = ↑z.re

full_name: Complex.re_eq_abs
code: @[simp]
lemma re_eq_abs {z : ℂ} : z.re = abs z ↔ 0 ≤ z 
goal: z.re = Complex.abs z ↔ 0 ≤ z

full_name: Complex.neg_re_eq_abs
code: @[simp]
lemma neg_re_eq_abs {z : ℂ} : -z.re = abs z ↔ z ≤ 0 
goal: -z.re = Complex.abs z ↔ z ≤ 0

full_name: Complex.re_eq_neg_abs
code: @[simp]
lemma re_eq_neg_abs {z : ℂ} : z.re = -abs z ↔ z ≤ 0 
goal: z.re = -Complex.abs z ↔ z ≤ 0

full_name: Complex.monotone_ofReal
code: lemma monotone_ofReal : Monotone ofReal' 
goal: Monotone Complex.ofReal'

full_name: Mathlib.Meta.Positivity.evalComplexOfReal
code: /-- Extension for the `positivity` tactic: `Complex.ofReal` is positive/nonnegative/nonzero if its
input is. -/
@[positivity Complex.ofReal' _, Complex.ofReal _]
def evalComplexOfReal : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt
File: Mathlib/Data/Complex/Cardinality.lean

full_name: mk_complex
code: /-- The cardinality of the complex numbers, as a type. -/
@[simp]
theorem mk_complex : #ℂ = 𝔠 
goal: #ℂ = 𝔠

full_name: mk_univ_complex
code: /-- The cardinality of the complex numbers, as a set. -/
-- @[simp] -- Porting note (#10618): simp can prove this
theorem mk_univ_complex : #(Set.univ : Set ℂ) = 𝔠 
goal: #↑Set.univ = 𝔠

full_name: not_countable_complex
code: /-- The complex numbers are not countable. -/
theorem not_countable_complex : ¬(Set.univ : Set ℂ).Countable 
goal: ¬Set.univ.Countable
File: Mathlib/Data/Complex/ExponentialBounds.lean

full_name: Real.exp_one_near_10
code: theorem exp_one_near_10 : |exp 1 - 2244083 / 825552| ≤ 1 / 10 ^ 10 
goal: |Real.exp 1 - 2244083 / 825552| ≤ 1 / 10 ^ 10

full_name: Real.exp_one_near_20
code: theorem exp_one_near_20 : |exp 1 - 363916618873 / 133877442384| ≤ 1 / 10 ^ 20 
goal: |Real.exp 1 - 363916618873 / 133877442384| ≤ 1 / 10 ^ 20

full_name: Real.exp_one_gt_d9
code: theorem exp_one_gt_d9 : 2.7182818283 < exp 1 
goal: 2.7182818283 < Real.exp 1

full_name: Real.exp_one_lt_d9
code: theorem exp_one_lt_d9 : exp 1 < 2.7182818286 
goal: Real.exp 1 < 2.7182818286

full_name: Real.exp_neg_one_gt_d9
code: theorem exp_neg_one_gt_d9 : 0.36787944116 < exp (-1) 
goal: 0.36787944116 < Real.exp (-1)

full_name: Real.exp_neg_one_lt_d9
code: theorem exp_neg_one_lt_d9 : exp (-1) < 0.3678794412 
goal: Real.exp (-1) < 0.3678794412

full_name: Real.log_two_near_10
code: theorem log_two_near_10 : |log 2 - 287209 / 414355| ≤ 1 / 10 ^ 10 
goal: |Real.log 2 - 287209 / 414355| ≤ 1 / 10 ^ 10

full_name: Real.log_two_gt_d9
code: theorem log_two_gt_d9 : 0.6931471803 < log 2 
goal: 0.6931471803 < Real.log 2

full_name: Real.log_two_lt_d9
code: theorem log_two_lt_d9 : log 2 < 0.6931471808 
goal: Real.log 2 < 0.6931471808
File: Mathlib/Data/Seq/Parallel.lean

full_name: Computation.parallel.aux2
code: def parallel.aux2 : List (Computation α) → α ⊕ (List (Computation α)) 
goal: List (Computation α) → α ⊕ List (Computation α)

full_name: Computation.parallel.aux1
code: def parallel.aux1 :
    List (Computation α) × WSeq (Computation α) →
      α ⊕ (List (Computation α) × WSeq (Computation α))
  
goal: List (Computation α) × Stream'.WSeq (Computation α) → α ⊕ List (Computation α) × Stream'.WSeq (Computation α)

full_name: Computation.parallel
code: /-- Parallel computation of an infinite stream of computations,
  taking the first result -/
def parallel (S : WSeq (Computation α)) : Computation α 
goal: Computation α

full_name: Computation.terminates_parallel.aux
code: theorem terminates_parallel.aux :
    ∀ {l : List (Computation α)} {S c},
      c ∈ l → Terminates c → Terminates (corec parallel.aux1 (l, S)) 
goal: c ∈ l → c.Terminates → (Computation.corec Computation.parallel.aux1 (l, S)).Terminates

full_name: Computation.terminates_parallel
code: theorem terminates_parallel {S : WSeq (Computation α)} {c} (h : c ∈ S) [T : Terminates c] :
    Terminates (parallel S) 
goal: (Computation.parallel S).Terminates

full_name: Computation.exists_of_mem_parallel
code: theorem exists_of_mem_parallel {S : WSeq (Computation α)} {a} (h : a ∈ parallel S) :
    ∃ c ∈ S, a ∈ c 
goal: ∃ c, c ∈ S ∧ a ∈ c

full_name: Computation.map_parallel
code: theorem map_parallel (f : α → β) (S) : map f (parallel S) = parallel (S.map (map f)) 
goal: Computation.map f (Computation.parallel S) = Computation.parallel (Stream'.WSeq.map (Computation.map f) S)

full_name: Computation.parallel_empty
code: theorem parallel_empty (S : WSeq (Computation α)) (h : S.head ~> none) : parallel S = empty _ 
goal: Computation.parallel S = Computation.empty α

full_name: Computation.parallelRec
code: def parallelRec {S : WSeq (Computation α)} (C : α → Sort v) (H : ∀ s ∈ S, ∀ a ∈ s, C a) {a}
    (h : a ∈ parallel S) : C a 
goal: C a

full_name: Computation.parallel_promises
code: theorem parallel_promises {S : WSeq (Computation α)} {a} (H : ∀ s ∈ S, s ~> a) : parallel S ~> a 
goal: (Computation.parallel S).Promises a

full_name: Computation.mem_parallel
code: theorem mem_parallel {S : WSeq (Computation α)} {a} (H : ∀ s ∈ S, s ~> a) {c} (cs : c ∈ S)
    (ac : a ∈ c) : a ∈ parallel S 
goal: a ∈ Computation.parallel S

full_name: Computation.parallel_congr_lem
code: theorem parallel_congr_lem {S T : WSeq (Computation α)} {a} (H : S.LiftRel Equiv T) :
    (∀ s ∈ S, s ~> a) ↔ ∀ t ∈ T, t ~> a 
goal: (∀ (s : Computation α), s ∈ S → s.Promises a) ↔ ∀ (t : Computation α), t ∈ T → t.Promises a

full_name: Computation.parallel_congr_left
code: theorem parallel_congr_left {S T : WSeq (Computation α)} {a} (h1 : ∀ s ∈ S, s ~> a)
    (H : S.LiftRel Equiv T) : parallel S ~ parallel T 
goal: (Computation.parallel S).Equiv (Computation.parallel T)

full_name: Computation.parallel_congr_right
code: theorem parallel_congr_right {S T : WSeq (Computation α)} {a} (h2 : ∀ t ∈ T, t ~> a)
    (H : S.LiftRel Equiv T) : parallel S ~ parallel T 
goal: (Computation.parallel S).Equiv (Computation.parallel T)