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

full_name: rat_add_continuous_lemma
code: theorem rat_add_continuous_lemma {ε : α} (ε0 : 0 < ε) :
    ∃ δ > 0, ∀ {a₁ a₂ b₁ b₂ : β}, abv (a₁ - b₁) < δ → abv (a₂ - b₂) < δ →
      abv (a₁ + a₂ - (b₁ + b₂)) < ε 
goal: ∃ δ > 0, ∀ {a₁ a₂ b₁ b₂ : β}, abv (a₁ - b₁) < δ → abv (a₂ - b₂) < δ → abv (a₁ + a₂ - (b₁ + b₂)) < ε

full_name: rat_mul_continuous_lemma
code: theorem rat_mul_continuous_lemma {ε K₁ K₂ : α} (ε0 : 0 < ε) :
    ∃ δ > 0, ∀ {a₁ a₂ b₁ b₂ : β}, abv a₁ < K₁ → abv b₂ < K₂ → abv (a₁ - b₁) < δ →
      abv (a₂ - b₂) < δ → abv (a₁ * a₂ - b₁ * b₂) < ε 
goal: ∃ δ > 0,
  ∀ {a₁ a₂ b₁ b₂ : β}, abv a₁ < K₁ → abv b₂ < K₂ → abv (a₁ - b₁) < δ → abv (a₂ - b₂) < δ → abv (a₁ * a₂ - b₁ * b₂) < ε

full_name: rat_inv_continuous_lemma
code: theorem rat_inv_continuous_lemma {β : Type*} [DivisionRing β] (abv : β → α) [IsAbsoluteValue abv]
    {ε K : α} (ε0 : 0 < ε) (K0 : 0 < K) :
    ∃ δ > 0, ∀ {a b : β}, K ≤ abv a → K ≤ abv b → abv (a - b) < δ → abv (a⁻¹ - b⁻¹) < ε 
goal: ∃ δ > 0, ∀ {a b : β}, K ≤ abv a → K ≤ abv b → abv (a - b) < δ → abv (a⁻¹ - b⁻¹) < ε

full_name: IsCauSeq
code: /-- A sequence is Cauchy if the distance between its entries tends to zero. -/
def IsCauSeq {α : Type*} [LinearOrderedField α] {β : Type*} [Ring β] (abv : β → α) (f : ℕ → β) :
    Prop 
goal: Prop

full_name: IsCauSeq.cauchy₂
code: theorem cauchy₂ (hf : IsCauSeq abv f) {ε : α} (ε0 : 0 < ε) :
    ∃ i, ∀ j ≥ i, ∀ k ≥ i, abv (f j - f k) < ε 
goal: ∃ i, ∀ j ≥ i, ∀ k ≥ i, abv (f j - f k) < ε

full_name: IsCauSeq.cauchy₃
code: theorem cauchy₃ (hf : IsCauSeq abv f) {ε : α} (ε0 : 0 < ε) :
    ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (f k - f j) < ε 
goal: ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (f k - f j) < ε

full_name: IsCauSeq.bounded
code: lemma bounded (hf : IsCauSeq abv f) : ∃ r, ∀ i, abv (f i) < r 
goal: ∃ r, ∀ (i : ℕ), abv (f i) < r

full_name: IsCauSeq.bounded'
code: lemma bounded' (hf : IsCauSeq abv f) (x : α) : ∃ r > x, ∀ i, abv (f i) < r 
goal: ∃ r > x, ∀ (i : ℕ), abv (f i) < r

full_name: IsCauSeq.const
code: lemma const (x : β) : IsCauSeq abv fun _ ↦ x 
goal: IsCauSeq abv fun x_1 => x

full_name: IsCauSeq.add
code: theorem add (hf : IsCauSeq abv f) (hg : IsCauSeq abv g) : IsCauSeq abv (f + g) 
goal: IsCauSeq abv (f + g)

full_name: IsCauSeq.mul
code: lemma mul (hf : IsCauSeq abv f) (hg : IsCauSeq abv g) : IsCauSeq abv (f * g) 
goal: IsCauSeq abv (f * g)

full_name: isCauSeq_neg
code: @[simp] lemma _root_.isCauSeq_neg : IsCauSeq abv (-f) ↔ IsCauSeq abv f 
goal: IsCauSeq abv (-f) ↔ IsCauSeq abv f

full_name: CauSeq
code: /-- `CauSeq β abv` is the type of `β`-valued Cauchy sequences, with respect to the absolute value
function `abv`. -/
def CauSeq {α : Type*} [LinearOrderedField α] (β : Type*) [Ring β] (abv : β → α) : Type _ 
goal: Type u_4

full_name: CauSeq.instCoeFunForallNat
code: instance : CoeFun (CauSeq β abv) fun _ => ℕ → β 
goal: CoeFun (CauSeq β abv) fun x => ℕ → β

full_name: CauSeq.ext
code: @[ext]
theorem ext {f g : CauSeq β abv} (h : ∀ i, f i = g i) : f = g 
goal: f = g

full_name: CauSeq.isCauSeq
code: theorem isCauSeq (f : CauSeq β abv) : IsCauSeq abv f 
goal: IsCauSeq abv ↑f

full_name: CauSeq.cauchy
code: theorem cauchy (f : CauSeq β abv) : ∀ {ε}, 0 < ε → ∃ i, ∀ j ≥ i, abv (f j - f i) < ε 
goal: 0 < ε → ∃ i, ∀ j ≥ i, abv (↑f j - ↑f i) < ε

full_name: CauSeq.ofEq
code: /-- Given a Cauchy sequence `f`, create a Cauchy sequence from a sequence `g` with
the same values as `f`. -/
def ofEq (f : CauSeq β abv) (g : ℕ → β) (e : ∀ i, f i = g i) : CauSeq β abv 
goal: CauSeq β abv

full_name: CauSeq.cauchy₂
code: theorem cauchy₂ (f : CauSeq β abv) {ε} :
    0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ i, abv (f j - f k) < ε 
goal: 0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ i, abv (↑f j - ↑f k) < ε

full_name: CauSeq.cauchy₃
code: theorem cauchy₃ (f : CauSeq β abv) {ε} : 0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (f k - f j) < ε 
goal: 0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (↑f k - ↑f j) < ε

full_name: CauSeq.bounded
code: theorem bounded (f : CauSeq β abv) : ∃ r, ∀ i, abv (f i) < r 
goal: ∃ r, ∀ (i : ℕ), abv (↑f i) < r

full_name: CauSeq.bounded'
code: theorem bounded' (f : CauSeq β abv) (x : α) : ∃ r > x, ∀ i, abv (f i) < r 
goal: ∃ r > x, ∀ (i : ℕ), abv (↑f i) < r

full_name: CauSeq.instAdd
code: instance : Add (CauSeq β abv) 
goal: Add (CauSeq β abv)

full_name: CauSeq.coe_add
code: @[simp, norm_cast]
theorem coe_add (f g : CauSeq β abv) : ⇑(f + g) = (f : ℕ → β) + g 
goal: ↑(f + g) = ↑f + ↑g

full_name: CauSeq.add_apply
code: @[simp, norm_cast]
theorem add_apply (f g : CauSeq β abv) (i : ℕ) : (f + g) i = f i + g i 
goal: ↑(f + g) i = ↑f i + ↑g i

full_name: CauSeq.const
code: /-- The constant Cauchy sequence. -/
def const (x : β) : CauSeq β abv 
goal: CauSeq β abv

full_name: CauSeq._aux_Mathlib_Algebra_Order_CauSeq_Basic___unexpand_CauSeq_const_1
code: /-- The constant Cauchy sequence -/
local notation "const" => const abv
goal: Lean.PrettyPrinter.Unexpander

full_name: CauSeq._aux_Mathlib_Algebra_Order_CauSeq_Basic___macroRules_CauSeq_termConst_1
code: /-- The constant Cauchy sequence -/
local notation "const" => const abv
goal: Lean.Macro

full_name: CauSeq.coe_const
code: @[simp, norm_cast]
theorem coe_const (x : β) : (const x : ℕ → β) = Function.const ℕ x 
goal: ↑(CauSeq.const abv x) = Function.const ℕ x

full_name: CauSeq.const_apply
code: @[simp, norm_cast]
theorem const_apply (x : β) (i : ℕ) : (const x : ℕ → β) i = x 
goal: ↑(CauSeq.const abv x) i = x

full_name: CauSeq.const_inj
code: theorem const_inj {x y : β} : (const x : CauSeq β abv) = const y ↔ x = y 
goal: CauSeq.const abv x = CauSeq.const abv y ↔ x = y

full_name: CauSeq.instZero
code: instance : Zero (CauSeq β abv) 
goal: Zero (CauSeq β abv)

full_name: CauSeq.instOne
code: instance : One (CauSeq β abv) 
goal: One (CauSeq β abv)

full_name: CauSeq.instInhabited
code: instance : Inhabited (CauSeq β abv) 
goal: Inhabited (CauSeq β abv)

full_name: CauSeq.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ⇑(0 : CauSeq β abv) = 0 
goal: ↑0 = 0

full_name: CauSeq.coe_one
code: @[simp, norm_cast]
theorem coe_one : ⇑(1 : CauSeq β abv) = 1 
goal: ↑1 = 1

full_name: CauSeq.zero_apply
code: @[simp, norm_cast]
theorem zero_apply (i) : (0 : CauSeq β abv) i = 0 
goal: ↑0 i = 0

full_name: CauSeq.one_apply
code: @[simp, norm_cast]
theorem one_apply (i) : (1 : CauSeq β abv) i = 1 
goal: ↑1 i = 1

full_name: CauSeq.const_zero
code: @[simp]
theorem const_zero : const 0 = 0 
goal: CauSeq.const abv 0 = 0

full_name: CauSeq.const_one
code: @[simp]
theorem const_one : const 1 = 1 
goal: CauSeq.const abv 1 = 1

full_name: CauSeq.const_add
code: theorem const_add (x y : β) : const (x + y) = const x + const y 
goal: CauSeq.const abv (x + y) = CauSeq.const abv x + CauSeq.const abv y

full_name: CauSeq.instMul
code: instance : Mul (CauSeq β abv) 
goal: Mul (CauSeq β abv)

full_name: CauSeq.coe_mul
code: @[simp, norm_cast]
theorem coe_mul (f g : CauSeq β abv) : ⇑(f * g) = (f : ℕ → β) * g 
goal: ↑(f * g) = ↑f * ↑g

full_name: CauSeq.mul_apply
code: @[simp, norm_cast]
theorem mul_apply (f g : CauSeq β abv) (i : ℕ) : (f * g) i = f i * g i 
goal: ↑(f * g) i = ↑f i * ↑g i

full_name: CauSeq.const_mul
code: theorem const_mul (x y : β) : const (x * y) = const x * const y 
goal: CauSeq.const abv (x * y) = CauSeq.const abv x * CauSeq.const abv y

full_name: CauSeq.instNeg
code: instance : Neg (CauSeq β abv) 
goal: Neg (CauSeq β abv)

full_name: CauSeq.coe_neg
code: @[simp, norm_cast]
theorem coe_neg (f : CauSeq β abv) : ⇑(-f) = -f 
goal: ↑(-f) = -↑f

full_name: CauSeq.neg_apply
code: @[simp, norm_cast]
theorem neg_apply (f : CauSeq β abv) (i) : (-f) i = -f i 
goal: ↑(-f) i = -↑f i

full_name: CauSeq.const_neg
code: theorem const_neg (x : β) : const (-x) = -const x 
goal: CauSeq.const abv (-x) = -CauSeq.const abv x

full_name: CauSeq.instSub
code: instance : Sub (CauSeq β abv) 
goal: Sub (CauSeq β abv)

full_name: CauSeq.coe_sub
code: @[simp, norm_cast]
theorem coe_sub (f g : CauSeq β abv) : ⇑(f - g) = (f : ℕ → β) - g 
goal: ↑(f - g) = ↑f - ↑g

full_name: CauSeq.sub_apply
code: @[simp, norm_cast]
theorem sub_apply (f g : CauSeq β abv) (i : ℕ) : (f - g) i = f i - g i 
goal: ↑(f - g) i = ↑f i - ↑g i

full_name: CauSeq.const_sub
code: theorem const_sub (x y : β) : const (x - y) = const x - const y 
goal: CauSeq.const abv (x - y) = CauSeq.const abv x - CauSeq.const abv y

full_name: CauSeq.instSMul
code: instance : SMul G (CauSeq β abv) 
goal: SMul G (CauSeq β abv)

full_name: CauSeq.coe_smul
code: @[simp, norm_cast]
theorem coe_smul (a : G) (f : CauSeq β abv) : ⇑(a • f) = a • (f : ℕ → β) 
goal: ↑(a • f) = a • ↑f

full_name: CauSeq.smul_apply
code: @[simp, norm_cast]
theorem smul_apply (a : G) (f : CauSeq β abv) (i : ℕ) : (a • f) i = a • f i 
goal: ↑(a • f) i = a • ↑f i

full_name: CauSeq.const_smul
code: theorem const_smul (a : G) (x : β) : const (a • x) = a • const x 
goal: CauSeq.const abv (a • x) = a • CauSeq.const abv x

full_name: CauSeq.instIsScalarTower
code: instance : IsScalarTower G (CauSeq β abv) (CauSeq β abv) 
goal: IsScalarTower G (CauSeq β abv) (CauSeq β abv)

full_name: CauSeq.addGroup
code: instance addGroup : AddGroup (CauSeq β abv) 
goal: AddGroup (CauSeq β abv)

full_name: CauSeq.instNatCast
code: instance instNatCast : NatCast (CauSeq β abv) 
goal: NatCast (CauSeq β abv)

full_name: CauSeq.instIntCast
code: instance instIntCast : IntCast (CauSeq β abv) 
goal: IntCast (CauSeq β abv)

full_name: CauSeq.addGroupWithOne
code: instance addGroupWithOne : AddGroupWithOne (CauSeq β abv) 
goal: AddGroupWithOne (CauSeq β abv)

full_name: CauSeq.instPowNat
code: instance : Pow (CauSeq β abv) ℕ 
goal: Pow (CauSeq β abv) ℕ

full_name: CauSeq.coe_pow
code: @[simp, norm_cast]
theorem coe_pow (f : CauSeq β abv) (n : ℕ) : ⇑(f ^ n) = (f : ℕ → β) ^ n 
goal: ↑(f ^ n) = ↑f ^ n

full_name: CauSeq.pow_apply
code: @[simp, norm_cast]
theorem pow_apply (f : CauSeq β abv) (n i : ℕ) : (f ^ n) i = f i ^ n 
goal: ↑(f ^ n) i = ↑f i ^ n

full_name: CauSeq.const_pow
code: theorem const_pow (x : β) (n : ℕ) : const (x ^ n) = const x ^ n 
goal: CauSeq.const abv (x ^ n) = CauSeq.const abv x ^ n

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

full_name: CauSeq.instCommRingOfIsAbsoluteValue
code: instance {β : Type*} [CommRing β] {abv : β → α} [IsAbsoluteValue abv] : CommRing (CauSeq β abv) 
goal: CommRing (CauSeq β abv)

full_name: CauSeq.LimZero
code: /-- `LimZero f` holds when `f` approaches 0. -/
def LimZero {abv : β → α} (f : CauSeq β abv) : Prop 
goal: Prop

full_name: CauSeq.add_limZero
code: theorem add_limZero {f g : CauSeq β abv} (hf : LimZero f) (hg : LimZero g) : LimZero (f + g)
  
goal: (f + g).LimZero

full_name: CauSeq.mul_limZero_right
code: theorem mul_limZero_right (f : CauSeq β abv) {g} (hg : LimZero g) : LimZero (f * g)
  
goal: (f * g).LimZero

full_name: CauSeq.mul_limZero_left
code: theorem mul_limZero_left {f} (g : CauSeq β abv) (hg : LimZero f) : LimZero (f * g)
  
goal: (f * g).LimZero

full_name: CauSeq.neg_limZero
code: theorem neg_limZero {f : CauSeq β abv} (hf : LimZero f) : LimZero (-f) 
goal: (-f).LimZero

full_name: CauSeq.sub_limZero
code: theorem sub_limZero {f g : CauSeq β abv} (hf : LimZero f) (hg : LimZero g) : LimZero (f - g) 
goal: (f - g).LimZero

full_name: CauSeq.limZero_sub_rev
code: theorem limZero_sub_rev {f g : CauSeq β abv} (hfg : LimZero (f - g)) : LimZero (g - f) 
goal: (g - f).LimZero

full_name: CauSeq.zero_limZero
code: theorem zero_limZero : LimZero (0 : CauSeq β abv)
  
goal: CauSeq.LimZero 0

full_name: CauSeq.const_limZero
code: theorem const_limZero {x : β} : LimZero (const x) ↔ x = 0 
goal: (CauSeq.const abv x).LimZero ↔ x = 0

full_name: CauSeq.equiv
code: instance equiv : Setoid (CauSeq β abv) 
goal: Setoid (CauSeq β abv)

full_name: CauSeq.add_equiv_add
code: theorem add_equiv_add {f1 f2 g1 g2 : CauSeq β abv} (hf : f1 ≈ f2) (hg : g1 ≈ g2) :
    f1 + g1 ≈ f2 + g2 
goal: f1 + g1 ≈ f2 + g2

full_name: CauSeq.neg_equiv_neg
code: theorem neg_equiv_neg {f g : CauSeq β abv} (hf : f ≈ g) : -f ≈ -g 
goal: -f ≈ -g

full_name: CauSeq.sub_equiv_sub
code: theorem sub_equiv_sub {f1 f2 g1 g2 : CauSeq β abv} (hf : f1 ≈ f2) (hg : g1 ≈ g2) :
    f1 - g1 ≈ f2 - g2 
goal: f1 - g1 ≈ f2 - g2

full_name: CauSeq.equiv_def₃
code: theorem equiv_def₃ {f g : CauSeq β abv} (h : f ≈ g) {ε : α} (ε0 : 0 < ε) :
    ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (f k - g j) < ε 
goal: ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (↑f k - ↑g j) < ε

full_name: CauSeq.limZero_congr
code: theorem limZero_congr {f g : CauSeq β abv} (h : f ≈ g) : LimZero f ↔ LimZero g 
goal: f.LimZero ↔ g.LimZero

full_name: CauSeq.abv_pos_of_not_limZero
code: theorem abv_pos_of_not_limZero {f : CauSeq β abv} (hf : ¬LimZero f) :
    ∃ K > 0, ∃ i, ∀ j ≥ i, K ≤ abv (f j) 
goal: ∃ K > 0, ∃ i, ∀ j ≥ i, K ≤ abv (↑f j)

full_name: CauSeq.of_near
code: theorem of_near (f : ℕ → β) (g : CauSeq β abv) (h : ∀ ε > 0, ∃ i, ∀ j ≥ i, abv (f j - g j) < ε) :
    IsCauSeq abv f
  
goal: IsCauSeq abv f

full_name: CauSeq.not_limZero_of_not_congr_zero
code: theorem not_limZero_of_not_congr_zero {f : CauSeq _ abv} (hf : ¬f ≈ 0) : ¬LimZero f 
goal: ¬f.LimZero

full_name: CauSeq.mul_equiv_zero
code: theorem mul_equiv_zero (g : CauSeq _ abv) {f : CauSeq _ abv} (hf : f ≈ 0) : g * f ≈ 0 
goal: g * f ≈ 0

full_name: CauSeq.mul_equiv_zero'
code: theorem mul_equiv_zero' (g : CauSeq _ abv) {f : CauSeq _ abv} (hf : f ≈ 0) : f * g ≈ 0 
goal: f * g ≈ 0

full_name: CauSeq.mul_not_equiv_zero
code: theorem mul_not_equiv_zero {f g : CauSeq _ abv} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0) : ¬f * g ≈ 0 
goal: ¬f * g ≈ 0

full_name: CauSeq.const_equiv
code: theorem const_equiv {x y : β} : const x ≈ const y ↔ x = y 
goal: CauSeq.const abv x ≈ CauSeq.const abv y ↔ x = y

full_name: CauSeq.mul_equiv_mul
code: theorem mul_equiv_mul {f1 f2 g1 g2 : CauSeq β abv} (hf : f1 ≈ f2) (hg : g1 ≈ g2) :
    f1 * g1 ≈ f2 * g2 
goal: f1 * g1 ≈ f2 * g2

full_name: CauSeq.smul_equiv_smul
code: theorem smul_equiv_smul {G : Type*} [SMul G β] [IsScalarTower G β β] {f1 f2 : CauSeq β abv} (c : G)
    (hf : f1 ≈ f2) : c • f1 ≈ c • f2 
goal: c • f1 ≈ c • f2

full_name: CauSeq.pow_equiv_pow
code: theorem pow_equiv_pow {f1 f2 : CauSeq β abv} (hf : f1 ≈ f2) (n : ℕ) : f1 ^ n ≈ f2 ^ n 
goal: f1 ^ n ≈ f2 ^ n

full_name: CauSeq.one_not_equiv_zero
code: theorem one_not_equiv_zero : ¬const abv 1 ≈ const abv 0 
goal: ¬CauSeq.const abv 1 ≈ CauSeq.const abv 0

full_name: CauSeq.inv_aux
code: theorem inv_aux {f : CauSeq β abv} (hf : ¬LimZero f) :
    ∀ ε > 0, ∃ i, ∀ j ≥ i, abv ((f j)⁻¹ - (f i)⁻¹) < ε
  
goal: ε > 0 → ∃ i, ∀ j ≥ i, abv ((↑f j)⁻¹ - (↑f i)⁻¹) < ε

full_name: CauSeq.inv
code: /-- Given a Cauchy sequence `f` with nonzero limit, create a Cauchy sequence with values equal to
the inverses of the values of `f`. -/
def inv (f : CauSeq β abv) (hf : ¬LimZero f) : CauSeq β abv 
goal: CauSeq β abv

full_name: CauSeq.coe_inv
code: @[simp, norm_cast]
theorem coe_inv {f : CauSeq β abv} (hf) : ⇑(inv f hf) = (f : ℕ → β)⁻¹ 
goal: ↑(f.inv hf) = (↑f)⁻¹

full_name: CauSeq.inv_apply
code: @[simp, norm_cast]
theorem inv_apply {f : CauSeq β abv} (hf i) : inv f hf i = (f i)⁻¹ 
goal: ↑(f.inv hf) i = (↑f i)⁻¹

full_name: CauSeq.inv_mul_cancel
code: theorem inv_mul_cancel {f : CauSeq β abv} (hf) : inv f hf * f ≈ 1 
goal: f.inv hf * f ≈ 1

full_name: CauSeq.mul_inv_cancel
code: theorem mul_inv_cancel {f : CauSeq β abv} (hf) : f * inv f hf ≈ 1 
goal: f * f.inv hf ≈ 1

full_name: CauSeq.const_inv
code: theorem const_inv {x : β} (hx : x ≠ 0) :
    const abv x⁻¹ = inv (const abv x) (by rwa [const_limZero]) 
goal: CauSeq.const abv x⁻¹ = (CauSeq.const abv x).inv ⋯

full_name: CauSeq._aux_Mathlib_Algebra_Order_CauSeq_Basic___macroRules_CauSeq_termConst_2
code: /-- The constant Cauchy sequence -/
local notation "const" => const abs
goal: Lean.Macro

full_name: CauSeq._aux_Mathlib_Algebra_Order_CauSeq_Basic___unexpand_CauSeq_const_2
code: /-- The constant Cauchy sequence -/
local notation "const" => const abs
goal: Lean.PrettyPrinter.Unexpander

full_name: CauSeq.Pos
code: /-- The entries of a positive Cauchy sequence eventually have a positive lower bound. -/
def Pos (f : CauSeq α abs) : Prop 
goal: Prop

full_name: CauSeq.not_limZero_of_pos
code: theorem not_limZero_of_pos {f : CauSeq α abs} : Pos f → ¬LimZero f
  
goal: f.Pos → ¬f.LimZero

full_name: CauSeq.const_pos
code: theorem const_pos {x : α} : Pos (const x) ↔ 0 < x 
goal: (CauSeq.const abs x).Pos ↔ 0 < x

full_name: CauSeq.add_pos
code: theorem add_pos {f g : CauSeq α abs} : Pos f → Pos g → Pos (f + g)
  
goal: f.Pos → g.Pos → (f + g).Pos

full_name: CauSeq.pos_add_limZero
code: theorem pos_add_limZero {f g : CauSeq α abs} : Pos f → LimZero g → Pos (f + g)
  
goal: f.Pos → g.LimZero → (f + g).Pos

full_name: CauSeq.mul_pos
code: protected theorem mul_pos {f g : CauSeq α abs} : Pos f → Pos g → Pos (f * g)
  
goal: f.Pos → g.Pos → (f * g).Pos

full_name: CauSeq.trichotomy
code: theorem trichotomy (f : CauSeq α abs) : Pos f ∨ LimZero f ∨ Pos (-f) 
goal: f.Pos ∨ f.LimZero ∨ (-f).Pos

full_name: CauSeq.instLTAbs
code: instance : LT (CauSeq α abs) 
goal: LT (CauSeq α abs)

full_name: CauSeq.instLEAbs
code: instance : LE (CauSeq α abs) 
goal: LE (CauSeq α abs)

full_name: CauSeq.lt_of_lt_of_eq
code: theorem lt_of_lt_of_eq {f g h : CauSeq α abs} (fg : f < g) (gh : g ≈ h) : f < h 
goal: f < h

full_name: CauSeq.lt_of_eq_of_lt
code: theorem lt_of_eq_of_lt {f g h : CauSeq α abs} (fg : f ≈ g) (gh : g < h) : f < h 
goal: f < h

full_name: CauSeq.lt_trans
code: theorem lt_trans {f g h : CauSeq α abs} (fg : f < g) (gh : g < h) : f < h 
goal: f < h

full_name: CauSeq.lt_irrefl
code: theorem lt_irrefl {f : CauSeq α abs} : ¬f < f
  
goal: ¬f < f

full_name: CauSeq.le_of_eq_of_le
code: theorem le_of_eq_of_le {f g h : CauSeq α abs} (hfg : f ≈ g) (hgh : g ≤ h) : f ≤ h 
goal: f ≤ h

full_name: CauSeq.le_of_le_of_eq
code: theorem le_of_le_of_eq {f g h : CauSeq α abs} (hfg : f ≤ g) (hgh : g ≈ h) : f ≤ h 
goal: f ≤ h

full_name: CauSeq.instPreorderAbs
code: instance : Preorder (CauSeq α abs) 
goal: Preorder (CauSeq α abs)

full_name: CauSeq.le_antisymm
code: theorem le_antisymm {f g : CauSeq α abs} (fg : f ≤ g) (gf : g ≤ f) : f ≈ g 
goal: f ≈ g

full_name: CauSeq.lt_total
code: theorem lt_total (f g : CauSeq α abs) : f < g ∨ f ≈ g ∨ g < f 
goal: f < g ∨ f ≈ g ∨ g < f

full_name: CauSeq.le_total
code: theorem le_total (f g : CauSeq α abs) : f ≤ g ∨ g ≤ f 
goal: f ≤ g ∨ g ≤ f

full_name: CauSeq.const_lt
code: theorem const_lt {x y : α} : const x < const y ↔ x < y 
goal: CauSeq.const abs x < CauSeq.const abs y ↔ x < y

full_name: CauSeq.const_le
code: theorem const_le {x y : α} : const x ≤ const y ↔ x ≤ y 
goal: CauSeq.const abs x ≤ CauSeq.const abs y ↔ x ≤ y

full_name: CauSeq.le_of_exists
code: theorem le_of_exists {f g : CauSeq α abs} (h : ∃ i, ∀ j ≥ i, f j ≤ g j) : f ≤ g 
goal: f ≤ g

full_name: CauSeq.exists_gt
code: theorem exists_gt (f : CauSeq α abs) : ∃ a : α, f < const a 
goal: ∃ a, f < CauSeq.const abs a

full_name: CauSeq.exists_lt
code: theorem exists_lt (f : CauSeq α abs) : ∃ a : α, const a < f 
goal: ∃ a, CauSeq.const abs a < f

full_name: CauSeq.rat_sup_continuous_lemma
code: theorem rat_sup_continuous_lemma {ε : α} {a₁ a₂ b₁ b₂ : α} :
    abs (a₁ - b₁) < ε → abs (a₂ - b₂) < ε → abs (a₁ ⊔ a₂ - b₁ ⊔ b₂) < ε 
goal: |a₁ - b₁| < ε → |a₂ - b₂| < ε → |a₁ ⊔ a₂ - b₁ ⊔ b₂| < ε

full_name: CauSeq.rat_inf_continuous_lemma
code: theorem rat_inf_continuous_lemma {ε : α} {a₁ a₂ b₁ b₂ : α} :
    abs (a₁ - b₁) < ε → abs (a₂ - b₂) < ε → abs (a₁ ⊓ a₂ - b₁ ⊓ b₂) < ε 
goal: |a₁ - b₁| < ε → |a₂ - b₂| < ε → |a₁ ⊓ a₂ - b₁ ⊓ b₂| < ε

full_name: CauSeq.instSupAbs
code: instance : Sup (CauSeq α abs) 
goal: Sup (CauSeq α abs)

full_name: CauSeq.instInfAbs
code: instance : Inf (CauSeq α abs) 
goal: Inf (CauSeq α abs)

full_name: CauSeq.coe_sup
code: @[simp, norm_cast]
theorem coe_sup (f g : CauSeq α abs) : ⇑(f ⊔ g) = (f : ℕ → α) ⊔ g 
goal: ↑(f ⊔ g) = ↑f ⊔ ↑g

full_name: CauSeq.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (f g : CauSeq α abs) : ⇑(f ⊓ g) = (f : ℕ → α) ⊓ g 
goal: ↑(f ⊓ g) = ↑f ⊓ ↑g

full_name: CauSeq.sup_limZero
code: theorem sup_limZero {f g : CauSeq α abs} (hf : LimZero f) (hg : LimZero g) : LimZero (f ⊔ g)
  
goal: (f ⊔ g).LimZero

full_name: CauSeq.inf_limZero
code: theorem inf_limZero {f g : CauSeq α abs} (hf : LimZero f) (hg : LimZero g) : LimZero (f ⊓ g)
  
goal: (f ⊓ g).LimZero

full_name: CauSeq.sup_equiv_sup
code: theorem sup_equiv_sup {a₁ b₁ a₂ b₂ : CauSeq α abs} (ha : a₁ ≈ a₂) (hb : b₁ ≈ b₂) :
    a₁ ⊔ b₁ ≈ a₂ ⊔ b₂ 
goal: a₁ ⊔ b₁ ≈ a₂ ⊔ b₂

full_name: CauSeq.inf_equiv_inf
code: theorem inf_equiv_inf {a₁ b₁ a₂ b₂ : CauSeq α abs} (ha : a₁ ≈ a₂) (hb : b₁ ≈ b₂) :
    a₁ ⊓ b₁ ≈ a₂ ⊓ b₂ 
goal: a₁ ⊓ b₁ ≈ a₂ ⊓ b₂

full_name: CauSeq.sup_lt
code: protected theorem sup_lt {a b c : CauSeq α abs} (ha : a < c) (hb : b < c) : a ⊔ b < c 
goal: a ⊔ b < c

full_name: CauSeq.lt_inf
code: protected theorem lt_inf {a b c : CauSeq α abs} (hb : a < b) (hc : a < c) : a < b ⊓ c 
goal: a < b ⊓ c

full_name: CauSeq.sup_idem
code: @[simp]
protected theorem sup_idem (a : CauSeq α abs) : a ⊔ a = a 
goal: a ⊔ a = a

full_name: CauSeq.inf_idem
code: @[simp]
protected theorem inf_idem (a : CauSeq α abs) : a ⊓ a = a 
goal: a ⊓ a = a

full_name: CauSeq.sup_comm
code: protected theorem sup_comm (a b : CauSeq α abs) : a ⊔ b = b ⊔ a 
goal: a ⊔ b = b ⊔ a

full_name: CauSeq.inf_comm
code: protected theorem inf_comm (a b : CauSeq α abs) : a ⊓ b = b ⊓ a 
goal: a ⊓ b = b ⊓ a

full_name: CauSeq.sup_eq_right
code: protected theorem sup_eq_right {a b : CauSeq α abs} (h : a ≤ b) : a ⊔ b ≈ b 
goal: a ⊔ b ≈ b

full_name: CauSeq.inf_eq_right
code: protected theorem inf_eq_right {a b : CauSeq α abs} (h : b ≤ a) : a ⊓ b ≈ b 
goal: a ⊓ b ≈ b

full_name: CauSeq.sup_eq_left
code: protected theorem sup_eq_left {a b : CauSeq α abs} (h : b ≤ a) : a ⊔ b ≈ a 
goal: a ⊔ b ≈ a

full_name: CauSeq.inf_eq_left
code: protected theorem inf_eq_left {a b : CauSeq α abs} (h : a ≤ b) : a ⊓ b ≈ a 
goal: a ⊓ b ≈ a

full_name: CauSeq.le_sup_left
code: protected theorem le_sup_left {a b : CauSeq α abs} : a ≤ a ⊔ b 
goal: a ≤ a ⊔ b

full_name: CauSeq.inf_le_left
code: protected theorem inf_le_left {a b : CauSeq α abs} : a ⊓ b ≤ a 
goal: a ⊓ b ≤ a

full_name: CauSeq.le_sup_right
code: protected theorem le_sup_right {a b : CauSeq α abs} : b ≤ a ⊔ b 
goal: b ≤ a ⊔ b

full_name: CauSeq.inf_le_right
code: protected theorem inf_le_right {a b : CauSeq α abs} : a ⊓ b ≤ b 
goal: a ⊓ b ≤ b

full_name: CauSeq.sup_le
code: protected theorem sup_le {a b c : CauSeq α abs} (ha : a ≤ c) (hb : b ≤ c) : a ⊔ b ≤ c 
goal: a ⊔ b ≤ c

full_name: CauSeq.le_inf
code: protected theorem le_inf {a b c : CauSeq α abs} (hb : a ≤ b) (hc : a ≤ c) : a ≤ b ⊓ c 
goal: a ≤ b ⊓ c

full_name: CauSeq.sup_inf_distrib_left
code: protected theorem sup_inf_distrib_left (a b c : CauSeq α abs) : a ⊔ b ⊓ c = (a ⊔ b) ⊓ (a ⊔ c) 
goal: a ⊔ b ⊓ c = (a ⊔ b) ⊓ (a ⊔ c)

full_name: CauSeq.sup_inf_distrib_right
code: protected theorem sup_inf_distrib_right (a b c : CauSeq α abs) : a ⊓ b ⊔ c = (a ⊔ c) ⊓ (b ⊔ c) 
goal: a ⊓ b ⊔ c = (a ⊔ c) ⊓ (b ⊔ c)