ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem list_prod_map_rpow' {ι} (l : List ι) (f : ι → ℝ≥0) (r : ℝ) :
    (l.map (f · ^ r)).prod = (l.map f).prod ^ r
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem snd_add [Add R] [Add A] (x₁ x₂ : Unitization R A) : (x₁ + x₂).snd = x₁.snd + x₂.snd
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
@[simp]
lemma tensorQuotEquivQuotSMul_symm_mk (I : Ideal R) (x : M) :
    (tensorQuotEquivQuotSMul M I).symm (Submodule.Quotient.mk x) = x ⊗ₜ[R] 1
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- An equalizer of an idempotent morphism and the identity is split mono. -/
@[simps]
def splitMonoOfIdempotentOfIsLimitFork {X : C} {f : X ⟶ X} (hf : f ≫ f = f) {c : Fork (𝟙 X) f}
    (i : IsLimit c) : SplitMono c.ι
-- Mathlib/Computability/Encoding.lean
theorem inclusionBoolΓ'_injective : Function.Injective inclusionBoolΓ'
-- Mathlib/Topology/UrysohnsLemma.lean
theorem approx_nonneg (c : CU P) (n : ℕ) (x : X) : 0 ≤ c.approx n x
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem _root_.Finset.infsep_pos_iff_nontrivial (s : Finset α) :
    0 < (s : Set α).infsep ↔ (s : Set α).Nontrivial
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem map_join (f : α → β) (L : List (List α)) : map f (join L) = join (map (map f) L)
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem degree_of_b_eq_zero' : (toPoly ⟨0, 0, c, d⟩).degree ≤ 1
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isLittleO_const_mul_right_iff {g : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) :
    (f =o[l] fun x => c * g x) ↔ f =o[l] g
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem add_div : (a + b) / c = a / c + b / c
-- Mathlib/Algebra/Polynomial/Div.lean
@[simp]
theorem rootMultiplicity_zero {x : R} : rootMultiplicity x 0 = 0
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
theorem induction_linear {P : PolynomialModule R M → Prop} (f : PolynomialModule R M) (h0 : P 0)
    (hadd : ∀ f g, P f → P g → P (f + g)) (hsingle : ∀ a b, P (single R a b)) : P f
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem neg_normalize (n d z) : -normalize n d z = normalize (-n) d z
-- Mathlib/SetTheory/Cardinal/ToNat.lean
@[simp]
theorem toNat_add (hc : c < ℵ₀) (hd : d < ℵ₀) : toNat (c + d) = toNat c + toNat d
-- Mathlib/RingTheory/Idempotents.lean
theorem eq_of_isNilpotent_sub_of_isIdempotentElem_of_commute {e₁ e₂ : R}
    (he₁ : IsIdempotentElem e₁) (he₂ : IsIdempotentElem e₂) (H : IsNilpotent (e₁ - e₂))
    (H' : Commute e₁ e₂) :
    e₁ = e₂
-- Mathlib/ModelTheory/Substructures.lean
theorem range_coe (f : M →[L] N) : (range f : Set N) = Set.range f
-- Mathlib/Algebra/Module/Rat.lean
/-- If `E` is a vector space over two division rings `R` and `S`, then scalar multiplications
agree on rational numbers in `R` and `S`. -/
theorem ratCast_smul_eq {E : Type*} (R S : Type*) [AddCommGroup E] [DivisionRing R]
    [DivisionRing S] [Module R E] [Module S E] (r : ℚ) (x : E) : (r : R) • x = (r : S) • x
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem soln_unique (z : ℤ_[p]) (hev : F.eval z = 0)
    (hnlt : ‖z - a‖ < ‖F.derivative.eval a‖) : z = soln
-- Mathlib/Computability/TuringMachine.lean
/-- A pointed map of `Inhabited` types is a map that sends one default value to the other. -/
structure PointedMap.{u, v} (Γ : Type u) (Γ' : Type v) [Inhabited Γ] [Inhabited Γ'] :
    Type max u v where
  /-- The map underlying this instance. -/
  f : Γ → Γ'
  map_pt' : f default = default
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem iff_eventually_eq (f : X → Y) : IsLocallyConstant f ↔ ∀ x, ∀ᶠ y in 𝓝 x, f y = f x
-- Mathlib/Data/Matroid/Dual.lean
theorem dual_indep_iff_exists' : (M✶.Indep I) ↔ I ⊆ M.E ∧ (∃ B, M.Base B ∧ Disjoint I B)
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[simp]
theorem coe_zero : ⇑(0 : A →ₑ+[φ] B) = 0
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
@[simp] theorem add_eval (l₁ l₂ : LinearCombo) (v : Coeffs) :
    (l₁ + l₂).eval v = l₁.eval v + l₂.eval v
-- Mathlib/Combinatorics/SimpleGraph/LapMatrix.lean
theorem degMatrix_mulVec_apply [NonAssocSemiring R] (v : V) (vec : V → R) :
    (G.degMatrix R *ᵥ vec) v = G.degree v * vec v
-- Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean
@[simp]
theorem antidiagonalTuple_zero_succ (n : ℕ) : antidiagonalTuple 0 (n + 1) = []
-- Mathlib/GroupTheory/Transfer.lean
theorem ker_transferSylow_disjoint (Q : Subgroup G) (hQ : IsPGroup p Q) :
    Disjoint (transferSylow P hP).ker Q
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc]
lemma LeftHomologyData.leftHomologyIso_hom_naturality
    (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData) :
    h₁.homologyIso.hom ≫ leftHomologyMap' φ h₁ h₂ =
      homologyMap φ ≫ h₂.homologyIso.hom
-- Mathlib/Algebra/Group/Nat.lean
@[simp] lemma two_dvd_ne_zero : ¬2 ∣ n ↔ n % 2 = 1
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
@[simp]
theorem SpecMap_ΓSpecIso_hom (R : CommRingCat.{u}) :
    Spec.map ((Scheme.ΓSpecIso R).hom) = adjunction.unit.app (Spec R)
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean
@[measurability]
theorem Measurable.clog : Measurable fun x => Complex.log (f x)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
/-- If `K` is a compact set in an R₁ space and `s ⊇ K` is a Borel measurable superset,
then `s` includes the closure of `K` as well. -/
theorem IsCompact.closure_subset_measurableSet [R1Space γ] {K s : Set γ} (hK : IsCompact K)
    (hs : MeasurableSet s) (hKs : K ⊆ s) : closure K ⊆ s
-- Mathlib/Data/Set/Card.lean
theorem ncard_eq_of_bijective {n : ℕ} (f : ∀ i, i < n → α)
    (hf : ∀ a ∈ s, ∃ i, ∃ h : i < n, f i h = a) (hf' : ∀ (i) (h : i < n), f i h ∈ s)
    (f_inj : ∀ (i j) (hi : i < n) (hj : j < n), f i hi = f j hj → i = j) : s.ncard = n
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem mapDomain_equiv_apply {f : α ≃ β} (x : α →₀ M) (a : β) :
    mapDomain f x a = x (f.symm a)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem length_erase_of_mem [LawfulBEq α] {a : α} {l : List α} (h : a ∈ l) :
    length (l.erase a) = Nat.pred (length l)
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
theorem col_eq_prod {μ : YoungDiagram} {j : ℕ} : μ.col j = Finset.range (μ.colLen j) ×ˢ {j}
-- Mathlib/SetTheory/Game/PGame.lean
theorem not_fuzzy_of_le {x y : PGame} (h : x ≤ y) : ¬x ‖ y
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
@[simp]
theorem edgeDensity_empty_left (t : Finset β) : edgeDensity r ∅ t = 0
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem derivative_rootMultiplicity_of_root_of_mem_nonZeroDivisors
    {p : R[X]} {t : R} (hpt : Polynomial.IsRoot p t)
    (hnzd : (p.rootMultiplicity t : R) ∈ nonZeroDivisors R) :
    (derivative p).rootMultiplicity t = p.rootMultiplicity t - 1
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
@[simp]
protected theorem disjointed {f : ℕ → Set α} (h : ∀ i, NullMeasurableSet (f i) μ) (n) :
    NullMeasurableSet (disjointed f n) μ
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem restrict_ite (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    (s.restrict fun a => if a ∈ s then f a else g a) = s.restrict f
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
/--
If `x` is a point in the basic open set `D(f)` where `f` is a homogeneous element of positive
degree, then the homogeneously localized ring `A⁰ₓ` has the universal property of the localization
of `A⁰_f` at `φ(x)` where `φ : Proj|D(f) ⟶ Spec A⁰_f` is the morphism of locally ringed space
constructed as above.
-/
lemma isLocalization_atPrime (f) (x : pbo f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    @IsLocalization (Away 𝒜 f) _ ((toSpec 𝒜 f).1.base x).asIdeal.primeCompl
      (AtPrime 𝒜 x.1.asHomogeneousIdeal.toIdeal) _
      (mapId 𝒜 (Submonoid.powers_le.mpr x.2)).toAlgebra
-- Mathlib/Data/Set/Function.lean
lemma SurjOn.prodMap (h₁ : SurjOn f₁ s₁ t₁) (h₂ : SurjOn f₂ s₂ t₂) :
    SurjOn (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂)
-- Mathlib/LinearAlgebra/QuadraticForm/TensorProduct/Isometries.lean
@[simp] lemma tensorRId_apply (Q₁ : QuadraticForm R M₁) (x : M₁ ⊗[R] R) :
    tensorRId Q₁ x = TensorProduct.rid R M₁ x
-- Mathlib/Topology/Order/Basic.lean
/-- A set in a nontrivial densely linear ordered type is dense in the sense of topology if and only
if for any `a < b` there exists `c ∈ s`, `a < c < b`. Each implication requires less typeclass
assumptions. -/
theorem dense_iff_exists_between [OrderTopology α] [DenselyOrdered α] [Nontrivial α] {s : Set α} :
    Dense s ↔ ∀ a b, a < b → ∃ c ∈ s, a < c ∧ c < b
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem continuous_coe : Continuous ((↑) : α → Completion α)
-- Mathlib/Data/Set/Defs.lean
/-- The restriction of a function onto the preimage of a set. -/
@[simps!]
def restrictPreimage (t : Set β) (f : α → β) : f ⁻¹' t → t
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem aevalTower_comp_C : (aevalTower g y : R[X] →+* A').comp C = g
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := norm_cast)]
theorem coe_mk (x : G) (hx : x ∈ H) : ((⟨x, hx⟩ : H) : G) = x
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_pos (hx : 1 < x) : 0 < logb b x
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
theorem normalized_count_X_eq_of_coe {P : k[X]} (hP : P ≠ 0) :
    Multiset.count PowerSeries.X (normalizedFactors (P : k⟦X⟧)) =
      Multiset.count Polynomial.X (normalizedFactors P)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem measure_univ_pos : 0 < μ univ ↔ μ ≠ 0
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
/-- A `σ₁₂`-semilinear isometric embedding of a normed `R`-module into an `R₂`-module. -/
structure LinearIsometry (σ₁₂ : R →+* R₂) (E E₂ : Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] extends E →ₛₗ[σ₁₂] E₂ where
  norm_map' : ∀ x, ‖toLinearMap x‖ = ‖x‖
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_eq_iff (hn : n ≠ 0) : ⌈a⌉₊ = n ↔ ↑(n - 1) < a ∧ a ≤ n
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_left_comm {γ : Type*} {u : Finset γ} {f : α → δ → ε} {g : β → γ → δ}
    {f' : α → γ → δ'} {g' : β → δ' → ε} (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    image₂ f s (image₂ g t u) = image₂ g' t (image₂ f' s u)
-- Mathlib/Data/Matroid/Restrict.lean
theorem Base.basis_of_restriction (hI : N.Base I) (hNM : N ≤r M) : M.Basis I N.E
-- Mathlib/Order/SupClosed.lean
@[simp] lemma subset_latticeClosure : s ⊆ latticeClosure s
-- Mathlib/Analysis/Normed/Module/Basic.lean
@[simp]
theorem nnnorm_algebraMap_nnreal (x : ℝ≥0) : ‖algebraMap ℝ≥0 𝕜' x‖₊ = x
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem coe_map (f : R →+* S) (s : Subring R) : (s.map f : Set S) = f '' s
-- Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean
theorem IsExtrOn.hasLineDerivAt_eq_zero (h : IsExtrOn f s a) (hd : HasLineDerivAt ℝ f f' a b)
    (h' : ∀ᶠ t : ℝ in 𝓝 0, a + t • b ∈ s) : f' = 0
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem map_inv_le_iff (f : F) {a : α} {b : β} : EquivLike.inv f b ≤ a ↔ b ≤ f a
-- Mathlib/Data/List/Pi.lean
lemma forall_rel_cons_ext {r : ∀ ⦃i⦄, α i → α i → Prop} {a₁ a₂ : α i} {f₁ f₂ : ∀ j ∈ l, α j}
    (ha : r a₁ a₂) (hf : ∀ (i : ι) (hi : i ∈ l), r (f₁ i hi) (f₂ i hi)) :
    ∀ j hj, r (cons _ _ a₁ f₁ j hj) (cons _ _ a₂ f₂ j hj)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_Iic_iff : b ∈ Iic a ↔ b ≤ a
-- Mathlib/Analysis/NormedSpace/MatrixExponential.lean
theorem exp_conj' (U : Matrix m m 𝔸) (A : Matrix m m 𝔸) (hy : IsUnit U) :
    exp 𝕂 (U⁻¹ * A * U) = U⁻¹ * exp 𝕂 A * U
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
/-- `coprod F G` is a colimit cocone. -/
@[simps]
def binaryCoproductColimit : IsColimit (binaryCoproductCocone F G)
-- Mathlib/Geometry/Euclidean/Basic.lean
/-- The `orthogonalProjection` lies in the orthogonal subspace. -/
theorem orthogonalProjection_mem_orthogonal (s : AffineSubspace ℝ P) [Nonempty s]
    [HasOrthogonalProjection s.direction] (p : P) :
    ↑(orthogonalProjection s p) ∈ mk' p s.directionᗮ
-- Mathlib/Algebra/Order/Group/Int.lean
@[simp]
theorem emod_abs (a b : ℤ) : a % |b| = a % b
-- Mathlib/Algebra/CharZero/Defs.lean
@[simp, norm_cast]
theorem cast_inj {m n : ℕ} : (m : R) = n ↔ m = n
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
@[simp] lemma map_dblXYZ : dblXYZ (W'.map f) (f ∘ P) = f ∘ dblXYZ W' P
-- Mathlib/Analysis/Convex/Combination.lean
lemma Finset.centerMass_smul_left {c : R'} [Module R' R] [Module R' E] [SMulCommClass R' R R]
    [IsScalarTower R' R R] [SMulCommClass R R' E] [IsScalarTower R' R E] (hc : c ≠ 0) :
    t.centerMass (c • w) z = t.centerMass w z
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem mul_right_strictMono [IsDedekindDomain A] {I : FractionalIdeal A⁰ K} (hI : I ≠ 0) :
    StrictMono (· * I)
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem wittNeg_vars (n : ℕ) : (wittNeg p n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
-- Mathlib/ModelTheory/Ultraproducts.lean
/-- **Łoś's Theorem**: A sentence is true in an ultraproduct if and only if the set of structures
it is true in is in the ultrafilter. -/
theorem sentence_realize (φ : L.Sentence) :
    (u : Filter α).Product M ⊨ φ ↔ ∀ᶠ a : α in u, M a ⊨ φ
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp, norm_cast]
theorem disjoint_withBotCoe {I J : WithBot (Box ι)} :
    Disjoint (I : Set (ι → ℝ)) J ↔ Disjoint I J
-- Mathlib/Data/Rat/Floor.lean
@[simp, norm_cast]
theorem cast_fract (x : ℚ) : (↑(fract x) : α) = fract (x : α)
-- Mathlib/Data/Finset/Option.lean
lemma forall_mem_insertNone {s : Finset α} {p : Option α → Prop} :
    (∀ a ∈ insertNone s, p a) ↔ p none ∧ ∀ a ∈ s, p a
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem hasFDerivAt_cpow {p : ℂ × ℂ} (hp : p.1 ∈ slitPlane) :
    HasFDerivAt (fun x : ℂ × ℂ => x.1 ^ x.2)
      ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ +
        (p.1 ^ p.2 * log p.1) • ContinuousLinearMap.snd ℂ ℂ ℂ) p
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem hasDerivWithinAt_neg : HasDerivWithinAt Neg.neg (-1) s x
-- Mathlib/Data/Set/Function.lean
theorem MapsTo.congr (h₁ : MapsTo f₁ s t) (h : EqOn f₁ f₂ s) : MapsTo f₂ s t
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_sub_int (a : α) (z : ℤ) : ⌈a - z⌉ = ⌈a⌉ - z
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A vector is in the direction of a nonempty affine subspace if and only if it is the subtraction
of two vectors in the subspace. -/
theorem mem_direction_iff_eq_vsub {s : AffineSubspace k P} (h : (s : Set P).Nonempty) (v : V) :
    v ∈ s.direction ↔ ∃ p1 ∈ s, ∃ p2 ∈ s, v = p1 -ᵥ p2
-- Mathlib/Analysis/RCLike/Basic.lean
theorem norm_re_le_norm (z : K) : ‖re z‖ ≤ ‖z‖
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- The multilinear version of `LinearMap.comp_codRestrict` -/
@[simp]
theorem compMultilinearMap_codRestrict (g : M₂ →ₗ[R] M₃) (f : MultilinearMap R M₁ M₂)
    (p : Submodule R M₃) (h) :
    (g.codRestrict p h).compMultilinearMap f =
      (g.compMultilinearMap f).codRestrict p fun v => h (f v)
-- Mathlib/Algebra/Group/Fin/Basic.lean
lemma neg_natCast_eq_one (n : ℕ) : -(n : Fin (n + 1)) = 1
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma equiv_iff_eq_of_Z_eq' {P Q : Fin 3 → R} (hz : P z = Q z) (mem : Q z ∈ nonZeroDivisors R) :
    P ≈ Q ↔ P = Q
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem le_coe_addNat (m : Nat) (i : Fin n) : m ≤ addNat i m
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem liminf_const {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} [NeBot f]
    (b : β) : liminf (fun _ => b) f = b
-- Mathlib/Data/Real/EReal.lean
@[simp] lemma bot_mul_bot : (⊥ : EReal) * ⊥ = ⊤
-- Mathlib/Order/Ideal.lean
theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem add_cons (a : α) (s t : Multiset α) : s + a ::ₘ t = a ::ₘ (s + t)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem coe_zero : ((0 : S) : A) = 0
-- Mathlib/Algebra/Module/Submodule/Range.lean
@[simp] theorem ker_rangeRestrict : ker f.rangeRestrict = ker f
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem rightAngleRotation_rightAngleRotation (x : E) : J (J x) = -x
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem equivMapDomain_refl (l : α →₀ M) : equivMapDomain (Equiv.refl _) l = l
-- Mathlib/Algebra/Lie/Weights/Killing.lean
/-- Given a splitting Cartan subalgebra `H` of a finite-dimensional Lie algebra with non-singular
Killing form, the corresponding roots span the dual space of `H`. -/
@[simp]
lemma span_weight_eq_top :
    span K (range (Weight.toLinear K H L)) = ⊤
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
lemma stalkMap_inv_hom_apply (e : X ≅ Y) (x : X) (y) :
    e.hom.stalkMap x (e.inv.stalkMap (e.hom.val.base x) y) =
      X.presheaf.stalkSpecializes (specializes_of_eq <| by simp) y
-- Mathlib/CategoryTheory/MorphismProperty/Composition.lean
lemma comp_mem (W : MorphismProperty C) [W.IsStableUnderComposition]
    {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) (hg : W g) : W (f ≫ g)
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
theorem val_smul (n : ℕ) (r : R) (f : AdicCompletion I M) : (r • f).val n = r • f.val n
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem inverse_domain : (inverse f).domain = LinearMap.range f.toFun
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma posSMulMono_iff_posSMulStrictMono : PosSMulMono α β ↔ PosSMulStrictMono α β
-- Mathlib/RingTheory/Localization/LocalizationLocalization.lean
@[simp]
theorem mem_localizationLocalizationSubmodule {x : R} :
    x ∈ localizationLocalizationSubmodule M N ↔
      ∃ (y : N) (z : M), algebraMap R S x = y * algebraMap R S z
-- Mathlib/Probability/Kernel/Composition.lean
theorem setLIntegral_compProd_univ_right (κ : Kernel α β) [IsSFiniteKernel κ]
    (η : Kernel (α × β) γ) [IsSFiniteKernel η] (a : α) {f : β × γ → ℝ≥0∞} (hf : Measurable f)
    {s : Set β} (hs : MeasurableSet s) :
    ∫⁻ z in s ×ˢ Set.univ, f z ∂(κ ⊗ₖ η) a = ∫⁻ x in s, ∫⁻ y, f (x, y) ∂η (a, x) ∂κ a
-- Mathlib/Algebra/Ring/Equiv.lean
theorem symm_bijective : Function.Bijective (RingEquiv.symm : (R ≃+* S) → S ≃+* R)
-- Mathlib/Algebra/Group/Int.lean
@[norm_cast]
lemma ofNat_isUnit {n : ℕ} : IsUnit (n : ℤ) ↔ IsUnit n
-- Mathlib/NumberTheory/ClassNumber/AdmissibleAbsoluteValue.lean
/-- Any large enough family of vectors in `R^n` has a pair of elements
whose remainders are close together, pointwise. -/
theorem exists_approx_aux (n : ℕ) (h : abv.IsAdmissible) :
    ∀ {ε : ℝ} (_hε : 0 < ε) {b : R} (_hb : b ≠ 0) (A : Fin (h.card ε ^ n).succ → Fin n → R),
      ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ k, (abv (A i₁ k % b - A i₀ k % b) : ℝ) < abv b • ε
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem toENNRealVectorMeasure_zero : (0 : Measure α).toENNRealVectorMeasure = 0
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem denseRange_coe : DenseRange ((↑) : α → Completion α)
-- Mathlib/Algebra/Module/Defs.lean
theorem sub_smul (r s : R) (y : M) : (r - s) • y = r • y - s • y
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_smul_measure {f : α → β} {c : ℝ≥0∞} (h₁ : c ≠ 0) (h₂ : c ≠ ∞) :
    Integrable f (c • μ) ↔ Integrable f μ
-- Mathlib/ModelTheory/Basic.lean
theorem injective (f : M ↪[L] N) : Function.Injective f
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
protected lemma leibniz_lie (x : L) (D₁ D₂ : LieDerivation R L L) :
    ⁅x, ⁅D₁, D₂⁆⁆ = ⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆
-- Mathlib/Data/Nat/Factorization/Root.lean
@[simp] lemma floorRoot_eq_zero : floorRoot n a = 0 ↔ n = 0 ∨ a = 0
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
theorem charpoly_sub_diagonal_degree_lt :
    (M.charpoly - ∏ i : n, (X - C (M i i))).degree < ↑(Fintype.card n - 1)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Icc_subset_Icc_left (h : a₁ ≤ a₂) : Icc a₂ b ⊆ Icc a₁ b
-- Mathlib/Algebra/Module/Torsion.lean
lemma isTorsionBySet_quotient_ideal_smul :
    IsTorsionBySet R (M⧸I • (⊤ : Submodule R M)) I
-- Mathlib/Algebra/Group/Invertible/Defs.lean
theorem invOf_mul_self [Mul α] [One α] (a : α) [Invertible a] : ⅟ a * a = 1
-- Mathlib/ModelTheory/Complexity.lean
theorem isPrenex_toPrenexImp {φ ψ : L.BoundedFormula α n} (hφ : IsPrenex φ) (hψ : IsPrenex ψ) :
    IsPrenex (φ.toPrenexImp ψ)
-- Mathlib/FieldTheory/AbelRuffini.lean
theorem gal_prod_isSolvable {s : Multiset F[X]} (hs : ∀ p ∈ s, IsSolvable (Gal p)) :
    IsSolvable s.prod.Gal
-- Mathlib/AlgebraicGeometry/Gluing.lean
theorem isOpen_iff (U : Set D.glued.carrier) : IsOpen U ↔ ∀ i, IsOpen ((D.ι i).1.base ⁻¹' U)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Square.lean
lemma IsPullback.iff_of_iso {sq₁ sq₂ : Square C} (e : sq₁ ≅ sq₂) :
    sq₁.IsPullback ↔ sq₂.IsPullback
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma isWeaklyRegular_singleton_iff (r : R) :
    IsWeaklyRegular M [r] ↔ IsSMulRegular M r
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem equivOfMinpoly_gen (pb : PowerBasis A S) (pb' : PowerBasis A S')
    (h : minpoly A pb.gen = minpoly A pb'.gen) : pb.equivOfMinpoly pb' h pb.gen = pb'.gen
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
lemma isReduced_iff : P.IsReduced ↔ ∀ i j : ι, i ≠ j →
    ¬ LinearIndependent R ![P.root i, P.root j] → P.root i = - P.root j
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem getElem?_range' (s step) :
    ∀ {m n : Nat}, m < n → (range' s n step)[m]? = some (s + step * m)
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure
-- Mathlib/Order/Minimal.lean
theorem RelEmbedding.image_maximals_eq (f : r ↪r s) (x : Set α) :
    f '' maximals r x = maximals s (f '' x)
-- Mathlib/Algebra/DirectSum/Module.lean
theorem smul_apply (b : R) (v : ⨁ i, M i) (i : ι) : (b • v) i = b • v i
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem coe_Iio (a : α) : ↑(Iio a) = Set.Iio a
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem not_prime_mul {a b : ℕ} (a1 : a ≠ 1) (b1 : b ≠ 1) : ¬Prime (a * b)
-- Mathlib/Order/Filter/Lift.lean
theorem comap_lift'_eq2 {m : β → α} {g : Set β → Set γ} (hg : Monotone g) :
    (comap m f).lift' g = f.lift' (g ∘ preimage m)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem findSome?_replicate_of_pos (h : 0 < n) : findSome? f (replicate n a) = f a
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem of_a_eq_zero (ha : P.a = 0) : P.toPoly = C P.b * X ^ 2 + C P.c * X + C P.d
-- Mathlib/Order/MinMax.lean
@[gcongr]
theorem max_le_max : a ≤ c → b ≤ d → max a b ≤ max c d
-- Mathlib/Data/Set/Function.lean
theorem eqOn (h : RightInvOn f' f t) : EqOn (f ∘ f') id t
-- Mathlib/Data/Nat/PrimeFin.lean
lemma primeFactors_mul (ha : a ≠ 0) (hb : b ≠ 0) :
    (a * b).primeFactors = a.primeFactors ∪ b.primeFactors
-- Mathlib/Order/Filter/Basic.lean
theorem comap_eq_bot_iff_compl_range {f : Filter β} {m : α → β} : comap m f = ⊥ ↔ (range m)ᶜ ∈ f
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp] theorem toZeroAtInftyCLM_apply (f : 𝓢(E, F)) (x : E) : toZeroAtInftyCLM 𝕜 E F f x = f x
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ico_mem_nhdsWithin_Ioi {a b c : α} (H : b ∈ Ico a c) : Ico a c ∈ 𝓝[>] b
-- Mathlib/Logic/Equiv/Set.lean
theorem sumCompl_symm_apply_of_not_mem {α : Type u} {s : Set α} [DecidablePred (· ∈ s)] {x : α}
    (hx : x ∉ s) : (Equiv.Set.sumCompl s).symm x = Sum.inr ⟨x, hx⟩
-- Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean
theorem integral_comp_inv_mul_right (g : ℝ → F) (a : ℝ) :
    (∫ x : ℝ, g (x * a⁻¹)) = |a| • ∫ y : ℝ, g y
-- Mathlib/LinearAlgebra/Matrix/IsDiag.lean
/-- Diagonal matrices are generated by the `Matrix.diagonal` of their `Matrix.diag`. -/
theorem IsDiag.diagonal_diag [Zero α] [DecidableEq n] {A : Matrix n n α} (h : A.IsDiag) :
    diagonal (diag A) = A
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem perm_append_comm : ∀ {l₁ l₂ : List α}, l₁ ++ l₂ ~ l₂ ++ l₁
-- Mathlib/Analysis/Analytic/Basic.lean
@[simp]
theorem radius_neg (p : FormalMultilinearSeries 𝕜 E F) : (-p).radius = p.radius
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/--
Two linear maps `S` and `T` are equal, if and only if the identity `⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ` holds
for all `x`.
-/
theorem ext_inner_map (S T : V →ₗ[ℂ] V) : (∀ x : V, ⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ) ↔ S = T