File: Mathlib/Data/Real/Basic.lean

full_name: Real.cauchy
code: /-- The type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational
numbers. -/
structure Real where ofCauchy ::
  /-- The underlying Cauchy completion -/
  cauchy : CauSeq.Completion.Cauchy (abs : ℚ → ℚ)
goal: CauSeq.Completion.Cauchy abs

full_name: Real
code: /-- The type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational
numbers. -/
structure Real where ofCauchy ::
  /-- The underlying Cauchy completion -/
  cauchy : CauSeq.Completion.Cauchy (abs : ℚ → ℚ)
goal: Type

full_name: Real.ofCauchy
code: /-- The type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational
numbers. -/
structure Real where ofCauchy ::
  /-- The underlying Cauchy completion -/
  cauchy : CauSeq.Completion.Cauchy (abs : ℚ → ℚ)
goal: ℝ

full_name: _aux_Mathlib_Data_Real_Basic___unexpand_Real_1
code: @[inherit_doc]
notation "ℝ" => Real
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Data_Real_Basic___macroRules_termℝ_1
code: @[inherit_doc]
notation "ℝ" => Real
goal: Lean.Macro

full_name: CauSeq.Completion.ofRat_rat
code: @[simp]
theorem ofRat_rat {abv : ℚ → ℚ} [IsAbsoluteValue abv] (q : ℚ) :
    ofRat (q : ℚ) = (q : Cauchy abv) 
goal: CauSeq.Completion.ofRat q = ↑q

full_name: Real.ext_cauchy_iff
code: theorem ext_cauchy_iff : ∀ {x y : Real}, x = y ↔ x.cauchy = y.cauchy
  
goal: x = y ↔ x.cauchy = y.cauchy

full_name: Real.ext_cauchy
code: theorem ext_cauchy {x y : Real} : x.cauchy = y.cauchy → x = y 
goal: x.cauchy = y.cauchy → x = y

full_name: Real.equivCauchy
code: /-- The real numbers are isomorphic to the quotient of Cauchy sequences on the rationals. -/
def equivCauchy : ℝ ≃ CauSeq.Completion.Cauchy (abs : ℚ → ℚ) 
goal: ℝ ≃ CauSeq.Completion.Cauchy abs

full_name: _private.Mathlib.Data.Real.Basic.0.Real.zero_def
code: private irreducible_def zero : ℝ 
goal: Real.zero = { cauchy := 0 }

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.437
code: private irreducible_def zero : ℝ 
goal: Subtype (Eq Real.definition✝)

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.437
code: private irreducible_def zero : ℝ 
goal: ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.zero
code: private irreducible_def zero : ℝ 
goal: ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.one
code: private irreducible_def one : ℝ 
goal: ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.one_def
code: private irreducible_def one : ℝ 
goal: Real.one = { cauchy := 1 }

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.572
code: private irreducible_def one : ℝ 
goal: Subtype (Eq Real.definition✝)

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.572
code: private irreducible_def one : ℝ 
goal: ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.add
code: private irreducible_def add : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.add_def
code: private irreducible_def add : ℝ → ℝ → ℝ
  
goal: ∀ (x x_1 : ℝ),
  Real.add x x_1 =
    match x, x_1 with
    | { cauchy := a }, { cauchy := b } => { cauchy := a + b }

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.707
code: private irreducible_def add : ℝ → ℝ → ℝ
  
goal: Subtype (Eq Real.definition✝)

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.707
code: private irreducible_def add : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.894
code: private irreducible_def neg : ℝ → ℝ
  
goal: ℝ → ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.neg
code: private irreducible_def neg : ℝ → ℝ
  
goal: ℝ → ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.neg_def
code: private irreducible_def neg : ℝ → ℝ
  
goal: ∀ (x : ℝ),
  Real.neg x =
    match x with
    | { cauchy := a } => { cauchy := -a }

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.894
code: private irreducible_def neg : ℝ → ℝ
  
goal: Subtype (Eq Real.definition✝)

full_name: _private.Mathlib.Data.Real.Basic.0.Real.mul_def
code: private irreducible_def mul : ℝ → ℝ → ℝ
  
goal: ∀ (x x_1 : ℝ),
  Real.mul x x_1 =
    match x, x_1 with
    | { cauchy := a }, { cauchy := b } => { cauchy := a * b }

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.1057
code: private irreducible_def mul : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.1057
code: private irreducible_def mul : ℝ → ℝ → ℝ
  
goal: Subtype (Eq Real.definition✝)

full_name: _private.Mathlib.Data.Real.Basic.0.Real.mul
code: private irreducible_def mul : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.1244
code: private noncomputable irreducible_def inv' : ℝ → ℝ
  
goal: Subtype (Eq Real.definition✝)

full_name: _private.Mathlib.Data.Real.Basic.0.Real.inv'_def
code: private noncomputable irreducible_def inv' : ℝ → ℝ
  
goal: ∀ (x : ℝ),
  Real.inv' x =
    match x with
    | { cauchy := a } => { cauchy := a⁻¹ }

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.1244
code: private noncomputable irreducible_def inv' : ℝ → ℝ
  
goal: ℝ → ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.inv'
code: private noncomputable irreducible_def inv' : ℝ → ℝ
  
goal: ℝ → ℝ

full_name: Real.instZero
code: instance : Zero ℝ 
goal: Zero ℝ

full_name: Real.instOne
code: instance : One ℝ 
goal: One ℝ

full_name: Real.instAdd
code: instance : Add ℝ 
goal: Add ℝ

full_name: Real.instNeg
code: instance : Neg ℝ 
goal: Neg ℝ

full_name: Real.instMul
code: instance : Mul ℝ 
goal: Mul ℝ

full_name: Real.instSub
code: instance : Sub ℝ 
goal: Sub ℝ

full_name: Real.instInv
code: noncomputable instance : Inv ℝ 
goal: Inv ℝ

full_name: Real.ofCauchy_zero
code: theorem ofCauchy_zero : (⟨0⟩ : ℝ) = 0 
goal: { cauchy := 0 } = 0

full_name: Real.ofCauchy_one
code: theorem ofCauchy_one : (⟨1⟩ : ℝ) = 1 
goal: { cauchy := 1 } = 1

full_name: Real.ofCauchy_add
code: theorem ofCauchy_add (a b) : (⟨a + b⟩ : ℝ) = ⟨a⟩ + ⟨b⟩ 
goal: { cauchy := a + b } = { cauchy := a } + { cauchy := b }

full_name: Real.ofCauchy_neg
code: theorem ofCauchy_neg (a) : (⟨-a⟩ : ℝ) = -⟨a⟩ 
goal: { cauchy := -a } = -{ cauchy := a }

full_name: Real.ofCauchy_sub
code: theorem ofCauchy_sub (a b) : (⟨a - b⟩ : ℝ) = ⟨a⟩ - ⟨b⟩ 
goal: { cauchy := a - b } = { cauchy := a } - { cauchy := b }

full_name: Real.ofCauchy_mul
code: theorem ofCauchy_mul (a b) : (⟨a * b⟩ : ℝ) = ⟨a⟩ * ⟨b⟩ 
goal: { cauchy := a * b } = { cauchy := a } * { cauchy := b }

full_name: Real.ofCauchy_inv
code: theorem ofCauchy_inv {f} : (⟨f⁻¹⟩ : ℝ) = ⟨f⟩⁻¹ 
goal: { cauchy := f⁻¹ } = { cauchy := f }⁻¹

full_name: Real.cauchy_zero
code: theorem cauchy_zero : (0 : ℝ).cauchy = 0 
goal: Real.cauchy 0 = 0

full_name: Real.cauchy_one
code: theorem cauchy_one : (1 : ℝ).cauchy = 1 
goal: Real.cauchy 1 = 1

full_name: Real.cauchy_add
code: theorem cauchy_add : ∀ a b, (a + b : ℝ).cauchy = a.cauchy + b.cauchy
  
goal: (a + b).cauchy = a.cauchy + b.cauchy

full_name: Real.cauchy_neg
code: theorem cauchy_neg : ∀ a, (-a : ℝ).cauchy = -a.cauchy
  
goal: (-a).cauchy = -a.cauchy

full_name: Real.cauchy_mul
code: theorem cauchy_mul : ∀ a b, (a * b : ℝ).cauchy = a.cauchy * b.cauchy
  
goal: (a * b).cauchy = a.cauchy * b.cauchy

full_name: Real.cauchy_sub
code: theorem cauchy_sub : ∀ a b, (a - b : ℝ).cauchy = a.cauchy - b.cauchy
  
goal: (a - b).cauchy = a.cauchy - b.cauchy

full_name: Real.cauchy_inv
code: theorem cauchy_inv : ∀ f, (f⁻¹ : ℝ).cauchy = f.cauchy⁻¹
  
goal: f⁻¹.cauchy = f.cauchy⁻¹

full_name: Real.instNatCast
code: instance instNatCast : NatCast ℝ 
goal: NatCast ℝ

full_name: Real.instIntCast
code: instance instIntCast : IntCast ℝ 
goal: IntCast ℝ

full_name: Real.instNNRatCast
code: instance instNNRatCast : NNRatCast ℝ 
goal: NNRatCast ℝ

full_name: Real.instRatCast
code: instance instRatCast : RatCast ℝ 
goal: RatCast ℝ

full_name: Real.ofCauchy_natCast
code: lemma ofCauchy_natCast (n : ℕ) : (⟨n⟩ : ℝ) = n 
goal: { cauchy := ↑n } = ↑n

full_name: Real.ofCauchy_intCast
code: lemma ofCauchy_intCast (z : ℤ) : (⟨z⟩ : ℝ) = z 
goal: { cauchy := ↑z } = ↑z

full_name: Real.ofCauchy_nnratCast
code: lemma ofCauchy_nnratCast (q : ℚ≥0) : (⟨q⟩ : ℝ) = q 
goal: { cauchy := ↑q } = ↑q

full_name: Real.ofCauchy_ratCast
code: lemma ofCauchy_ratCast (q : ℚ) : (⟨q⟩ : ℝ) = q 
goal: { cauchy := ↑q } = ↑q

full_name: Real.cauchy_natCast
code: lemma cauchy_natCast (n : ℕ) : (n : ℝ).cauchy = n 
goal: (↑n).cauchy = ↑n

full_name: Real.cauchy_intCast
code: lemma cauchy_intCast (z : ℤ) : (z : ℝ).cauchy = z 
goal: (↑z).cauchy = ↑z

full_name: Real.cauchy_nnratCast
code: lemma cauchy_nnratCast (q : ℚ≥0) : (q : ℝ).cauchy = q 
goal: (↑q).cauchy = ↑q

full_name: Real.cauchy_ratCast
code: lemma cauchy_ratCast (q : ℚ) : (q : ℝ).cauchy = q 
goal: (↑q).cauchy = ↑q

full_name: Real.commRing
code: instance commRing : CommRing ℝ 
goal: CommRing ℝ

full_name: Real.ringEquivCauchy_symm_apply_cauchy
code: /-- `Real.equivCauchy` as a ring equivalence. -/
@[simps]
def ringEquivCauchy : ℝ ≃+* CauSeq.Completion.Cauchy (abs : ℚ → ℚ) 
goal: (Real.ringEquivCauchy.symm cauchy).cauchy = cauchy

full_name: Real.ringEquivCauchy_apply
code: /-- `Real.equivCauchy` as a ring equivalence. -/
@[simps]
def ringEquivCauchy : ℝ ≃+* CauSeq.Completion.Cauchy (abs : ℚ → ℚ) 
goal: Real.ringEquivCauchy self = self.cauchy

full_name: Real.ringEquivCauchy
code: /-- `Real.equivCauchy` as a ring equivalence. -/
@[simps]
def ringEquivCauchy : ℝ ≃+* CauSeq.Completion.Cauchy (abs : ℚ → ℚ) 
goal: ℝ ≃+* CauSeq.Completion.Cauchy abs

full_name: Real.instRing
code: instance instRing : Ring ℝ 
goal: Ring ℝ

full_name: Real.instCommSemiring
code: instance : CommSemiring ℝ 
goal: CommSemiring ℝ

full_name: Real.semiring
code: instance semiring : Semiring ℝ 
goal: Semiring ℝ

full_name: Real.instCommMonoidWithZero
code: instance : CommMonoidWithZero ℝ 
goal: CommMonoidWithZero ℝ

full_name: Real.instMonoidWithZero
code: instance : MonoidWithZero ℝ 
goal: MonoidWithZero ℝ

full_name: Real.instAddCommGroup
code: instance : AddCommGroup ℝ 
goal: AddCommGroup ℝ

full_name: Real.instAddGroup
code: instance : AddGroup ℝ 
goal: AddGroup ℝ

full_name: Real.instAddCommMonoid
code: instance : AddCommMonoid ℝ 
goal: AddCommMonoid ℝ

full_name: Real.instAddMonoid
code: instance : AddMonoid ℝ 
goal: AddMonoid ℝ

full_name: Real.instAddLeftCancelSemigroup
code: instance : AddLeftCancelSemigroup ℝ 
goal: AddLeftCancelSemigroup ℝ

full_name: Real.instAddRightCancelSemigroup
code: instance : AddRightCancelSemigroup ℝ 
goal: AddRightCancelSemigroup ℝ

full_name: Real.instAddCommSemigroup
code: instance : AddCommSemigroup ℝ 
goal: AddCommSemigroup ℝ

full_name: Real.instAddSemigroup
code: instance : AddSemigroup ℝ 
goal: AddSemigroup ℝ

full_name: Real.instCommMonoid
code: instance : CommMonoid ℝ 
goal: CommMonoid ℝ

full_name: Real.instMonoid
code: instance : Monoid ℝ 
goal: Monoid ℝ

full_name: Real.instCommSemigroup
code: instance : CommSemigroup ℝ 
goal: CommSemigroup ℝ

full_name: Real.instSemigroup
code: instance : Semigroup ℝ 
goal: Semigroup ℝ

full_name: Real.instInhabited
code: instance : Inhabited ℝ 
goal: Inhabited ℝ

full_name: Real.mk
code: /-- Make a real number from a Cauchy sequence of rationals (by taking the equivalence class). -/
def mk (x : CauSeq ℚ abs) : ℝ 
goal: ℝ

full_name: Real.mk_eq
code: theorem mk_eq {f g : CauSeq ℚ abs} : mk f = mk g ↔ f ≈ g 
goal: Real.mk f = Real.mk g ↔ f ≈ g

full_name: _private.Mathlib.Data.Real.Basic.0.Real.lt
code: private irreducible_def lt : ℝ → ℝ → Prop
  
goal: ℝ → ℝ → Prop

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.3651
code: private irreducible_def lt : ℝ → ℝ → Prop
  
goal: Subtype (Eq Real.definition✝)

full_name: _private.Mathlib.Data.Real.Basic.0.Real.lt_def
code: private irreducible_def lt : ℝ → ℝ → Prop
  
goal: ∀ (x x_1 : ℝ),
  Real.lt x x_1 =
    match x, x_1 with
    | { cauchy := x }, { cauchy := y } => Quotient.liftOn₂ x y (fun x x_2 => x < x_2) Real.definition.proof_1✝

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.3651
code: private irreducible_def lt : ℝ → ℝ → Prop
  
goal: ℝ → ℝ → Prop

full_name: Real.instLT
code: instance : LT ℝ 
goal: LT ℝ

full_name: Real.lt_cauchy
code: theorem lt_cauchy {f g} : (⟨⟦f⟧⟩ : ℝ) < ⟨⟦g⟧⟩ ↔ f < g 
goal: { cauchy := ⟦f⟧ } < { cauchy := ⟦g⟧ } ↔ f < g

full_name: Real.mk_lt
code: @[simp]
theorem mk_lt {f g : CauSeq ℚ abs} : mk f < mk g ↔ f < g 
goal: Real.mk f < Real.mk g ↔ f < g

full_name: Real.mk_zero
code: theorem mk_zero : mk 0 = 0 
goal: Real.mk 0 = 0

full_name: Real.mk_one
code: theorem mk_one : mk 1 = 1 
goal: Real.mk 1 = 1

full_name: Real.mk_add
code: theorem mk_add {f g : CauSeq ℚ abs} : mk (f + g) = mk f + mk g 
goal: Real.mk (f + g) = Real.mk f + Real.mk g

full_name: Real.mk_mul
code: theorem mk_mul {f g : CauSeq ℚ abs} : mk (f * g) = mk f * mk g 
goal: Real.mk (f * g) = Real.mk f * Real.mk g

full_name: Real.mk_neg
code: theorem mk_neg {f : CauSeq ℚ abs} : mk (-f) = -mk f 
goal: Real.mk (-f) = -Real.mk f

full_name: Real.mk_pos
code: @[simp]
theorem mk_pos {f : CauSeq ℚ abs} : 0 < mk f ↔ Pos f 
goal: 0 < Real.mk f ↔ f.Pos

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.4347
code: private irreducible_def le (x y : ℝ) : Prop 
goal: Prop

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.4347
code: private irreducible_def le (x y : ℝ) : Prop 
goal: Subtype (Eq Real.definition✝)

full_name: _private.Mathlib.Data.Real.Basic.0.Real.le_def
code: private irreducible_def le (x y : ℝ) : Prop 
goal: Real.le x y = (x < y ∨ x = y)

full_name: _private.Mathlib.Data.Real.Basic.0.Real.le
code: private irreducible_def le (x y : ℝ) : Prop 
goal: Prop

full_name: Real.instLE
code: instance : LE ℝ 
goal: LE ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.le_def'
code: private theorem le_def' {x y : ℝ} : x ≤ y ↔ x < y ∨ x = y 
goal: x ≤ y ↔ x < y ∨ x = y

full_name: Real.mk_le
code: @[simp]
theorem mk_le {f g : CauSeq ℚ abs} : mk f ≤ mk g ↔ f ≤ g 
goal: Real.mk f ≤ Real.mk g ↔ f ≤ g

full_name: Real.ind_mk
code: @[elab_as_elim]
protected theorem ind_mk {C : Real → Prop} (x : Real) (h : ∀ y, C (mk y)) : C x 
goal: C x

full_name: Real.add_lt_add_iff_left
code: theorem add_lt_add_iff_left {a b : ℝ} (c : ℝ) : c + a < c + b ↔ a < b 
goal: c + a < c + b ↔ a < b

full_name: Real.partialOrder
code: instance partialOrder : PartialOrder ℝ 
goal: PartialOrder ℝ

full_name: Real.instPreorder
code: instance : Preorder ℝ 
goal: Preorder ℝ

full_name: Real.ratCast_lt
code: theorem ratCast_lt {x y : ℚ} : (x : ℝ) < (y : ℝ) ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: Real.zero_lt_one
code: protected theorem zero_lt_one : (0 : ℝ) < 1 
goal: 0 < 1

full_name: Real.fact_zero_lt_one
code: protected theorem fact_zero_lt_one : Fact ((0 : ℝ) < 1) 
goal: Fact (0 < 1)

full_name: Real.mul_pos
code: protected theorem mul_pos {a b : ℝ} : 0 < a → 0 < b → 0 < a * b 
goal: 0 < a → 0 < b → 0 < a * b

full_name: Real.instStrictOrderedCommRing
code: instance : StrictOrderedCommRing ℝ 
goal: StrictOrderedCommRing ℝ

full_name: Real.strictOrderedRing
code: instance strictOrderedRing : StrictOrderedRing ℝ 
goal: StrictOrderedRing ℝ

full_name: Real.strictOrderedCommSemiring
code: instance strictOrderedCommSemiring : StrictOrderedCommSemiring ℝ 
goal: StrictOrderedCommSemiring ℝ

full_name: Real.strictOrderedSemiring
code: instance strictOrderedSemiring : StrictOrderedSemiring ℝ 
goal: StrictOrderedSemiring ℝ

full_name: Real.orderedRing
code: instance orderedRing : OrderedRing ℝ 
goal: OrderedRing ℝ

full_name: Real.orderedSemiring
code: instance orderedSemiring : OrderedSemiring ℝ 
goal: OrderedSemiring ℝ

full_name: Real.orderedAddCommGroup
code: instance orderedAddCommGroup : OrderedAddCommGroup ℝ 
goal: OrderedAddCommGroup ℝ

full_name: Real.orderedCancelAddCommMonoid
code: instance orderedCancelAddCommMonoid : OrderedCancelAddCommMonoid ℝ 
goal: OrderedCancelAddCommMonoid ℝ

full_name: Real.orderedAddCommMonoid
code: instance orderedAddCommMonoid : OrderedAddCommMonoid ℝ 
goal: OrderedAddCommMonoid ℝ

full_name: Real.nontrivial
code: instance nontrivial : Nontrivial ℝ 
goal: Nontrivial ℝ

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.5357
code: private irreducible_def sup : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.sup
code: private irreducible_def sup : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: _private.Mathlib.Data.Real.Basic.0.Real.sup_def
code: private irreducible_def sup : ℝ → ℝ → ℝ
  
goal: ∀ (x x_1 : ℝ),
  Real.sup x x_1 =
    match x, x_1 with
    | { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x x_2 => x ⊔ x_2) ⋯ x y }

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.5357
code: private irreducible_def sup : ℝ → ℝ → ℝ
  
goal: Subtype (Eq Real.definition✝)

full_name: Real.instSup
code: instance : Sup ℝ 
goal: Sup ℝ

full_name: Real.ofCauchy_sup
code: theorem ofCauchy_sup (a b) : (⟨⟦a ⊔ b⟧⟩ : ℝ) = ⟨⟦a⟧⟩ ⊔ ⟨⟦b⟧⟩ 
goal: { cauchy := ⟦a ⊔ b⟧ } = { cauchy := ⟦a⟧ } ⊔ { cauchy := ⟦b⟧ }

full_name: Real.mk_sup
code: @[simp]
theorem mk_sup (a b) : (mk (a ⊔ b) : ℝ) = mk a ⊔ mk b 
goal: Real.mk (a ⊔ b) = Real.mk a ⊔ Real.mk b

full_name: _private.Mathlib.Data.Real.Basic.0.Real.inf_def
code: private irreducible_def inf : ℝ → ℝ → ℝ
  
goal: ∀ (x x_1 : ℝ),
  Real.inf x x_1 =
    match x, x_1 with
    | { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x x_2 => x ⊓ x_2) ⋯ x y }

full_name: _private.Mathlib.Data.Real.Basic.0.Real.inf
code: private irreducible_def inf : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: Real.wrapped._@.Mathlib.Data.Real.Basic._hyg.5735
code: private irreducible_def inf : ℝ → ℝ → ℝ
  
goal: Subtype (Eq Real.definition✝)

full_name: Real.definition._@.Mathlib.Data.Real.Basic._hyg.5735
code: private irreducible_def inf : ℝ → ℝ → ℝ
  
goal: ℝ → ℝ → ℝ

full_name: Real.instInf
code: instance : Inf ℝ 
goal: Inf ℝ

full_name: Real.ofCauchy_inf
code: theorem ofCauchy_inf (a b) : (⟨⟦a ⊓ b⟧⟩ : ℝ) = ⟨⟦a⟧⟩ ⊓ ⟨⟦b⟧⟩ 
goal: { cauchy := ⟦a ⊓ b⟧ } = { cauchy := ⟦a⟧ } ⊓ { cauchy := ⟦b⟧ }

full_name: Real.mk_inf
code: @[simp]
theorem mk_inf (a b) : (mk (a ⊓ b) : ℝ) = mk a ⊓ mk b 
goal: Real.mk (a ⊓ b) = Real.mk a ⊓ Real.mk b

full_name: Real.instDistribLattice
code: instance : DistribLattice ℝ 
goal: DistribLattice ℝ

full_name: Real.lattice
code: instance lattice : Lattice ℝ 
goal: Lattice ℝ

full_name: Real.instSemilatticeInf
code: instance : SemilatticeInf ℝ 
goal: SemilatticeInf ℝ

full_name: Real.instSemilatticeSup
code: instance : SemilatticeSup ℝ 
goal: SemilatticeSup ℝ

full_name: Real.instIsTotalLe
code: instance : IsTotal ℝ (· ≤ ·) 
goal: IsTotal ℝ fun x x_1 => x ≤ x_1

full_name: Real.linearOrder
code: noncomputable instance linearOrder : LinearOrder ℝ 
goal: LinearOrder ℝ

full_name: Real.linearOrderedCommRing
code: noncomputable instance linearOrderedCommRing : LinearOrderedCommRing ℝ 
goal: LinearOrderedCommRing ℝ

full_name: Real.instLinearOrderedRing
code: noncomputable instance : LinearOrderedRing ℝ 
goal: LinearOrderedRing ℝ

full_name: Real.instLinearOrderedSemiring
code: noncomputable instance : LinearOrderedSemiring ℝ 
goal: LinearOrderedSemiring ℝ

full_name: Real.instIsDomain
code: instance : IsDomain ℝ 
goal: IsDomain ℝ

full_name: Real.instDivInvMonoid
code: noncomputable instance instDivInvMonoid : DivInvMonoid ℝ 
goal: DivInvMonoid ℝ

full_name: Real.ofCauchy_div
code: lemma ofCauchy_div (f g) : (⟨f / g⟩ : ℝ) = (⟨f⟩ : ℝ) / (⟨g⟩ : ℝ) 
goal: { cauchy := f / g } = { cauchy := f } / { cauchy := g }

full_name: Real.instLinearOrderedField
code: noncomputable instance instLinearOrderedField : LinearOrderedField ℝ 
goal: LinearOrderedField ℝ

full_name: Real.instLinearOrderedAddCommGroup
code: noncomputable instance : LinearOrderedAddCommGroup ℝ 
goal: LinearOrderedAddCommGroup ℝ

full_name: Real.field
code: noncomputable instance field : Field ℝ 
goal: Field ℝ

full_name: Real.instDivisionRing
code: noncomputable instance : DivisionRing ℝ 
goal: DivisionRing ℝ

full_name: Real.decidableLT
code: noncomputable instance decidableLT (a b : ℝ) : Decidable (a < b) 
goal: Decidable (a < b)

full_name: Real.decidableLE
code: noncomputable instance decidableLE (a b : ℝ) : Decidable (a ≤ b) 
goal: Decidable (a ≤ b)

full_name: Real.decidableEq
code: noncomputable instance decidableEq (a b : ℝ) : Decidable (a = b) 
goal: Decidable (a = b)

full_name: Real.instRepr
code: /-- Show an underlying cauchy sequence for real numbers.

The representative chosen is the one passed in the VM to `Quot.mk`, so two cauchy sequences
converging to the same number may be printed differently.
-/
unsafe instance : Repr ℝ 
goal: Repr ℝ

full_name: Real.le_mk_of_forall_le
code: theorem le_mk_of_forall_le {f : CauSeq ℚ abs} : (∃ i, ∀ j ≥ i, x ≤ f j) → x ≤ mk f 
goal: (∃ i, ∀ j ≥ i, x ≤ ↑(↑f j)) → x ≤ Real.mk f

full_name: Real.mk_le_of_forall_le
code: theorem mk_le_of_forall_le {f : CauSeq ℚ abs} {x : ℝ} (h : ∃ i, ∀ j ≥ i, (f j : ℝ) ≤ x) :
    mk f ≤ x 
goal: Real.mk f ≤ x

full_name: Real.mk_near_of_forall_near
code: theorem mk_near_of_forall_near {f : CauSeq ℚ abs} {x : ℝ} {ε : ℝ}
    (H : ∃ i, ∀ j ≥ i, |(f j : ℝ) - x| ≤ ε) : |mk f - x| ≤ ε 
goal: |Real.mk f - x| ≤ ε

full_name: IsNonarchimedean
code: /-- A function `f : R → ℝ≥0` is nonarchimedean if it satisfies the strong triangle inequality
  `f (r + s) ≤ max (f r) (f s)` for all `r s : R`. -/
def IsNonarchimedean {A : Type*} [Add A] (f : A → ℝ) : Prop 
goal: Prop

full_name: IsPowMul
code: /-- A function `f : R → ℝ` is power-multiplicative if for all `r ∈ R` and all positive `n ∈ ℕ`,
`f (r ^ n) = (f r) ^ n`. -/
def IsPowMul {R : Type*} [Pow R ℕ] (f : R → ℝ) 
goal: Prop