ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem bind_continuous' {β γ : Type v} (f : α → Part β) (g : α → β → Part γ) :
    Continuous' f → Continuous' g → Continuous' fun x => f x >>= g x
-- Mathlib/Probability/Independence/Basic.lean
lemma iIndepSets.meas_biInter (h : iIndepSets π μ) (s : Finset ι) {f : ι → Set Ω}
    (hf : ∀ i, i ∈ s → f i ∈ π i) : μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)
-- Mathlib/Logic/Function/Defs.lean
theorem bijective_id : Bijective (@id α)
-- Mathlib/Topology/Compactification/OnePoint.lean
@[simp, norm_cast]
theorem specializes_coe {x y : X} : (x : OnePoint X) ⤳ y ↔ x ⤳ y
-- Mathlib/Computability/Primrec.lean
theorem list_tail : Primrec (@List.tail α)
-- Mathlib/CategoryTheory/Functor/KanExtension/Adjunction.lean
lemma isIso_ranAdjunction_unit_app_iff (G : D ⥤ H) :
    IsIso ((L.ranAdjunction H).unit.app G) ↔ G.IsRightKanExtension (𝟙 (L ⋙ G))
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem Associates.mk_normalize (x : α) : Associates.mk (normalize x) = Associates.mk x
-- Mathlib/Combinatorics/SimpleGraph/Acyclic.lean
theorem isAcyclic_of_path_unique (h : ∀ (v w : V) (p q : G.Path v w), p = q) : G.IsAcyclic
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
/-- A quiver `HasInvolutiveReverse` if reversing twice is the identity. -/
class HasInvolutiveReverse extends HasReverse V where
  /-- `reverse` is involutive -/
  inv' : ∀ {a b : V} (f : a ⟶ b), reverse (reverse f) = f
-- .lake/packages/lean4/src/lean/Init/Classical.lean
theorem or_iff_not_imp_left  : a ∨ b ↔ (¬a → b)
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
nonrec theorem ContDiffAt.inner (hf : ContDiffAt ℝ n f x) (hg : ContDiffAt ℝ n g x) :
    ContDiffAt ℝ n (fun x => ⟪f x, g x⟫) x
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem Image.lift_fac (F' : MonoFactorisation f) : Image.lift F' ≫ F'.m = Image.ι f
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_pow [AddMonoid G] {a : G} {b : k} : ∀ n : ℕ, single a b ^ n = single (n • a) (b ^ n)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The cosine of the angle between two vectors, multiplied by the
product of their norms. -/
theorem cos_angle_mul_norm_mul_norm (x y : V) : Real.cos (angle x y) * (‖x‖ * ‖y‖) = ⟪x, y⟫
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_last_apply {i : Fin (n + 2)} :
    predAbove (last n) i = if hi : i = last _ then last _ else i.castPred hi
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem sigmaFinsuppEquivDFinsupp_apply [Zero N] (f : (Σi, η i) →₀ N) :
    (sigmaFinsuppEquivDFinsupp f : ∀ i, η i →₀ N) = Finsupp.split f
-- Mathlib/Analysis/Convex/Topology.lean
/-- If `s` is a convex set, then `a • closure s + b • interior s ⊆ interior s` for all `0 ≤ a`,
`0 < b`, `a + b = 1`. See also `Convex.combo_self_interior_subset_interior` for a weaker version. -/
theorem Convex.combo_closure_interior_subset_interior {s : Set E} (hs : Convex 𝕜 s) {a b : 𝕜}
    (ha : 0 ≤ a) (hb : 0 < b) (hab : a + b = 1) : a • closure s + b • interior s ⊆ interior s
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_eq_one_iff' [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α} (ha : 1 ≤ a) (hb : 1 ≤ b) :
    a * b = 1 ↔ a = 1 ∧ b = 1
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive two_zsmul] lemma zpow_two (a : G) : a ^ (2 : ℤ) = a * a
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
@[simp]
lemma singularPart_self (μ : Measure α) : μ.singularPart μ = 0
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem cons_diff_of_not_mem {a : α} {l₂ : List α} (h : a ∉ l₂) (l₁ : List α) :
    (a :: l₁).diff l₂ = a :: l₁.diff l₂
-- Mathlib/MeasureTheory/Integral/DivergenceTheorem.lean
/-- **Divergence theorem** for functions on the plane along rectangles. It is formulated in terms of
two functions `f g : ℝ × ℝ → E` and an integral over `Icc a b = [a.1, b.1] × [a.2, b.2]`, where
`a b : ℝ × ℝ`, `a ≤ b`. When thinking of `f` and `g` as the two coordinates of a single function
`F : ℝ × ℝ → E × E` and when `E = ℝ`, this is the usual statement that the integral of the
divergence of `F` inside the rectangle equals the integral of the normal derivative of `F` along the
boundary.

See also `MeasureTheory.integral2_divergence_prod_of_hasFDerivWithinAt_off_countable` for a
version that does not assume `a ≤ b` and uses iterated interval integral instead of the integral
over `Icc a b`. -/
theorem integral_divergence_prod_Icc_of_hasFDerivWithinAt_off_countable_of_le (f g : ℝ × ℝ → E)
    (f' g' : ℝ × ℝ → ℝ × ℝ →L[ℝ] E) (a b : ℝ × ℝ) (hle : a ≤ b) (s : Set (ℝ × ℝ)) (hs : s.Countable)
    (Hcf : ContinuousOn f (Icc a b)) (Hcg : ContinuousOn g (Icc a b))
    (Hdf : ∀ x ∈ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2 \ s, HasFDerivAt f (f' x) x)
    (Hdg : ∀ x ∈ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2 \ s, HasFDerivAt g (g' x) x)
    (Hi : IntegrableOn (fun x => f' x (1, 0) + g' x (0, 1)) (Icc a b)) :
    (∫ x in Icc a b, f' x (1, 0) + g' x (0, 1)) =
      (((∫ x in a.1..b.1, g (x, b.2)) - ∫ x in a.1..b.1, g (x, a.2)) +
          ∫ y in a.2..b.2, f (b.1, y)) -
        ∫ y in a.2..b.2, f (a.1, y)
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
theorem tendsto_iff_forall_toWeakDualBCNN_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → FiniteMeasure Ω} {μ : FiniteMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ≥0, Tendsto (fun i => (μs i).toWeakDualBCNN f) F (𝓝 (μ.toWeakDualBCNN f))
-- Mathlib/LinearAlgebra/Quotient.lean
@[simp]
theorem mk_smul (r : S) (x : M) : (mk (r • x) : M ⧸ p) = r • mk x
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem mkContinuousMultilinear_norm_le' (f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)) (C : ℝ)
    (H : ∀ m₁ m₂, ‖f m₁ m₂‖ ≤ (C * ∏ i, ‖m₁ i‖) * ∏ i, ‖m₂ i‖) :
    ‖mkContinuousMultilinear f C H‖ ≤ max C 0
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
/-- See also `Ideal.mem_quotient_iff_mem_sup` if the assumption `I ≤ J` is not available. -/
theorem mem_quotient_iff_mem {I J : Ideal R} (hIJ : I ≤ J) {x : R} :
    Quotient.mk I x ∈ J.map (Quotient.mk I) ↔ x ∈ J
-- Mathlib/Logic/Nontrivial/Defs.lean
theorem nontrivial_of_ne (x y : α) (h : x ≠ y) : Nontrivial α
-- Mathlib/RingTheory/Idempotents.lean
lemma bijective_pi_of_isIdempotentElem (e : I → R)
    (he : ∀ i, IsIdempotentElem (e i))
    (he₁ : ∀ i j, i ≠ j → (1 - e i) * (1 - e j) = 0) (he₂ : ∏ i, e i = 0) :
    Function.Bijective (Pi.ringHom fun i ↦ Ideal.Quotient.mk (Ideal.span {e i}))
-- Mathlib/Data/Part.lean
theorem mem_map (f : α → β) {o : Part α} : ∀ {a}, a ∈ o → f a ∈ map f o
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem map_iInf_le {ι β} (f : α → β) (m : ι → OuterMeasure α) :
    map f (⨅ i, m i) ≤ ⨅ i, map f (m i)
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem add_tsub_add_eq_tsub_left (a b c : α) : a + b - (a + c) = b - c
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Restrict.lean
lemma closedEmbedding_nonUnitalStarAlgHom {a : A} {φ : C(σₙ S a, S)₀ →⋆ₙₐ[S] A}
    (hφ : ClosedEmbedding φ) {f : C(S, R)} (h : QuasispectrumRestricts a f)
    (halg : UniformEmbedding (algebraMap R S)) [h_cpct : CompactSpace (σₙ S a)] :
    ClosedEmbedding (h.nonUnitalStarAlgHom φ)
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp] theorem card_of_isEmpty [IsEmpty α] : Nat.card α = 0
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
@[simp]
theorem unop_op (S : Subsemiring R) : S.op.unop = S
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem K'.elim_update_aux {a b c d c'} : update (K'.elim a b c d) aux c' = K'.elim a b c' d
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem Monic.mul_natDegree_lt_iff (h : Monic p) {q : R[X]} :
    (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0
-- Mathlib/Data/Multiset/Basic.lean
theorem rel_replicate_left {m : Multiset α} {a : α} {r : α → α → Prop} {n : ℕ} :
    (replicate n a).Rel r m ↔ card m = n ∧ ∀ x, x ∈ m → r a x
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
theorem measurableSet_bliminf {s : ℕ → Set α} {p : ℕ → Prop} (h : ∀ n, p n → MeasurableSet (s n)) :
    MeasurableSet <| Filter.bliminf s Filter.atTop p
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
theorem transReflReparamAux_mem_I (t : I) : transReflReparamAux t ∈ I
-- Mathlib/CategoryTheory/Limits/Indization/IndObject.lean
theorem finallySmall (h : IsIndObject A) : FinallySmall.{v} (CostructuredArrow yoneda A)
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem toFinset_univ [Fintype α] [Fintype (Set.univ : Set α)] :
    (Set.univ : Set α).toFinset = Finset.univ
-- Mathlib/Order/SuccPred/Basic.lean
lemma pred_succ_le (a : α) : pred (succ a) ≤ a
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem enumFrom_map_fst (n) :
    ∀ (l : List α), map Prod.fst (enumFrom n l) = range' n l.length
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
theorem eq_zero_of_inner_right (hK : Dense (K : Set E)) (h : ∀ v : K, ⟪(v : E), x⟫ = 0) : x = 0
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
@[simp]
theorem hasSum_unop {f : β → αᵐᵒᵖ} {a : αᵐᵒᵖ} :
    HasSum (fun a ↦ unop (f a)) (unop a) ↔ HasSum f a
-- Mathlib/CategoryTheory/Generator.lean
theorem IsDetector.isSeparator [HasEqualizers C] {G : C} : IsDetector G → IsSeparator G
-- Mathlib/Analysis/Distribution/AEEqOfIntegralContDiff.lean
/-- If a function `f` locally integrable on an open subset `U` of a finite-dimensional real
  manifold has zero integral when multiplied by any smooth function compactly supported
  in `U`, then `f` vanishes almost everywhere in `U`. -/
nonrec theorem IsOpen.ae_eq_zero_of_integral_smooth_smul_eq_zero' {U : Set M} (hU : IsOpen U)
    (hSig : IsSigmaCompact U) (hf : LocallyIntegrableOn f U μ)
    (h : ∀ g : M → ℝ,
      Smooth I 𝓘(ℝ) g → HasCompactSupport g → tsupport g ⊆ U → ∫ x, g x • f x ∂μ = 0) :
    ∀ᵐ x ∂μ, x ∈ U → f x = 0
-- Mathlib/Analysis/Convolution.lean
theorem integrable_posConvolution {f : ℝ → E} {g : ℝ → E'} {μ ν : Measure ℝ} [SFinite μ]
    [SFinite ν] [IsAddRightInvariant μ] [NoAtoms ν] (hf : IntegrableOn f (Ioi 0) ν)
    (hg : IntegrableOn g (Ioi 0) μ) (L : E →L[ℝ] E' →L[ℝ] F) :
    Integrable (posConvolution f g L ν) μ
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem neg_iInf {ι : Sort*} (S : ι → Submodule R M) : (-⨅ i, S i) = ⨅ i, -S i
-- Mathlib/CategoryTheory/Sites/Preserves.lean
theorem piComparison_fac :
    have : HasCoproduct X := ⟨⟨c, hc⟩⟩
    piComparison F (fun x ↦ op (X x)) = F.map (opCoproductIsoProduct' hc (productIsProduct _)).inv ≫
    Equalizer.Presieve.Arrows.forkMap F X c.inj
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem smul_univ₀' {s : Set α} (hs : s.Nontrivial) : s • (univ : Set β) = univ
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
/-- `ContinuousMultilinearMap.pi` as a `LinearEquiv`. -/
@[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)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- The angle between three points is π if and only if the second point is strictly between the
other two. -/
theorem angle_eq_pi_iff_sbtw {p₁ p₂ p₃ : P} : ∠ p₁ p₂ p₃ = π ↔ Sbtw ℝ p₁ p₂ p₃
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- `LinearMap.BilinForm.toQuadraticMap` as a linear map -/
@[simps!]
def toQuadraticMapLinearMap [Semiring S] [Module S N] [SMulCommClass S R N] [SMulCommClass R S N] :
    (BilinMap R M N) →ₗ[S] QuadraticMap R M N
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
@[simp]
lemma preNormEDS'_two : preNormEDS' b c d 2 = 1
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem coeff_root_pow (h : IsAdjoinRootMonic S f) {n} (hn : n < natDegree f) :
    h.coeff (h.root ^ n) = Pi.single n 1
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
/-- The natural isomorphism between a pushout cocone and the corresponding pushout cocone
reconstructed using `PushoutCocone.mk`. -/
@[simps!]
def eta (t : PushoutCocone f g) : t ≅ mk t.inl t.inr t.condition
-- Mathlib/Order/Filter/Extr.lean
theorem IsExtrFilter.filter_mono (h : IsExtrFilter f l a) (hl : l' ≤ l) : IsExtrFilter f l' a
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Basic.lean
/-- The natural map from `characterSpace ℂ (elementalStarAlgebra ℂ x)` to `spectrum ℂ x` given
by evaluating `φ` at `x`. This is essentially just evaluation of the `gelfandTransform` of `x`,
but because we want something in `spectrum ℂ x`, as opposed to
`spectrum ℂ ⟨x, elementalStarAlgebra.self_mem ℂ x⟩` there is slightly more work to do. -/
@[simps]
noncomputable def elementalStarAlgebra.characterSpaceToSpectrum (x : A)
    (φ : characterSpace ℂ (elementalStarAlgebra ℂ x)) : spectrum ℂ x
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_mulSingle_one : mulSupport (mulSingle a (1 : B)) = ∅
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem tendsto_logGammaSeq (hf_conv : ConvexOn ℝ (Ioi 0) f)
    (hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y) (hx : 0 < x) :
    Tendsto (logGammaSeq x) atTop (𝓝 <| f x - f 1)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasFDerivAt.cpow (hf : HasFDerivAt f f' x) (hg : HasFDerivAt g g' x)
    (h0 : f x ∈ slitPlane) : HasFDerivAt (fun x => f x ^ g x)
      ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log (f x)) • g') x
-- Mathlib/Topology/Instances/ENNReal.lean
/-- Closed intervals `Set.Icc (x - ε) (x + ε)`, `ε ≠ 0`, form a basis of neighborhoods of an
extended nonnegative real number `x ≠ ∞`. We use `Set.Icc` instead of `Set.Ioo` because this way the
statement works for `x = 0`.
-/
theorem hasBasis_nhds_of_ne_top' (xt : x ≠ ∞) :
    (𝓝 x).HasBasis (· ≠ 0) (fun ε => Icc (x - ε) (x + ε))
-- Mathlib/Data/Real/Irrational.lean
theorem of_int_mul (m : ℤ) (h : Irrational (m * x)) : Irrational x
-- Mathlib/Data/Rat/Cast/Order.lean
@[simp] lemma cast_lt_zero : (q : K) < 0 ↔ q < 0
-- Mathlib/RingTheory/Etale/Basic.lean
/-- Etale is stable under composition. -/
theorem comp [Algebra A B] [IsScalarTower R A B] [Etale R A] [Etale A B] : Etale R B
-- Mathlib/Data/Nat/Cast/Basic.lean
lemma _root_.Even.natCast [AddMonoidWithOne α] {n : ℕ} (hn : Even n) : Even (n : α)
-- Mathlib/LinearAlgebra/Vandermonde.lean
@[simp]
theorem det_vandermonde_add {n : ℕ} (v : Fin n → R) (a : R) :
    (Matrix.vandermonde fun i ↦ v i + a).det = (Matrix.vandermonde v).det
-- Mathlib/Algebra/Ring/Divisibility/Lemmas.lean
lemma add_pow_dvd_pow_of_pow_eq_zero_left (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hy : y ^ n = 0) : (x + y) ^ m ∣ x ^ p
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.sizeOf_eq_sizeOf [SizeOf α] {l₁ l₂ : List α} (h : l₁ ~ l₂) :
    sizeOf l₁ = sizeOf l₂
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
@[simp]
theorem SpectralRadius.of_subsingleton [Subsingleton A] (a : A) : spectralRadius 𝕜 a = 0
-- Mathlib/Algebra/MvPolynomial/Expand.lean
theorem expand_comp_bind₁ (p : ℕ) (f : σ → MvPolynomial τ R) :
    (expand p).comp (bind₁ f) = bind₁ fun i ↦ expand p (f i)
-- Mathlib/Topology/Algebra/Valued/ValuationTopology.lean
/-- The unit ball of a valued ring is open. -/
theorem integer_isOpen : IsOpen (_i.v.integer : Set R)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem inv_mem_inv (ha : a ∈ s) : a⁻¹ ∈ s⁻¹
-- Mathlib/GroupTheory/OrderOfElement.lean
/-- Elements of finite order are closed under multiplication. -/
@[to_additive "Elements of finite additive order are closed under addition."]
theorem IsOfFinOrder.mul (hx : IsOfFinOrder x) (hy : IsOfFinOrder y) : IsOfFinOrder (x * y)
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive]
theorem map_mk' (M : Subgroup H) [M.Normal] (f : G →* H) (h : N ≤ M.comap f) (x : G) :
    map N M f h (mk' _ x) = ↑(f x)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The angle between a vector and a positive multiple of a vector. -/
@[simp]
theorem angle_smul_right_of_pos (x y : V) {r : ℝ} (hr : 0 < r) : angle x (r • y) = angle x y
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem all_eq_true {l : List α} : l.all p ↔ ∀ x, x ∈ l →  p x
-- Mathlib/CategoryTheory/Grothendieck.lean
theorem map_obj {α : F ⟶ G} (X : Grothendieck F) :
    (Grothendieck.map α).obj X = ⟨X.base, (α.app X.base).obj X.fiber⟩
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotating the first vector by the angle between the two vectors results in an angle of 0. -/
@[simp]
theorem oangle_rotation_oangle_left (x y : V) : o.oangle (o.rotation (o.oangle x y) x) y = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[fun_prop]
theorem continuousOn_sin {s} : ContinuousOn sin s
-- Mathlib/Topology/Category/Compactum.lean
@[simp]
theorem join_distrib (X : Compactum) (uux : Ultrafilter (Ultrafilter X)) :
    X.str (X.join uux) = X.str (map X.str uux)
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem coe_zero : DFunLike.coe (0 : 𝓢(E, F)) = (0 : E → F)
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
/-- On a locally ringed space `X`, the preimage of the zero locus of the prime spectrum
of `Γ(X, ⊤)` under `toΓSpecFun` agrees with the associated zero locus on `X`. -/
lemma Scheme.toΓSpec_preimage_zeroLocus_eq {X : Scheme.{u}} (s : Set Γ(X, ⊤)) :
    (ΓSpec.adjunction.unit.app X).val.base ⁻¹' PrimeSpectrum.zeroLocus s = X.zeroLocus s
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
theorem dist_pointReflection_self (x y : P) :
    dist (pointReflection 𝕜 x y) y = ‖(2 : 𝕜)‖ * dist x y
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasDerivAt.comp_hasFDerivAt {f : E → 𝕜'} {f' : E →L[𝕜] 𝕜'} (x)
    (hh : HasDerivAt h₂ h₂' (f x)) (hf : HasFDerivAt f f' x) : HasFDerivAt (h₂ ∘ f) (h₂' • f') x
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
@[simp]
theorem vars_neg : (-p).vars = p.vars
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma isLittleO_self_div_log_id :
    (fun (n : ℕ) => n / log n ^ 2) =o[atTop] (fun (n : ℕ) => (n : ℝ))
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp] theorem comm_toLinearEquiv :
    (Algebra.TensorProduct.comm R A B).toLinearEquiv = _root_.TensorProduct.comm R A B
-- Mathlib/Analysis/Seminorm.lean
@[simp]
theorem smul_apply [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] (r : R) (p : Seminorm 𝕜 E)
    (x : E) : (r • p) x = r • p x
-- Mathlib/GroupTheory/NoncommCoprod.lean
@[to_additive (attr := simp)]
theorem noncommCoprod_comp_inl : (f.noncommCoprod g comm).comp (inl M N) = f
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[simp]
theorem vsub_nonempty : (s -ᵥ t : Set α).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Mathlib/Order/Ideal.lean
@[simp]
theorem principal_bot : principal (⊥ : P) = ⊥
-- Mathlib/Probability/Process/Stopping.lean
theorem measurableSpace_le_of_le (hτ : IsStoppingTime f τ) {n : ι} (hτ_le : ∀ ω, τ ω ≤ n) :
    hτ.measurableSpace ≤ m
-- Mathlib/Data/Finset/Card.lean
theorem card_le_three : card {a, b, c} ≤ 3
-- Mathlib/MeasureTheory/Function/L2Space.lean
theorem integrable_inner (f g : α →₂[μ] E) : Integrable (fun x : α => ⟪f x, g x⟫) μ
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
theorem hasPushout_of_right_iso : HasPushout f g
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem vadd_lineMap (v : V₁) (p₁ p₂ : P₁) (c : k) :
    v +ᵥ lineMap p₁ p₂ c = lineMap (v +ᵥ p₁) (v +ᵥ p₂) c
-- Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean
theorem map_mul_map_eq_neg_of_isOrtho_of_mem_evenOdd_one
    (hm₁ : m₁ ∈ evenOdd Q₁ 1) (hm₂ : m₂ ∈ evenOdd Q₂ 1) :
    map f₁ m₁ * map f₂ m₂ = - map f₂ m₂ * map f₁ m₁
-- Mathlib/LinearAlgebra/Charpoly/ToMatrix.lean
lemma charpoly_prodMap (f₁ : M₁ →ₗ[R] M₁) (f₂ : M₂ →ₗ[R] M₂) :
    (f₁.prodMap f₂).charpoly = f₁.charpoly * f₂.charpoly
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
/-- If `L` is a finite separable extension of `K = Frac(A)`, where `A` is a principal ring
and `L` has no zero smul divisors by `A`, the integral closure `C` of `A` in `L` is
a free `A`-module. -/
theorem IsIntegralClosure.module_free [NoZeroSMulDivisors A L] [IsPrincipalIdealRing A] :
    Module.Free A C
-- Mathlib/Data/ENNReal/Real.lean
theorem toNNReal_lt_of_lt_coe (h : a < p) : a.toNNReal < p
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem denumerable_iff {α : Type u} : Nonempty (Denumerable α) ↔ #α = ℵ₀
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := simp)]
theorem MonoidHom.coe_coe [MonoidHomClass F M N] (f : F) : ((f : M →* N) : M → N) = f
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem one_le_card {o} : 1 ≤ card o ↔ 1 ≤ o
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem norm_setToFun_le_mul_norm' (hT : DominatedFinMeasAdditive μ T C) (f : α →₁[μ] E) :
    ‖setToFun μ T hT f‖ ≤ max C 0 * ‖f‖
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem or_self_right : (a ∨ b) ∨ b ↔ a ∨ b
-- Mathlib/Analysis/Calculus/LHopital.lean
/-- **L'Hôpital's rule** for approaching a real from the left, `deriv` version -/
theorem lhopital_zero_nhds_left (hdf : ∀ᶠ x in 𝓝[<] a, DifferentiableAt ℝ f x)
    (hg' : ∀ᶠ x in 𝓝[<] a, deriv g x ≠ 0) (hfa : Tendsto f (𝓝[<] a) (𝓝 0))
    (hga : Tendsto g (𝓝[<] a) (𝓝 0))
    (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝[<] a) l) :
    Tendsto (fun x => f x / g x) (𝓝[<] a) l
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
/-- The identity morphism in `SingleFunctors C D A`. -/
@[simps]
def id : Hom F F
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. A measurable function is smaller than its integral on a set f
positive measure. -/
theorem measure_le_lintegral_pos (hf : AEMeasurable f μ) : 0 < μ {x | f x ≤ ∫⁻ a, f a ∂μ}
-- Mathlib/Order/Interval/Finset/Basic.lean
/-- A function from a locally finite preorder is monotone if and only if it is monotone when
restricted to pairs satisfying `a ⩿ b`. -/
lemma monotone_iff_forall_wcovBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Monotone f ↔ ∀ a b : α, a ⩿ b → f a ≤ f b
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem mclosure_preimage_le (f : F) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[measurability]
theorem MeasurableSet.iInter [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
    MeasurableSet (⋂ b, f b)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_imp : (a ∧ b → c) ↔ (a → b → c)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem dist_eq_iff_eq_sq_sinh (hr : 0 ≤ r) :
    dist z w = r ↔ dist (z : ℂ) w ^ 2 / (4 * z.im * w.im) = sinh (r / 2) ^ 2
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem IsSubordinate.mono [Fintype ι] {π : TaggedPrepartition I} (hr₁ : π.IsSubordinate r₁)
    (h : ∀ x ∈ Box.Icc I, r₁ x ≤ r₂ x) : π.IsSubordinate r₂
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
theorem biprod.desc_eq {T : C} {f : X ⟶ T} {g : Y ⟶ T} :
    biprod.desc f g = biprod.fst ≫ f + biprod.snd ≫ g
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem le_of_abs_le (h : |a| ≤ b) : a ≤ b
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem one_not_equiv_zero : ¬const abv 1 ≈ const abv 0
-- Mathlib/Algebra/CharZero/Defs.lean
theorem cast_add_one_ne_zero (n : ℕ) : (n + 1 : R) ≠ 0
-- Mathlib/GroupTheory/Finiteness.lean
@[to_additive]
theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
    Group.rank G ≤ S.card
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem dotProduct_sub : u ⬝ᵥ (v - w) = u ⬝ᵥ v - u ⬝ᵥ w
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Ioi_insert [DecidableEq α] (a : α) : insert a (Ioi a) = Ici a
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem SameCycle.eq_of_left (h : SameCycle f x y) (hx : IsFixedPt f x) : x = y
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
    IsCycle f
-- Mathlib/Analysis/Convex/Measure.lean
/-- Haar measure of the frontier of a convex set is zero. -/
theorem addHaar_frontier (hs : Convex ℝ s) : μ (frontier s) = 0
-- Mathlib/Topology/Instances/AddCircle.lean
@[simp]
theorem equivAddCircle_symm_apply_mk (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜) :
    (equivAddCircle p q hp hq).symm (x : 𝕜) = (x * (q⁻¹ * p) : 𝕜)