ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive (attr := simp)]
theorem curry_inv [∀ a b, Inv (γ a b)] (x : (i : Σ a, β a) → γ i.1 i.2) :
    Sigma.curry (x⁻¹) = (Sigma.curry x)⁻¹
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem hasSum_geometric_of_norm_lt_one (h : ‖ξ‖ < 1) : HasSum (fun n : ℕ ↦ ξ ^ n) (1 - ξ)⁻¹
-- Mathlib/CategoryTheory/Triangulated/Functor.lean
lemma mem_mapTriangle_essImage_of_distinguished
    [F.IsTriangulated] [F.mapArrow.EssSurj] (T : Triangle D) (hT : T ∈ distTriang D) :
    ∃ (T' : Triangle C) (_ : T' ∈ distTriang C), Nonempty (F.mapTriangle.obj T' ≅ T)
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[ext]
theorem ModularForm.ext {f g : ModularForm Γ k} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem compl_bihimp_self : aᶜ ⇔ a = ⊥
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem Algebra.restrictScalars_adjoin (F : Type*) [CommSemiring F] {E : Type*} [CommSemiring E]
    [Algebra F E] (K : Subalgebra F E) (S : Set E) :
    (Algebra.adjoin K S).restrictScalars F = Algebra.adjoin F (K ∪ S)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Gcd.lean
theorem lcm_ne_zero (hm : m ≠ 0) (hn : n ≠ 0) : lcm m n ≠ 0
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
lemma isIso_counit_app_iff_mem_essImage [L.Faithful] [L.Full] {X : D} :
    IsIso (h.counit.app X) ↔ X ∈ L.essImage
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_X : X.eval₂ f x = x
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma map_neg : (-z).map Φ = -z.map Φ
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem tsum_comm {f : α → β → ℝ≥0∞} : ∑' a, ∑' b, f a b = ∑' b, ∑' a, f a b
-- Mathlib/Order/Filter/Bases.lean
theorem _root_.Pairwise.exists_mem_filter_basis_of_disjoint {I} [Finite I] {l : I → Filter α}
    {ι : I → Sort*} {p : ∀ i, ι i → Prop} {s : ∀ i, ι i → Set α} (hd : Pairwise (Disjoint on l))
    (h : ∀ i, (l i).HasBasis (p i) (s i)) :
    ∃ ind : ∀ i, ι i, (∀ i, p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem length_mono {s₁ s₂ : Set ℝ} (h : s₁ ⊆ s₂) : f.length s₁ ≤ f.length s₂
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem Multipliable.inv (hf : Multipliable f) : Multipliable fun b ↦ (f b)⁻¹
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem map_isCycle_iff_of_injective {p : G.Walk u u} (hinj : Function.Injective f) :
    (p.map f).IsCycle ↔ p.IsCycle
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem mem_ball : y ∈ ball x ε ↔ dist y x < ε
-- Mathlib/Topology/Algebra/Module/Multilinear/Topology.lean
theorem tsum_eval [T2Space F] {α : Type*} {p : α → ContinuousMultilinearMap 𝕜 E F} (hp : Summable p)
    (m : Π i, E i) : (∑' a, p a) m = ∑' a, p a m
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.measurable_measure_stieltjesFunction :
    Measurable fun a ↦ (hf.stieltjesFunction a).measure
-- Mathlib/Order/Max.lean
theorem NoTopOrder.to_noMaxOrder (α : Type*) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
/-- `SemilinearIsometryClass F σ E E₂` asserts `F` is a type of bundled `σ`-semilinear isometries
`E → E₂`.

See also `LinearIsometryClass F R E E₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearIsometryClass (𝓕 : Type*) {R R₂ : outParam Type*} [Semiring R] [Semiring R₂]
  (σ₁₂ : outParam <| R →+* R₂) (E E₂ : outParam Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] [FunLike 𝓕 E E₂] extends
  SemilinearMapClass 𝓕 σ₁₂ E E₂ : Prop where
  norm_map : ∀ (f : 𝓕) (x : E), ‖f x‖ = ‖x‖
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ico [NoMaxOrder α] : AECover μ l fun i => Ico (a i) (b i)
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_mul_nat_iff : Irrational (x * n) ↔ n ≠ 0 ∧ Irrational x
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma Hom.comp_eq {X Y Z : C} (z₁ : W.LeftFraction X Y) (z₂ : W.LeftFraction Y Z) :
    Hom.comp (mk z₁) (mk z₂) = z₁.comp z₂
-- Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean
lemma eval₂_minpolyDiv_of_eval₂_eq_zero {T} [CommRing T]
    [IsDomain T] [DecidableEq T] {x y}
    (σ : S →+* T) (hy : eval₂ (σ.comp (algebraMap R S)) y (minpoly R x) = 0) :
    eval₂ σ y (minpolyDiv R x) =
      if σ x = y then σ (aeval x (derivative <| minpoly R x)) else 0
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
@[simp]
theorem coe_neg (f : SlashInvariantForm Γ k) : ⇑(-f) = -f
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem iInf_Ioi_eq (f : StieltjesFunction) (x : ℝ) : ⨅ r : Ioi x, f r = f x
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem prod_of_left {α β γ} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ]
    {f : α × β → γ} {μ : Measure α} {ν : Measure β} {τ : Measure γ} (hf : Measurable f)
    [SFinite μ] [SFinite ν]
    (h2f : ∀ᵐ y ∂ν, QuasiMeasurePreserving (fun x => f (x, y)) μ τ) :
    QuasiMeasurePreserving f (μ.prod ν) τ
-- Mathlib/CategoryTheory/Adjunction/Comma.lean
/-- Implementation: If each costructured arrow category on `G` has a terminal object, an equivalence
which is helpful for constructing a right adjoint to `G`.
-/
@[simps]
def rightAdjointOfCostructuredArrowTerminalsAux (B : D) (A : C) :
    (G.obj B ⟶ A) ≃ (B ⟶ (⊤_ CostructuredArrow G A).left)
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
/-- A component of a transposed version of the inverse mates correspondence. -/
theorem unit_mateEquiv_symm (α : R₁ ⋙ G ⟶ H ⋙ R₂) (c : C) :
    G.map (adj₁.unit.app c) ≫ α.app _ =
      adj₂.unit.app _ ≫ R₂.map (((mateEquiv adj₁ adj₂).symm α).app _)
-- Mathlib/CategoryTheory/ComposableArrows.lean
/-- Inductive construction of isomorphisms in `ComposableArrows C (n + 1)`: in order to
construct an isomorphism `F ≅ G`, it suffices to provide `α : F.obj' 0 ≅ G.obj' 0` and
`β : F.δ₀ ≅ G.δ₀` such that `F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1`. -/
@[simps]
def isoMkSucc {F G : ComposableArrows C (n + 1)} (α : F.obj' 0 ≅ G.obj' 0)
    (β : F.δ₀ ≅ G.δ₀) (w : F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1) : F ≅ G
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- To prove a property of a finite product, it suffices to prove that the property is
multiplicative and holds on factors. -/
@[to_additive
      "To prove a property of a finite sum, it suffices to prove that the property is
      additive and holds on summands."]
theorem finprod_mem_induction (p : M → Prop) (hp₀ : p 1) (hp₁ : ∀ x y, p x → p y → p (x * y))
    (hp₂ : ∀ x ∈ s, p <| f x) : p (∏ᶠ i ∈ s, f i)
-- Mathlib/Order/Circular.lean
theorem sbtw_cyclic_left {a b c : α} (h : sbtw a b c) : sbtw b c a
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Sized.node3R {l x m y r} (hl : @Sized α l) (hm : Sized m) (hr : Sized r) :
    Sized (node3R l x m y r)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasDerivWithinAt.cpow (hf : HasDerivWithinAt f f' s x) (hg : HasDerivWithinAt g g' s x)
    (h0 : f x ∈ slitPlane) : HasDerivWithinAt (fun x => f x ^ g x)
      (g x * f x ^ (g x - 1) * f' + f x ^ g x * Complex.log (f x) * g') s x
-- Mathlib/Topology/Homotopy/Basic.lean
/-- `ContinuousMap.Homotopy f₀ f₁` is the type of homotopies from `f₀` to `f₁`.

When possible, instead of parametrizing results over `(f : Homotopy f₀ f₁)`,
you should parametrize over `{F : Type*} [HomotopyLike F f₀ f₁] (f : F)`.

When you extend this structure, make sure to extend `ContinuousMap.HomotopyLike`. -/
structure Homotopy (f₀ f₁ : C(X, Y)) extends C(I × X, Y) where
  /-- value of the homotopy at 0 -/
  map_zero_left : ∀ x, toFun (0, x) = f₀ x
  /-- value of the homotopy at 1 -/
  map_one_left : ∀ x, toFun (1, x) = f₁ x
-- Mathlib/Algebra/Lie/Basic.lean
theorem coe_to_lieHom (e : L₁ ≃ₗ⁅R⁆ L₂) : ⇑(e : L₁ →ₗ⁅R⁆ L₂) = e
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- If the restrictions of a measure to countably many open sets covering the space are
outer regular, then the measure itself is outer regular. -/
lemma of_restrict [OpensMeasurableSpace α] {μ : Measure α} {s : ℕ → Set α}
    (h : ∀ n, OuterRegular (μ.restrict (s n))) (h' : ∀ n, IsOpen (s n)) (h'' : univ ⊆ ⋃ n, s n) :
    OuterRegular μ
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem StructureGroupoid.mem_iff_of_eqOnSource {G : StructureGroupoid H}
    {e e' : PartialHomeomorph H H} (h : e ≈ e') : e ∈ G ↔ e' ∈ G
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem mul_min_mul_right (a b c : Nat) : min (a * c) (b * c) = min a b * c
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem measure_Ioi_pos [NoMaxOrder X] (a : X) : 0 < μ (Ioi a)
-- Mathlib/Data/Set/Lattice.lean
lemma nonempty_iInter_Ici_iff [Preorder α] {f : ι → α} :
    (⋂ i, Ici (f i)).Nonempty ↔ BddAbove (range f)
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma gaussianPDFReal_sub {μ : ℝ} {v : ℝ≥0} (x y : ℝ) :
    gaussianPDFReal μ v (x - y) = gaussianPDFReal (μ + y) v x
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem ofNat_toNat (m : Nat) (x : BitVec n) : BitVec.ofNat m x.toNat = truncate m x
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem Ioo_ae_eq_Ico' (ha : μ {a} = 0) : Ioo a b =ᵐ[μ] Ico a b
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
@[deprecated measure_sUnion_null_iff (since := "2024-05-14")]
theorem sUnion_null_iff (m : OuterMeasure α) {S : Set (Set α)} (hS : S.Countable) :
    m (⋃₀ S) = 0 ↔ ∀ s ∈ S, m s = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma map_polynomial : (W'.map f).toJacobian.polynomial = MvPolynomial.map f W'.polynomial
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.diff [DecidableEq α] : l₁.Nodup → (l₁.diff l₂).Nodup
-- Mathlib/Data/Nat/Factorization/Basic.lean
@[simp]
lemma factorizationLCMLeft_zero_right : factorizationLCMLeft a 0 = 1
-- Mathlib/FieldTheory/IntermediateField.lean
theorem mem_restrict (x : E) : x ∈ restrict h ↔ x.1 ∈ F
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
@[ext]
lemma FunctorsInverting.ext {W : MorphismProperty C} {F₁ F₂ : FunctorsInverting W D}
    (h : F₁.obj = F₂.obj) : F₁ = F₂
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem mk_right (f : S.obj Y ⟶ T) : (mk f).right = ⟨⟨⟩⟩
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem exists_ball_subset_ball (h : y ∈ ball x ε) : ∃ ε' > 0, ball y ε' ⊆ ball x ε
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem galoisConnection_map_comap (hφ : Function.Injective φ.obj) :
    GaloisConnection (map φ hφ) (comap φ)
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem col_empty (v : Fin 0 → α) : col ι v = vecEmpty
-- Mathlib/RingTheory/LaurentSeries.lean
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_one : ((1 : PowerSeries R) : LaurentSeries R) = 1
-- Mathlib/LinearAlgebra/Pi.lean
@[simp, norm_cast]
theorem coe_pi : (pi I p : Set ((i : ι) → φ i)) = Set.pi I fun i => p i
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem toFinset_symmDiff [Fintype (s ∆ t : Set _)] :
    (s ∆ t).toFinset = s.toFinset ∆ t.toFinset
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderivWithin_congr (hs : EqOn f₁ f s) (hx : f₁ x = f x) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x
-- Mathlib/MeasureTheory/Measure/Haar/Quotient.lean
/-- Given a subgroup `Γ` of a topological group `G` with measure `ν`, and a measure 'μ' on the
  quotient `G ⧸ Γ` satisfying `QuotientMeasureEqMeasurePreimage`, the restriction
  of `ν` to a fundamental domain is measure-preserving with respect to `μ`. -/
@[to_additive]
theorem measurePreserving_quotientGroup_mk_of_QuotientMeasureEqMeasurePreimage
    {𝓕 : Set G} (h𝓕 : IsFundamentalDomain Γ.op 𝓕 ν) (μ : Measure (G ⧸ Γ))
    [QuotientMeasureEqMeasurePreimage ν μ] :
    MeasurePreserving (@QuotientGroup.mk G _ Γ) (ν.restrict 𝓕) μ
-- Mathlib/SetTheory/Ordinal/Notation.lean
@[simp]
theorem repr_ofNat (n : ℕ) : repr (ofNat n) = n
-- Mathlib/AlgebraicGeometry/FunctionField.lean
theorem functionField_isFractionRing_of_isAffineOpen [IsIntegral X] (U : X.Opens)
    (hU : IsAffineOpen U) [Nonempty U] :
    IsFractionRing Γ(X, U) X.functionField
-- Mathlib/Algebra/Algebra/Operations.lean
theorem mem_span_singleton_mul {x y : A} : x ∈ span R {y} * P ↔ ∃ z ∈ P, y * z = x
-- Mathlib/Computability/Primrec.lean
protected theorem beq [DecidableEq α] : Primrec₂ (@BEq.beq α _)
-- Mathlib/Control/EquivFunctor.lean
/-- An `EquivFunctor` is only functorial with respect to equivalences.

To construct an `EquivFunctor`, it suffices to supply just the function `f α → f β` from
an equivalence `α ≃ β`, and then prove the functor laws. It's then a consequence that
this function is part of an equivalence, provided by `EquivFunctor.mapEquiv`.
-/
class EquivFunctor (f : Type u₀ → Type u₁) where
  /-- The action of `f` on isomorphisms. -/
  map : ∀ {α β}, α ≃ β → f α → f β
  /-- `map` of `f` preserves the identity morphism. -/
  map_refl' : ∀ α, map (Equiv.refl α) = @id (f α) := by rfl
  /-- `map` is functorial on equivalences. -/
  map_trans' : ∀ {α β γ} (k : α ≃ β) (h : β ≃ γ), map (k.trans h) = map h ∘ map k := by rfl
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
/-- A function `f` has the continuous linear map `f'` as derivative along the filter `L` if
`f x' = f x + f' (x' - x) + o (x' - x)` when `x'` converges along the filter `L`. This definition
is designed to be specialized for `L = 𝓝 x` (in `HasFDerivAt`), giving rise to the usual notion
of Fréchet derivative, and for `L = 𝓝[s] x` (in `HasFDerivWithinAt`), giving rise to
the notion of Fréchet derivative along the set `s`. -/
@[mk_iff hasFDerivAtFilter_iff_isLittleO]
structure HasFDerivAtFilter (f : E → F) (f' : E →L[𝕜] F) (x : E) (L : Filter E) : Prop where
  of_isLittleO :: isLittleO : (fun x' => f x' - f x - f' (x' - x)) =o[L] fun x' => x' - x
-- Mathlib/Order/Interval/Set/OrdConnected.lean
theorem ordConnected_of_Ioo {α : Type*} [PartialOrder α] {s : Set α}
    (hs : ∀ x ∈ s, ∀ y ∈ s, x < y → Ioo x y ⊆ s) : OrdConnected s
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem ofFractionRing_zero : (ofFractionRing 0 : RatFunc K) = 0
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem hnot_sup_self (a : α) : ￢a ⊔ a = ⊤
-- Mathlib/Topology/Compactness/Compact.lean
/-- The preimage of a compact set in the image of an inducing map is compact. -/
lemma Inducing.isCompact_preimage' {f : X → Y} (hf : Inducing f) {K : Set Y}
    (hK : IsCompact K) (Kf : K ⊆ range f) : IsCompact (f ⁻¹' K)
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
theorem contMDiff_iff_contDiff {f : E → E'} : ContMDiff 𝓘(𝕜, E) 𝓘(𝕜, E') n f ↔ ContDiff 𝕜 n f
-- Mathlib/RingTheory/Polynomial/Content.lean
@[simp]
theorem primPart_mul {p q : R[X]} (h0 : p * q ≠ 0) :
    (p * q).primPart = p.primPart * q.primPart
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ + ‖a / b‖₊
-- Mathlib/Logic/Basic.lean
protected theorem Ne.ite_eq_left_iff (h : a ≠ b) : ite P a b = a ↔ P
-- Mathlib/Data/List/Lattice.lean
theorem forall_mem_inter_of_forall_left (h : ∀ x ∈ l₁, p x) (l₂ : List α) :
    ∀ x, x ∈ l₁ ∩ l₂ → p x
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast]
theorem mul_to_nat (m) : ∀ n, ((m * n : PosNum) : ℕ) = m * n
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
theorem HasSum.const_smul {a : α} (b : γ) (hf : HasSum f a) : HasSum (fun i ↦ b • f i) (b • a)
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem divInt_zero (n) : n /. 0 = 0
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem cancel_right {g₁ g₂ : BoundedOrderHom β γ} {f : BoundedOrderHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- Mathlib/Logic/Function/Conjugate.lean
theorem isIdempotent_right [Std.IdempotentOp ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
    Std.IdempotentOp gb
-- Mathlib/CategoryTheory/Elements.lean
/-- The forward direction of the equivalence `F.Elementsᵒᵖ ≅ (yoneda, F)`,
given by `CategoryTheory.yonedaEquiv`.
-/
@[simps]
def toCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : F.Elementsᵒᵖ ⥤ CostructuredArrow yoneda F
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_le_mul_right : c ≠ 0 → c ≠ ∞ → (a * c ≤ b * c ↔ a ≤ b)
-- Mathlib/Algebra/Homology/ImageToKernel.lean
@[simp]
theorem imageToKernel_zero_left [HasKernels V] [HasZeroObject V] {w} :
    imageToKernel (0 : A ⟶ B) g w = 0
-- Mathlib/Data/Set/Defs.lean
@[mfld_simps]
theorem prod_mk_mem_set_prod_eq : ((a, b) ∈ s ×ˢ t) = (a ∈ s ∧ b ∈ t)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem prod_add : ∀ a b : FactorSet α, (a + b).prod = a.prod * b.prod
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem log_conj (x : ℂ) (h : x.arg ≠ π) : log (conj x) = conj (log x)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem smul_apply (f : MultilinearMap A M₁ M₂) (c : R') (m : ∀ i, M₁ i) : (c • f) m = c • f m
-- Mathlib/Topology/Bornology/Constructions.lean
theorem cobounded_pi : cobounded (∀ i, π i) = Filter.coprodᵢ fun i => cobounded (π i)
-- Mathlib/Topology/Filter.lean
theorem inducing_nhds : Inducing (𝓝 : X → Filter X)
-- Mathlib/Data/Num/Lemmas.lean
theorem toZNumNeg_succ : ∀ n : Num, n.succ.toZNumNeg = n.toZNumNeg.pred
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem natDegree_eq_card_roots {p : K[X]} {i : K →+* L} (hsplit : Splits i p) :
    p.natDegree = Multiset.card (p.map i).roots
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp)]
theorem inv_one : (1 : G)⁻¹ = 1
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasStrictDerivAt.congr_deriv (h : HasStrictDerivAt f f' x) (h' : f' = g') :
    HasStrictDerivAt f g' x
-- Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean
/-- If the sequence has not terminated before position `n + 1`, the value at `n + 1` gets
squashed into position `n`. -/
theorem squashSeq_nth_of_not_terminated {gp_n gp_succ_n : Pair K} (s_nth_eq : s.get? n = some gp_n)
    (s_succ_nth_eq : s.get? (n + 1) = some gp_succ_n) :
    (squashSeq s n).get? n = some ⟨gp_n.a, gp_n.b + gp_succ_n.a / gp_succ_n.b⟩
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.quotKerTotalEquiv_symm_comp_D :
    (KaehlerDifferential.quotKerTotalEquiv R S).symm.toLinearMap.compDer
        (KaehlerDifferential.D R S) =
      KaehlerDifferential.derivationQuotKerTotal R S
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    X.σ j.succ ≫ X.δ (Fin.castSucc i) = X.δ i ≫ X.σ j
-- Mathlib/CategoryTheory/Comma/Arrow.lean
@[reassoc (attr := simp)]
theorem w_mk_right {f : Arrow T} {X Y : T} {g : X ⟶ Y} (sq : f ⟶ mk g) :
    sq.left ≫ g = f.hom ≫ sq.right
-- Mathlib/Data/TwoPointing.lean
theorem to_nontrivial : Nontrivial α
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem self_comp_symm (f : M ≃[L] N) : f.comp f.symm = refl L N
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem relMap_apply₂ (r : r₂) (x y : M) :
    @Structure.RelMap _ M (Structure.mk₂ c' f₁' f₂' r₁' r₂') 2 r ![x, y] = r₂' r x y
-- Mathlib/Data/Fintype/Basic.lean
lemma singleton_eq_univ [Subsingleton α] (a : α) : ({a} : Finset α) = univ
-- Mathlib/RingTheory/LocalRing/Module.lean
theorem free_of_flat_of_localRing [Module.FinitePresentation R P] [Module.Flat R P] :
    Module.Free R P
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive]
theorem unop_closure (s : Set Mᵐᵒᵖ) : (closure s).unop = closure (MulOpposite.op ⁻¹' s)
-- Mathlib/Data/Rat/Lemmas.lean
@[simp]
theorem isSquare_ofNat_iff {n : ℕ} :
    IsSquare (no_index (OfNat.ofNat n) : ℚ) ↔ IsSquare (OfNat.ofNat n : ℕ)
-- Mathlib/GroupTheory/Submonoid/Inverses.lean
@[to_additive]
theorem leftInv_leftInv_le : S.leftInv.leftInv ≤ S
-- Mathlib/Algebra/Homology/QuasiIso.lean
lemma quasiIso_of_comp_right (φ : K ⟶ L) (φ' : L ⟶ M) [∀ i, K.HasHomology i]
    [∀ i, L.HasHomology i] [∀ i, M.HasHomology i]
    [hφ : QuasiIso φ'] [hφφ' : QuasiIso (φ ≫ φ')] :
    QuasiIso φ
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
theorem OneHom.cancel_right [One M] [One N] [One P] {g₁ g₂ : OneHom N P} {f : OneHom M N}
    (hf : Function.Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
theorem symm_comp_eq {α : Type*} (e : M ≃* N) (f : α → M) (g : α → N) :
    e.symm ∘ g = f ↔ g = e ∘ f
-- Mathlib/MeasureTheory/PiSystem.lean
/-- Every element of the π-system generated by the union of a family of π-systems
is a finite intersection of elements from the π-systems.
For an indexed union version, see `mem_generatePiSystem_iUnion_elim'`. -/
theorem mem_generatePiSystem_iUnion_elim {α β} {g : β → Set (Set α)} (h_pi : ∀ b, IsPiSystem (g b))
    (t : Set α) (h_t : t ∈ generatePiSystem (⋃ b, g b)) :
    ∃ (T : Finset β) (f : β → Set α), (t = ⋂ b ∈ T, f b) ∧ ∀ b ∈ T, f b ∈ g b
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem equicontinuousAt_finite [Finite ι] {F : ι → X → α} {x₀ : X} :
    EquicontinuousAt F x₀ ↔ ∀ i, ContinuousAt (F i) x₀
-- Mathlib/Data/ZMod/Basic.lean
theorem neg_val {n : ℕ} [NeZero n] (a : ZMod n) : (-a).val = if a = 0 then 0 else n - a.val
-- Mathlib/SetTheory/Surreal/Basic.lean
theorem numeric_zero : Numeric 0
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[reassoc, simp]
theorem sub_comp : (f - f') ≫ g = f ≫ g - f' ≫ g
-- Mathlib/Algebra/Group/Hom/Instances.lean
@[to_additive]
theorem map_inv₂ {_ : Group M} {_ : MulOneClass N} {_ : CommGroup P} (f : M →* N →* P) (m : M)
    (n : N) : f m⁻¹ n = (f m n)⁻¹
-- Mathlib/Topology/Connected/PathConnected.lean
theorem IsPathConnected.exists_path_through_family' {n : ℕ}
    {s : Set X} (h : IsPathConnected s) (p : Fin (n + 1) → X) (hp : ∀ i, p i ∈ s) :
    ∃ (γ : Path (p 0) (p n)) (t : Fin (n + 1) → I), (∀ t, γ t ∈ s) ∧ ∀ i, γ (t i) = p i
-- Mathlib/Data/ZMod/Coprime.lean
/-- If an integer `a` and a prime `p` satisfy `gcd a p = 1`, then `a : ZMod p` is nonzero. -/
theorem ne_zero_of_gcd_eq_one {a : ℤ} {p : ℕ} (pp : p.Prime) (h : a.gcd p = 1) : (a : ZMod p) ≠ 0
-- Mathlib/RingTheory/Algebraic.lean
theorem IsAlgebraic.of_finite (e : A) [FiniteDimensional K A] : IsAlgebraic K e
-- Mathlib/RingTheory/LocalProperties.lean
lemma surjective_respectsIso : RingHom.RespectsIso (fun f ↦ Function.Surjective f)
-- Mathlib/Topology/Instances/Rat.lean
theorem Int.uniformEmbedding_coe_rat : UniformEmbedding ((↑) : ℤ → ℚ)
-- Mathlib/Data/Real/ENatENNReal.lean
@[mono]
theorem toENNReal_mono : Monotone ((↑) : ℕ∞ → ℝ≥0∞)
-- Mathlib/NumberTheory/SmoothNumbers.lean
@[simp]
lemma factoredNumbers_empty : factoredNumbers ∅ = {1}
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
/-- This is a helper construction that can be useful when verifying that a category has all
    pullbacks. Given `F : WalkingCospan ⥤ C`, which is really the same as
    `cospan (F.map inl) (F.map inr)`, and a pullback cone on `F.map inl` and `F.map inr`, we
    get a cone on `F`.

    If you're thinking about using this, have a look at `hasPullbacks_of_hasLimit_cospan`,
    which you may find to be an easier way of achieving your goal. -/
@[simps]
def Cone.ofPullbackCone {F : WalkingCospan ⥤ C} (t : PullbackCone (F.map inl) (F.map inr)) :
    Cone F
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma NumberField.InfinitePlace.isUnramifiedIn [IsUnramifiedAtInfinitePlaces k K]
    (w : InfinitePlace k) : IsUnramifiedIn K w
-- Mathlib/Topology/Constructions.lean
@[continuity]
theorem continuous_fst : Continuous (@Prod.fst X Y)
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
theorem hermite_monic (n : ℕ) : (hermite n).Monic
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem sublist_append_of_sublist_right (s : l <+ l₂) : l <+ l₁ ++ l₂
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
theorem isRefl_neg {B : BilinForm R₁ M₁} : (-B).IsRefl ↔ B.IsRefl
-- Mathlib/Analysis/Calculus/FDeriv/RestrictScalars.lean
@[fun_prop]
theorem HasFDerivWithinAt.restrictScalars (h : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt f (f'.restrictScalars 𝕜) s x
-- Mathlib/Analysis/Analytic/Within.lean
lemma AnalyticWithinAt.continuousWithinAt {f : E → F} {s : Set E} {x : E}
    (h : AnalyticWithinAt 𝕜 f s x) : ContinuousWithinAt f s x