ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ContinuousMultilinearMap.map_sub
@[simp]
theorem map_sub [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (x y : M₁ i) :
    f (update m i (x - y)) = f (update m i x) - f (update m i y) 
Arguments: {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [Ring R] [(i : ι) → AddCommGroup (M₁ i)] [AddCommGroup M₂] [(i : ι) → Module R (M₁ i)] [Module R M₂] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] (f : ContinuousMultilinearMap R M₁ M₂) [DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (x y : M₁ i)
Goal: f (Function.update m i (x - y)) = f (Function.update m i x) - f (Function.update m i y)
-- ContinuousMultilinearMap.neg_apply
@[simp]
theorem neg_apply (m : ∀ i, M₁ i) : (-f) m = -f m 
Arguments: {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [Ring R] [(i : ι) → AddCommGroup (M₁ i)] [AddCommGroup M₂] [(i : ι) → Module R (M₁ i)] [Module R M₂] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] (f : ContinuousMultilinearMap R M₁ M₂) [TopologicalAddGroup M₂] (m : (i : ι) → M₁ i)
Goal: (-f) m = -f m
-- ContinuousMultilinearMap.sub_apply
@[simp]
theorem sub_apply (m : ∀ i, M₁ i) : (f - f') m = f m - f' m 
Arguments: {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [Ring R] [(i : ι) → AddCommGroup (M₁ i)] [AddCommGroup M₂] [(i : ι) → Module R (M₁ i)] [Module R M₂] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] (f f' : ContinuousMultilinearMap R M₁ M₂) [TopologicalAddGroup M₂] (m : (i : ι) → M₁ i)
Goal: (f - f') m = f m - f' m
-- ContinuousMultilinearMap.map_piecewise_smul
theorem map_piecewise_smul [DecidableEq ι] (c : ι → R) (m : ∀ i, M₁ i) (s : Finset ι) :
    f (s.piecewise (fun i => c i • m i) m) = (∏ i ∈ s, c i) • f m 
Arguments: {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [CommSemiring R] [(i : ι) → AddCommMonoid (M₁ i)] [AddCommMonoid M₂] [(i : ι) → Module R (M₁ i)] [Module R M₂] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] (f : ContinuousMultilinearMap R M₁ M₂) [DecidableEq ι] (c : ι → R) (m : (i : ι) → M₁ i) (s : Finset ι)
Goal: f (s.piecewise (fun i => c i • m i) m) = (∏ i ∈ s, c i) • f m
-- ContinuousMultilinearMap.map_smul_univ
theorem map_smul_univ [Fintype ι] (c : ι → R) (m : ∀ i, M₁ i) :
    (f fun i => c i • m i) = (∏ i, c i) • f m 
Arguments: {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [CommSemiring R] [(i : ι) → AddCommMonoid (M₁ i)] [AddCommMonoid M₂] [(i : ι) → Module R (M₁ i)] [Module R M₂] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] (f : ContinuousMultilinearMap R M₁ M₂) [Fintype ι] (c : ι → R) (m : (i : ι) → M₁ i)
Goal: (f fun i => c i • m i) = (∏ i : ι, c i) • f m
-- ContinuousMultilinearMap.toMultilinearMapLinear_apply
@[simps]
def toMultilinearMapLinear : ContinuousMultilinearMap A M₁ M₂ →ₗ[R'] MultilinearMap A M₁ M₂ 
Arguments: {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} {R' : Type u_1} {A : Type u_2} [Semiring R'] [Semiring A] [(i : ι) → AddCommMonoid (M₁ i)] [AddCommMonoid M₂] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] [ContinuousAdd M₂] [(i : ι) → Module A (M₁ i)] [Module A M₂] [Module R' M₂] [ContinuousConstSMul R' M₂] [SMulCommClass A R' M₂] (self : ContinuousMultilinearMap A M₁ M₂)
Goal: ContinuousMultilinearMap.toMultilinearMapLinear self = self.toMultilinearMap
-- ContinuousMultilinearMap.piLinearEquiv_apply
@[simps (config := { simpRhs := true })]
def piLinearEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, ContinuousAdd (M' i)] [∀ i, Module R' (M' i)]
    [∀ i, Module A (M' i)] [∀ i, SMulCommClass A R' (M' i)] [∀ i, ContinuousConstSMul R' (M' i)] :
    (∀ i, ContinuousMultilinearMap A M₁ (M' i)) ≃ₗ[R'] ContinuousMultilinearMap A M₁ (∀ i, M' i) 
Arguments: {ι : Type v} {M₁ : ι → Type w₁} {R' : Type u_1} {A : Type u_2} [Semiring R'] [Semiring A] [(i : ι) → AddCommMonoid (M₁ i)] [(i : ι) → TopologicalSpace (M₁ i)] [(i : ι) → Module A (M₁ i)] {ι' : Type u_3} {M' : ι' → Type u_4} [(i : ι') → AddCommMonoid (M' i)] [(i : ι') → TopologicalSpace (M' i)] [∀ (i : ι'), ContinuousAdd (M' i)] [(i : ι') → Module R' (M' i)] [(i : ι') → Module A (M' i)] [∀ (i : ι'), SMulCommClass A R' (M' i)] [∀ (i : ι'), ContinuousConstSMul R' (M' i)]
Goal: ∀ (a : (i : ι') → ContinuousMultilinearMap A M₁ (M' i)),
  ContinuousMultilinearMap.piLinearEquiv a = ContinuousMultilinearMap.pi a
-- ContinuousMultilinearMap.piLinearEquiv_symm_apply
@[simps (config := { simpRhs := true })]
def piLinearEquiv {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, ContinuousAdd (M' i)] [∀ i, Module R' (M' i)]
    [∀ i, Module A (M' i)] [∀ i, SMulCommClass A R' (M' i)] [∀ i, ContinuousConstSMul R' (M' i)] :
    (∀ i, ContinuousMultilinearMap A M₁ (M' i)) ≃ₗ[R'] ContinuousMultilinearMap A M₁ (∀ i, M' i) 
Arguments: {ι : Type v} {M₁ : ι → Type w₁} {R' : Type u_1} {A : Type u_2} [Semiring R'] [Semiring A] [(i : ι) → AddCommMonoid (M₁ i)] [(i : ι) → TopologicalSpace (M₁ i)] [(i : ι) → Module A (M₁ i)] {ι' : Type u_3} {M' : ι' → Type u_4} [(i : ι') → AddCommMonoid (M' i)] [(i : ι') → TopologicalSpace (M' i)] [∀ (i : ι'), ContinuousAdd (M' i)] [(i : ι') → Module R' (M' i)] [(i : ι') → Module A (M' i)] [∀ (i : ι'), SMulCommClass A R' (M' i)] [∀ (i : ι'), ContinuousConstSMul R' (M' i)]
Goal: ∀ (a : ContinuousMultilinearMap A M₁ ((i : ι') → M' i)) (i : ι'),
  ContinuousMultilinearMap.piLinearEquiv.symm a i = (ContinuousLinearMap.proj i).compContinuousMultilinearMap a
-- ContinuousMultilinearMap.mkPiAlgebra_apply
@[simp]
theorem mkPiAlgebra_apply (m : ι → A) : ContinuousMultilinearMap.mkPiAlgebra R ι A m = ∏ i, m i 
Arguments: (R : Type u) (ι : Type v) (A : Type u_1) [Fintype ι] [CommSemiring R] [CommSemiring A] [Algebra R A] [TopologicalSpace A] [ContinuousMul A] (m : ι → A)
Goal: (ContinuousMultilinearMap.mkPiAlgebra R ι A) m = ∏ i : ι, m i
-- ContinuousMultilinearMap.mkPiAlgebraFin_apply
@[simp]
theorem mkPiAlgebraFin_apply (m : Fin n → A) :
    ContinuousMultilinearMap.mkPiAlgebraFin R n A m = (List.ofFn m).prod 
Arguments: {R : Type u} {n : ℕ} {A : Type u_1} [CommSemiring R] [Semiring A] [Algebra R A] [TopologicalSpace A] [ContinuousMul A] (m : Fin n → A)
Goal: (ContinuousMultilinearMap.mkPiAlgebraFin R n A) m = (List.ofFn m).prod
-- ContinuousMultilinearMap.smulRight_apply
@[simps! toMultilinearMap apply]
def smulRight : ContinuousMultilinearMap R M₁ M₂ 
Arguments: {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [CommSemiring R] [(i : ι) → AddCommMonoid (M₁ i)] [AddCommMonoid M₂] [(i : ι) → Module R (M₁ i)] [Module R M₂] [TopologicalSpace R] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] [ContinuousSMul R M₂] (f : ContinuousMultilinearMap R M₁ R) (z : M₂)
Goal: ∀ (a : (i : ι) → M₁ i), (f.smulRight z) a = f a • z
-- ContinuousMultilinearMap.smulRight_toMultilinearMap
@[simps! toMultilinearMap apply]
def smulRight : ContinuousMultilinearMap R M₁ M₂ 
Arguments: {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [CommSemiring R] [(i : ι) → AddCommMonoid (M₁ i)] [AddCommMonoid M₂] [(i : ι) → Module R (M₁ i)] [Module R M₂] [TopologicalSpace R] [(i : ι) → TopologicalSpace (M₁ i)] [TopologicalSpace M₂] [ContinuousSMul R M₂] (f : ContinuousMultilinearMap R M₁ R) (z : M₂)
Goal: (f.smulRight z).toMultilinearMap = f.smulRight z
-- ContinuousMultilinearMap.mkPiRing_apply
@[simp]
theorem mkPiRing_apply (z : M) (m : ι → R) :
    (ContinuousMultilinearMap.mkPiRing R ι z : (ι → R) → M) m = (∏ i, m i) • z 
Arguments: {R : Type u} {ι : Type v} {M : Type u_1} [Fintype ι] [CommRing R] [AddCommMonoid M] [Module R M] [TopologicalSpace R] [TopologicalSpace M] [ContinuousMul R] [ContinuousSMul R M] (z : M) (m : ι → R)
Goal: (ContinuousMultilinearMap.mkPiRing R ι z) m = (∏ i : ι, m i) • z
-- ContinuousMultilinearMap.mkPiRing_apply_one_eq_self
theorem mkPiRing_apply_one_eq_self (f : ContinuousMultilinearMap R (fun _ : ι => R) M) :
    ContinuousMultilinearMap.mkPiRing R ι (f fun _ => 1) = f 
Arguments: {R : Type u} {ι : Type v} {M : Type u_1} [Fintype ι] [CommRing R] [AddCommMonoid M] [Module R M] [TopologicalSpace R] [TopologicalSpace M] [ContinuousMul R] [ContinuousSMul R M] (f : ContinuousMultilinearMap R (fun x => R) M)
Goal: ContinuousMultilinearMap.mkPiRing R ι (f fun x => 1) = f
-- ContinuousMultilinearMap.mkPiRing_eq_iff
theorem mkPiRing_eq_iff {z₁ z₂ : M} :
    ContinuousMultilinearMap.mkPiRing R ι z₁ = ContinuousMultilinearMap.mkPiRing R ι z₂ ↔
      z₁ = z₂ 
Arguments: {R : Type u} {ι : Type v} {M : Type u_1} [Fintype ι] [CommRing R] [AddCommMonoid M] [Module R M] [TopologicalSpace R] [TopologicalSpace M] [ContinuousMul R] [ContinuousSMul R M] {z₁ z₂ : M}
Goal: ContinuousMultilinearMap.mkPiRing R ι z₁ = ContinuousMultilinearMap.mkPiRing R ι z₂ ↔ z₁ = z₂
-- ContinuousMultilinearMap.mkPiRing_zero
theorem mkPiRing_zero : ContinuousMultilinearMap.mkPiRing R ι (0 : M) = 0 
Arguments: {R : Type u} {ι : Type v} {M : Type u_1} [Fintype ι] [CommRing R] [AddCommMonoid M] [Module R M] [TopologicalSpace R] [TopologicalSpace M] [ContinuousMul R] [ContinuousSMul R M]
Goal: ContinuousMultilinearMap.mkPiRing R ι 0 = 0
-- ContinuousMultilinearMap.mkPiRing_eq_zero_iff
theorem mkPiRing_eq_zero_iff (z : M) : ContinuousMultilinearMap.mkPiRing R ι z = 0 ↔ z = 0 
Arguments: {R : Type u} {ι : Type v} {M : Type u_1} [Fintype ι] [CommRing R] [AddCommMonoid M] [Module R M] [TopologicalSpace R] [TopologicalSpace M] [ContinuousMul R] [ContinuousSMul R M] (z : M)
Goal: ContinuousMultilinearMap.mkPiRing R ι z = 0 ↔ z = 0
-- Ideal.coe_closure
@[simp]
theorem Ideal.coe_closure (I : Ideal R) : (I.closure : Set R) = closure I 
Arguments: {R : Type u_1} [TopologicalSpace R] [Ring R] [TopologicalRing R] (I : Ideal R)
Goal: ↑I.closure = closure ↑I
-- Ideal.closure_eq_of_isClosed
theorem Ideal.closure_eq_of_isClosed (I : Ideal R) (hI : IsClosed (I : Set R)) : I.closure = I 
Arguments: {R : Type u_1} [TopologicalSpace R] [Ring R] [TopologicalRing R] (I : Ideal R) (hI : IsClosed ↑I)
Goal: I.closure = I
-- QuotientRing.isOpenMap_coe
theorem QuotientRing.isOpenMap_coe : IsOpenMap (mk N) 
Arguments: {R : Type u_1} [TopologicalSpace R] [CommRing R] (N : Ideal R) [TopologicalRing R]
Goal: IsOpenMap ⇑(Ideal.Quotient.mk N)
-- QuotientRing.quotientMap_coe_coe
theorem QuotientRing.quotientMap_coe_coe : QuotientMap fun p : R × R => (mk N p.1, mk N p.2) 
Arguments: {R : Type u_1} [TopologicalSpace R] [CommRing R] (N : Ideal R) [TopologicalRing R]
Goal: QuotientMap fun p => ((Ideal.Quotient.mk N) p.1, (Ideal.Quotient.mk N) p.2)
-- AddOpposite.continuous_unop
@[to_additive (attr := continuity)]
theorem continuous_unop : Continuous (unop : Mᵐᵒᵖ → M) 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: Continuous AddOpposite.unop
-- MulOpposite.continuous_unop
@[to_additive (attr := continuity)]
theorem continuous_unop : Continuous (unop : Mᵐᵒᵖ → M) 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: Continuous MulOpposite.unop
-- AddOpposite.continuous_op
@[to_additive (attr := continuity)]
theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: Continuous AddOpposite.op
-- MulOpposite.continuous_op
@[to_additive (attr := continuity)]
theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: Continuous MulOpposite.op
-- AddOpposite.opHomeomorph_apply
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: ∀ (a : M), AddOpposite.opHomeomorph a = AddOpposite.op a
-- MulOpposite.opHomeomorph_apply
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: ∀ (a : M), MulOpposite.opHomeomorph a = MulOpposite.op a
-- MulOpposite.opHomeomorph_symm_apply
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: ∀ (a : Mᵐᵒᵖ), MulOpposite.opHomeomorph.symm a = MulOpposite.unop a
-- AddOpposite.opHomeomorph_symm_apply
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
Arguments: {M : Type u_1} [TopologicalSpace M]
Goal: ∀ (a : Mᵃᵒᵖ), AddOpposite.opHomeomorph.symm a = AddOpposite.unop a
-- AddOpposite.map_op_nhds
@[to_additive (attr := simp)]
theorem map_op_nhds (x : M) : map (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (op x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : M)
Goal: Filter.map AddOpposite.op (𝓝 x) = 𝓝 (AddOpposite.op x)
-- MulOpposite.map_op_nhds
@[to_additive (attr := simp)]
theorem map_op_nhds (x : M) : map (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (op x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : M)
Goal: Filter.map MulOpposite.op (𝓝 x) = 𝓝 (MulOpposite.op x)
-- AddOpposite.map_unop_nhds
@[to_additive (attr := simp)]
theorem map_unop_nhds (x : Mᵐᵒᵖ) : map (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (unop x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : Mᵃᵒᵖ)
Goal: Filter.map AddOpposite.unop (𝓝 x) = 𝓝 (AddOpposite.unop x)
-- MulOpposite.map_unop_nhds
@[to_additive (attr := simp)]
theorem map_unop_nhds (x : Mᵐᵒᵖ) : map (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (unop x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : Mᵐᵒᵖ)
Goal: Filter.map MulOpposite.unop (𝓝 x) = 𝓝 (MulOpposite.unop x)
-- AddOpposite.comap_op_nhds
@[to_additive (attr := simp)]
theorem comap_op_nhds (x : Mᵐᵒᵖ) : comap (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (unop x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : Mᵃᵒᵖ)
Goal: Filter.comap AddOpposite.op (𝓝 x) = 𝓝 (AddOpposite.unop x)
-- MulOpposite.comap_op_nhds
@[to_additive (attr := simp)]
theorem comap_op_nhds (x : Mᵐᵒᵖ) : comap (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (unop x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : Mᵐᵒᵖ)
Goal: Filter.comap MulOpposite.op (𝓝 x) = 𝓝 (MulOpposite.unop x)
-- MulOpposite.comap_unop_nhds
@[to_additive (attr := simp)]
theorem comap_unop_nhds (x : M) : comap (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (op x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : M)
Goal: Filter.comap MulOpposite.unop (𝓝 x) = 𝓝 (MulOpposite.op x)
-- AddOpposite.comap_unop_nhds
@[to_additive (attr := simp)]
theorem comap_unop_nhds (x : M) : comap (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (op x) 
Arguments: {M : Type u_1} [TopologicalSpace M] (x : M)
Goal: Filter.comap AddOpposite.unop (𝓝 x) = 𝓝 (AddOpposite.op x)
-- AddUnits.inducing_embedProduct
@[to_additive]
theorem inducing_embedProduct : Inducing (embedProduct M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [AddMonoid M]
Goal: Inducing ⇑(AddUnits.embedProduct M)
-- Units.inducing_embedProduct
@[to_additive]
theorem inducing_embedProduct : Inducing (embedProduct M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [Monoid M]
Goal: Inducing ⇑(Units.embedProduct M)
-- AddUnits.embedding_embedProduct
@[to_additive]
theorem embedding_embedProduct : Embedding (embedProduct M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [AddMonoid M]
Goal: Embedding ⇑(AddUnits.embedProduct M)
-- Units.embedding_embedProduct
@[to_additive]
theorem embedding_embedProduct : Embedding (embedProduct M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [Monoid M]
Goal: Embedding ⇑(Units.embedProduct M)
-- Units.topology_eq_inf
@[to_additive] lemma topology_eq_inf :
    instTopologicalSpaceUnits =
      .induced (val : Mˣ → M) ‹_› ⊓ .induced (fun u ↦ ↑u⁻¹ : Mˣ → M) ‹_› 
Arguments: {M : Type u_1} [TopologicalSpace M] [Monoid M]
Goal: Units.instTopologicalSpaceUnits =
  TopologicalSpace.induced Units.val inst✝ ⊓ TopologicalSpace.induced (fun u => ↑u⁻¹) inst✝
-- AddUnits.topology_eq_inf
@[to_additive] lemma topology_eq_inf :
    instTopologicalSpaceUnits =
      .induced (val : Mˣ → M) ‹_› ⊓ .induced (fun u ↦ ↑u⁻¹ : Mˣ → M) ‹_› 
Arguments: {M : Type u_1} [TopologicalSpace M] [AddMonoid M]
Goal: AddUnits.instTopologicalSpaceAddUnits =
  TopologicalSpace.induced AddUnits.val inst✝ ⊓ TopologicalSpace.induced (fun u => ↑(-u)) inst✝
-- AddUnits.embedding_val_mk'
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk' {M : Type*} [Monoid M] [TopologicalSpace M] {f : M → M}
    (hc : ContinuousOn f {x : M | IsUnit x}) (hf : ∀ u : Mˣ, f u.1 = ↑u⁻¹) :
    Embedding (val : Mˣ → M) 
Arguments: {M : Type u_3} [AddMonoid M] [TopologicalSpace M] {f : M → M} (hc : ContinuousOn f {x | IsAddUnit x}) (hf : ∀ (u : AddUnits M), f ↑u = ↑(-u))
Goal: Embedding AddUnits.val
-- Units.embedding_val_mk'
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk' {M : Type*} [Monoid M] [TopologicalSpace M] {f : M → M}
    (hc : ContinuousOn f {x : M | IsUnit x}) (hf : ∀ u : Mˣ, f u.1 = ↑u⁻¹) :
    Embedding (val : Mˣ → M) 
Arguments: {M : Type u_3} [Monoid M] [TopologicalSpace M] {f : M → M} (hc : ContinuousOn f {x | IsUnit x}) (hf : ∀ (u : Mˣ), f ↑u = ↑u⁻¹)
Goal: Embedding Units.val
-- Units.embedding_val_mk
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk {M : Type*} [DivisionMonoid M] [TopologicalSpace M]
    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) 
Arguments: {M : Type u_3} [DivisionMonoid M] [TopologicalSpace M] (h : ContinuousOn Inv.inv {x | IsUnit x})
Goal: Embedding Units.val
-- AddUnits.embedding_val_mk
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk {M : Type*} [DivisionMonoid M] [TopologicalSpace M]
    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) 
Arguments: {M : Type u_3} [SubtractionMonoid M] [TopologicalSpace M] (h : ContinuousOn Neg.neg {x | IsAddUnit x})
Goal: Embedding AddUnits.val
-- AddUnits.continuous_embedProduct
@[to_additive]
theorem continuous_embedProduct : Continuous (embedProduct M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [AddMonoid M]
Goal: Continuous ⇑(AddUnits.embedProduct M)
-- Units.continuous_embedProduct
@[to_additive]
theorem continuous_embedProduct : Continuous (embedProduct M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [Monoid M]
Goal: Continuous ⇑(Units.embedProduct M)
-- Units.continuous_val
@[to_additive]
theorem continuous_val : Continuous ((↑) : Mˣ → M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [Monoid M]
Goal: Continuous Units.val
-- AddUnits.continuous_val
@[to_additive]
theorem continuous_val : Continuous ((↑) : Mˣ → M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [AddMonoid M]
Goal: Continuous AddUnits.val
-- Units.continuous_iff
@[to_additive]
protected theorem continuous_iff {f : X → Mˣ} :
    Continuous f ↔ Continuous (val ∘ f) ∧ Continuous (fun x => ↑(f x)⁻¹ : X → M) 
Arguments: {M : Type u_1} {X : Type u_2} [TopologicalSpace M] [Monoid M] [TopologicalSpace X] {f : X → Mˣ}
Goal: Continuous f ↔ Continuous (Units.val ∘ f) ∧ Continuous fun x => ↑(f x)⁻¹
-- AddUnits.continuous_iff
@[to_additive]
protected theorem continuous_iff {f : X → Mˣ} :
    Continuous f ↔ Continuous (val ∘ f) ∧ Continuous (fun x => ↑(f x)⁻¹ : X → M) 
Arguments: {M : Type u_1} {X : Type u_2} [TopologicalSpace M] [AddMonoid M] [TopologicalSpace X] {f : X → AddUnits M}
Goal: Continuous f ↔ Continuous (AddUnits.val ∘ f) ∧ Continuous fun x => ↑(-f x)
-- AddUnits.continuous_coe_neg
@[to_additive]
theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [AddMonoid M]
Goal: Continuous fun u => ↑(-u)
-- Units.continuous_coe_inv
@[to_additive]
theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M) 
Arguments: {M : Type u_1} [TopologicalSpace M] [Monoid M]
Goal: Continuous fun u => ↑u⁻¹
-- separatedNhds_iff_disjoint
theorem separatedNhds_iff_disjoint {s t : Set X} : SeparatedNhds s t ↔ Disjoint (𝓝ˢ s) (𝓝ˢ t) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: SeparatedNhds s t ↔ Disjoint (𝓝ˢ s) (𝓝ˢ t)
-- hasSeparatingCovers_iff_separatedNhds
theorem hasSeparatingCovers_iff_separatedNhds {s t : Set X} :
    HasSeparatingCover s t ∧ HasSeparatingCover t s ↔ SeparatedNhds s t 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: HasSeparatingCover s t ∧ HasSeparatingCover t s ↔ SeparatedNhds s t
-- Set.hasSeparatingCover_empty_left
theorem Set.hasSeparatingCover_empty_left (s : Set X) : HasSeparatingCover ∅ s 
Arguments: {X : Type u_1} [TopologicalSpace X] (s : Set X)
Goal: HasSeparatingCover ∅ s
-- Set.hasSeparatingCover_empty_right
theorem Set.hasSeparatingCover_empty_right (s : Set X) : HasSeparatingCover s ∅ 
Arguments: {X : Type u_1} [TopologicalSpace X] (s : Set X)
Goal: HasSeparatingCover s ∅
-- HasSeparatingCover.mono
theorem HasSeparatingCover.mono {s₁ s₂ t₁ t₂ : Set X} (sc_st : HasSeparatingCover s₂ t₂)
    (s_sub : s₁ ⊆ s₂) (t_sub : t₁ ⊆ t₂) : HasSeparatingCover s₁ t₁ 
Arguments: {X : Type u_1} [TopologicalSpace X] {s₁ s₂ t₁ t₂ : Set X} (sc_st : HasSeparatingCover s₂ t₂) (s_sub : s₁ ⊆ s₂) (t_sub : t₁ ⊆ t₂)
Goal: HasSeparatingCover s₁ t₁
-- SeparatedNhds.symm
@[symm]
theorem symm : SeparatedNhds s t → SeparatedNhds t s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: SeparatedNhds s t → SeparatedNhds t s
-- SeparatedNhds.comm
theorem comm (s t : Set X) : SeparatedNhds s t ↔ SeparatedNhds t s 
Arguments: {X : Type u_1} [TopologicalSpace X] (s t : Set X)
Goal: SeparatedNhds s t ↔ SeparatedNhds t s
-- SeparatedNhds.preimage
theorem preimage [TopologicalSpace Y] {f : X → Y} {s t : Set Y} (h : SeparatedNhds s t)
    (hf : Continuous f) : SeparatedNhds (f ⁻¹' s) (f ⁻¹' t) 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {s t : Set Y} (h : SeparatedNhds s t) (hf : Continuous f)
Goal: SeparatedNhds (f ⁻¹' s) (f ⁻¹' t)
-- SeparatedNhds.disjoint
protected theorem disjoint (h : SeparatedNhds s t) : Disjoint s t 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X} (h : SeparatedNhds s t)
Goal: Disjoint s t
-- SeparatedNhds.disjoint_closure_left
theorem disjoint_closure_left (h : SeparatedNhds s t) : Disjoint (closure s) t 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X} (h : SeparatedNhds s t)
Goal: Disjoint (closure s) t
-- SeparatedNhds.disjoint_closure_right
theorem disjoint_closure_right (h : SeparatedNhds s t) : Disjoint s (closure t) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X} (h : SeparatedNhds s t)
Goal: Disjoint s (closure t)
-- SeparatedNhds.empty_right
@[simp] theorem empty_right (s : Set X) : SeparatedNhds s ∅ 
Arguments: {X : Type u_1} [TopologicalSpace X] (s : Set X)
Goal: SeparatedNhds s ∅
-- SeparatedNhds.empty_left
@[simp] theorem empty_left (s : Set X) : SeparatedNhds ∅ s 
Arguments: {X : Type u_1} [TopologicalSpace X] (s : Set X)
Goal: SeparatedNhds ∅ s
-- SeparatedNhds.mono
theorem mono (h : SeparatedNhds s₂ t₂) (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : SeparatedNhds s₁ t₁ 
Arguments: {X : Type u_1} [TopologicalSpace X] {s₁ s₂ t₁ t₂ : Set X} (h : SeparatedNhds s₂ t₂) (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂)
Goal: SeparatedNhds s₁ t₁
-- SeparatedNhds.union_left
theorem union_left : SeparatedNhds s u → SeparatedNhds t u → SeparatedNhds (s ∪ t) u 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t u : Set X}
Goal: SeparatedNhds s u → SeparatedNhds t u → SeparatedNhds (s ∪ t) u
-- SeparatedNhds.union_right
theorem union_right (ht : SeparatedNhds s t) (hu : SeparatedNhds s u) : SeparatedNhds s (t ∪ u) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t u : Set X} (ht : SeparatedNhds s t) (hu : SeparatedNhds s u)
Goal: SeparatedNhds s (t ∪ u)
-- T0Space.t0
class T0Space (X : Type u) [TopologicalSpace X] : Prop where
    t0 : ∀ ⦃x y : X⦄, Inseparable x y → x = y
Arguments: {X : Type u} [TopologicalSpace X] [self : T0Space X] ⦃x y : X⦄
Goal: Inseparable x y → x = y
-- t0Space_iff_inseparable
theorem t0Space_iff_inseparable (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ ∀ x y : X, Inseparable x y → x = y 
Arguments: (X : Type u) [TopologicalSpace X]
Goal: T0Space X ↔ ∀ (x y : X), Inseparable x y → x = y