l3lab/ntp-mathlib huggingface dataset:
theorem swap_apply_apply (f : Perm α) (x y : α) : swap (f x) (f y) = f * swap x y * f⁻¹ := by
  

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
f : Perm α
x y : α
⊢ swap (f x) (f y) = f * swap x y * f⁻¹

Next tactic:
rw [mul_swap_eq_swap_mul, mul_inv_cancel_right]
/-- Left-multiplying a permutation with `swap i j` twice gives the original permutation.

  This specialization of `swap_mul_self` is useful when using cosets of permutations.
-/
@[simp]
theorem swap_mul_self_mul (i j : α) (σ : Perm α) : Equiv.swap i j * (Equiv.swap i j * σ) = σ := by
  

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
⊢ swap i j * (swap i j * σ) = σ

Next tactic:
rw [← mul_assoc, swap_mul_self, one_mul]
/-- Right-multiplying a permutation with `swap i j` twice gives the original permutation.

  This specialization of `swap_mul_self` is useful when using cosets of permutations.
-/
@[simp]
theorem mul_swap_mul_self (i j : α) (σ : Perm α) : σ * Equiv.swap i j * Equiv.swap i j = σ := by
  

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
⊢ σ * swap i j * swap i j = σ

Next tactic:
rw [mul_assoc, swap_mul_self, mul_one]
theorem swap_mul_eq_iff {i j : α} {σ : Perm α} : swap i j * σ = σ ↔ i = j := by
  

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
⊢ swap i j * σ = σ ↔ i = j

Next tactic:
rw [mul_left_eq_self, swap_eq_one_iff]
theorem mul_swap_eq_iff {i j : α} {σ : Perm α} : σ * swap i j = σ ↔ i = j := by
  

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
⊢ σ * swap i j = σ ↔ i = j

Next tactic:
rw [mul_right_eq_self, swap_eq_one_iff]
theorem swap_mul_swap_mul_swap {x y z : α} (hxy : x ≠ y) (hxz : x ≠ z) :
    swap y z * swap x y * swap y z = swap z x := by
  

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
x y z : α
hxy : x ≠ y
hxz : x ≠ z
⊢ swap y z * swap x y * swap y z = swap z x

Next tactic:
nth_rewrite 2 [← swap_inv]
theorem swap_mul_swap_mul_swap {x y z : α} (hxy : x ≠ y) (hxz : x ≠ z) :
    swap y z * swap x y * swap y z = swap z x := by
  nth_rewrite 2 [← swap_inv]
  

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
x y z : α
hxy : x ≠ y
hxz : x ≠ z
⊢ swap y z * swap x y * (swap y z)⁻¹ = swap z x

Next tactic:
rw [← swap_apply_apply, swap_apply_left, swap_apply_of_ne_of_ne hxy hxz, swap_comm]
@[simp] lemma pow_addLeft (n : ℕ) : Equiv.addLeft a ^ n = Equiv.addLeft (n • a) := by
  

Proof state:
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
⊢ Equiv.addLeft a ^ n = Equiv.addLeft (n • a)

Next tactic:
ext
@[simp] lemma pow_addLeft (n : ℕ) : Equiv.addLeft a ^ n = Equiv.addLeft (n • a) := by
  ext; 

Proof state:
case H
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
x✝ : α
⊢ (Equiv.addLeft a ^ n) x✝ = (Equiv.addLeft (n • a)) x✝

Next tactic:
simp [Perm.coe_pow]
@[simp] lemma pow_addRight (n : ℕ) : Equiv.addRight a ^ n = Equiv.addRight (n • a) := by
  

Proof state:
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
⊢ Equiv.addRight a ^ n = Equiv.addRight (n • a)

Next tactic:
ext
@[simp] lemma pow_addRight (n : ℕ) : Equiv.addRight a ^ n = Equiv.addRight (n • a) := by
  ext; 

Proof state:
case H
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
x✝ : α
⊢ (Equiv.addRight a ^ n) x✝ = (Equiv.addRight (n • a)) x✝

Next tactic:
simp [Perm.coe_pow]
@[simp] lemma zpow_addRight : ∀ (n : ℤ), Equiv.addRight a ^ n = Equiv.addRight (n • a)
  | (Int.ofNat n) => by 

Proof state:
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
⊢ Equiv.addRight a ^ Int.ofNat n = Equiv.addRight (Int.ofNat n • a)

Next tactic:
simp
@[simp] lemma zpow_addRight : ∀ (n : ℤ), Equiv.addRight a ^ n = Equiv.addRight (n • a)
  | (Int.ofNat n) => by simp
  | (Int.negSucc n) => by 

Proof state:
α : Type u
β : Type v
inst✝ : AddGroup α
a b : α
n : ℕ
⊢ Equiv.addRight a ^ Int.negSucc n = Equiv.addRight (Int.negSucc n • a)

Next tactic:
simp
@[to_additive existing (attr := simp) pow_addLeft]
lemma pow_mulLeft (n : ℕ) : Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n) := by
  

Proof state:
α : Type u
β : Type v
inst✝ : Group α
a b : α
n : ℕ
⊢ Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n)

Next tactic:
ext
@[to_additive existing (attr := simp) pow_addLeft]
lemma pow_mulLeft (n : ℕ) : Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n) := by
  ext; 

Proof state:
case H
α : Type u
β : Type v
inst✝ : Group α
a b : α
n : ℕ
x✝ : α
⊢ (Equiv.mulLeft a ^ n) x✝ = (Equiv.mulLeft (a ^ n)) x✝

Next tactic:
simp [Perm.coe_pow]
@[to_additive existing (attr := simp) pow_addRight]
lemma pow_mulRight (n : ℕ) : Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n) := by
  

Proof state:
α : Type u
β : Type v
inst✝ : Group α
a b : α
n : ℕ
⊢ Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)

Next tactic:
ext
@[to_additive existing (attr := simp) pow_addRight]
lemma pow_mulRight (n : ℕ) : Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n) := by
  ext; 

Proof state:
case H
α : Type u
β : Type v
inst✝ : Group α
a b : α
n : ℕ
x✝ : α
⊢ (Equiv.mulRight a ^ n) x✝ = (Equiv.mulRight (a ^ n)) x✝

Next tactic:
simp [Perm.coe_pow]
@[to_additive existing (attr := simp) zpow_addRight]
lemma zpow_mulRight : ∀ n : ℤ, Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)
  | (Int.ofNat n) => by 

Proof state:
α : Type u
β : Type v
inst✝ : Group α
a b : α
n : ℕ
⊢ Equiv.mulRight a ^ Int.ofNat n = Equiv.mulRight (a ^ Int.ofNat n)

Next tactic:
simp
@[to_additive existing (attr := simp) zpow_addRight]
lemma zpow_mulRight : ∀ n : ℤ, Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)
  | (Int.ofNat n) => by simp
  | (Int.negSucc n) => by 

Proof state:
α : Type u
β : Type v
inst✝ : Group α
a b : α
n : ℕ
⊢ Equiv.mulRight a ^ Int.negSucc n = Equiv.mulRight (a ^ Int.negSucc n)

Next tactic:
simp
lemma MapsTo.perm_pow : MapsTo f s s → ∀ n : ℕ, MapsTo (f ^ n) s s := by
  

Proof state:
α : Type u_1
f : Perm α
s : Set α
⊢ MapsTo (⇑f) s s → ∀ (n : ℕ), MapsTo (⇑(f ^ n)) s s

Next tactic:
simp_rw [Equiv.Perm.coe_pow]
lemma MapsTo.perm_pow : MapsTo f s s → ∀ n : ℕ, MapsTo (f ^ n) s s := by
  simp_rw [Equiv.Perm.coe_pow]; 

Proof state:
α : Type u_1
f : Perm α
s : Set α
⊢ MapsTo (⇑f) s s → ∀ (n : ℕ), MapsTo (⇑f)^[n] s s

Next tactic:
exact MapsTo.iterate
lemma SurjOn.perm_pow : SurjOn f s s → ∀ n : ℕ, SurjOn (f ^ n) s s := by
  

Proof state:
α : Type u_1
f : Perm α
s : Set α
⊢ SurjOn (⇑f) s s → ∀ (n : ℕ), SurjOn (⇑(f ^ n)) s s

Next tactic:
simp_rw [Equiv.Perm.coe_pow]
lemma SurjOn.perm_pow : SurjOn f s s → ∀ n : ℕ, SurjOn (f ^ n) s s := by
  simp_rw [Equiv.Perm.coe_pow]; 

Proof state:
α : Type u_1
f : Perm α
s : Set α
⊢ SurjOn (⇑f) s s → ∀ (n : ℕ), SurjOn (⇑f)^[n] s s

Next tactic:
exact SurjOn.iterate
lemma BijOn.perm_pow : BijOn f s s → ∀ n : ℕ, BijOn (f ^ n) s s := by
  

Proof state:
α : Type u_1
f : Perm α
s : Set α
⊢ BijOn (⇑f) s s → ∀ (n : ℕ), BijOn (⇑(f ^ n)) s s

Next tactic:
simp_rw [Equiv.Perm.coe_pow]
lemma BijOn.perm_pow : BijOn f s s → ∀ n : ℕ, BijOn (f ^ n) s s := by
  simp_rw [Equiv.Perm.coe_pow]; 

Proof state:
α : Type u_1
f : Perm α
s : Set α
⊢ BijOn (⇑f) s s → ∀ (n : ℕ), BijOn (⇑f)^[n] s s

Next tactic:
exact BijOn.iterate
@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one_of_basis {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis p fun i => { f : α →ᵤ G | ∀ x, toFun f x ∈ b i } := by
  

Proof state:
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
⊢ HasBasis (𝓝 1) p fun i => {f | ∀ (x : α), toFun f x ∈ b i}

Next tactic:
have := h.comap fun p : G × G => p.2 / p.1
@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one_of_basis {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis p fun i => { f : α →ᵤ G | ∀ x, toFun f x ∈ b i } := by
  have := h.comap fun p : G × G => p.2 / p.1
  

Proof state:
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (comap (fun p => p.2 / p.1) (𝓝 1)) p fun i => (fun p => p.2 / p.1) ⁻¹' b i
⊢ HasBasis (𝓝 1) p fun i => {f | ∀ (x : α), toFun f x ∈ b i}

Next tactic:
rw [← uniformity_eq_comap_nhds_one] at this
@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one_of_basis {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis p fun i => { f : α →ᵤ G | ∀ x, toFun f x ∈ b i } := by
  have := h.comap fun p : G × G => p.2 / p.1
  rw [← uniformity_eq_comap_nhds_one] at this
  

Proof state:
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (uniformity G) p fun i => (fun p => p.2 / p.1) ⁻¹' b i
⊢ HasBasis (𝓝 1) p fun i => {f | ∀ (x : α), toFun f x ∈ b i}

Next tactic:
convert UniformFun.hasBasis_nhds_of_basis α _ (1 : α →ᵤ G) this
@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one_of_basis {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis p fun i => { f : α →ᵤ G | ∀ x, toFun f x ∈ b i } := by
  have := h.comap fun p : G × G => p.2 / p.1
  rw [← uniformity_eq_comap_nhds_one] at this
  convert UniformFun.hasBasis_nhds_of_basis α _ (1 : α →ᵤ G) this
  -- Porting note: removed `ext i f` here, as it has already been done by `convert`.
  

Proof state:
case h.e'_5.h.h.e'_2.h.a
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (uniformity G) p fun i => (fun p => p.2 / p.1) ⁻¹' b i
x✝¹ : ι
x✝ : α →ᵤ G
⊢ (∀ (x : α), toFun x✝ x ∈ b x✝¹) ↔ (1, x✝) ∈ UniformFun.gen α G ((fun p => p.2 / p.1) ⁻¹' b x✝¹)

Next tactic:
simp
@[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one_of_basis (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ Si.1, toFun 𝔖 f x ∈ b Si.2 } := by
  

Proof state:
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
⊢ HasBasis (𝓝 1) (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (toFun 𝔖) f x ∈ b Si.2}

Next tactic:
have := h.comap fun p : G × G => p.1 / p.2
@[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one_of_basis (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ Si.1, toFun 𝔖 f x ∈ b Si.2 } := by
  have := h.comap fun p : G × G => p.1 / p.2
  

Proof state:
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (comap (fun p => p.1 / p.2) (𝓝 1)) p fun i => (fun p => p.1 / p.2) ⁻¹' b i
⊢ HasBasis (𝓝 1) (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (toFun 𝔖) f x ∈ b Si.2}

Next tactic:
rw [← uniformity_eq_comap_nhds_one_swapped] at this
@[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one_of_basis (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ Si.1, toFun 𝔖 f x ∈ b Si.2 } := by
  have := h.comap fun p : G × G => p.1 / p.2
  rw [← uniformity_eq_comap_nhds_one_swapped] at this
  

Proof state:
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (uniformity G) p fun i => (fun p => p.1 / p.2) ⁻¹' b i
⊢ HasBasis (𝓝 1) (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (toFun 𝔖) f x ∈ b Si.2}

Next tactic:
convert UniformOnFun.hasBasis_nhds_of_basis α _ 𝔖 (1 : α →ᵤ[𝔖] G) h𝔖₁ h𝔖₂ this
@[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one_of_basis (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ Si.1, toFun 𝔖 f x ∈ b Si.2 } := by
  have := h.comap fun p : G × G => p.1 / p.2
  rw [← uniformity_eq_comap_nhds_one_swapped] at this
  convert UniformOnFun.hasBasis_nhds_of_basis α _ 𝔖 (1 : α →ᵤ[𝔖] G) h𝔖₁ h𝔖₂ this
  -- Porting note: removed `ext i f` here, as it has already been done by `convert`.
  

Proof state:
case h.e'_5.h.h.e'_2.h.a
α : Type u_1
G : Type u_2
ι : Type u_3
inst✝² : Group G
𝔖✝ : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
𝔖 : Set (Set α)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (uniformity G) p fun i => (fun p => p.1 / p.2) ⁻¹' b i
x✝¹ : Set α × ι
x✝ : α →ᵤ[𝔖] G
⊢ (∀ x ∈ x✝¹.1, (toFun 𝔖) x✝ x ∈ b x✝¹.2) ↔ (x✝, 1) ∈ UniformOnFun.gen 𝔖 x✝¹.1 ((fun p => p.1 / p.2) ⁻¹' b x✝¹.2)

Next tactic:
simp [UniformOnFun.gen]
/-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
`S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
equipped with the topology of `𝔖`-convergence, is a TVS.

For convenience, we don't literally ask for `H : Submodule (α →ᵤ[𝔖] E)`. Instead, we prove the
result for any vector space `H` equipped with a linear inducing to `α →ᵤ[𝔖] E`, which is often
easier to use. We also state the `Submodule` version as
`UniformOnFun.continuousSMul_submodule_of_image_bounded`. -/
theorem UniformOnFun.continuousSMul_induced_of_image_bounded (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) (φ : hom) (hφ : Inducing φ)
    (h : ∀ u : H, ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 ((φ u : α → E) '' s)) :
    ContinuousSMul 𝕜 H := by
  

Proof state:
𝕜 : Type u_1
α : Type u_2
E : Type u_3
H : Type u_4
hom : Type u_5
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup H
inst✝⁷ : Module 𝕜 H
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : TopologicalSpace H
inst✝³ : UniformSpace E
inst✝² : UniformAddGroup E
inst✝¹ : ContinuousSMul 𝕜 E
𝔖 : Set (Set α)
inst✝ : LinearMapClass hom 𝕜 H (α →ᵤ[𝔖] E)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
φ : hom
hφ : Inducing ⇑φ
h : ∀ (u : H), ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 (φ u '' s)
⊢ ContinuousSMul 𝕜 H

Next tactic:
have : TopologicalAddGroup H := by
    rw [hφ.induced]
    exact topologicalAddGroup_induced φ
/-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
`S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
equipped with the topology of `𝔖`-convergence, is a TVS.

For convenience, we don't literally ask for `H : Submodule (α →ᵤ[𝔖] E)`. Instead, we prove the
result for any vector space `H` equipped with a linear inducing to `α →ᵤ[𝔖] E`, which is often
easier to use. We also state the `Submodule` version as
`UniformOnFun.continuousSMul_submodule_of_image_bounded`. -/
theorem UniformOnFun.continuousSMul_induced_of_image_bounded (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) (φ : hom) (hφ : Inducing φ)
    (h : ∀ u : H, ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 ((φ u : α → E) '' s)) :
    ContinuousSMul 𝕜 H := by
  have : TopologicalAddGroup H := by
    

Proof state:
𝕜 : Type u_1
α : Type u_2
E : Type u_3
H : Type u_4
hom : Type u_5
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup H
inst✝⁷ : Module 𝕜 H
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : TopologicalSpace H
inst✝³ : UniformSpace E
inst✝² : UniformAddGroup E
inst✝¹ : ContinuousSMul 𝕜 E
𝔖 : Set (Set α)
inst✝ : LinearMapClass hom 𝕜 H (α →ᵤ[𝔖] E)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
φ : hom
hφ : Inducing ⇑φ
h : ∀ (u : H), ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 (φ u '' s)
⊢ TopologicalAddGroup H

Next tactic:
rw [hφ.induced]
/-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
`S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
equipped with the topology of `𝔖`-convergence, is a TVS.

For convenience, we don't literally ask for `H : Submodule (α →ᵤ[𝔖] E)`. Instead, we prove the
result for any vector space `H` equipped with a linear inducing to `α →ᵤ[𝔖] E`, which is often
easier to use. We also state the `Submodule` version as
`UniformOnFun.continuousSMul_submodule_of_image_bounded`. -/
theorem UniformOnFun.continuousSMul_induced_of_image_bounded (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) (φ : hom) (hφ : Inducing φ)
    (h : ∀ u : H, ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 ((φ u : α → E) '' s)) :
    ContinuousSMul 𝕜 H := by
  have : TopologicalAddGroup H := by
    rw [hφ.induced]
    

Proof state:
𝕜 : Type u_1
α : Type u_2
E : Type u_3
H : Type u_4
hom : Type u_5
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup H
inst✝⁷ : Module 𝕜 H
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : TopologicalSpace H
inst✝³ : UniformSpace E
inst✝² : UniformAddGroup E
inst✝¹ : ContinuousSMul 𝕜 E
𝔖 : Set (Set α)
inst✝ : LinearMapClass hom 𝕜 H (α →ᵤ[𝔖] E)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
φ : hom
hφ : Inducing ⇑φ
h : ∀ (u : H), ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 (φ u '' s)
⊢ TopologicalAddGroup H

Next tactic:
exact topologicalAddGroup_induced φ
/-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
`S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
equipped with the topology of `𝔖`-convergence, is a TVS.

For convenience, we don't literally ask for `H : Submodule (α →ᵤ[𝔖] E)`. Instead, we prove the
result for any vector space `H` equipped with a linear inducing to `α →ᵤ[𝔖] E`, which is often
easier to use. We also state the `Submodule` version as
`UniformOnFun.continuousSMul_submodule_of_image_bounded`. -/
theorem UniformOnFun.continuousSMul_induced_of_image_bounded (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) (φ : hom) (hφ : Inducing φ)
    (h : ∀ u : H, ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 ((φ u : α → E) '' s)) :
    ContinuousSMul 𝕜 H := by
  have : TopologicalAddGroup H := by
    rw [hφ.induced]
    exact topologicalAddGroup_induced φ
  

Proof state:
𝕜 : Type u_1
α : Type u_2
E : Type u_3
H : Type u_4
hom : Type u_5
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup H
inst✝⁷ : Module 𝕜 H
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : TopologicalSpace H
inst✝³ : UniformSpace E
inst✝² : UniformAddGroup E
inst✝¹ : ContinuousSMul 𝕜 E
𝔖 : Set (Set α)
inst✝ : LinearMapClass hom 𝕜 H (α →ᵤ[𝔖] E)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
φ : hom
hφ : Inducing ⇑φ
h : ∀ (u : H), ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 (φ u '' s)
this : TopologicalAddGroup H
⊢ ContinuousSMul 𝕜 H

Next tactic:
have : (𝓝 0 : Filter H).HasBasis _ _ := by
    rw [hφ.induced, nhds_induced, map_zero]
    exact (UniformOnFun.hasBasis_nhds_zero 𝔖 h𝔖₁ h𝔖₂).comap φ
/-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
`S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
equipped with the topology of `𝔖`-convergence, is a TVS.

For convenience, we don't literally ask for `H : Submodule (α →ᵤ[𝔖] E)`. Instead, we prove the
result for any vector space `H` equipped with a linear inducing to `α →ᵤ[𝔖] E`, which is often
easier to use. We also state the `Submodule` version as
`UniformOnFun.continuousSMul_submodule_of_image_bounded`. -/
theorem UniformOnFun.continuousSMul_induced_of_image_bounded (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) (φ : hom) (hφ : Inducing φ)
    (h : ∀ u : H, ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 ((φ u : α → E) '' s)) :
    ContinuousSMul 𝕜 H := by
  have : TopologicalAddGroup H := by
    rw [hφ.induced]
    exact topologicalAddGroup_induced φ
  have : (𝓝 0 : Filter H).HasBasis _ _ := by
    

Proof state:
𝕜 : Type u_1
α : Type u_2
E : Type u_3
H : Type u_4
hom : Type u_5
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup H
inst✝⁷ : Module 𝕜 H
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : TopologicalSpace H
inst✝³ : UniformSpace E
inst✝² : UniformAddGroup E
inst✝¹ : ContinuousSMul 𝕜 E
𝔖 : Set (Set α)
inst✝ : LinearMapClass hom 𝕜 H (α →ᵤ[𝔖] E)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
φ : hom
hφ : Inducing ⇑φ
h : ∀ (u : H), ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 (φ u '' s)
this : TopologicalAddGroup H
⊢ HasBasis (𝓝 0) ?m.99988 ?m.99989

Next tactic:
rw [hφ.induced, nhds_induced, map_zero]
/-- Let `E` be a TVS, `𝔖 : Set (Set α)` and `H` a submodule of `α →ᵤ[𝔖] E`. If the image of any
`S ∈ 𝔖` by any `u ∈ H` is bounded (in the sense of `Bornology.IsVonNBounded`), then `H`,
equipped with the topology of `𝔖`-convergence, is a TVS.

For convenience, we don't literally ask for `H : Submodule (α →ᵤ[𝔖] E)`. Instead, we prove the
result for any vector space `H` equipped with a linear inducing to `α →ᵤ[𝔖] E`, which is often
easier to use. We also state the `Submodule` version as
`UniformOnFun.continuousSMul_submodule_of_image_bounded`. -/
theorem UniformOnFun.continuousSMul_induced_of_image_bounded (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) (φ : hom) (hφ : Inducing φ)
    (h : ∀ u : H, ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 ((φ u : α → E) '' s)) :
    ContinuousSMul 𝕜 H := by
  have : TopologicalAddGroup H := by
    rw [hφ.induced]
    exact topologicalAddGroup_induced φ
  have : (𝓝 0 : Filter H).HasBasis _ _ := by
    rw [hφ.induced, nhds_induced, map_zero]
    exact (UniformOnFun.hasBasis_nhds_zero 𝔖 h𝔖₁ h𝔖₂).comap φ
  

Proof state:
𝕜 : Type u_1
α : Type u_2
E : Type u_3
H : Type u_4
hom : Type u_5
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup H
inst✝⁷ : Module 𝕜 H
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : TopologicalSpace H
inst✝³ : UniformSpace E
inst✝² : UniformAddGroup E
inst✝¹ : ContinuousSMul 𝕜 E
𝔖 : Set (Set α)
inst✝ : LinearMapClass hom 𝕜 H (α →ᵤ[𝔖] E)
h𝔖₁ : Set.Nonempty 𝔖
h𝔖₂ : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖
φ : hom
hφ : Inducing ⇑φ
h : ∀ (u : H), ∀ s ∈ 𝔖, Bornology.IsVonNBounded 𝕜 (φ u '' s)
this✝ : TopologicalAddGroup H
this : HasBasis (𝓝 0) (fun SV => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓝 0) fun i => ⇑φ ⁻¹' {f | ∀ x ∈ i.1, f x ∈ i.2}
⊢ ContinuousSMul 𝕜 H

Next tactic:
refine' ContinuousSMul.of_basis_zero this _ _ _