File: Mathlib/Algebra/Order/CauSeq/Completion.lean

full_name: CauSeq.Completion.Cauchy
code: /-- The Cauchy completion of a ring with absolute value. -/
def Cauchy 
goal: Type u_2

full_name: CauSeq.Completion.mk
code: /-- The map from Cauchy sequences into the Cauchy completion. -/
def mk : CauSeq _ abv → Cauchy abv 
goal: CauSeq β abv → CauSeq.Completion.Cauchy abv

full_name: CauSeq.Completion.mk_eq_mk
code: @[simp]
theorem mk_eq_mk (f : CauSeq _ abv) : @Eq (Cauchy abv) ⟦f⟧ (mk f) 
goal: ⟦f⟧ = CauSeq.Completion.mk f

full_name: CauSeq.Completion.mk_eq
code: theorem mk_eq {f g : CauSeq _ abv} : mk f = mk g ↔ f ≈ g 
goal: CauSeq.Completion.mk f = CauSeq.Completion.mk g ↔ f ≈ g

full_name: CauSeq.Completion.ofRat
code: /-- The map from the original ring into the Cauchy completion. -/
def ofRat (x : β) : Cauchy abv 
goal: CauSeq.Completion.Cauchy abv

full_name: CauSeq.Completion.instZeroCauchy
code: instance : Zero (Cauchy abv) 
goal: Zero (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.instOneCauchy
code: instance : One (Cauchy abv) 
goal: One (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.instInhabitedCauchy
code: instance : Inhabited (Cauchy abv) 
goal: Inhabited (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.ofRat_zero
code: theorem ofRat_zero : (ofRat 0 : Cauchy abv) = 0 
goal: CauSeq.Completion.ofRat 0 = 0

full_name: CauSeq.Completion.ofRat_one
code: theorem ofRat_one : (ofRat 1 : Cauchy abv) = 1 
goal: CauSeq.Completion.ofRat 1 = 1

full_name: CauSeq.Completion.mk_eq_zero
code: @[simp]
theorem mk_eq_zero {f : CauSeq _ abv} : mk f = 0 ↔ LimZero f 
goal: CauSeq.Completion.mk f = 0 ↔ f.LimZero

full_name: CauSeq.Completion.instAddCauchy
code: instance : Add (Cauchy abv) 
goal: Add (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.mk_add
code: @[simp]
theorem mk_add (f g : CauSeq β abv) : mk f + mk g = mk (f + g) 
goal: CauSeq.Completion.mk f + CauSeq.Completion.mk g = CauSeq.Completion.mk (f + g)

full_name: CauSeq.Completion.instNegCauchy
code: instance : Neg (Cauchy abv) 
goal: Neg (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.mk_neg
code: @[simp]
theorem mk_neg (f : CauSeq β abv) : -mk f = mk (-f) 
goal: -CauSeq.Completion.mk f = CauSeq.Completion.mk (-f)

full_name: CauSeq.Completion.instMulCauchy
code: instance : Mul (Cauchy abv) 
goal: Mul (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.mk_mul
code: @[simp]
theorem mk_mul (f g : CauSeq β abv) : mk f * mk g = mk (f * g) 
goal: CauSeq.Completion.mk f * CauSeq.Completion.mk g = CauSeq.Completion.mk (f * g)

full_name: CauSeq.Completion.instSubCauchy
code: instance : Sub (Cauchy abv) 
goal: Sub (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.mk_sub
code: @[simp]
theorem mk_sub (f g : CauSeq β abv) : mk f - mk g = mk (f - g) 
goal: CauSeq.Completion.mk f - CauSeq.Completion.mk g = CauSeq.Completion.mk (f - g)

full_name: CauSeq.Completion.instSMulCauchyOfIsScalarTower
code: instance {γ : Type*} [SMul γ β] [IsScalarTower γ β β] : SMul γ (Cauchy abv) 
goal: SMul γ (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.mk_smul
code: @[simp]
theorem mk_smul {γ : Type*} [SMul γ β] [IsScalarTower γ β β] (c : γ) (f : CauSeq β abv) :
    c • mk f = mk (c • f) 
goal: c • CauSeq.Completion.mk f = CauSeq.Completion.mk (c • f)

full_name: CauSeq.Completion.instPowCauchyNat
code: instance : Pow (Cauchy abv) ℕ 
goal: Pow (CauSeq.Completion.Cauchy abv) ℕ

full_name: CauSeq.Completion.mk_pow
code: @[simp]
theorem mk_pow (n : ℕ) (f : CauSeq β abv) : mk f ^ n = mk (f ^ n) 
goal: CauSeq.Completion.mk f ^ n = CauSeq.Completion.mk (f ^ n)

full_name: CauSeq.Completion.instNatCastCauchy
code: instance : NatCast (Cauchy abv) 
goal: NatCast (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.instIntCastCauchy
code: instance : IntCast (Cauchy abv) 
goal: IntCast (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.ofRat_natCast
code: @[simp]
theorem ofRat_natCast (n : ℕ) : (ofRat n : Cauchy abv) = n 
goal: CauSeq.Completion.ofRat ↑n = ↑n

full_name: CauSeq.Completion.ofRat_intCast
code: @[simp]
theorem ofRat_intCast (z : ℤ) : (ofRat z : Cauchy abv) = z 
goal: CauSeq.Completion.ofRat ↑z = ↑z

full_name: CauSeq.Completion.ofRat_add
code: theorem ofRat_add (x y : β) :
    ofRat (x + y) = (ofRat x + ofRat y : Cauchy abv) 
goal: CauSeq.Completion.ofRat (x + y) = CauSeq.Completion.ofRat x + CauSeq.Completion.ofRat y

full_name: CauSeq.Completion.ofRat_neg
code: theorem ofRat_neg (x : β) : ofRat (-x) = (-ofRat x : Cauchy abv) 
goal: CauSeq.Completion.ofRat (-x) = -CauSeq.Completion.ofRat x

full_name: CauSeq.Completion.ofRat_mul
code: theorem ofRat_mul (x y : β) :
    ofRat (x * y) = (ofRat x * ofRat y : Cauchy abv) 
goal: CauSeq.Completion.ofRat (x * y) = CauSeq.Completion.ofRat x * CauSeq.Completion.ofRat y

full_name: _private.Mathlib.Algebra.Order.CauSeq.Completion.0.CauSeq.Completion.zero_def
code: private theorem zero_def : 0 = mk (abv := abv) 0 
goal: 0 = CauSeq.Completion.mk 0

full_name: _private.Mathlib.Algebra.Order.CauSeq.Completion.0.CauSeq.Completion.one_def
code: private theorem one_def : 1 = mk (abv := abv) 1 
goal: 1 = CauSeq.Completion.mk 1

full_name: CauSeq.Completion.Cauchy.ring
code: instance Cauchy.ring : Ring (Cauchy abv) 
goal: Ring (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.ofRatRingHom
code: /-- `CauSeq.Completion.ofRat` as a `RingHom` -/
@[simps]
def ofRatRingHom : β →+* (Cauchy abv) 
goal: β →+* CauSeq.Completion.Cauchy abv

full_name: CauSeq.Completion.ofRatRingHom_apply
code: /-- `CauSeq.Completion.ofRat` as a `RingHom` -/
@[simps]
def ofRatRingHom : β →+* (Cauchy abv) 
goal: CauSeq.Completion.ofRatRingHom x = CauSeq.Completion.ofRat x

full_name: CauSeq.Completion.ofRat_sub
code: theorem ofRat_sub (x y : β) : ofRat (x - y) = (ofRat x - ofRat y : Cauchy abv) 
goal: CauSeq.Completion.ofRat (x - y) = CauSeq.Completion.ofRat x - CauSeq.Completion.ofRat y

full_name: CauSeq.Completion.Cauchy.commRing
code: instance Cauchy.commRing : CommRing (Cauchy abv) 
goal: CommRing (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.instNNRatCast
code: instance instNNRatCast : NNRatCast (Cauchy abv) 
goal: NNRatCast (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.instRatCast
code: instance instRatCast : RatCast (Cauchy abv) 
goal: RatCast (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.ofRat_nnratCast
code: @[simp, norm_cast] lemma ofRat_nnratCast (q : ℚ≥0) : ofRat (q : β) = (q : Cauchy abv) 
goal: CauSeq.Completion.ofRat ↑q = ↑q

full_name: CauSeq.Completion.ofRat_ratCast
code: @[simp, norm_cast] lemma ofRat_ratCast (q : ℚ) : ofRat (q : β) = (q : Cauchy abv) 
goal: CauSeq.Completion.ofRat ↑q = ↑q

full_name: CauSeq.Completion.instInvCauchy
code: noncomputable instance : Inv (Cauchy abv) 
goal: Inv (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.inv_zero
code: theorem inv_zero : (0 : (Cauchy abv))⁻¹ = 0 
goal: 0⁻¹ = 0

full_name: CauSeq.Completion.inv_mk
code: @[simp]
theorem inv_mk {f} (hf) : (mk (abv := abv) f)⁻¹ = mk (inv f hf) 
goal: (CauSeq.Completion.mk f)⁻¹ = CauSeq.Completion.mk (f.inv hf)

full_name: CauSeq.Completion.cau_seq_zero_ne_one
code: theorem cau_seq_zero_ne_one : ¬(0 : CauSeq _ abv) ≈ 1 
goal: ¬0 ≈ 1

full_name: CauSeq.Completion.zero_ne_one
code: theorem zero_ne_one : (0 : (Cauchy abv)) ≠ 1 
goal: 0 ≠ 1

full_name: CauSeq.Completion.inv_mul_cancel
code: protected theorem inv_mul_cancel {x : (Cauchy abv)} : x ≠ 0 → x⁻¹ * x = 1 
goal: x ≠ 0 → x⁻¹ * x = 1

full_name: CauSeq.Completion.mul_inv_cancel
code: protected theorem mul_inv_cancel {x : (Cauchy abv)} : x ≠ 0 → x * x⁻¹ = 1 
goal: x ≠ 0 → x * x⁻¹ = 1

full_name: CauSeq.Completion.ofRat_inv
code: theorem ofRat_inv (x : β) : ofRat x⁻¹ = ((ofRat x)⁻¹ : (Cauchy abv)) 
goal: CauSeq.Completion.ofRat x⁻¹ = (CauSeq.Completion.ofRat x)⁻¹

full_name: CauSeq.Completion.instDivInvMonoid
code: noncomputable instance instDivInvMonoid : DivInvMonoid (Cauchy abv) 
goal: DivInvMonoid (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.ofRat_div
code: lemma ofRat_div (x y : β) : ofRat (x / y) = (ofRat x / ofRat y : Cauchy abv) 
goal: CauSeq.Completion.ofRat (x / y) = CauSeq.Completion.ofRat x / CauSeq.Completion.ofRat y

full_name: CauSeq.Completion.Cauchy.divisionRing
code: /-- The Cauchy completion forms a division ring. -/
noncomputable instance Cauchy.divisionRing : DivisionRing (Cauchy abv) 
goal: DivisionRing (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.instReprCauchy
code: /-- Show the first 10 items of a representative of this equivalence class of cauchy sequences.

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 β] : Repr (Cauchy abv) 
goal: Repr (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.Completion.Cauchy.field
code: /-- The Cauchy completion forms a field. -/
noncomputable instance Cauchy.field : Field (Cauchy abv) 
goal: Field (CauSeq.Completion.Cauchy abv)

full_name: CauSeq.IsComplete
code: /-- A class stating that a ring with an absolute value is complete, i.e. every Cauchy
sequence has a limit. -/
class IsComplete : Prop where
  /-- Every Cauchy sequence has a limit. -/
  isComplete : ∀ s : CauSeq β abv, ∃ b : β, s ≈ const abv b
goal: Prop

full_name: CauSeq.IsComplete.isComplete
code: /-- A class stating that a ring with an absolute value is complete, i.e. every Cauchy
sequence has a limit. -/
class IsComplete : Prop where
  /-- Every Cauchy sequence has a limit. -/
  isComplete : ∀ s : CauSeq β abv, ∃ b : β, s ≈ const abv b
goal: ∃ b, s ≈ CauSeq.const abv b

full_name: CauSeq.complete
code: theorem complete : ∀ s : CauSeq β abv, ∃ b : β, s ≈ const abv b 
goal: ∃ b, s ≈ CauSeq.const abv b

full_name: CauSeq.lim
code: /-- The limit of a Cauchy sequence in a complete ring. Chosen non-computably. -/
noncomputable def lim (s : CauSeq β abv) : β 
goal: β

full_name: CauSeq.equiv_lim
code: theorem equiv_lim (s : CauSeq β abv) : s ≈ const abv (lim s) 
goal: s ≈ CauSeq.const abv s.lim

full_name: CauSeq.eq_lim_of_const_equiv
code: theorem eq_lim_of_const_equiv {f : CauSeq β abv} {x : β} (h : CauSeq.const abv x ≈ f) : x = lim f 
goal: x = f.lim

full_name: CauSeq.lim_eq_of_equiv_const
code: theorem lim_eq_of_equiv_const {f : CauSeq β abv} {x : β} (h : f ≈ CauSeq.const abv x) : lim f = x 
goal: f.lim = x

full_name: CauSeq.lim_eq_lim_of_equiv
code: theorem lim_eq_lim_of_equiv {f g : CauSeq β abv} (h : f ≈ g) : lim f = lim g 
goal: f.lim = g.lim

full_name: CauSeq.lim_const
code: @[simp]
theorem lim_const (x : β) : lim (const abv x) = x 
goal: (CauSeq.const abv x).lim = x

full_name: CauSeq.lim_add
code: theorem lim_add (f g : CauSeq β abv) : lim f + lim g = lim (f + g) 
goal: f.lim + g.lim = (f + g).lim

full_name: CauSeq.lim_mul_lim
code: theorem lim_mul_lim (f g : CauSeq β abv) : lim f * lim g = lim (f * g) 
goal: f.lim * g.lim = (f * g).lim

full_name: CauSeq.lim_mul
code: theorem lim_mul (f : CauSeq β abv) (x : β) : lim f * x = lim (f * const abv x) 
goal: f.lim * x = (f * CauSeq.const abv x).lim

full_name: CauSeq.lim_neg
code: theorem lim_neg (f : CauSeq β abv) : lim (-f) = -lim f 
goal: (-f).lim = -f.lim

full_name: CauSeq.lim_eq_zero_iff
code: theorem lim_eq_zero_iff (f : CauSeq β abv) : lim f = 0 ↔ LimZero f 
goal: f.lim = 0 ↔ f.LimZero

full_name: CauSeq.lim_inv
code: theorem lim_inv {f : CauSeq β abv} (hf : ¬LimZero f) : lim (inv f hf) = (lim f)⁻¹ 
goal: (f.inv hf).lim = f.lim⁻¹

full_name: CauSeq.lim_le
code: theorem lim_le {f : CauSeq α abs} {x : α} (h : f ≤ CauSeq.const abs x) : lim f ≤ x 
goal: f.lim ≤ x

full_name: CauSeq.le_lim
code: theorem le_lim {f : CauSeq α abs} {x : α} (h : CauSeq.const abs x ≤ f) : x ≤ lim f 
goal: x ≤ f.lim

full_name: CauSeq.lt_lim
code: theorem lt_lim {f : CauSeq α abs} {x : α} (h : CauSeq.const abs x < f) : x < lim f 
goal: x < f.lim

full_name: CauSeq.lim_lt
code: theorem lim_lt {f : CauSeq α abs} {x : α} (h : f < CauSeq.const abs x) : lim f < x 
goal: f.lim < x