ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem antilipschitzWith_iff_le_mul_nndist :
    AntilipschitzWith K f ↔ ∀ x y, nndist x y ≤ K * nndist (f x) (f y)
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem prod_mul_tprod_nat_mul'
    {f : ℕ → M} {k : ℕ} (h : Multipliable (fun n ↦ f (n + k))) :
    ((∏ i ∈ range k, f i) * ∏' i, f (i + k)) = ∏' i, f i
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem size_uset (a : Array α) (v i h) : (uset a i v h).size = a.size
-- Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean
@[to_additive]
theorem smul_Lp_add (c : Mᵈᵐᵃ) : ∀ f g : Lp E p μ, c • (f + g) = c • f + c • g
-- Mathlib/Topology/Homeomorph.lean
/-- `Equiv.piCongrRight` as a homeomorphism: this is the natural homeomorphism
`Π i, Y₁ i ≃ₜ Π j, Y₂ i` obtained from homeomorphisms `Y₁ i ≃ₜ Y₂ i` for each `i`. -/
@[simps! apply toEquiv]
def piCongrRight {ι : Type*} {Y₁ Y₂ : ι → Type*} [∀ i, TopologicalSpace (Y₁ i)]
    [∀ i, TopologicalSpace (Y₂ i)] (F : ∀ i, Y₁ i ≃ₜ Y₂ i) : (∀ i, Y₁ i) ≃ₜ ∀ i, Y₂ i
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
/-- Mapping an integral closure along an `AlgEquiv` gives the integral closure. -/
theorem integralClosure_map_algEquiv [Algebra R S] (f : A ≃ₐ[R] S) :
    (integralClosure R A).map (f : A →ₐ[R] S) = integralClosure R S
-- Mathlib/Algebra/BigOperators/Ring/Multiset.lean
lemma sum_map_mul_left : sum (s.map fun i ↦ a * f i) = a * sum (s.map f)
-- Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean
@[ext 1100]
theorem hom_ext (g1 g2 : widePushout _ _ arrows ⟶ X) : (∀ j : J,
    ι arrows j ≫ g1 = ι arrows j ≫ g2) → head arrows ≫ g1 = head arrows ≫ g2 → g1 = g2
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_of_succ_le (p : Fin n) (i : Fin (n + 1)) (h : succ p ≤ i)
    (hi := Fin.ne_of_gt $ Fin.lt_of_lt_of_le (succ_pos _) h) :
    p.predAbove i = i.pred hi
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_lintegral_mul {β} [MeasurableSpace β] {ν : Measure β} {f : α → ℝ≥0∞}
    {g : β → ℝ≥0∞} (hf : AEMeasurable f μ) (hg : AEMeasurable g ν) :
    ∫⁻ x, ∫⁻ y, f x * g y ∂ν ∂μ = (∫⁻ x, f x ∂μ) * ∫⁻ y, g y ∂ν
-- Mathlib/ModelTheory/ElementaryMaps.lean
/-- Composition of elementary embeddings is associative. -/
theorem comp_assoc (f : M ↪ₑ[L] N) (g : N ↪ₑ[L] P) (h : P ↪ₑ[L] Q) :
    (h.comp g).comp f = h.comp (g.comp f)
-- Mathlib/FieldTheory/IntermediateField.lean
theorem map_le_iff_le_comap {f : L →ₐ[K] L'}
    {s : IntermediateField K L} {t : IntermediateField K L'} :
    s.map f ≤ t ↔ s ≤ t.comap f
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem cauchy_iff' {f : Filter α} :
    Cauchy f ↔ NeBot f ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem h_apply_fromCoset (x : B) :
    (h x) (fromCoset ⟨f.range, 1, one_leftCoset _⟩) =
      fromCoset ⟨f.range, 1, one_leftCoset _⟩
-- Mathlib/Data/Finite/Card.lean
theorem one_lt_card [Finite α] [h : Nontrivial α] : 1 < Nat.card α
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem mem_map_iff (hφ : Function.Injective φ.obj) (S : Subgroupoid C) {c d : D} (f : c ⟶ d) :
    f ∈ (map φ hφ S).arrows c d ↔
      ∃ (a b : C) (g : a ⟶ b) (ha : φ.obj a = c) (hb : φ.obj b = d) (_hg : g ∈ S.arrows a b),
        f = eqToHom ha.symm ≫ φ.map g ≫ eqToHom hb
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[to_additive (attr := simp)]
lemma UniformFun.ofFun_inv [Inv β] (f : α → β) : ofFun (f⁻¹) = (ofFun f)⁻¹
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem canonicalEquiv_flip (I) : canonicalEquiv S P P' (canonicalEquiv S P' P I) = I
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem add_one_le_ceil_iff : z + 1 ≤ ⌈a⌉ ↔ (z : α) < a
-- Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean
@[to_additive (attr := simp)]
theorem nnnorm_smul_Lp (c : Mᵈᵐᵃ) (f : Lp E p μ) : ‖c • f‖₊ = ‖f‖₊
-- Mathlib/Algebra/CharZero/Lemmas.lean
@[simp]
theorem add_self_eq_zero {a : R} : a + a = 0 ↔ a = 0
-- Mathlib/Order/RelClasses.lean
theorem ssubset_of_subset_of_ne [IsAntisymm α (· ⊆ ·)] (h₁ : a ⊆ b) (h₂ : a ≠ b) : a ⊂ b
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A map `f : X → Y` between two topological spaces is said to be **proper** if it is continuous
and, for all `ℱ : Filter X`, any cluster point of `map f ℱ` is the image by `f` of a cluster point
of `ℱ`. -/
@[mk_iff isProperMap_iff_clusterPt, fun_prop]
structure IsProperMap (f : X → Y) extends Continuous f : Prop where
  /-- By definition, if `f` is a proper map and `ℱ` is any filter on `X`, then any cluster point of
  `map f ℱ` is the image by `f` of some cluster point of `ℱ`. -/
  clusterPt_of_mapClusterPt :
    ∀ ⦃ℱ : Filter X⦄, ∀ ⦃y : Y⦄, MapClusterPt y ℱ f → ∃ x, f x = y ∧ ClusterPt x ℱ
-- Mathlib/Computability/RegularExpressions.lean
@[simp]
protected theorem map_pow (f : α → β) (P : RegularExpression α) :
    ∀ n : ℕ, map f (P ^ n) = map f P ^ n
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp, norm_cast]
theorem coe_eq : (f : Germ l β) = g ↔ f =ᶠ[l] g
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem isHomogeneous_monomial {d : σ →₀ ℕ} (r : R) {n : ℕ} (hn : d.degree = n) :
    IsHomogeneous (monomial d r) n
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
@[reassoc]
lemma mapComp_id_left_hom (f : a ⟶ b) : (F.mapComp (𝟙 a) f).hom =
    F.map₂ (λ_ f).hom ≫ (λ_ (F.map f)).inv ≫ (F.mapId a).inv ▷ F.map f
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contMDiffAt_iff_target_of_mem_source {x : M} {y : M'} (hy : f x ∈ (chartAt H' y).source) :
    ContMDiffAt I I' n f x ↔
      ContinuousAt f x ∧ ContMDiffAt I 𝓘(𝕜, E') n (extChartAt I' y ∘ f) x
-- Mathlib/Data/Matrix/Invertible.lean
/-- Together `Matrix.invertibleTranspose` and `Matrix.invertibleOfInvertibleTranspose` form an
equivalence, although both sides of the equiv are subsingleton anyway. -/
@[simps]
def transposeInvertibleEquivInvertible : Invertible Aᵀ ≃ Invertible A
-- Mathlib/Data/List/Infix.lean
theorem insert_eq_ite (a : α) (l : List α) : insert a l = if a ∈ l then l else a :: l
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.prod_map {f : α → γ} {g : β → δ} {s : Set α} {t : Set β} {x : α} {y : β}
    (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g t y) :
    ContinuousWithinAt (Prod.map f g) (s ×ˢ t) (x, y)
-- Mathlib/Analysis/Convex/Cone/Pointed.lean
theorem comap_comap (g : F →ₗ[𝕜] G) (f : E →ₗ[𝕜] F) (S : PointedCone 𝕜 G) :
    (S.comap g).comap f = S.comap (g.comp f)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/MinMax.lean
protected theorem min_le_right (a b : Nat) : min a b ≤ b
-- Mathlib/Data/Matroid/Basic.lean
/-- This is the same as `Indep.exists_insert_of_not_base`, but phrased so that
  it is defeq to the augmentation axiom for independent sets. -/
theorem Indep.exists_insert_of_not_mem_maximals (M : Matroid α) ⦃I B : Set α⦄ (hI : M.Indep I)
    (hInotmax : I ∉ maximals (· ⊆ ·) {I | M.Indep I}) (hB : B ∈ maximals (· ⊆ ·) {I | M.Indep I}) :
    ∃ x ∈ B \ I, M.Indep (insert x I)
-- Mathlib/Data/Real/Cardinality.lean
/-- The cardinality of the reals, as a set. -/
theorem mk_univ_real : #(Set.univ : Set ℝ) = 𝔠
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem isRotated_nil_iff : l ~r [] ↔ l = []
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem eq_sub_iff_add_eq {x y z : BitVec w} : x = z - y ↔ x + y = z
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
lemma densityToFinite_ae_ne_top (μ : Measure α) [SigmaFinite μ] :
    ∀ᵐ x ∂μ, μ.densityToFinite x ≠ ∞
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem ofNat_lt_of_lt {x y : Nat} (h : x < y) : (x : Int) < (y : Int)
-- Mathlib/Combinatorics/Derangements/Basic.lean
theorem mem_derangements_iff_fixedPoints_eq_empty {f : Perm α} :
    f ∈ derangements α ↔ fixedPoints f = ∅
-- Mathlib/RingTheory/QuotSMulTop.lean
lemma equivTensorQuot_naturality (f : M →ₗ[R] M') :
    equivTensorQuot r M' ∘ₗ map r f =
      f.rTensor (R ⧸ Ideal.span {r}) ∘ₗ equivTensorQuot r M
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem degree_basis (hvs : Set.InjOn v s) (hi : i ∈ s) :
    (Lagrange.basis s v i).degree = ↑(s.card - 1)
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem starLift_range_le
    {f : A →⋆ₙₐ[R] C} {S : StarSubalgebra R C} :
    (starLift f).range ≤ S ↔ NonUnitalStarAlgHom.range f ≤ S.toNonUnitalStarSubalgebra
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma unit_of_mem_ofUnits_spec_val_eq_of_mem (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) :
    S.unit_of_mem_ofUnits h = x
-- Mathlib/Data/Set/Image.lean
theorem subset_preimage_image (f : α → β) (s : Set α) : s ⊆ f ⁻¹' (f '' s)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem bfamilyOfFamily_typein {ι} (f : ι → α) (i) :
    bfamilyOfFamily f (typein _ i) (typein_lt_type _ i) = f i
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (fst N P).comp (f.prod g) = f
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioo_subset_closure_interior : Ioo a b ⊆ closure (interior (Ioo a b))
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[to_additive Ioc_add_Ico_subset]
theorem Ioc_mul_Ico_subset' (a b c d : α) : Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d)
-- Mathlib/Combinatorics/SimpleGraph/Partition.lean
/-- The partition where every vertex is in its own part. -/
@[simps]
instance : Inhabited (Partition G)
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
theorem invOfUnit_eq (φ : k⟦X⟧) (h : constantCoeff k φ ≠ 0) :
    invOfUnit φ (Units.mk0 _ h) = φ⁻¹
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
lemma sup'_inv [SemilatticeSup β] {s : Finset α} (hs : s⁻¹.Nonempty) (f : α → β) :
    sup' s⁻¹ hs f = sup' s hs.of_inv (f ·⁻¹)
-- Mathlib/Deprecated/Submonoid.lean
/-- The image of a monoid hom is a submonoid of the codomain. -/
@[to_additive "The image of an `AddMonoid` hom is an `AddSubmonoid` of the codomain."]
theorem Range.isSubmonoid {γ : Type*} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f) :
    IsSubmonoid (Set.range f)
-- Mathlib/Data/Set/MulAntidiagonal.lean
@[to_additive Set.AddAntidiagonal.eq_of_fst_eq_fst]
theorem eq_of_fst_eq_fst (h : (x : α × α).fst = (y : α × α).fst) : x = y
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem mul_sup_eq_of_coprime_right (h : K ⊔ J = ⊤) : I * K ⊔ J = I ⊔ J
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
theorem fderivWithin_continuousMultilinear_apply_const (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (u : ∀ i, M i) :
    fderivWithin 𝕜 (fun y ↦ (c y) u) s x = ((fderivWithin 𝕜 c s x).flipMultilinear u)
-- Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
@[simp]
theorem Complex.volume_ball (a : ℂ) (r : ℝ) :
    volume (Metric.ball a r) = .ofReal r ^ 2 * NNReal.pi
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
protected theorem antilipschitz : AntilipschitzWith 1 e
-- Mathlib/CategoryTheory/SingleObj.lean
/-- Reinterpret a monoid isomorphism `f : M ≃* N` as an equivalence `SingleObj M ≌ SingleObj N`. -/
@[simps!]
def toSingleObjEquiv (e : M ≃* N) : SingleObj M ≌ SingleObj N
-- Mathlib/Order/Filter/Lift.lean
theorem lift'_iInf_of_map_univ {f : ι → Filter α} {g : Set α → Set β}
    (hg : ∀ {s t}, g (s ∩ t) = g s ∩ g t) (hg' : g univ = univ) :
    (iInf f).lift' g = ⨅ i, (f i).lift' g
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
theorem norm_div_natCast {m n : ℕ} :
    ‖(↑(↑m / ↑n * p) : AddCircle p)‖ = p * (↑(min (m % n) (n - m % n)) / n)
-- Mathlib/Order/Filter/Basic.lean
theorem inf_principal_eq_bot_iff_comap {F : Filter α} {s : Set α} :
    F ⊓ 𝓟 s = ⊥ ↔ comap ((↑) : s → α) F = ⊥
-- Mathlib/FieldTheory/Normal.lean
theorem AlgHom.fieldRange_of_normal [Algebra F K] {E : IntermediateField F K} [Normal F E]
    (f : E →ₐ[F] K) : f.fieldRange = E
-- Mathlib/Order/Lattice.lean
theorem Ne.lt_sup_or_lt_sup (hab : a ≠ b) : a < a ⊔ b ∨ b < a ⊔ b
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem bot_lt_affineSpan : ⊥ < affineSpan k s ↔ s.Nonempty
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem aeval_eq_zero_of_mem_rootSet {p : T[X]} [CommRing S] [IsDomain S] [Algebra T S] {a : S}
    (hx : a ∈ p.rootSet S) : aeval a p = 0
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Fundamental theorem of calculus-2: If `f : ℝ → E` has a derivative at `f' x` for all `x` in
  `[a, b]` and `f'` is integrable on `[a, b]`, then `∫ y in a..b, f' y` equals `f b - f a`. -/
theorem integral_eq_sub_of_hasDerivAt (hderiv : ∀ x ∈ uIcc a b, HasDerivAt f (f' x) x)
    (hint : IntervalIntegrable f' volume a b) : ∫ y in a..b, f' y = f b - f a
-- Mathlib/Topology/Semicontinuous.lean
theorem IsClosed.upperSemicontinuousOn_indicator (hs : IsClosed s) (hy : 0 ≤ y) :
    UpperSemicontinuousOn (indicator s fun _x => y) t
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem Filter.Tendsto.isBoundedUnder_le (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u
-- Mathlib/Algebra/Polynomial/Eval.lean
/-- If `R` and `S` are isomorphic, then so are their polynomial rings. -/
@[simps!]
def mapEquiv (e : R ≃+* S) : R[X] ≃+* S[X]
-- Mathlib/Algebra/Order/CauSeq/BigOperators.lean
lemma series_ratio_test {f : ℕ → β} (n : ℕ) (r : α) (hr0 : 0 ≤ r) (hr1 : r < 1)
    (h : ∀ m, n ≤ m → abv (f m.succ) ≤ r * abv (f m)) :
    IsCauSeq abv fun m ↦ ∑ n ∈ range m, f n
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function.Injective f) :
    ker f = trivial G
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem div_def (a b : Int) : a / b = Int.ediv a b
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
lemma greatestFib_mono : Monotone greatestFib
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
/-- A diagram `WalkingSpan ⥤ C` is isomorphic to some `PushoutCocone.mk` after composing with
`diagramIsoSpan`. -/
@[simps!]
def PushoutCocone.isoMk {F : WalkingSpan ⥤ C} (t : Cocone F) :
    (Cocones.precompose (diagramIsoSpan.{v} _).inv).obj t ≅
      PushoutCocone.mk (t.ι.app WalkingSpan.left) (t.ι.app WalkingSpan.right)
        ((t.ι.naturality fst).trans (t.ι.naturality snd).symm)
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean
theorem _root_.IsPrimitiveRoot.minpoly_eq_cyclotomic_of_irreducible {K : Type*} [Field K]
    {R : Type*} [CommRing R] [IsDomain R] {μ : R} {n : ℕ} [Algebra K R] (hμ : IsPrimitiveRoot μ n)
    (h : Irreducible <| cyclotomic n K) [NeZero (n : K)] : cyclotomic n K = minpoly K μ
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[reassoc (attr := simp)]
lemma germ_stalkIso_hom' {X : Scheme.{u}} (U : X.Opens)
    {V : TopologicalSpace.Opens U} (x : U) (hx : x ∈ V) :
      U.toScheme.presheaf.germ ⟨x, hx⟩ ≫ (U.stalkIso x).hom =
        X.presheaf.germ ⟨x.1, show x.1 ∈ U.ι ''ᵁ V from ⟨x, hx, rfl⟩⟩
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem ofNat_succ_pos (n : Nat) : 0 < (succ n : Int)
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
/-- A congruence lemma for `mfderiv`, (ab)using the fact that `TangentSpace I' (f x)` is
definitionally equal to `E'`. -/
theorem mfderiv_congr_point {x' : M} (h : x = x') :
    @Eq (E →L[𝕜] E') (mfderiv I I' f x) (mfderiv I I' f x')
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_update_le (p : R[X]) (n : ℕ) (a : R) : degree (p.update n a) ≤ max (degree p) n
-- Mathlib/Logic/Basic.lean
theorem eqRec_heq' {α : Sort*} {a' : α} {motive : (a : α) → a' = a → Sort*}
    (p : motive a' (rfl : a' = a')) {a : α} (t : a' = a) :
    HEq (@Eq.rec α a' motive p a t) p
-- Mathlib/Init/Logic.lean
theorem imp_of_if_pos {c t e : Prop} [Decidable c] (h : ite c t e) (hc : c) : t
-- Mathlib/RingTheory/Generators.lean
/-- If `S` is the localization of `R` away from `r`, we obtain a canonical generator mapping
to the inverse of `r`. -/
@[simps val, simps (config := .lemmasOnly) vars σ]
noncomputable
def localizationAway : Generators R S
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem Zlattice.rank [hs : IsZlattice K L] : finrank ℤ L = finrank K E
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
@[simp]
theorem toOuterMeasure_pure_apply : (pure a).toOuterMeasure s = if a ∈ s then 1 else 0
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
theorem isLocallySurjective_iff_whisker_forget {F G : Cᵒᵖ ⥤ A} (f : F ⟶ G) :
    IsLocallySurjective J f ↔ IsLocallySurjective J (whiskerRight f (forget A))
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The Hausdorff distances between two sets and their closures coincide. -/
-- @[simp] -- Porting note (#10618): simp can prove this
theorem hausdorffDist_closure : hausdorffDist (closure s) (closure t) = hausdorffDist s t
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem map_zero (f : α → β) : (0 : Measure α).map f = 0
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem IsBaseChange.comp {f : M →ₗ[R] N} (hf : IsBaseChange S f) {g : N →ₗ[S] O}
    (hg : IsBaseChange T g) : IsBaseChange T ((g.restrictScalars R).comp f)
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[reassoc, simp]
theorem comp_neg : f ≫ (-g) = -f ≫ g
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_linear (ha : a ≠ 0) : degree (C a * X + C b) = 1
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.merge (s₁ s₂ : α → α → Bool) (hl : l₁ ~ l₂) (hr : r₁ ~ r₂) :
    merge s₁ l₁ r₁ ~ merge s₂ l₂ r₂
-- Mathlib/Data/Set/Function.lean
lemma _root_.Equiv.image_eq_iff_bijOn (e : α ≃ β) : e '' s = t ↔ BijOn e s t
-- Mathlib/Data/Holor.lean
@[simp]
nonrec theorem zero_mul {α : Type} [Ring α] (x : Holor α ds₂) : (0 : Holor α ds₁) ⊗ x = 0
-- Mathlib/Analysis/Fourier/AddCircle.lean
theorem hasDerivAt_fourier_neg (n : ℤ) (x : ℝ) :
    HasDerivAt (fun y : ℝ => fourier (-n) (y : AddCircle T))
      (-2 * π * I * n / T * fourier (-n) (x : AddCircle T)) x
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem eq_zero_iff {m : M} : f m = 0 ↔ ∃ s' : S, s' • m = 0
-- Mathlib/Data/Sum/Order.lean
theorem lt_def [LT α] [LT β] {a b : α ⊕ₗ β} : a < b ↔ Lex (· < ·) (· < ·) (ofLex a) (ofLex b)
-- Mathlib/Topology/Algebra/Order/Compact.lean
/-- The **extreme value theorem**: a continuous function realizes its minimum on a compact set. -/
theorem IsCompact.exists_isMinOn [ClosedIicTopology α] {s : Set β} (hs : IsCompact s)
    (ne_s : s.Nonempty) {f : β → α} (hf : ContinuousOn f s) : ∃ x ∈ s, IsMinOn f s x
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem mul_right_inj (h : IsUnit a) : a * b = a * c ↔ b = c
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem map_coe_Ioo_atTop {a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atTop = 𝓝[<] b
-- Mathlib/Combinatorics/Young/SemistandardTableau.lean
theorem row_weak_of_le {μ : YoungDiagram} (T : SemistandardYoungTableau μ) {i j1 j2 : ℕ}
    (hj : j1 ≤ j2) (cell : (i, j2) ∈ μ) : T i j1 ≤ T i j2
-- Mathlib/Algebra/Regular/Basic.lean
/-- An element admitting a left inverse is left-regular. -/
@[to_additive "An element admitting a left additive opposite is add-left-regular."]
theorem isLeftRegular_of_mul_eq_one (h : b * a = 1) : IsLeftRegular a
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem exists_measurable_superset_of_trim_eq_zero {m : OuterMeasure α} {s : Set α}
    (h : m.trim s = 0) : ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = 0
-- Mathlib/Topology/Connected/Basic.lean
/-- If any two points of a set are contained in a preconnected subset,
then the original set is preconnected as well. -/
theorem isPreconnected_of_forall_pair {s : Set α}
    (H : ∀ x ∈ s, ∀ y ∈ s, ∃ t, t ⊆ s ∧ x ∈ t ∧ y ∈ t ∧ IsPreconnected t) :
    IsPreconnected s
-- Mathlib/Order/Disjoint.lean
theorem mk_top : (⟨⊤, isComplemented_top⟩ : Complementeds α) = ⊤
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem _root_.NumberField.mixedEmbedding_injective [NumberField K] :
    Function.Injective (NumberField.mixedEmbedding K)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem toSet_singleton (x : ZFSet) : ({x} : ZFSet).toSet = {x}
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
theorem contDiffOn_stereoToFun :
    ContDiffOn ℝ ⊤ (stereoToFun v) {x : E | innerSL _ v x ≠ (1 : ℝ)}
-- Mathlib/Algebra/GCDMonoid/Finset.lean
/-- Given a nonempty Finset `s` and a function `f` from `s` to `ℕ`, if `d = s.gcd`,
then the `gcd` of `(f i) / d` is equal to `1`. -/
lemma gcd_div_eq_one (his : i ∈ s) (hfi : f i ≠ 0) : s.gcd (fun j ↦ f j / s.gcd f) = 1
-- Mathlib/Data/Set/Basic.lean
theorem subset_symmDiff_union_symmDiff_left (h : Disjoint s t) : u ⊆ s ∆ u ∪ t ∆ u
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulSupport_mulIndicator_subset : mulSupport (s.mulIndicator f) ⊆ s
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
@[simp]
lemma map_add (F : C ⥤ D) (hF : W.IsInvertedBy F) [Preadditive D] [F.Additive] :
    φ.add.map F hF = φ.fst.map F hF + φ.snd.map F hF
-- Mathlib/Data/Nat/Defs.lean
lemma le_sqrt' : m ≤ sqrt n ↔ m ^ 2 ≤ n
-- Mathlib/CategoryTheory/Sites/Plus.lean
/-- The plus construction, a functor sending `P` to `J.plusObj P`. -/
@[simps]
def plusFunctor : (Cᵒᵖ ⥤ D) ⥤ Cᵒᵖ ⥤ D
-- Mathlib/Data/Set/Basic.lean
theorem compl_subset_comm : sᶜ ⊆ t ↔ tᶜ ⊆ s
-- Mathlib/RingTheory/Finiteness.lean
theorem Module.End.isNilpotent_iff_of_finite {R M : Type*} [CommSemiring R] [AddCommMonoid M]
    [Module R M] [Module.Finite R M] {f : End R M} :
    IsNilpotent f ↔ ∀ m : M, ∃ n : ℕ, (f ^ n) m = 0
-- Mathlib/CategoryTheory/Monoidal/Free/Coherence.lean
theorem normalize_naturality (n : NormalMonoidalObject C) {X Y : F C} (f : X ⟶ Y) :
    inclusionObj n ◁ f ≫ (normalizeIsoApp' C Y n).hom =
      (normalizeIsoApp' C X n).hom ≫
        inclusion.map (eqToHom (Discrete.ext _ _ (normalizeObj_congr n f)))
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iUnion_eq_empty : ⋃ i, s i = ∅ ↔ ∀ i, s i = ∅
-- Mathlib/Algebra/Algebra/Defs.lean
@[simp]
theorem _root_.smul_algebraMap {α : Type*} [Monoid α] [MulDistribMulAction α A]
    [SMulCommClass α R A] (a : α) (r : R) : a • algebraMap R A r = algebraMap R A r
-- Mathlib/Data/Matrix/Basic.lean
theorem add_vecMul [Fintype m] (A : Matrix m n α) (x y : m → α) :
    (x + y) ᵥ* A = x ᵥ* A + y ᵥ* A
-- Mathlib/Data/Multiset/Basic.lean
theorem card_pair (a b : α) : card {a, b} = 2
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- The Monge plane associated with vertices `i₁` and `i₂` equals that
associated with `i₂` and `i₁`. -/
theorem mongePlane_comm {n : ℕ} (s : Simplex ℝ P (n + 2)) (i₁ i₂ : Fin (n + 3)) :
    s.mongePlane i₁ i₂ = s.mongePlane i₂ i₁
-- Mathlib/Algebra/Lie/Sl2.lean
/-- Given a representation of a Lie algebra with distinguished `sl₂` triple, a simultaneous
eigenvector for the action of both `h` and `e` necessarily has eigenvalue zero for `e`. -/
lemma HasPrimitiveVectorWith.mk' [NoZeroSMulDivisors ℤ M] (t : IsSl2Triple h e f) (m : M) (μ ρ : R)
    (hm : m ≠ 0) (hm' : ⁅h, m⁆ = μ • m) (he : ⁅e, m⁆ = ρ • m) :
    HasPrimitiveVectorWith t m μ
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem mem_nsmul {a : α} {s : Multiset α} {n : ℕ} : a ∈ n • s ↔ n ≠ 0 ∧ a ∈ s
-- Mathlib/Algebra/Module/PointwisePi.lean
@[to_additive]
theorem smul_pi [Group K] [∀ i, MulAction K (R i)] (r : K) (S : Set ι) (t : ∀ i, Set (R i)) :
    r • S.pi t = S.pi (r • t)
-- Mathlib/Order/WithBot.lean
@[simp] lemma map₂_coe_left (f : α → β → γ) (a : α) (b) : map₂ f a b = b.map fun b ↦ f a b
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem mem_supp_iff (C : G.ConnectedComponent) (v : V) :
    v ∈ C.supp ↔ G.connectedComponentMk v = C
-- Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
@[simp] theorem toIsometryEquiv_refl : toIsometryEquiv (.refl X) = .refl _
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem sInf_coe_to_submodule (S : Set (LieSubalgebra R L)) :
    (↑(sInf S) : Submodule R L) = sInf {(s : Submodule R L) | s ∈ S}
-- Mathlib/Data/Analysis/Topology.lean
@[simp]
theorem nhds_F (F : Realizer α) (a : α) (s) : (F.nhds a).F s = F.F s.1
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := mono)]
theorem smul_finset_subset_smul_finset : s ⊆ t → a • s ⊆ a • t