ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Comma/Arrow.lean
/-- An object in the arrow category is simply a morphism in `T`. -/
@[simps]
def mk {X Y : T} (f : X ⟶ Y) : Arrow T
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.isLimit {f} (H : IsNormal f) {o} (l : IsLimit o) : IsLimit (f o)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem map_sup (s t : Subring R) (f : R →+* S) : (s ⊔ t).map f = s.map f ⊔ t.map f
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem map_one_of_isLeftRegular (h : IsLeftRegular (abv 1)) : abv 1 = 1
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem symm_dual_id : SupHom.dual.symm (InfHom.id _) = SupHom.id α
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem length_cons {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).length = p.length + 1
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem mk'_add_mk' (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ + mk' f m₂ s₂ = mk' f (s₂ • m₁ + s₁ • m₂) (s₁ * s₂)
-- Mathlib/Algebra/FreeNonUnitalNonAssocAlgebra.lean
@[simp]
theorem of_comp_lift (f : X → A) : lift R f ∘ of R = f
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem mul_apply (f g : M₁ →L[R₁] M₁) (x : M₁) : (f * g) x = f (g x)
-- Mathlib/Topology/Basic.lean
theorem closure_subset_preimage_closure_image (h : Continuous f) :
    closure s ⊆ f ⁻¹' closure (f '' s)
-- Mathlib/Data/Int/GCD.lean
protected theorem coe_nat_lcm (m n : ℕ) : Int.lcm ↑m ↑n = Nat.lcm m n
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma norm_term_eq (f : ℕ → ℂ) (s : ℂ) (n : ℕ) :
    ‖term f s n‖ = if n = 0 then 0 else ‖f n‖ / n ^ s.re
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
@[simp]
theorem factorThru_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y}
    (h : P.Factors (0 : X ⟶ Y)) : P.factorThru 0 h = 0
-- Mathlib/Order/Monotone/Basic.lean
theorem strictMonoOn_dual_iff :
    StrictMonoOn (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) s ↔ StrictMonoOn f s
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem AEMeasurable.mul_const [MeasurableMul M] (hf : AEMeasurable f μ) (c : M) :
    AEMeasurable (fun x => f x * c) μ
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem optionEquivSumPUnit_none : optionEquivSumPUnit α none = Sum.inr PUnit.unit
-- Mathlib/LinearAlgebra/StdBasis.lean
theorem proj_stdBasis_same (i : ι) : (proj i).comp (stdBasis R φ i) = id
-- Mathlib/CategoryTheory/Limits/EssentiallySmall.lean
theorem hasProductsOfShape_of_small (β : Type w₂) [Small.{w₁} β] [HasProducts.{w₁} C] :
    HasProductsOfShape β C
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem le_trailingDegree_X : (1 : ℕ∞) ≤ trailingDegree (X : R[X])
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem not_isField_iff_exists_prime [Nontrivial R] :
    ¬IsField R ↔ ∃ p : Ideal R, p ≠ ⊥ ∧ p.IsPrime
-- Mathlib/Algebra/Lie/Derivation/AdjointAction.lean
/-- The commutator of a derivation `D` and a derivation of the form `ad x` is `ad (D x)`. -/
lemma lie_der_ad_eq_ad_der (D : LieDerivation R L L) (x : L) : ⁅D, ad R L x⁆ = ad R L (D x)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem polar_comm (f : M → N) (x y : M) : polar f x y = polar f y x
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem mem_mk {s : Set E} {h₁ h₂ x} : x ∈ @mk 𝕜 _ _ _ _ s h₁ h₂ ↔ x ∈ s
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- If any finite measure has a Lebesgue decomposition with respect to `ν`,
then the same is true for any s-finite measure. -/
theorem HaveLebesgueDecomposition.sfinite_of_isFiniteMeasure [SFinite μ]
    (_h : ∀ (μ : Measure α) [IsFiniteMeasure μ], HaveLebesgueDecomposition μ ν) :
    HaveLebesgueDecomposition μ ν
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem preimage_closedBall (x : E₂) (r : ℝ) :
    e ⁻¹' Metric.closedBall x r = Metric.closedBall (e.symm x) r
-- Mathlib/RingTheory/Discriminant.lean
/-- Formula for the discriminant of a power basis using the norm of the field extension. -/
-- Porting note: `(minpoly K pb.gen).derivative` does not work anymore.
theorem discr_powerBasis_eq_norm [Algebra.IsSeparable K L] :
    discr K pb.basis =
      (-1) ^ (n * (n - 1) / 2) *
      norm K (aeval pb.gen (derivative (R := K) (minpoly K pb.gen)))
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem separatingLeft_iff_det_ne_zero {B : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁} (b : Basis ι R₁ M₁) :
    B.SeparatingLeft ↔ (toMatrix₂ b b B).det ≠ 0
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
/-- The canonical (bundled) continuous map from the underlying topological
space of `X` to the prime spectrum of its global sections. -/
@[simps]
def toΓSpecBase : X.toTopCat ⟶ Spec.topObj (Γ.obj (op X))
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem mem_inv_iff (hI : I ≠ 0) {x : K} : x ∈ I⁻¹ ↔ ∀ y ∈ I, x * y ∈ (1 : FractionalIdeal R₁⁰ K)
-- .lake/packages/lean4/src/lean/Init/Core.lean
/--
`LawfulBEq α` is a typeclass which asserts that the `BEq α` implementation
(which supplies the `a == b` notation) coincides with logical equality `a = b`.
In other words, `a == b` implies `a = b`, and `a == a` is true.
-/
class LawfulBEq (α : Type u) [BEq α] : Prop where
  /-- If `a == b` evaluates to `true`, then `a` and `b` are equal in the logic. -/
  eq_of_beq : {a b : α} → a == b → a = b
  /-- `==` is reflexive, that is, `(a == a) = true`. -/
  protected rfl : {a : α} → a == a
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp, reassoc]
theorem morphismRestrict_ι {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
    (f ∣_ U) ≫ U.ι = (f ⁻¹ᵁ U).ι ≫ f
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
lemma integrable (f : 𝓢(D, V)) : Integrable f μ
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
/-- The norm of the `0` operator is `0`. -/
theorem opNorm_zero : ‖(0 : E →SL[σ₁₂] F)‖ = 0
-- Mathlib/LinearAlgebra/LinearIndependent.lean
/-- Every finite subset of a linearly independent set is linearly independent. -/
theorem linearIndependent_finset_map_embedding_subtype (s : Set M)
    (li : LinearIndependent R ((↑) : s → M)) (t : Finset s) :
    LinearIndependent R ((↑) : Finset.map (Embedding.subtype s) t → M)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformContinuous.prod_mk_left {f : α × β → γ} (h : UniformContinuous f) (b) :
    UniformContinuous fun a => f (a, b)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem cons_diff_of_mem {a : α} {l₂ : List α} (h : a ∈ l₂) (l₁ : List α) :
    (a :: l₁).diff l₂ = l₁.diff (l₂.erase a)
-- Mathlib/AlgebraicTopology/SimplicialSet.lean
/-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u}
-- Mathlib/Data/Set/Image.lean
lemma preimage_subset_of_surjOn {t : Set β} (hf : Injective f) (h : SurjOn f s t) :
    f ⁻¹' t ⊆ s
-- Mathlib/Topology/Category/Profinite/Product.lean
theorem eq_of_forall_π_app_eq (a b : C)
    (h : ∀ (J : Finset ι), π_app C (· ∈ J) a = π_app C (· ∈ J) b) : a = b
-- Mathlib/SetTheory/Surreal/Basic.lean
lemma mk_sub {x y : PGame} (hx : x.Numeric) (hy : y.Numeric) :
    Surreal.mk (x - y) (hx.sub hy) = Surreal.mk x hx - Surreal.mk y hy
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
@[simp]
theorem leftDual_v [LeftRigidCategory V] : (ᘁX).V = ᘁX.V
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- Eta rule for cones. -/
@[simps!]
def eta (c : Cone F) : c ≅ ⟨c.pt, c.π⟩
-- Mathlib/Data/Finset/Sups.lean
theorem Nonempty.of_disjSups_left : (s ○ t).Nonempty → s.Nonempty
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp, norm_cast]
theorem coeIdeal_bot : ((⊥ : Ideal R) : FractionalIdeal S P) = 0
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cycleFactorsFinset g) :
    Disjoint (g * f⁻¹) f
-- Mathlib/Dynamics/FixedPoints/Basic.lean
/-- If `x` is a fixed point of `f`, then `f x = x`. This is useful, e.g., for `rw` or `simp`. -/
protected theorem eq (hf : IsFixedPt f x) : f x = x
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem tprod_eq_tprod_of_hasProd_iff_hasProd {f : β → α} {g : γ → α}
    (h : ∀ {a}, HasProd f a ↔ HasProd g a) : ∏' b, f b = ∏' c, g c
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
@[simp]
theorem whiskerRight_hom {X Y : Action V G} (f : X ⟶ Y) (Z : Action V G) :
    (f ▷ Z).hom = f.hom ▷ Z.V
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem Submonoid.equivMapOfInjective_coe_mulEquiv (e : M ≃* N) :
    S.equivMapOfInjective (e : M →* N) (EquivLike.injective e) = e.submonoidMap S
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem ext_iff (x y : L') : x = y ↔ (x : L) = y
-- Mathlib/Order/Interval/Set/Basic.lean
@[gcongr]
theorem Ioc_subset_Ioc_left (h : a₁ ≤ a₂) : Ioc a₂ b ⊆ Ioc a₁ b
-- Mathlib/Data/Set/Lattice.lean
theorem subset_sInter {S : Set (Set α)} {t : Set α} (h : ∀ t' ∈ S, t ⊆ t') : t ⊆ ⋂₀ S
-- Mathlib/Data/Finset/Piecewise.lean
lemma piecewise_mem_set_pi (hf : f ∈ Set.pi t t') (hg : g ∈ Set.pi t t') :
    s.piecewise f g ∈ Set.pi t t'
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- If `f : X → Z` is a surjective Borel measurable map from a standard Borel space
to a countably separated measurable space, then the preimage of a set `s`
is measurable if and only if the set is measurable.
One implication is the definition of measurability, the other one heavily relies on `X` being a
standard Borel space. -/
theorem measurableSet_preimage_iff_of_surjective [CountablySeparated Z]
    {f : X → Z} (hf : Measurable f) (hsurj : Surjective f) {s : Set Z} :
    MeasurableSet (f ⁻¹' s) ↔ MeasurableSet s
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem Submonoid.topologicalClosure_minimal (s : Submonoid M) {t : Submonoid M} (h : s ≤ t)
    (ht : IsClosed (t : Set M)) : s.topologicalClosure ≤ t
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem snd_comp_quotientInfEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
    (RingHom.snd _ _).comp
        (quotientInfEquivQuotientProd I J coprime : R ⧸ I ⊓ J →+* (R ⧸ I) × R ⧸ J) =
      Ideal.Quotient.factor (I ⊓ J) J inf_le_right
-- Mathlib/Combinatorics/Colex.lean
lemma le_iff_max'_mem {s t : Colex α} :
    s ≤ t ↔ ∀ h : s ≠ t, (ofColex s ∆ ofColex t).max' (max_mem_aux h) ∈ ofColex t
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem inl_le_inl_iff [LE α] [LE β] {a b : α} : (inl a : α ⊕ β) ≤ inl b ↔ a ≤ b
-- Mathlib/Data/List/Sublists.lean
theorem revzip_sublists (l : List α) : ∀ l₁ l₂, (l₁, l₂) ∈ revzip l.sublists → l₁ ++ l₂ ~ l
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem le_map_map_zero : f 0 + ⌊g 0⌋ ≤ f (g 0)
-- Mathlib/Order/Basic.lean
@[simp]
theorem mk_lt_mk [LT α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y} :
    (⟨x, hx⟩ : Subtype p) < ⟨y, hy⟩ ↔ x < y
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_rec (m n : Nat) : gcd m n = gcd (n % m) m
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem cocompact_le_atTop [OrderBot α] [CompactIccSpace α] :
    cocompact α ≤ atTop
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioc_mem_nhdsWithin_Ioi' {a b : α} (H : a < b) : Ioc a b ∈ 𝓝[>] a
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem ChartedSpace.secondCountable_of_countable_cover [SecondCountableTopology H] {s : Set M}
    (hs : ⋃ (x) (_ : x ∈ s), (chartAt H x).source = univ) (hsc : s.Countable) :
    SecondCountableTopology M
-- Mathlib/Data/Finset/Lattice.lean
/-- To rewrite from right to left, use `Finset.inf'_comp_eq_map`. -/
@[simp]
theorem inf'_map {s : Finset γ} {f : γ ↪ β} (g : β → α) (hs : (s.map f).Nonempty) :
    (s.map f).inf' hs g = s.inf' (map_nonempty.1 hs) (g ∘ f)
-- Mathlib/Data/Set/Defs.lean
theorem mem_image2_of_mem (ha : a ∈ s) (hb : b ∈ t) : f a b ∈ image2 f s t
-- Mathlib/Order/Directed.lean
theorem directedOn_image {s : Set β} {f : β → α} :
    DirectedOn r (f '' s) ↔ DirectedOn (f ⁻¹'o r) s
-- Mathlib/MeasureTheory/Measure/Regular.lean
lemma innerRegularWRT_isClosed_isOpen [R1Space α] [OpensMeasurableSpace α] [h : InnerRegular μ] :
    InnerRegularWRT μ IsClosed IsOpen
-- Mathlib/Data/Set/Prod.lean
theorem pi_eq_empty (hs : i ∈ s) (ht : t i = ∅) : s.pi t = ∅
-- Mathlib/Order/Lattice.lean
theorem inf_comm (a b : α) : a ⊓ b = b ⊓ a
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙHom_mono {a : A} (ha : p a) {f g : C(σₙ R a, R)₀} (hfg : f ≤ g) :
    cfcₙHom ha f ≤ cfcₙHom ha g
-- Mathlib/Combinatorics/Quiver/Path.lean
@[simp]
theorem comp_nil {a b : V} (p : Path a b) : p.comp Path.nil = p
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem range'_eq_map_range (s n : Nat) : range' s n = map (s + ·) (range n)
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem preimage_sInter {f : α → β} {s : Set (Set β)} : f ⁻¹' ⋂₀ s = ⋂ t ∈ s, f ⁻¹' t
-- Mathlib/Logic/Basic.lean
theorem peirce (a b : Prop) : ((a → b) → a) → a
-- Mathlib/Data/Finset/NAry.lean
lemma sup'_image₂_left (g : γ → δ) (h : (image₂ f s t).Nonempty) :
    sup' (image₂ f s t) h g =
      sup' s h.of_image₂_left fun x ↦ sup' t h.of_image₂_right (g <| f x ·)
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma div_zero {a : EReal} : a / 0 = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem mul_le_mul_left {n m : Nat} (k : Nat) (h : n ≤ m) : k * n ≤ k * m
-- Mathlib/Order/PropInstances.lean
@[simp]
theorem Prop.top_eq_true : (⊤ : Prop) = True
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp, nolint simpNF]
theorem type_uLift_aux (r : α → α → Prop) [IsWellOrder α r] :
    @type.{max v u} _ (fun x y => r (ULift.down.{v,u} x) (ULift.down.{v,u} y))
      (inferInstanceAs (IsWellOrder (ULift α) (ULift.down ⁻¹'o r))) = lift.{v} (type r)
-- Mathlib/Algebra/GradedMonoid.lean
@[simp]
theorem SetLike.homogeneous_coe {A : ι → S} {i} (x : A i) : SetLike.Homogeneous A (x : R)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem pi_div_two_le_arcsin {x} : π / 2 ≤ arcsin x ↔ 1 ≤ x
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.def' (h : f =o[l] g) (hc : 0 < c) : IsBigOWith c l f g
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive (attr := simp)]
theorem prod_cons (a : α) (s) : prod (a ::ₘ s) = a * prod s
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
/-- In a finite dimensional vector space over `ℝ`, the series `∑ x, ‖f x‖` is unconditionally
summable if and only if the series `∑ x, f x` is unconditionally summable. One implication holds in
any complete normed space, while the other holds only in finite dimensional spaces. -/
theorem summable_norm_iff {α E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] {f : α → E} : (Summable fun x => ‖f x‖) ↔ Summable f
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem indicator_meas_zero (hs : μ s = 0) : indicator s f =ᵐ[μ] 0
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem toAlternatingMap_zero : (0 : M [⋀^ι]→L[R] N).toAlternatingMap = 0
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
@[simp]
lemma sumCoeffsExp_p_eq_one : ∑ i, a i * (b i) ^ p a b = 1
-- Mathlib/Topology/Bases.lean
theorem isBasis_countableBasis [SecondCountableTopology α] :
    IsTopologicalBasis (countableBasis α)
-- Mathlib/NumberTheory/NumberField/House.lean
/-- There exists a "small" non-zero algebraic integral solution of an
 non-trivial underdetermined system of linear equations with algebraic integer coefficients.-/
theorem exists_ne_zero_int_vec_house_le :
    ∃ (ξ : β → 𝓞 K), ξ ≠ 0 ∧ a *ᵥ ξ = 0 ∧
    ∀ l, house (ξ l).1 ≤ c₁ K * ((c₁ K * q * A) ^ ((p : ℝ) / (q - p)))
-- Mathlib/Data/Nat/Cast/Synonym.lean
@[simp]
theorem toDual_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    (toDual (no_index (OfNat.ofNat n : α))) = OfNat.ofNat n
-- Mathlib/CategoryTheory/MorphismProperty/Factorization.lean
@[simp]
lemma mapZ_id : data.mapZ (𝟙 (Arrow.mk f)) = 𝟙 _
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
protected theorem map_zero (f : A →ₛₙₐ[φ] B) : f 0 = 0
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem mem_sInf {S : Set (NonUnitalSubalgebra R A)} {x : A} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- Mathlib/Order/RelSeries.lean
/--
For two preorders `α, β`, if `f : α → β` is surjective and strictly comonotonic, then a
strict series of `β` can be pulled back to a strict chain of `α` by
`b₀ < b₁ < ... < bₙ ↦ f⁻¹ b₀ < f⁻¹ b₁ < ... < f⁻¹ bₙ` where `f⁻¹ bᵢ` is an arbitrary element in the
preimage of `f⁻¹ {bᵢ}`.
-/
@[simps!]
noncomputable def comap (p : LTSeries β) (f : α → β)
  (comap : ∀ ⦃x y⦄, f x < f y → x < y)
  (surjective : Function.Surjective f) :
  LTSeries α
-- Mathlib/Order/Bounds/Basic.lean
/-- If `s` has a greatest element, then it is bounded above. -/
theorem IsGreatest.bddAbove (h : IsGreatest s a) : BddAbove s
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem finite_norm_eq (x : e.finiteSubspace) : ‖x‖ = (e x).toReal
-- Mathlib/Order/Heyting/Basic.lean
theorem compl_anti : Antitone (compl : α → α)
-- Mathlib/RingTheory/Localization/Basic.lean
nonrec theorem algEquiv_symm_mk' (x : R) (y : M) :
    (algEquiv M S).symm (mk' S x y) = mk' (Localization M) x y
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem le_of_le_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a ≤ b * c) (hb : b ≤ 1)
    (hc : 0 ≤ c) : a ≤ c
-- Mathlib/Topology/Irreducible.lean
theorem isIrreducible_iff_closure : IsIrreducible (closure s) ↔ IsIrreducible s
-- Mathlib/Data/List/Permutation.lean
theorem map_permutationsAux (f : α → β) :
    ∀ ts is :
    List α, map (map f) (permutationsAux ts is) = permutationsAux (map f ts) (map f is)
-- Mathlib/Data/Fintype/Card.lean
theorem Fintype.card_subtype_eq' (y : α) [Fintype { x // y = x }] :
    Fintype.card { x // y = x } = 1
-- Mathlib/Control/Functor.lean
theorem of_mem_supp {α : Type u} {x : F α} {p : α → Prop} (h : Liftp p x) : ∀ y ∈ supp x, p y
-- Mathlib/Probability/Process/PartitionFiltration.lean
lemma measurable_memPartitionSet (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) :
    Measurable (memPartitionSet t n)
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[simp] lemma id_f₃ : Hom.f₃ (𝟙 S) = 𝟙 _
-- Mathlib/Data/Real/Hyperreal.lean
theorem neg_lt_of_tendsto_zero_of_pos {f : ℕ → ℝ} (hf : Tendsto f atTop (𝓝 0)) :
    ∀ {r : ℝ}, 0 < r → (-r : ℝ*) < ofSeq f
-- Mathlib/Data/Set/Accumulate.lean
theorem biUnion_accumulate [Preorder α] (x : α) : ⋃ y ≤ x, Accumulate s y = ⋃ y ≤ x, s y
-- Mathlib/InformationTheory/Hamming.lean
@[simp]
theorem toHamming_sub [∀ i, Sub (β i)] {x y : ∀ i, β i} :
    toHamming (x - y) = toHamming x - toHamming y
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem projIcc_of_le_left (hx : x ≤ a) : projIcc a b h x = ⟨a, left_mem_Icc.2 h⟩
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Iic_mem_nhdsSet_Ico (h : b ≤ c) : Iic c ∈ 𝓝ˢ (Ico a b)
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coeff_monomial_mul (a : R) :
    coeff R m (monomial R n a * φ) = if n ≤ m then a * coeff R (m - n) φ else 0
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[trans]
theorem IsLittleO.trans_isBigO {f : α → E} {g : α → F} {k : α → G'} (hfg : f =o[l] g)
    (hgk : g =O[l] k) : f =o[l] k
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem coe_hom {X Y : T} (f : Y ⟶ X) : (f : Over X).hom = f
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
theorem toBasis_adjustToOrientation :
    (e.adjustToOrientation x).toBasis = e.toBasis.adjustToOrientation x
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem fst_himp [HImp α] [HImp β] (a b : α × β) : (a ⇨ b).1 = a.1 ⇨ b.1
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
theorem SmoothOn.inv₀ (hf : SmoothOn I' I f s) (h0 : ∀ x ∈ s, f x ≠ 0) :
    SmoothOn I' I (fun x => (f x)⁻¹) s
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_lt_of_mul_lt_right [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
    (h : a * b < c) (hle : d ≤ a) :
    d * b < c
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem equicontinuousWithinAt_unique [Unique ι] {F : ι → X → α} {S : Set X} {x : X} :
    EquicontinuousWithinAt F S x ↔ ContinuousWithinAt (F default) S x
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma fromSpec_toSpec {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) (x : Proj.T| pbo f) :
    FromSpec.toFun f_deg hm (toSpec 𝒜 f x) = x
-- Mathlib/MeasureTheory/Integral/Periodic.lean
theorem isAddFundamentalDomain_Ioc' {T : ℝ} (hT : 0 < T) (t : ℝ) (μ : Measure ℝ := by volume_tac) :
    IsAddFundamentalDomain (AddSubgroup.op <| .zmultiples T) (Ioc t (t + T)) μ
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem comap_iInf {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap m (f i)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp, norm_cast]
theorem coe_sub (m m' : N) : (↑(m - m') : M) = (m : M) - (m' : M)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem next : ∀ {s}, ValidFor l (m₁ ++ c :: m₂) r s →
    s.next ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + c.utf8Size⟩
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Icc : AECover μ l fun i => Icc (a i) (b i)
-- Mathlib/Order/Interval/Multiset.lean
@[simp]
theorem Ico_eq_zero_iff : Ico a b = 0 ↔ ¬a < b
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem drop_subset (n) (l : List α) : drop n l ⊆ l
-- Mathlib/Data/Nat/Squarefree.lean
lemma primeFactors_div_gcd (hm : Squarefree m) (hn : n ≠ 0) :
    primeFactors (m / m.gcd n) = primeFactors m \ primeFactors n
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableWithinAt.smul_const (hc : DifferentiableWithinAt 𝕜 c s x) (f : F) :
    DifferentiableWithinAt 𝕜 (fun y => c y • f) s x
-- Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean
lemma exists_isCompact_closedBall [WeaklyLocallyCompactSpace α] (x : α) :
    ∃ r, 0 < r ∧ IsCompact (closedBall x r)
-- Mathlib/FieldTheory/Separable.lean
theorem Separable.ne_zero [Nontrivial R] {f : R[X]} (h : f.Separable) : f ≠ 0
-- Mathlib/CategoryTheory/Limits/Types.lean
@[simp]
theorem Limit.map_π_apply' {F G : J ⥤ Type v} (α : F ⟶ G) (j : J) (x : limit F) :
    limit.π G j (limMap α x) = α.app j (limit.π F j x)
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_sub {S} [Ring S] (f : R →+* S) {x : S} :
    (p - q).eval₂ f x = p.eval₂ f x - q.eval₂ f x
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem smul_finset_subset_iff : a • s ⊆ t ↔ s ⊆ a⁻¹ • t
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem subtype_Icc_eq : Icc a b = (Icc (a : α) b).subtype p
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
protected theorem dist_left (y : α) : LipschitzWith 1 (dist · y)
-- Mathlib/Topology/Algebra/Group/Basic.lean
/-- The topological closure of a normal subgroup is normal. -/
@[to_additive "The topological closure of a normal additive subgroup is normal."]
theorem Subgroup.is_normal_topologicalClosure {G : Type*} [TopologicalSpace G] [Group G]
    [TopologicalGroup G] (N : Subgroup G) [N.Normal] : (Subgroup.topologicalClosure N).Normal
-- Mathlib/Logic/Relation.lean
theorem iff_comp {r : Prop → α → Prop} : (· ↔ ·) ∘r r = r
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
/-- A certain linear combination of the previous three identities,
which we'll want later.
-/
theorem variance (n : ℕ) :
    (∑ ν ∈ Finset.range (n + 1), (n • Polynomial.X - (ν : R[X])) ^ 2 * bernsteinPolynomial R n ν) =
      n • Polynomial.X * ((1 : R[X]) - Polynomial.X)
-- Mathlib/Order/Filter/Bases.lean
@[instance]
theorem isCountablyGenerated_bot : IsCountablyGenerated (⊥ : Filter α)
-- Mathlib/Topology/Order/LeftRightLim.lean
theorem rightLim_eq_sInf [TopologicalSpace α] [OrderTopology α] (h : 𝓝[>] x ≠ ⊥) :
    rightLim f x = sInf (f '' Ioi x)
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp)]
theorem mul_right_inv (a : G) : a * a⁻¹ = 1
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_inter_Ioi : Ioo a b ∩ Ioi c = Ioo (max a c) b
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem measure_inter_lt_top_of_right_ne_top (ht_finite : μ t ≠ ∞) : μ (s ∩ t) < ∞
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem le_sdiff_iff : x ≤ y \ x ↔ x = ⊥
-- Mathlib/CategoryTheory/Limits/Lattice.lean
/-- The pullback in the category of a `SemilatticeInf` with `OrderTop` is the same as the infimum
over the objects.
-/
@[simp]
theorem pullback_eq_inf [SemilatticeInf α] [OrderTop α] {x y z : α} (f : x ⟶ z) (g : y ⟶ z) :
    pullback f g = x ⊓ y