l3lab/ntp-mathlib huggingface dataset:
theorem deriv_lt_ord {f : Ordinal.{u} → Ordinal} {c} (hc : IsRegular c) (hc' : c ≠ ℵ₀)
    (hf : ∀ i < c.ord, f i < c.ord) {a} : a < c.ord → deriv f a < c.ord :=
  derivFamily_lt_ord_lift hc
    (by 

Proof state:
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : IsRegular c
hc' : c ≠ ℵ₀
hf : ∀ i < ord c, f i < ord c
a : Ordinal.{u}
⊢ lift.{u, 0} #Unit < c

Next tactic:
simpa using Cardinal.one_lt_aleph0.trans (lt_of_le_of_ne hc.1 hc'.symm)
theorem univ_inaccessible : IsInaccessible univ.{u, v} :=
  IsInaccessible.mk (by 

Proof state:
α : Type u_1
r : α → α → Prop
⊢ ℵ₀ < univ.{u, v}

Next tactic:
simpa using lift_lt_univ' ℵ₀
theorem univ_inaccessible : IsInaccessible univ.{u, v} :=
  IsInaccessible.mk (by simpa using lift_lt_univ' ℵ₀) (by 

Proof state:
α : Type u_1
r : α → α → Prop
⊢ univ.{u, v} ≤ Ordinal.cof (ord univ.{u, v})

Next tactic:
simp
theorem univ_inaccessible : IsInaccessible univ.{u, v} :=
  IsInaccessible.mk (by simpa using lift_lt_univ' ℵ₀) (by simp) fun c h => by
    

Proof state:
α : Type u_1
r : α → α → Prop
c : Cardinal.{max (u + 1) v}
h : c < univ.{u, v}
⊢ 2 ^ c < univ.{u, v}

Next tactic:
rcases lt_univ'.1 h with ⟨c, rfl⟩
theorem univ_inaccessible : IsInaccessible univ.{u, v} :=
  IsInaccessible.mk (by simpa using lift_lt_univ' ℵ₀) (by simp) fun c h => by
    rcases lt_univ'.1 h with ⟨c, rfl⟩
    

Proof state:
case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ 2 ^ lift.{max (u + 1) v, u} c < univ.{u, v}

Next tactic:
rw [← lift_two_power.{u, max (u + 1) v}]
theorem univ_inaccessible : IsInaccessible univ.{u, v} :=
  IsInaccessible.mk (by simpa using lift_lt_univ' ℵ₀) (by simp) fun c h => by
    rcases lt_univ'.1 h with ⟨c, rfl⟩
    rw [← lift_two_power.{u, max (u + 1) v}]
    

Proof state:
case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ lift.{max (u + 1) v, u} (2 ^ c) < univ.{u, v}

Next tactic:
apply lift_lt_univ'
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    

Proof state:
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
⊢ ⟦α⟧ < ⟦α⟧ ^ Ordinal.cof (ord ⟦α⟧)

Next tactic:
rcases ord_eq α with ⟨r, wo, re⟩
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; 

Proof state:
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
⊢ ⟦α⟧ < ⟦α⟧ ^ Ordinal.cof (ord ⟦α⟧)

Next tactic:
skip
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    

Proof state:
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
⊢ ⟦α⟧ < ⟦α⟧ ^ Ordinal.cof (ord ⟦α⟧)

Next tactic:
have := ord_isLimit h
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    

Proof state:
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (ord ⟦α⟧)
⊢ ⟦α⟧ < ⟦α⟧ ^ Ordinal.cof (ord ⟦α⟧)

Next tactic:
rw [mk'_def, re] at this ⊢
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    

Proof state:
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
⊢ #α < #α ^ Ordinal.cof (type r)

Next tactic:
rcases cof_eq' r this with ⟨S, H, Se⟩
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    

Proof state:
case intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
⊢ #α < #α ^ Ordinal.cof (type r)

Next tactic:
have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
    · 

Proof state:
case intro.intro.intro.intro.refine_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
this : (sum fun a => #{ x // r x ↑a }) < prod fun x => #α
⊢ #α < #α ^ Ordinal.cof (type r)

Next tactic:
simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
    · simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
      

Proof state:
case intro.intro.intro.intro.refine_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ #α < #(↑S → α)

Next tactic:
refine' lt_of_le_of_lt _ this
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
    · simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
      refine' lt_of_le_of_lt _ this
      

Proof state:
case intro.intro.intro.intro.refine_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ #α ≤ #((i : ↑S) × { x // r x ↑i })

Next tactic:
refine' ⟨Embedding.ofSurjective _ _⟩
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
    · simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
      refine' lt_of_le_of_lt _ this
      refine' ⟨Embedding.ofSurjective _ _⟩
      · 

Proof state:
case intro.intro.intro.intro.refine_2.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ (i : ↑S) × { x // r x ↑i } → α

Next tactic:
exact fun x => x.2.1
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
    · simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
      refine' lt_of_le_of_lt _ this
      refine' ⟨Embedding.ofSurjective _ _⟩
      · exact fun x => x.2.1
      · 

Proof state:
case intro.intro.intro.intro.refine_2.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ Surjective fun x => ↑x.snd

Next tactic:
exact fun a =>
          let ⟨b, h, ab⟩ := H a
          ⟨⟨⟨_, h⟩, _, ab⟩, rfl⟩
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
    · simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
      refine' lt_of_le_of_lt _ this
      refine' ⟨Embedding.ofSurjective _ _⟩
      · exact fun x => x.2.1
      · exact fun a =>
          let ⟨b, h, ab⟩ := H a
          ⟨⟨⟨_, h⟩, _, ab⟩, rfl⟩
    · 

Proof state:
case intro.intro.intro.intro.refine_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
i : ↑S
⊢ (fun a => #{ x // r x ↑a }) i < (fun x => #α) i

Next tactic:
have := typein_lt_type r i
theorem lt_power_cof {c : Cardinal.{u}} : ℵ₀ ≤ c → c < (c^cof c.ord) :=
  Quotient.inductionOn c fun α h => by
    rcases ord_eq α with ⟨r, wo, re⟩; skip
    have := ord_isLimit h
    rw [mk'_def, re] at this ⊢
    rcases cof_eq' r this with ⟨S, H, Se⟩
    have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
    · simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
      refine' lt_of_le_of_lt _ this
      refine' ⟨Embedding.ofSurjective _ _⟩
      · exact fun x => x.2.1
      · exact fun a =>
          let ⟨b, h, ab⟩ := H a
          ⟨⟨⟨_, h⟩, _, ab⟩, rfl⟩
    · have := typein_lt_type r i
      

Proof state:
case intro.intro.intro.intro.refine_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = Ordinal.cof (type r)
i : ↑S
this : typein r ↑i < type r
⊢ (fun a => #{ x // r x ↑a }) i < (fun x => #α) i

Next tactic:
rwa [← re, lt_ord] at this
theorem lt_cof_power {a b : Cardinal} (ha : ℵ₀ ≤ a) (b1 : 1 < b) : a < cof (b^a).ord := by
  

Proof state:
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
⊢ a < Ordinal.cof (ord (b ^ a))

Next tactic:
have b0 : b ≠ 0 := (zero_lt_one.trans b1).ne'
theorem lt_cof_power {a b : Cardinal} (ha : ℵ₀ ≤ a) (b1 : 1 < b) : a < cof (b^a).ord := by
  have b0 : b ≠ 0 := (zero_lt_one.trans b1).ne'
  

Proof state:
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ a < Ordinal.cof (ord (b ^ a))

Next tactic:
apply lt_imp_lt_of_le_imp_le (power_le_power_left <| power_ne_zero a b0)
theorem lt_cof_power {a b : Cardinal} (ha : ℵ₀ ≤ a) (b1 : 1 < b) : a < cof (b^a).ord := by
  have b0 : b ≠ 0 := (zero_lt_one.trans b1).ne'
  apply lt_imp_lt_of_le_imp_le (power_le_power_left <| power_ne_zero a b0)
  

Proof state:
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ (b ^ a) ^ a < (b ^ a) ^ Ordinal.cof (ord (b ^ a))

Next tactic:
rw [← power_mul, mul_eq_self ha]
theorem lt_cof_power {a b : Cardinal} (ha : ℵ₀ ≤ a) (b1 : 1 < b) : a < cof (b^a).ord := by
  have b0 : b ≠ 0 := (zero_lt_one.trans b1).ne'
  apply lt_imp_lt_of_le_imp_le (power_le_power_left <| power_ne_zero a b0)
  rw [← power_mul, mul_eq_self ha]
  

Proof state:
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ b ^ a < (b ^ a) ^ Ordinal.cof (ord (b ^ a))

Next tactic:
exact lt_power_cof (ha.trans <| (cantor' _ b1).le)
lemma sup_sequence_lt_omega1 {α} [Countable α] (o : α → Ordinal) (ho : ∀ n, o n < ω₁) :
    sup o < ω₁ := by
  

Proof state:
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
inst✝ : Countable α
o : α → Ordinal.{max u_3 u_2}
ho : ∀ (n : α), o n < ord (aleph 1)
⊢ sup o < ord (aleph 1)

Next tactic:
apply sup_lt_ord_lift _ ho
lemma sup_sequence_lt_omega1 {α} [Countable α] (o : α → Ordinal) (ho : ∀ n, o n < ω₁) :
    sup o < ω₁ := by
  apply sup_lt_ord_lift _ ho
  

Proof state:
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
inst✝ : Countable α
o : α → Ordinal.{max u_3 u_2}
ho : ∀ (n : α), o n < ord (aleph 1)
⊢ Cardinal.lift.{u_3, u_2} #α < cof (ord (aleph 1))

Next tactic:
rw [Cardinal.isRegular_aleph_one.cof_eq]
lemma sup_sequence_lt_omega1 {α} [Countable α] (o : α → Ordinal) (ho : ∀ n, o n < ω₁) :
    sup o < ω₁ := by
  apply sup_lt_ord_lift _ ho
  rw [Cardinal.isRegular_aleph_one.cof_eq]
  

Proof state:
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
inst✝ : Countable α
o : α → Ordinal.{max u_3 u_2}
ho : ∀ (n : α), o n < ord (aleph 1)
⊢ Cardinal.lift.{u_3, u_2} #α < aleph 1

Next tactic:
exact lt_of_le_of_lt mk_le_aleph0 aleph0_lt_aleph_one
/-- If a (possibly non-unital and/or non-associative) ring `R` admits a submultiplicative
nonnegative norm `norm : R → 𝕜`, where `𝕜` is a linear ordered field, and the open balls
`{ x | norm x < ε }`, `ε > 0`, form a basis of neighborhoods of zero, then `R` is a topological
ring. -/
theorem TopologicalRing.of_norm {R 𝕜 : Type*} [NonUnitalNonAssocRing R] [LinearOrderedField 𝕜]
    [TopologicalSpace R] [TopologicalAddGroup R] (norm : R → 𝕜)
    (norm_nonneg : ∀ x, 0 ≤ norm x) (norm_mul_le : ∀ x y, norm (x * y) ≤ norm x * norm y)
    (nhds_basis : (𝓝 (0 : R)).HasBasis ((0 : 𝕜) < ·) (fun ε ↦ { x | norm x < ε })) :
    TopologicalRing R := by
  

Proof state:
R : Type u_1
𝕜 : Type u_2
inst✝³ : NonUnitalNonAssocRing R
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalAddGroup R
norm : R → 𝕜
norm_nonneg : ∀ (x : R), 0 ≤ norm x
norm_mul_le : ∀ (x y : R), norm (x * y) ≤ norm x * norm y
nhds_basis : HasBasis (𝓝 0) (fun x => 0 < x) fun ε => {x | norm x < ε}
⊢ TopologicalRing R

Next tactic:
have h0 : ∀ f : R → R, ∀ c ≥ (0 : 𝕜), (∀ x, norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)
/-- If a (possibly non-unital and/or non-associative) ring `R` admits a submultiplicative
nonnegative norm `norm : R → 𝕜`, where `𝕜` is a linear ordered field, and the open balls
`{ x | norm x < ε }`, `ε > 0`, form a basis of neighborhoods of zero, then `R` is a topological
ring. -/
theorem TopologicalRing.of_norm {R 𝕜 : Type*} [NonUnitalNonAssocRing R] [LinearOrderedField 𝕜]
    [TopologicalSpace R] [TopologicalAddGroup R] (norm : R → 𝕜)
    (norm_nonneg : ∀ x, 0 ≤ norm x) (norm_mul_le : ∀ x y, norm (x * y) ≤ norm x * norm y)
    (nhds_basis : (𝓝 (0 : R)).HasBasis ((0 : 𝕜) < ·) (fun ε ↦ { x | norm x < ε })) :
    TopologicalRing R := by
  have h0 : ∀ f : R → R, ∀ c ≥ (0 : 𝕜), (∀ x, norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)
  · 

Proof state:
case h0
R : Type u_1
𝕜 : Type u_2
inst✝³ : NonUnitalNonAssocRing R
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalAddGroup R
norm : R → 𝕜
norm_nonneg : ∀ (x : R), 0 ≤ norm x
norm_mul_le : ∀ (x y : R), norm (x * y) ≤ norm x * norm y
nhds_basis : HasBasis (𝓝 0) (fun x => 0 < x) fun ε => {x | norm x < ε}
⊢ ∀ (f : R → R), ∀ c ≥ 0, (∀ (x : R), norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)

Next tactic:
refine fun f c c0 hf ↦ (nhds_basis.tendsto_iff nhds_basis).2 fun ε ε0 ↦ ?_
/-- If a (possibly non-unital and/or non-associative) ring `R` admits a submultiplicative
nonnegative norm `norm : R → 𝕜`, where `𝕜` is a linear ordered field, and the open balls
`{ x | norm x < ε }`, `ε > 0`, form a basis of neighborhoods of zero, then `R` is a topological
ring. -/
theorem TopologicalRing.of_norm {R 𝕜 : Type*} [NonUnitalNonAssocRing R] [LinearOrderedField 𝕜]
    [TopologicalSpace R] [TopologicalAddGroup R] (norm : R → 𝕜)
    (norm_nonneg : ∀ x, 0 ≤ norm x) (norm_mul_le : ∀ x y, norm (x * y) ≤ norm x * norm y)
    (nhds_basis : (𝓝 (0 : R)).HasBasis ((0 : 𝕜) < ·) (fun ε ↦ { x | norm x < ε })) :
    TopologicalRing R := by
  have h0 : ∀ f : R → R, ∀ c ≥ (0 : 𝕜), (∀ x, norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)
  · refine fun f c c0 hf ↦ (nhds_basis.tendsto_iff nhds_basis).2 fun ε ε0 ↦ ?_
    

Proof state:
case h0
R : Type u_1
𝕜 : Type u_2
inst✝³ : NonUnitalNonAssocRing R
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalAddGroup R
norm : R → 𝕜
norm_nonneg : ∀ (x : R), 0 ≤ norm x
norm_mul_le : ∀ (x y : R), norm (x * y) ≤ norm x * norm y
nhds_basis : HasBasis (𝓝 0) (fun x => 0 < x) fun ε => {x | norm x < ε}
f : R → R
c : 𝕜
c0 : c ≥ 0
hf : ∀ (x : R), norm (f x) ≤ c * norm x
ε : 𝕜
ε0 : 0 < ε
⊢ ∃ ia, 0 < ia ∧ ∀ x ∈ {x | norm x < ia}, f x ∈ {x | norm x < ε}

Next tactic:
rcases exists_pos_mul_lt ε0 c with ⟨δ, δ0, hδ⟩
/-- If a (possibly non-unital and/or non-associative) ring `R` admits a submultiplicative
nonnegative norm `norm : R → 𝕜`, where `𝕜` is a linear ordered field, and the open balls
`{ x | norm x < ε }`, `ε > 0`, form a basis of neighborhoods of zero, then `R` is a topological
ring. -/
theorem TopologicalRing.of_norm {R 𝕜 : Type*} [NonUnitalNonAssocRing R] [LinearOrderedField 𝕜]
    [TopologicalSpace R] [TopologicalAddGroup R] (norm : R → 𝕜)
    (norm_nonneg : ∀ x, 0 ≤ norm x) (norm_mul_le : ∀ x y, norm (x * y) ≤ norm x * norm y)
    (nhds_basis : (𝓝 (0 : R)).HasBasis ((0 : 𝕜) < ·) (fun ε ↦ { x | norm x < ε })) :
    TopologicalRing R := by
  have h0 : ∀ f : R → R, ∀ c ≥ (0 : 𝕜), (∀ x, norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)
  · refine fun f c c0 hf ↦ (nhds_basis.tendsto_iff nhds_basis).2 fun ε ε0 ↦ ?_
    rcases exists_pos_mul_lt ε0 c with ⟨δ, δ0, hδ⟩
    

Proof state:
case h0.intro.intro
R : Type u_1
𝕜 : Type u_2
inst✝³ : NonUnitalNonAssocRing R
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalAddGroup R
norm : R → 𝕜
norm_nonneg : ∀ (x : R), 0 ≤ norm x
norm_mul_le : ∀ (x y : R), norm (x * y) ≤ norm x * norm y
nhds_basis : HasBasis (𝓝 0) (fun x => 0 < x) fun ε => {x | norm x < ε}
f : R → R
c : 𝕜
c0 : c ≥ 0
hf : ∀ (x : R), norm (f x) ≤ c * norm x
ε : 𝕜
ε0 : 0 < ε
δ : 𝕜
δ0 : 0 < δ
hδ : c * δ < ε
⊢ ∃ ia, 0 < ia ∧ ∀ x ∈ {x | norm x < ia}, f x ∈ {x | norm x < ε}

Next tactic:
refine ⟨δ, δ0, fun x hx ↦ (hf _).trans_lt ?_⟩
/-- If a (possibly non-unital and/or non-associative) ring `R` admits a submultiplicative
nonnegative norm `norm : R → 𝕜`, where `𝕜` is a linear ordered field, and the open balls
`{ x | norm x < ε }`, `ε > 0`, form a basis of neighborhoods of zero, then `R` is a topological
ring. -/
theorem TopologicalRing.of_norm {R 𝕜 : Type*} [NonUnitalNonAssocRing R] [LinearOrderedField 𝕜]
    [TopologicalSpace R] [TopologicalAddGroup R] (norm : R → 𝕜)
    (norm_nonneg : ∀ x, 0 ≤ norm x) (norm_mul_le : ∀ x y, norm (x * y) ≤ norm x * norm y)
    (nhds_basis : (𝓝 (0 : R)).HasBasis ((0 : 𝕜) < ·) (fun ε ↦ { x | norm x < ε })) :
    TopologicalRing R := by
  have h0 : ∀ f : R → R, ∀ c ≥ (0 : 𝕜), (∀ x, norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)
  · refine fun f c c0 hf ↦ (nhds_basis.tendsto_iff nhds_basis).2 fun ε ε0 ↦ ?_
    rcases exists_pos_mul_lt ε0 c with ⟨δ, δ0, hδ⟩
    refine ⟨δ, δ0, fun x hx ↦ (hf _).trans_lt ?_⟩
    

Proof state:
case h0.intro.intro
R : Type u_1
𝕜 : Type u_2
inst✝³ : NonUnitalNonAssocRing R
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalAddGroup R
norm : R → 𝕜
norm_nonneg : ∀ (x : R), 0 ≤ norm x
norm_mul_le : ∀ (x y : R), norm (x * y) ≤ norm x * norm y
nhds_basis : HasBasis (𝓝 0) (fun x => 0 < x) fun ε => {x | norm x < ε}
f : R → R
c : 𝕜
c0 : c ≥ 0
hf : ∀ (x : R), norm (f x) ≤ c * norm x
ε : 𝕜
ε0 : 0 < ε
δ : 𝕜
δ0 : 0 < δ
hδ : c * δ < ε
x : R
hx : x ∈ {x | norm x < δ}
⊢ c * norm x < ε

Next tactic:
exact (mul_le_mul_of_nonneg_left (le_of_lt hx) c0).trans_lt hδ
/-- If a (possibly non-unital and/or non-associative) ring `R` admits a submultiplicative
nonnegative norm `norm : R → 𝕜`, where `𝕜` is a linear ordered field, and the open balls
`{ x | norm x < ε }`, `ε > 0`, form a basis of neighborhoods of zero, then `R` is a topological
ring. -/
theorem TopologicalRing.of_norm {R 𝕜 : Type*} [NonUnitalNonAssocRing R] [LinearOrderedField 𝕜]
    [TopologicalSpace R] [TopologicalAddGroup R] (norm : R → 𝕜)
    (norm_nonneg : ∀ x, 0 ≤ norm x) (norm_mul_le : ∀ x y, norm (x * y) ≤ norm x * norm y)
    (nhds_basis : (𝓝 (0 : R)).HasBasis ((0 : 𝕜) < ·) (fun ε ↦ { x | norm x < ε })) :
    TopologicalRing R := by
  have h0 : ∀ f : R → R, ∀ c ≥ (0 : 𝕜), (∀ x, norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)
  · refine fun f c c0 hf ↦ (nhds_basis.tendsto_iff nhds_basis).2 fun ε ε0 ↦ ?_
    rcases exists_pos_mul_lt ε0 c with ⟨δ, δ0, hδ⟩
    refine ⟨δ, δ0, fun x hx ↦ (hf _).trans_lt ?_⟩
    exact (mul_le_mul_of_nonneg_left (le_of_lt hx) c0).trans_lt hδ
  

Proof state:
R : Type u_1
𝕜 : Type u_2
inst✝³ : NonUnitalNonAssocRing R
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalAddGroup R
norm : R → 𝕜
norm_nonneg : ∀ (x : R), 0 ≤ norm x
norm_mul_le : ∀ (x y : R), norm (x * y) ≤ norm x * norm y
nhds_basis : HasBasis (𝓝 0) (fun x => 0 < x) fun ε => {x | norm x < ε}
h0 : ∀ (f : R → R), ∀ c ≥ 0, (∀ (x : R), norm (f x) ≤ c * norm x) → Tendsto f (𝓝 0) (𝓝 0)
⊢ TopologicalRing R

Next tactic:
apply TopologicalRing.of_addGroup_of_nhds_zero